Delete base unittests and build files
Change-Id: I734ea94edff2974d8ebe5c990bbd18233e9ce356
Reviewed-on: https://gn-review.googlesource.com/1403
Reviewed-by: Brett Wilson <brettw@chromium.org>
diff --git a/base/BUILD.gn b/base/BUILD.gn
deleted file mode 100644
index 28542b2..0000000
--- a/base/BUILD.gn
+++ /dev/null
@@ -1,3164 +0,0 @@
-# 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.
-
-# HOW TO WRITE CONDITIONALS IN THIS FILE
-# ======================================
-#
-# In many other places, one would write a conditional that expresses all the
-# cases when a source file is used or unused, and then either add or subtract
-# it from the sources list in that case
-#
-# Since base includes so many low-level things that vary widely and
-# unpredictably for the various build types, we prefer a slightly different
-# style. Instead, there are big per-platform blocks of inclusions and
-# exclusions. If a given file has an inclusion or exclusion rule that applies
-# for multiple conditions, prefer to duplicate it in both lists. This makes it
-# a bit easier to see which files apply in which cases rather than having a
-# huge sequence of random-looking conditionals.
-
-import("//build/buildflag_header.gni")
-import("//build/config/allocator.gni")
-import("//build/config/arm.gni")
-import("//build/config/c++/c++.gni")
-import("//build/config/chromecast_build.gni")
-import("//build/config/compiler/compiler.gni")
-import("//build/config/dcheck_always_on.gni")
-import("//build/config/jumbo.gni")
-import("//build/config/nacl/config.gni")
-import("//build/config/sysroot.gni")
-import("//build/config/ui.gni")
-import("//build/nocompile.gni")
-import("//testing/libfuzzer/fuzzer_test.gni")
-import("//testing/test.gni")
-
-declare_args() {
- # Override this value to give a specific build date.
- # See //base/build_time.cc and //build/write_build_date_header.py for more
- # details and the expected format.
- override_build_date = "N/A"
-
- # Indicates if the Location object contains the source code information
- # (file, function, line). False means only the program counter (and currently
- # file name) is saved.
- enable_location_source = true
-
- # Unsafe developer build. Has developer-friendly features that may weaken or
- # disable security measures like sandboxing or ASLR.
- # IMPORTANT: Unsafe developer builds should never be distributed to end users.
- is_unsafe_developer_build = !is_official_build
-
- # Set to true to disable COM init check hooks.
- com_init_check_hook_disabled = false
-
- # Set to true to enable mutex priority inheritance. See the comments in
- # LockImpl::PriorityInheritanceAvailable() in lock_impl_posix.cc for the
- # platform requirements to safely enable priority inheritance.
- enable_mutex_priority_inheritance = false
-}
-
-# Determines whether libevent should be dep.
-dep_libevent = !is_fuchsia && !is_win && !(is_nacl && !is_nacl_nonsfi)
-
-# Determines whether message_pump_libevent should be used.
-use_libevent = dep_libevent && !is_ios
-
-if (is_android) {
- import("//build/config/android/rules.gni")
-}
-
-if (is_fuchsia) {
- import("//third_party/fuchsia-sdk/fidl_library.gni")
-}
-
-config("base_flags") {
- if (is_clang) {
- cflags = [
- # Don't die on dtoa code that uses a char as an array index.
- # This is required solely for base/third_party/dmg_fp/dtoa_wrapper.cc.
- "-Wno-char-subscripts",
-
- # Ideally all product code (but no test code) in chrome would have these
- # flags. But this isn't trivial so start with //base as a minimum
- # requirement.
- # https://groups.google.com/a/chromium.org/d/topic/chromium-dev/B9Q5KTD7iCo/discussion
- "-Wglobal-constructors",
- "-Wexit-time-destructors",
- ]
- }
-}
-
-config("base_implementation") {
- defines = [ "BASE_IMPLEMENTATION" ]
- configs = [ "//build/config/compiler:wexit_time_destructors" ]
-}
-
-if (is_win) {
- # This is in a separate config so the flags can be applied to dependents.
- # ldflags in GN aren't automatically inherited.
- config("base_win_linker_flags") {
- ldflags = [
- "/DELAYLOAD:cfgmgr32.dll",
- "/DELAYLOAD:powrprof.dll",
- "/DELAYLOAD:setupapi.dll",
- ]
- }
-}
-
-if (is_nacl_nonsfi) {
- # Must be in a config because of how GN orders flags (otherwise -Wall will
- # appear after this, and turn it back on).
- config("nacl_nonsfi_warnings") {
- # file_util_posix.cc contains a function which is not
- # being used by nacl_helper_nonsfi.
- cflags = [ "-Wno-unused-function" ]
- }
-}
-
-if (is_android) {
- config("android_system_libs") {
- libs = [ "log" ] # Used by logging.cc.
- }
-}
-
-# Base and everything it depends on should be a static library rather than
-# a source set. Base is more of a "library" in the classic sense in that many
-# small parts of it are used in many different contexts. This combined with a
-# few static initializers floating around means that dead code stripping
-# still leaves a lot of code behind that isn't always used. For example, this
-# saves more than 40K for a smaller target like chrome_elf.
-#
-# Use static libraries for the helper stuff as well like //base/debug since
-# those things refer back to base code, which will force base compilation units
-# to be linked in where they wouldn't have otherwise. This does not include
-# test code (test support and anything in the test directory) which should use
-# source_set as is recommended for GN targets).
-jumbo_component("base") {
- if (is_nacl_nonsfi) {
- # TODO(phosek) bug 570839: If field_trial.cc is in a static library,
- # nacl_helper_nonsfi doesn't link properly on Linux in debug builds. The
- # reasons for this seem to involve obscure toolchain bugs. This should be
- # fixed and this target should always be a static_library in the
- # non-component case.
- static_component_type = "source_set"
- }
- if (is_nacl || is_ios) {
- # Link errors related to malloc functions if libbase for nacl is
- # compiled with jumbo: https://crbug.com/775959.
- # Same for ios: https://crbug.com/776313.
- never_build_jumbo = true
- }
-
- sources = [
- "allocator/allocator_check.cc",
- "allocator/allocator_check.h",
- "allocator/allocator_extension.cc",
- "allocator/allocator_extension.h",
- "allocator/allocator_interception_mac.h",
- "allocator/allocator_interception_mac.mm",
- "allocator/allocator_shim.h",
- "allocator/malloc_zone_functions_mac.cc",
- "allocator/malloc_zone_functions_mac.h",
- "android/android_hardware_buffer_abi.h",
- "android/android_hardware_buffer_compat.cc",
- "android/android_hardware_buffer_compat.h",
- "android/animation_frame_time_histogram.cc",
- "android/apk_assets.cc",
- "android/apk_assets.h",
- "android/application_status_listener.cc",
- "android/application_status_listener.h",
- "android/base_jni_onload.cc",
- "android/base_jni_onload.h",
- "android/build_info.cc",
- "android/build_info.h",
- "android/callback_android.cc",
- "android/callback_android.h",
- "android/child_process_service.cc",
- "android/command_line_android.cc",
- "android/content_uri_utils.cc",
- "android/content_uri_utils.h",
- "android/cpu_features.cc",
- "android/early_trace_event_binding.cc",
- "android/event_log.cc",
- "android/event_log.h",
- "android/field_trial_list.cc",
- "android/important_file_writer_android.cc",
- "android/java_exception_reporter.cc",
- "android/java_exception_reporter.h",
- "android/java_handler_thread.cc",
- "android/java_handler_thread.h",
- "android/java_runtime.cc",
- "android/java_runtime.h",
- "android/jni_android.cc",
- "android/jni_android.h",
- "android/jni_array.cc",
- "android/jni_array.h",
- "android/jni_generator/jni_generator_helper.h",
- "android/jni_int_wrapper.h",
- "android/jni_registrar.cc",
- "android/jni_registrar.h",
- "android/jni_string.cc",
- "android/jni_string.h",
- "android/jni_utils.cc",
- "android/jni_utils.h",
- "android/jni_weak_ref.cc",
- "android/jni_weak_ref.h",
- "android/library_loader/anchor_functions.cc",
- "android/library_loader/anchor_functions.h",
- "android/library_loader/library_load_from_apk_status_codes.h",
- "android/library_loader/library_loader_hooks.cc",
- "android/library_loader/library_loader_hooks.h",
- "android/library_loader/library_prefetcher.cc",
- "android/library_loader/library_prefetcher.h",
- "android/locale_utils.cc",
- "android/locale_utils.h",
- "android/memory_pressure_listener_android.cc",
- "android/memory_pressure_listener_android.h",
- "android/path_service_android.cc",
- "android/path_utils.cc",
- "android/path_utils.h",
- "android/record_histogram.cc",
- "android/record_user_action.cc",
- "android/scoped_hardware_buffer_handle.cc",
- "android/scoped_hardware_buffer_handle.h",
- "android/scoped_java_ref.cc",
- "android/scoped_java_ref.h",
- "android/statistics_recorder_android.cc",
- "android/sys_utils.cc",
- "android/sys_utils.h",
- "android/throw_uncaught_exception.cc",
- "android/throw_uncaught_exception.h",
- "android/time_utils.cc",
- "android/timezone_utils.cc",
- "android/timezone_utils.h",
- "android/trace_event_binding.cc",
- "android/unguessable_token_android.cc",
- "android/unguessable_token_android.h",
- "at_exit.cc",
- "at_exit.h",
- "atomic_ref_count.h",
- "atomic_sequence_num.h",
- "atomicops.h",
- "atomicops_internals_atomicword_compat.h",
- "atomicops_internals_portable.h",
- "atomicops_internals_x86_msvc.h",
- "auto_reset.h",
- "barrier_closure.cc",
- "barrier_closure.h",
- "base64.cc",
- "base64.h",
- "base64url.cc",
- "base64url.h",
- "base_export.h",
- "base_switches.h",
- "big_endian.cc",
- "big_endian.h",
- "bind.h",
- "bind_helpers.h",
- "bind_internal.h",
- "bit_cast.h",
- "bits.h",
- "build_time.cc",
- "build_time.h",
- "callback.h",
- "callback_forward.h",
- "callback_helpers.cc",
- "callback_helpers.h",
- "callback_internal.cc",
- "callback_internal.h",
- "callback_list.h",
- "cancelable_callback.h",
- "command_line.cc",
- "command_line.h",
- "compiler_specific.h",
- "component_export.h",
- "containers/adapters.h",
- "containers/circular_deque.h",
- "containers/flat_map.h",
- "containers/flat_set.h",
- "containers/flat_tree.h",
- "containers/hash_tables.h",
- "containers/id_map.h",
- "containers/linked_list.h",
- "containers/mru_cache.h",
- "containers/small_map.h",
- "containers/span.h",
- "containers/stack.h",
- "containers/stack_container.h",
- "containers/unique_ptr_adapters.h",
- "containers/vector_buffer.h",
- "cpu.cc",
- "cpu.h",
- "critical_closure.h",
- "critical_closure_internal_ios.mm",
-
- # This file depends on files from the "debug/allocator" target,
- # but this target does not depend on "debug/allocator".
- "debug/activity_analyzer.cc",
- "debug/activity_analyzer.h",
- "debug/activity_tracker.cc",
- "debug/activity_tracker.h",
- "debug/alias.cc",
- "debug/alias.h",
- "debug/asan_invalid_access.cc",
- "debug/asan_invalid_access.h",
- "debug/close_handle_hook_win.cc",
- "debug/close_handle_hook_win.h",
- "debug/crash_logging.cc",
- "debug/crash_logging.h",
- "debug/debugger.cc",
- "debug/debugger.h",
- "debug/debugger_win.cc",
- "debug/dump_without_crashing.cc",
- "debug/dump_without_crashing.h",
- "debug/gdi_debug_util_win.cc",
- "debug/gdi_debug_util_win.h",
- "debug/leak_annotations.h",
- "debug/leak_tracker.h",
- "debug/proc_maps_linux.cc",
- "debug/proc_maps_linux.h",
- "debug/profiler.cc",
- "debug/profiler.h",
- "debug/stack_trace.cc",
- "debug/stack_trace.h",
- "debug/stack_trace_android.cc",
- "debug/stack_trace_win.cc",
- "debug/task_annotator.cc",
- "debug/task_annotator.h",
- "debug/thread_heap_usage_tracker.cc",
- "debug/thread_heap_usage_tracker.h",
- "deferred_sequenced_task_runner.cc",
- "deferred_sequenced_task_runner.h",
- "environment.cc",
- "environment.h",
- "export_template.h",
- "feature_list.cc",
- "feature_list.h",
- "file_descriptor_store.cc",
- "file_descriptor_store.h",
- "file_version_info.h",
- "file_version_info_mac.h",
- "file_version_info_mac.mm",
- "file_version_info_win.cc",
- "file_version_info_win.h",
- "files/dir_reader_fallback.h",
- "files/dir_reader_linux.h",
- "files/file.cc",
- "files/file.h",
- "files/file_enumerator.cc",
- "files/file_enumerator.h",
- "files/file_enumerator_win.cc",
- "files/file_path.cc",
- "files/file_path.h",
- "files/file_path_constants.cc",
- "files/file_path_watcher.cc",
- "files/file_path_watcher.h",
- "files/file_path_watcher_fsevents.cc",
- "files/file_path_watcher_fsevents.h",
- "files/file_path_watcher_kqueue.cc",
- "files/file_path_watcher_kqueue.h",
- "files/file_path_watcher_linux.cc",
- "files/file_path_watcher_mac.cc",
- "files/file_path_watcher_win.cc",
- "files/file_proxy.cc",
- "files/file_proxy.h",
- "files/file_tracing.cc",
- "files/file_tracing.h",
- "files/file_util.cc",
- "files/file_util.h",
- "files/file_util_android.cc",
- "files/file_util_linux.cc",
- "files/file_util_mac.mm",
- "files/file_util_win.cc",
- "files/file_win.cc",
- "files/important_file_writer.cc",
- "files/important_file_writer.h",
- "files/memory_mapped_file.cc",
- "files/memory_mapped_file.h",
- "files/memory_mapped_file_win.cc",
- "files/platform_file.h",
- "files/scoped_file.cc",
- "files/scoped_file.h",
- "files/scoped_temp_dir.cc",
- "files/scoped_temp_dir.h",
- "format_macros.h",
- "gtest_prod_util.h",
- "guid.cc",
- "guid.h",
- "hash.cc",
- "hash.h",
- "ios/block_types.h",
- "ios/crb_protocol_observers.h",
- "ios/crb_protocol_observers.mm",
- "ios/device_util.h",
- "ios/device_util.mm",
- "ios/ios_util.h",
- "ios/ios_util.mm",
- "ios/ns_error_util.h",
- "ios/ns_error_util.mm",
- "ios/scoped_critical_action.h",
- "ios/scoped_critical_action.mm",
- "ios/weak_nsobject.h",
- "ios/weak_nsobject.mm",
- "json/json_file_value_serializer.cc",
- "json/json_file_value_serializer.h",
- "json/json_parser.cc",
- "json/json_parser.h",
- "json/json_reader.cc",
- "json/json_reader.h",
- "json/json_string_value_serializer.cc",
- "json/json_string_value_serializer.h",
- "json/json_value_converter.cc",
- "json/json_value_converter.h",
- "json/json_writer.cc",
- "json/json_writer.h",
- "json/string_escape.cc",
- "json/string_escape.h",
- "lazy_instance.h",
- "lazy_instance_helpers.cc",
- "lazy_instance_helpers.h",
- "linux_util.cc",
- "linux_util.h",
- "location.cc",
- "location.h",
- "logging.cc",
- "logging.h",
- "logging_win.cc",
- "logging_win.h",
- "mac/authorization_util.h",
- "mac/authorization_util.mm",
- "mac/availability.h",
- "mac/bind_objc_block.h",
- "mac/bundle_locations.h",
- "mac/bundle_locations.mm",
- "mac/call_with_eh_frame.cc",
- "mac/call_with_eh_frame.h",
- "mac/call_with_eh_frame_asm.S",
- "mac/close_nocancel.cc",
- "mac/dispatch_source_mach.cc",
- "mac/dispatch_source_mach.h",
- "mac/foundation_util.h",
- "mac/foundation_util.mm",
- "mac/launch_services_util.h",
- "mac/launch_services_util.mm",
- "mac/launchd.cc",
- "mac/launchd.h",
- "mac/mac_logging.h",
- "mac/mac_logging.mm",
- "mac/mac_util.h",
- "mac/mac_util.mm",
- "mac/mach_logging.cc",
- "mac/mach_logging.h",
- "mac/mach_port_broker.h",
- "mac/mach_port_broker.mm",
- "mac/mach_port_util.cc",
- "mac/mach_port_util.h",
- "mac/objc_release_properties.h",
- "mac/objc_release_properties.mm",
- "mac/os_crash_dumps.cc",
- "mac/os_crash_dumps.h",
- "mac/scoped_aedesc.h",
- "mac/scoped_authorizationref.h",
- "mac/scoped_block.h",
- "mac/scoped_cffiledescriptorref.h",
- "mac/scoped_cftyperef.h",
- "mac/scoped_dispatch_object.h",
- "mac/scoped_ionotificationportref.h",
- "mac/scoped_ioobject.h",
- "mac/scoped_ioplugininterface.h",
- "mac/scoped_launch_data.h",
- "mac/scoped_mach_port.cc",
- "mac/scoped_mach_port.h",
- "mac/scoped_mach_vm.cc",
- "mac/scoped_mach_vm.h",
- "mac/scoped_nsautorelease_pool.h",
- "mac/scoped_nsautorelease_pool.mm",
- "mac/scoped_nsobject.h",
- "mac/scoped_nsobject.mm",
- "mac/scoped_objc_class_swizzler.h",
- "mac/scoped_objc_class_swizzler.mm",
- "mac/scoped_sending_event.h",
- "mac/scoped_sending_event.mm",
- "mac/sdk_forward_declarations.h",
- "mac/sdk_forward_declarations.mm",
- "macros.h",
- "md5.cc",
- "md5.h",
- "memory/aligned_memory.cc",
- "memory/aligned_memory.h",
- "memory/discardable_memory.cc",
- "memory/discardable_memory.h",
- "memory/discardable_memory_allocator.cc",
- "memory/discardable_memory_allocator.h",
- "memory/discardable_shared_memory.cc",
- "memory/discardable_shared_memory.h",
- "memory/free_deleter.h",
- "memory/linked_ptr.h",
- "memory/memory_coordinator_client.cc",
- "memory/memory_coordinator_client.h",
- "memory/memory_coordinator_client_registry.cc",
- "memory/memory_coordinator_client_registry.h",
- "memory/memory_coordinator_proxy.cc",
- "memory/memory_coordinator_proxy.h",
- "memory/memory_pressure_listener.cc",
- "memory/memory_pressure_listener.h",
- "memory/memory_pressure_monitor.cc",
- "memory/memory_pressure_monitor.h",
- "memory/memory_pressure_monitor_chromeos.cc",
- "memory/memory_pressure_monitor_chromeos.h",
- "memory/memory_pressure_monitor_mac.cc",
- "memory/memory_pressure_monitor_mac.h",
- "memory/memory_pressure_monitor_win.cc",
- "memory/memory_pressure_monitor_win.h",
- "memory/platform_shared_memory_region.cc",
- "memory/platform_shared_memory_region.h",
- "memory/protected_memory.cc",
- "memory/protected_memory.h",
- "memory/protected_memory_cfi.h",
- "memory/protected_memory_win.cc",
- "memory/ptr_util.h",
- "memory/raw_scoped_refptr_mismatch_checker.h",
- "memory/read_only_shared_memory_region.cc",
- "memory/read_only_shared_memory_region.h",
- "memory/ref_counted.cc",
- "memory/ref_counted.h",
- "memory/ref_counted_delete_on_sequence.h",
- "memory/ref_counted_memory.cc",
- "memory/ref_counted_memory.h",
- "memory/scoped_policy.h",
- "memory/scoped_refptr.h",
- "memory/shared_memory.h",
- "memory/shared_memory_handle.cc",
- "memory/shared_memory_handle.h",
- "memory/shared_memory_helper.cc",
- "memory/shared_memory_helper.h",
- "memory/shared_memory_mapping.cc",
- "memory/shared_memory_mapping.h",
- "memory/shared_memory_tracker.cc",
- "memory/shared_memory_tracker.h",
- "memory/singleton.h",
- "memory/unsafe_shared_memory_region.cc",
- "memory/unsafe_shared_memory_region.h",
- "memory/weak_ptr.cc",
- "memory/weak_ptr.h",
- "memory/writable_shared_memory_region.cc",
- "memory/writable_shared_memory_region.h",
- "message_loop/incoming_task_queue.cc",
- "message_loop/incoming_task_queue.h",
- "message_loop/message_loop.cc",
- "message_loop/message_loop.h",
- "message_loop/message_loop_current.cc",
- "message_loop/message_loop_current.h",
- "message_loop/message_loop_task_runner.cc",
- "message_loop/message_loop_task_runner.h",
- "message_loop/message_pump.cc",
- "message_loop/message_pump.h",
- "message_loop/message_pump_android.cc",
- "message_loop/message_pump_android.h",
- "message_loop/message_pump_default.cc",
- "message_loop/message_pump_default.h",
- "message_loop/message_pump_for_io.h",
- "message_loop/message_pump_for_ui.h",
- "message_loop/message_pump_glib.cc",
- "message_loop/message_pump_glib.h",
- "message_loop/message_pump_io_ios.cc",
- "message_loop/message_pump_io_ios.h",
- "message_loop/message_pump_mac.h",
- "message_loop/message_pump_mac.mm",
- "message_loop/message_pump_win.cc",
- "message_loop/message_pump_win.h",
- "message_loop/timer_slack.h",
- "metrics/bucket_ranges.cc",
- "metrics/bucket_ranges.h",
- "metrics/dummy_histogram.cc",
- "metrics/dummy_histogram.h",
- "metrics/field_trial.cc",
- "metrics/field_trial.h",
- "metrics/field_trial_param_associator.cc",
- "metrics/field_trial_param_associator.h",
- "metrics/field_trial_params.cc",
- "metrics/field_trial_params.h",
- "metrics/histogram.cc",
- "metrics/histogram.h",
- "metrics/histogram_base.cc",
- "metrics/histogram_base.h",
- "metrics/histogram_delta_serialization.cc",
- "metrics/histogram_delta_serialization.h",
- "metrics/histogram_flattener.h",
- "metrics/histogram_functions.cc",
- "metrics/histogram_functions.h",
- "metrics/histogram_macros.h",
- "metrics/histogram_macros_internal.h",
- "metrics/histogram_macros_local.h",
- "metrics/histogram_samples.cc",
- "metrics/histogram_samples.h",
- "metrics/histogram_snapshot_manager.cc",
- "metrics/histogram_snapshot_manager.h",
- "metrics/metrics_hashes.cc",
- "metrics/metrics_hashes.h",
- "metrics/persistent_histogram_allocator.cc",
- "metrics/persistent_histogram_allocator.h",
- "metrics/persistent_memory_allocator.cc",
- "metrics/persistent_memory_allocator.h",
- "metrics/persistent_sample_map.cc",
- "metrics/persistent_sample_map.h",
- "metrics/record_histogram_checker.h",
- "metrics/sample_map.cc",
- "metrics/sample_map.h",
- "metrics/sample_vector.cc",
- "metrics/sample_vector.h",
- "metrics/single_sample_metrics.cc",
- "metrics/single_sample_metrics.h",
- "metrics/sparse_histogram.cc",
- "metrics/sparse_histogram.h",
- "metrics/statistics_recorder.cc",
- "metrics/statistics_recorder.h",
- "metrics/user_metrics.cc",
- "metrics/user_metrics.h",
- "metrics/user_metrics_action.h",
- "native_library.cc",
- "native_library.h",
- "native_library_ios.mm",
- "native_library_mac.mm",
- "native_library_win.cc",
- "nix/mime_util_xdg.cc",
- "nix/mime_util_xdg.h",
- "nix/xdg_util.cc",
- "nix/xdg_util.h",
- "no_destructor.h",
- "observer_list.h",
- "observer_list_threadsafe.cc",
- "observer_list_threadsafe.h",
- "optional.h",
- "os_compat_android.cc",
- "os_compat_android.h",
- "os_compat_nacl.cc",
- "os_compat_nacl.h",
- "path_service.cc",
- "path_service.h",
- "pending_task.cc",
- "pending_task.h",
- "pickle.cc",
- "pickle.h",
- "post_task_and_reply_with_result_internal.h",
- "power_monitor/power_monitor.cc",
- "power_monitor/power_monitor.h",
- "power_monitor/power_monitor_device_source.cc",
- "power_monitor/power_monitor_device_source.h",
- "power_monitor/power_monitor_source.cc",
- "power_monitor/power_monitor_source.h",
- "power_monitor/power_observer.h",
- "process/internal_linux.cc",
- "process/internal_linux.h",
- "process/kill.cc",
- "process/kill.h",
- "process/kill_mac.cc",
- "process/kill_win.cc",
- "process/launch.cc",
- "process/launch.h",
- "process/launch_ios.cc",
- "process/launch_mac.cc",
- "process/launch_win.cc",
- "process/memory.cc",
- "process/memory.h",
- "process/memory_linux.cc",
- "process/memory_mac.mm",
- "process/memory_win.cc",
- "process/port_provider_mac.cc",
- "process/port_provider_mac.h",
- "process/process.h",
- "process/process_handle.cc",
- "process/process_handle.h",
-
- #"process/process_handle_freebsd.cc", # Unused in Chromium build.
- "process/process_handle_linux.cc",
- "process/process_handle_mac.cc",
-
- #"process/process_handle_openbsd.cc", # Unused in Chromium build.
- "process/process_handle_win.cc",
- "process/process_info.h",
- "process/process_info_linux.cc",
- "process/process_info_mac.cc",
- "process/process_info_win.cc",
- "process/process_iterator.cc",
- "process/process_iterator.h",
-
- #"process/process_iterator_freebsd.cc", # Unused in Chromium build.
- "process/process_iterator_linux.cc",
- "process/process_iterator_mac.cc",
-
- #"process/process_iterator_openbsd.cc", # Unused in Chromium build.
- "process/process_iterator_win.cc",
- "process/process_linux.cc",
- "process/process_mac.cc",
- "process/process_metrics.cc",
- "process/process_metrics.h",
-
- #"process/process_metrics_freebsd.cc", # Unused in Chromium build.
- "process/process_metrics_ios.cc",
- "process/process_metrics_linux.cc",
- "process/process_metrics_mac.cc",
-
- #"process/process_metrics_openbsd.cc", # Unused in Chromium build.
- "process/process_metrics_win.cc",
- "process/process_win.cc",
- "profiler/native_stack_sampler.cc",
- "profiler/native_stack_sampler.h",
- "profiler/native_stack_sampler_mac.cc",
- "profiler/native_stack_sampler_win.cc",
- "profiler/stack_sampling_profiler.cc",
- "profiler/stack_sampling_profiler.h",
- "rand_util.cc",
- "rand_util.h",
- "rand_util_nacl.cc",
- "rand_util_win.cc",
- "run_loop.cc",
- "run_loop.h",
- "sampling_heap_profiler/sampling_heap_profiler.cc",
- "sampling_heap_profiler/sampling_heap_profiler.h",
- "scoped_clear_errno.h",
- "scoped_generic.h",
- "scoped_native_library.cc",
- "scoped_native_library.h",
- "scoped_observer.h",
- "sequence_checker.h",
- "sequence_checker_impl.cc",
- "sequence_checker_impl.h",
- "sequence_token.cc",
- "sequence_token.h",
- "sequenced_task_runner.cc",
- "sequenced_task_runner.h",
- "sequenced_task_runner_helpers.h",
- "sha1.cc",
- "sha1.h",
- "single_thread_task_runner.h",
- "stl_util.h",
- "strings/char_traits.h",
- "strings/latin1_string_conversions.cc",
- "strings/latin1_string_conversions.h",
- "strings/nullable_string16.cc",
- "strings/nullable_string16.h",
- "strings/pattern.cc",
- "strings/pattern.h",
- "strings/safe_sprintf.cc",
- "strings/safe_sprintf.h",
- "strings/strcat.cc",
- "strings/strcat.h",
- "strings/string16.cc",
- "strings/string16.h",
- "strings/string_number_conversions.cc",
- "strings/string_number_conversions.h",
- "strings/string_piece.cc",
- "strings/string_piece.h",
- "strings/string_piece_forward.h",
- "strings/string_split.cc",
- "strings/string_split.h",
- "strings/string_tokenizer.h",
- "strings/string_util.cc",
- "strings/string_util.h",
- "strings/string_util_constants.cc",
- "strings/string_util_win.h",
- "strings/stringize_macros.h",
- "strings/stringprintf.cc",
- "strings/stringprintf.h",
- "strings/sys_string_conversions.h",
- "strings/sys_string_conversions_mac.mm",
- "strings/sys_string_conversions_win.cc",
- "strings/utf_offset_string_conversions.cc",
- "strings/utf_offset_string_conversions.h",
- "strings/utf_string_conversion_utils.cc",
- "strings/utf_string_conversion_utils.h",
- "strings/utf_string_conversions.cc",
- "strings/utf_string_conversions.h",
- "supports_user_data.cc",
- "supports_user_data.h",
- "sync_socket.h",
- "sync_socket_win.cc",
- "synchronization/atomic_flag.cc",
- "synchronization/atomic_flag.h",
- "synchronization/cancellation_flag.h",
- "synchronization/condition_variable.h",
- "synchronization/condition_variable_win.cc",
- "synchronization/lock.cc",
- "synchronization/lock.h",
- "synchronization/lock_impl.h",
- "synchronization/lock_impl_win.cc",
- "synchronization/spin_wait.h",
- "synchronization/waitable_event.h",
- "synchronization/waitable_event_mac.cc",
- "synchronization/waitable_event_watcher.h",
- "synchronization/waitable_event_watcher_mac.cc",
- "synchronization/waitable_event_watcher_win.cc",
- "synchronization/waitable_event_win.cc",
- "sys_byteorder.h",
- "sys_info.cc",
- "sys_info.h",
- "sys_info_android.cc",
- "sys_info_chromeos.cc",
- "sys_info_internal.h",
- "syslog_logging.cc",
- "syslog_logging.h",
-
- #"sys_info_freebsd.cc", # Unused in Chromium build.
- "sys_info_ios.mm",
- "sys_info_linux.cc",
- "sys_info_mac.mm",
-
- #"sys_info_openbsd.cc", # Unused in Chromium build.
- "sys_info_win.cc",
- "system_monitor/system_monitor.cc",
- "system_monitor/system_monitor.h",
- "task/cancelable_task_tracker.cc",
- "task/cancelable_task_tracker.h",
- "task_runner.cc",
- "task_runner.h",
- "task_runner_util.h",
- "task_scheduler/can_schedule_sequence_observer.h",
- "task_scheduler/delayed_task_manager.cc",
- "task_scheduler/delayed_task_manager.h",
- "task_scheduler/environment_config.cc",
- "task_scheduler/environment_config.h",
- "task_scheduler/initialization_util.cc",
- "task_scheduler/initialization_util.h",
- "task_scheduler/lazy_task_runner.cc",
- "task_scheduler/lazy_task_runner.h",
- "task_scheduler/platform_native_worker_pool_win.cc",
- "task_scheduler/platform_native_worker_pool_win.h",
- "task_scheduler/post_task.cc",
- "task_scheduler/post_task.h",
- "task_scheduler/priority_queue.cc",
- "task_scheduler/priority_queue.h",
- "task_scheduler/scheduler_lock.h",
- "task_scheduler/scheduler_lock_impl.cc",
- "task_scheduler/scheduler_lock_impl.h",
- "task_scheduler/scheduler_single_thread_task_runner_manager.cc",
- "task_scheduler/scheduler_single_thread_task_runner_manager.h",
- "task_scheduler/scheduler_worker.cc",
- "task_scheduler/scheduler_worker.h",
- "task_scheduler/scheduler_worker_observer.h",
- "task_scheduler/scheduler_worker_params.h",
- "task_scheduler/scheduler_worker_pool.cc",
- "task_scheduler/scheduler_worker_pool.h",
- "task_scheduler/scheduler_worker_pool_impl.cc",
- "task_scheduler/scheduler_worker_pool_impl.h",
- "task_scheduler/scheduler_worker_pool_params.cc",
- "task_scheduler/scheduler_worker_pool_params.h",
- "task_scheduler/scheduler_worker_stack.cc",
- "task_scheduler/scheduler_worker_stack.h",
- "task_scheduler/scoped_set_task_priority_for_current_thread.cc",
- "task_scheduler/scoped_set_task_priority_for_current_thread.h",
- "task_scheduler/sequence.cc",
- "task_scheduler/sequence.h",
- "task_scheduler/sequence_sort_key.cc",
- "task_scheduler/sequence_sort_key.h",
- "task_scheduler/service_thread.cc",
- "task_scheduler/service_thread.h",
- "task_scheduler/single_thread_task_runner_thread_mode.h",
- "task_scheduler/task.cc",
- "task_scheduler/task.h",
- "task_scheduler/task_scheduler.cc",
- "task_scheduler/task_scheduler.h",
- "task_scheduler/task_scheduler_impl.cc",
- "task_scheduler/task_scheduler_impl.h",
- "task_scheduler/task_tracker.cc",
- "task_scheduler/task_tracker.h",
- "task_scheduler/task_traits.cc",
- "task_scheduler/task_traits.h",
- "task_scheduler/task_traits_details.h",
- "task_scheduler/tracked_ref.h",
- "template_util.h",
- "test/malloc_wrapper.h",
- "third_party/dmg_fp/dmg_fp.h",
- "third_party/dmg_fp/dtoa_wrapper.cc",
- "third_party/dmg_fp/g_fmt.cc",
- "third_party/icu/icu_utf.cc",
- "third_party/icu/icu_utf.h",
- "third_party/nspr/prtime.cc",
- "third_party/nspr/prtime.h",
- "third_party/superfasthash/superfasthash.c",
- "thread_annotations.h",
- "threading/platform_thread.h",
- "threading/platform_thread_android.cc",
- "threading/platform_thread_linux.cc",
- "threading/platform_thread_mac.mm",
- "threading/platform_thread_win.cc",
- "threading/post_task_and_reply_impl.cc",
- "threading/post_task_and_reply_impl.h",
- "threading/scoped_blocking_call.cc",
- "threading/scoped_blocking_call.h",
- "threading/sequence_local_storage_map.cc",
- "threading/sequence_local_storage_map.h",
- "threading/sequence_local_storage_slot.cc",
- "threading/sequence_local_storage_slot.h",
- "threading/sequenced_task_runner_handle.cc",
- "threading/sequenced_task_runner_handle.h",
- "threading/simple_thread.cc",
- "threading/simple_thread.h",
- "threading/thread.cc",
- "threading/thread.h",
- "threading/thread_checker.h",
- "threading/thread_checker_impl.cc",
- "threading/thread_checker_impl.h",
- "threading/thread_collision_warner.cc",
- "threading/thread_collision_warner.h",
- "threading/thread_id_name_manager.cc",
- "threading/thread_id_name_manager.h",
- "threading/thread_local.h",
- "threading/thread_local_storage.cc",
- "threading/thread_local_storage.h",
- "threading/thread_local_storage_win.cc",
- "threading/thread_restrictions.cc",
- "threading/thread_restrictions.h",
- "threading/thread_task_runner_handle.cc",
- "threading/thread_task_runner_handle.h",
- "threading/watchdog.cc",
- "threading/watchdog.h",
- "time/clock.cc",
- "time/clock.h",
- "time/default_clock.cc",
- "time/default_clock.h",
- "time/default_tick_clock.cc",
- "time/default_tick_clock.h",
- "time/tick_clock.cc",
- "time/tick_clock.h",
- "time/time.cc",
- "time/time.h",
- "time/time_override.cc",
- "time/time_override.h",
- "time/time_to_iso8601.cc",
- "time/time_to_iso8601.h",
- "timer/elapsed_timer.cc",
- "timer/elapsed_timer.h",
- "timer/hi_res_timer_manager.h",
- "timer/hi_res_timer_manager_win.cc",
- "timer/mock_timer.cc",
- "timer/mock_timer.h",
- "timer/timer.cc",
- "timer/timer.h",
- "trace_event/auto_open_close_event.cc",
- "trace_event/auto_open_close_event.h",
- "trace_event/blame_context.cc",
- "trace_event/blame_context.h",
- "trace_event/category_registry.cc",
- "trace_event/category_registry.h",
- "trace_event/common/trace_event_common.h",
- "trace_event/event_name_filter.cc",
- "trace_event/event_name_filter.h",
- "trace_event/heap_profiler.h",
- "trace_event/heap_profiler_allocation_context.cc",
- "trace_event/heap_profiler_allocation_context.h",
- "trace_event/heap_profiler_allocation_context_tracker.cc",
- "trace_event/heap_profiler_allocation_context_tracker.h",
- "trace_event/heap_profiler_event_filter.cc",
- "trace_event/heap_profiler_event_filter.h",
- "trace_event/heap_profiler_heap_dump_writer.cc",
- "trace_event/heap_profiler_heap_dump_writer.h",
- "trace_event/heap_profiler_serialization_state.cc",
- "trace_event/heap_profiler_serialization_state.h",
- "trace_event/heap_profiler_stack_frame_deduplicator.cc",
- "trace_event/heap_profiler_stack_frame_deduplicator.h",
- "trace_event/heap_profiler_type_name_deduplicator.cc",
- "trace_event/heap_profiler_type_name_deduplicator.h",
- "trace_event/java_heap_dump_provider_android.cc",
- "trace_event/java_heap_dump_provider_android.h",
- "trace_event/malloc_dump_provider.cc",
- "trace_event/malloc_dump_provider.h",
- "trace_event/memory_allocator_dump.cc",
- "trace_event/memory_allocator_dump.h",
- "trace_event/memory_allocator_dump_guid.cc",
- "trace_event/memory_allocator_dump_guid.h",
- "trace_event/memory_dump_manager.cc",
- "trace_event/memory_dump_manager.h",
- "trace_event/memory_dump_manager_test_utils.h",
- "trace_event/memory_dump_provider.h",
- "trace_event/memory_dump_provider_info.cc",
- "trace_event/memory_dump_provider_info.h",
- "trace_event/memory_dump_request_args.cc",
- "trace_event/memory_dump_request_args.h",
- "trace_event/memory_dump_scheduler.cc",
- "trace_event/memory_dump_scheduler.h",
- "trace_event/memory_infra_background_whitelist.cc",
- "trace_event/memory_infra_background_whitelist.h",
- "trace_event/memory_peak_detector.cc",
- "trace_event/memory_peak_detector.h",
- "trace_event/memory_usage_estimator.cc",
- "trace_event/memory_usage_estimator.h",
- "trace_event/process_memory_dump.cc",
- "trace_event/process_memory_dump.h",
- "trace_event/trace_buffer.cc",
- "trace_event/trace_buffer.h",
- "trace_event/trace_category.h",
- "trace_event/trace_config.cc",
- "trace_event/trace_config.h",
- "trace_event/trace_config_category_filter.cc",
- "trace_event/trace_config_category_filter.h",
- "trace_event/trace_event.h",
- "trace_event/trace_event_android.cc",
- "trace_event/trace_event_argument.cc",
- "trace_event/trace_event_argument.h",
- "trace_event/trace_event_etw_export_win.cc",
- "trace_event/trace_event_etw_export_win.h",
- "trace_event/trace_event_filter.cc",
- "trace_event/trace_event_filter.h",
- "trace_event/trace_event_impl.cc",
- "trace_event/trace_event_impl.h",
- "trace_event/trace_event_memory_overhead.cc",
- "trace_event/trace_event_memory_overhead.h",
- "trace_event/trace_event_system_stats_monitor.cc",
- "trace_event/trace_event_system_stats_monitor.h",
- "trace_event/trace_log.cc",
- "trace_event/trace_log.h",
- "trace_event/trace_log_constants.cc",
- "trace_event/tracing_agent.cc",
- "trace_event/tracing_agent.h",
- "tuple.h",
- "unguessable_token.cc",
- "unguessable_token.h",
- "value_conversions.cc",
- "value_conversions.h",
- "value_iterators.cc",
- "value_iterators.h",
- "values.cc",
- "values.h",
- "version.cc",
- "version.h",
- "vlog.cc",
- "vlog.h",
- "win/async_operation.h",
- "win/com_init_check_hook.cc",
- "win/com_init_check_hook.h",
- "win/com_init_util.cc",
- "win/com_init_util.h",
- "win/core_winrt_util.cc",
- "win/core_winrt_util.h",
- "win/current_module.h",
- "win/enum_variant.cc",
- "win/enum_variant.h",
- "win/event_trace_consumer.h",
- "win/event_trace_controller.cc",
- "win/event_trace_controller.h",
- "win/event_trace_provider.cc",
- "win/event_trace_provider.h",
- "win/i18n.cc",
- "win/i18n.h",
- "win/iat_patch_function.cc",
- "win/iat_patch_function.h",
- "win/iunknown_impl.cc",
- "win/iunknown_impl.h",
- "win/message_window.cc",
- "win/message_window.h",
- "win/object_watcher.cc",
- "win/object_watcher.h",
- "win/patch_util.cc",
- "win/patch_util.h",
- "win/process_startup_helper.cc",
- "win/process_startup_helper.h",
- "win/registry.cc",
- "win/registry.h",
- "win/resource_util.cc",
- "win/resource_util.h",
- "win/scoped_bstr.cc",
- "win/scoped_bstr.h",
- "win/scoped_co_mem.h",
- "win/scoped_com_initializer.cc",
- "win/scoped_com_initializer.h",
- "win/scoped_gdi_object.h",
- "win/scoped_handle.cc",
- "win/scoped_handle.h",
- "win/scoped_handle_verifier.cc",
- "win/scoped_handle_verifier.h",
- "win/scoped_hdc.h",
- "win/scoped_hglobal.h",
- "win/scoped_hstring.cc",
- "win/scoped_hstring.h",
- "win/scoped_process_information.cc",
- "win/scoped_process_information.h",
- "win/scoped_propvariant.h",
- "win/scoped_select_object.h",
- "win/scoped_variant.cc",
- "win/scoped_variant.h",
- "win/scoped_windows_thread_environment.h",
- "win/scoped_winrt_initializer.cc",
- "win/scoped_winrt_initializer.h",
- "win/shortcut.cc",
- "win/shortcut.h",
- "win/startup_information.cc",
- "win/startup_information.h",
- "win/typed_event_handler.h",
- "win/wait_chain.cc",
- "win/wait_chain.h",
- "win/win_util.cc",
- "win/win_util.h",
- "win/windows_version.cc",
- "win/windows_version.h",
- "win/winrt_storage_util.cc",
- "win/winrt_storage_util.h",
- "win/wrapped_window_proc.cc",
- "win/wrapped_window_proc.h",
- ]
-
- # winternl.h and NTSecAPI.h have different definitions of UNICODE_STRING.
- # There's only one client of NTSecAPI.h in base but several of winternl.h,
- # so exclude the NTSecAPI.h one.
- if (is_win) {
- jumbo_excluded_sources = [ "rand_util_win.cc" ]
- }
-
- if (is_posix) {
- sources += [
- "base_paths_posix.h",
- "debug/debugger_posix.cc",
- "debug/stack_trace_posix.cc",
- "file_descriptor_posix.h",
- "files/dir_reader_posix.h",
- "files/file_descriptor_watcher_posix.cc",
- "files/file_descriptor_watcher_posix.h",
- "files/file_enumerator_posix.cc",
- "files/file_posix.cc",
- "files/file_util_posix.cc",
- "files/memory_mapped_file_posix.cc",
- "memory/protected_memory_posix.cc",
- "message_loop/watchable_io_message_pump_posix.cc",
- "message_loop/watchable_io_message_pump_posix.h",
- "native_library_posix.cc",
- "posix/eintr_wrapper.h",
- "posix/file_descriptor_shuffle.cc",
- "posix/file_descriptor_shuffle.h",
- "posix/global_descriptors.cc",
- "posix/global_descriptors.h",
- "posix/safe_strerror.cc",
- "posix/safe_strerror.h",
- "posix/unix_domain_socket.cc",
- "posix/unix_domain_socket.h",
- "process/kill_posix.cc",
- "process/launch_posix.cc",
- "process/process_handle_posix.cc",
- "process/process_metrics_posix.cc",
- "process/process_posix.cc",
- "profiler/native_stack_sampler_posix.cc",
- "rand_util_posix.cc",
- "strings/string_util_posix.h",
- "strings/sys_string_conversions_posix.cc",
- "sync_socket_posix.cc",
- "synchronization/condition_variable_posix.cc",
- "synchronization/lock_impl_posix.cc",
- "synchronization/waitable_event_posix.cc",
- "synchronization/waitable_event_watcher_posix.cc",
- "sys_info_posix.cc",
- "task_scheduler/task_tracker_posix.cc",
- "task_scheduler/task_tracker_posix.h",
- "threading/platform_thread_internal_posix.cc",
- "threading/platform_thread_internal_posix.h",
- "threading/platform_thread_posix.cc",
- "threading/thread_local_storage_posix.cc",
- "timer/hi_res_timer_manager_posix.cc",
- ]
- }
-
- if (!is_nacl) {
- sources += [
- "base_paths.cc",
- "base_paths.h",
- "base_paths_android.cc",
- "base_paths_android.h",
- "base_paths_mac.h",
- "base_paths_mac.mm",
- "base_paths_posix.h",
- "base_paths_win.cc",
- "base_paths_win.h",
- "metrics/persistent_histogram_storage.cc",
- "metrics/persistent_histogram_storage.h",
- ]
-
- if (is_linux) {
- sources += [
- "base_paths_posix.cc",
- "debug/elf_reader_linux.cc",
- "debug/elf_reader_linux.h",
- ]
- }
- }
-
- all_dependent_configs = []
- defines = []
- data = []
- data_deps = []
-
- configs += [
- ":base_flags",
- ":base_implementation",
- "//build/config:precompiled_headers",
- "//build/config/compiler:noshadowing",
- ]
-
- deps = [
- "//base/allocator",
- "//base/allocator:buildflags",
- "//base/third_party/dynamic_annotations",
- "//third_party/modp_b64",
- ]
-
- public_deps = [
- ":anchor_functions_buildflags",
- ":base_static",
- ":build_date",
- ":cfi_buildflags",
- ":debugging_buildflags",
- ":partition_alloc_buildflags",
- ":protected_memory_buildflags",
- ":synchronization_buildflags",
- "//base/numerics:base_numerics",
- ]
-
- # Needed for <atomic> if using newer C++ library than sysroot, except if
- # building inside the cros_sdk environment - use host_toolchain as a
- # more robust check for this.
- if (!use_sysroot && (is_android || (is_linux && !is_chromecast)) &&
- host_toolchain != "//build/toolchain/cros:host") {
- libs = [ "atomic" ]
- }
-
- if (use_allocator_shim) {
- sources += [
- "allocator/allocator_shim.cc",
- "allocator/allocator_shim.h",
- "allocator/allocator_shim_internals.h",
- "allocator/allocator_shim_override_cpp_symbols.h",
- "allocator/allocator_shim_override_libc_symbols.h",
- ]
- if (is_win) {
- sources += [
- "allocator/allocator_shim_default_dispatch_to_winheap.cc",
- "allocator/allocator_shim_override_ucrt_symbols_win.h",
- "allocator/winheap_stubs_win.cc",
- "allocator/winheap_stubs_win.h",
- ]
- } else if (is_linux && use_allocator == "tcmalloc") {
- sources += [
- "allocator/allocator_shim_default_dispatch_to_tcmalloc.cc",
- "allocator/allocator_shim_override_glibc_weak_symbols.h",
- ]
- deps += [ "//base/allocator:tcmalloc" ]
- } else if (is_linux && use_allocator == "none") {
- sources += [ "allocator/allocator_shim_default_dispatch_to_glibc.cc" ]
- } else if (is_android && use_allocator == "none") {
- sources += [
- "allocator/allocator_shim_default_dispatch_to_linker_wrapped_symbols.cc",
- "allocator/allocator_shim_override_linker_wrapped_symbols.h",
- ]
- all_dependent_configs += [ "//base/allocator:wrap_malloc_symbols" ]
- } else if (is_mac) {
- sources += [
- "allocator/allocator_shim_default_dispatch_to_mac_zoned_malloc.cc",
- "allocator/allocator_shim_default_dispatch_to_mac_zoned_malloc.h",
- "allocator/allocator_shim_override_mac_symbols.h",
- ]
- }
- }
-
- # Allow more direct string conversions on platforms with native utf8
- # strings
- if (is_mac || is_ios || is_chromeos || is_chromecast || is_fuchsia) {
- defines += [ "SYSTEM_NATIVE_UTF8" ]
- }
-
- # Android.
- if (is_android) {
- sources -= [ "debug/stack_trace_posix.cc" ]
- sources += [
- "memory/platform_shared_memory_region_android.cc",
- "memory/shared_memory_android.cc",
- "memory/shared_memory_handle_android.cc",
- "time/time_android.cc",
- ]
-
- # Android uses some Linux sources, put those back.
- set_sources_assignment_filter([])
- sources += [
- "debug/elf_reader_linux.cc",
- "debug/elf_reader_linux.h",
- "debug/proc_maps_linux.cc",
- "debug/proc_maps_linux.h",
- "files/file_path_watcher_linux.cc",
- "power_monitor/power_monitor_device_source_android.cc",
- "process/internal_linux.cc",
- "process/internal_linux.h",
- "process/memory_linux.cc",
- "process/process_handle_linux.cc",
- "process/process_info_linux.cc",
- "process/process_iterator_linux.cc",
- "process/process_metrics_linux.cc",
- "sys_info_linux.cc",
- ]
- set_sources_assignment_filter(sources_assignment_filter)
-
- deps += [
- ":base_jni_headers",
- "//third_party/android_tools:cpu_features",
- "//third_party/ashmem",
- ]
-
- # TODO(thomasanderson): Remove this once use_custom_libcxx is always set to
- # true on Android.
- if (!use_custom_libcxx) {
- deps += [ "//buildtools/third_party/libc++abi:cxa_demangle_stub" ]
- }
-
- # Needs to be a public config so that dependent targets link against it as
- # well when doing a component build.
- public_configs = [ ":android_system_libs" ]
-
- if (can_unwind_with_cfi_table) {
- sources += [
- "trace_event/cfi_backtrace_android.cc",
- "trace_event/cfi_backtrace_android.h",
- ]
- }
-
- # This is actually a linker script, but it can be added to the link in the
- # same way as a library.
- libs = [ "android/library_loader/anchor_functions.lds" ]
- }
-
- # Chromeos.
- if (is_chromeos) {
- sources += [ "power_monitor/power_monitor_device_source_chromeos.cc" ]
- }
-
- # Fuchsia.
- if (is_fuchsia) {
- sources += [
- "base_paths_fuchsia.cc",
- "base_paths_fuchsia.h",
- "debug/debugger_posix.cc",
- "debug/stack_trace_fuchsia.cc",
- "file_descriptor_posix.h",
- "files/dir_reader_posix.h",
- "files/file_descriptor_watcher_posix.cc",
- "files/file_descriptor_watcher_posix.h",
- "files/file_enumerator_posix.cc",
- "files/file_path_watcher_fuchsia.cc",
- "files/file_posix.cc",
- "files/file_util_posix.cc",
- "files/memory_mapped_file_posix.cc",
- "fuchsia/async_dispatcher.cc",
- "fuchsia/async_dispatcher.h",
- "fuchsia/component_context.cc",
- "fuchsia/component_context.h",
- "fuchsia/default_job.cc",
- "fuchsia/default_job.h",
- "fuchsia/fidl_interface_request.cc",
- "fuchsia/fidl_interface_request.h",
- "fuchsia/fuchsia_logging.cc",
- "fuchsia/fuchsia_logging.h",
- "fuchsia/scoped_zx_handle.cc",
- "fuchsia/scoped_zx_handle.h",
- "fuchsia/services_directory.cc",
- "fuchsia/services_directory.h",
- "memory/platform_shared_memory_region_fuchsia.cc",
- "memory/protected_memory_posix.cc",
- "memory/shared_memory_fuchsia.cc",
- "memory/shared_memory_handle_fuchsia.cc",
- "message_loop/message_pump_fuchsia.cc",
- "message_loop/message_pump_fuchsia.h",
- "message_loop/watchable_io_message_pump_posix.cc",
- "message_loop/watchable_io_message_pump_posix.h",
- "native_library_fuchsia.cc",
- "posix/eintr_wrapper.h",
- "posix/file_descriptor_shuffle.cc",
- "posix/file_descriptor_shuffle.h",
- "posix/global_descriptors.cc",
- "posix/global_descriptors.h",
- "posix/safe_strerror.cc",
- "posix/safe_strerror.h",
- "process/kill_fuchsia.cc",
- "process/launch_fuchsia.cc",
- "process/memory_fuchsia.cc",
- "process/process_fuchsia.cc",
- "process/process_handle_fuchsia.cc",
- "process/process_iterator_fuchsia.cc",
- "process/process_metrics_fuchsia.cc",
- "process/process_metrics_posix.cc",
- "profiler/native_stack_sampler_posix.cc",
- "rand_util_fuchsia.cc",
- "strings/string_util_posix.h",
- "strings/sys_string_conversions_posix.cc",
- "sync_socket_posix.cc",
- "synchronization/condition_variable_posix.cc",
- "synchronization/lock_impl_posix.cc",
- "synchronization/waitable_event_posix.cc",
- "synchronization/waitable_event_watcher_posix.cc",
- "sys_info_fuchsia.cc",
- "sys_info_posix.cc",
- "task_scheduler/task_tracker_posix.cc",
- "task_scheduler/task_tracker_posix.h",
- "threading/platform_thread_fuchsia.cc",
- "threading/platform_thread_posix.cc",
- "threading/thread_local_storage_posix.cc",
- "time/time_conversion_posix.cc",
- "time/time_exploded_posix.cc",
- "time/time_fuchsia.cc",
- "timer/hi_res_timer_manager_posix.cc",
- ]
-
- # These only need to be public deps because of includes of their headers
- # by public //base headers, which requires they be on the include path.
- # TODO(https://crbug.com/841171): Move these back to |deps|.
- public_deps += [
- "//third_party/fuchsia-sdk:async",
- "//third_party/fuchsia-sdk:launchpad",
- ]
-
- deps += [
- "//third_party/fuchsia-sdk:async_default",
- "//third_party/fuchsia-sdk:fdio",
- "//third_party/fuchsia-sdk:fidl",
- "//third_party/fuchsia-sdk:svc",
- "//third_party/fuchsia-sdk:zx",
- ]
- }
-
- # NaCl.
- if (is_nacl) {
- # We reset sources_assignment_filter in order to explicitly include
- # the linux file (which would otherwise be filtered out).
- set_sources_assignment_filter([])
- sources += [
- "files/file_path_watcher_stub.cc",
- "memory/shared_memory_nacl.cc",
- "process/process_metrics_nacl.cc",
- "sync_socket_nacl.cc",
- "threading/platform_thread_linux.cc",
- ]
- set_sources_assignment_filter(sources_assignment_filter)
-
- sources -= [
- "cpu.cc",
- "debug/crash_logging.cc",
- "debug/crash_logging.h",
- "debug/stack_trace.cc",
- "debug/stack_trace_posix.cc",
- "files/file_enumerator_posix.cc",
- "files/file_proxy.cc",
- "files/important_file_writer.cc",
- "files/important_file_writer.h",
- "files/scoped_temp_dir.cc",
- "memory/discardable_memory.cc",
- "memory/discardable_memory.h",
- "memory/discardable_memory_allocator.cc",
- "memory/discardable_memory_allocator.h",
- "memory/discardable_shared_memory.cc",
- "memory/discardable_shared_memory.h",
- "memory/shared_memory_helper.cc",
- "memory/shared_memory_helper.h",
- "native_library.cc",
- "native_library_posix.cc",
- "path_service.cc",
- "process/kill.cc",
- "process/kill.h",
- "process/memory.cc",
- "process/memory.h",
- "process/process_iterator.cc",
- "process/process_iterator.h",
- "process/process_metrics.cc",
- "process/process_metrics_posix.cc",
- "process/process_posix.cc",
- "scoped_native_library.cc",
- "sync_socket_posix.cc",
- "sys_info.cc",
- "sys_info_posix.cc",
- "task_scheduler/initialization_util.cc",
- "task_scheduler/initialization_util.h",
- "trace_event/trace_event_system_stats_monitor.cc",
- ]
-
- if (is_nacl_nonsfi) {
- sources -= [ "rand_util_nacl.cc" ]
- configs += [ ":nacl_nonsfi_warnings" ]
- } else {
- sources -= [
- "files/file_descriptor_watcher_posix.cc",
- "files/file_descriptor_watcher_posix.h",
- "files/file_util.cc",
- "files/file_util.h",
- "files/file_util_posix.cc",
- "json/json_file_value_serializer.cc",
- "json/json_file_value_serializer.h",
- "posix/unix_domain_socket.cc",
- "process/kill_posix.cc",
- "process/launch.cc",
- "process/launch.h",
- "process/launch_posix.cc",
- "rand_util_posix.cc",
- "task_scheduler/task_tracker_posix.cc",
- "task_scheduler/task_tracker_posix.h",
- ]
- }
- } else {
- # Remove NaCl stuff.
- sources -= [
- "os_compat_nacl.cc",
- "os_compat_nacl.h",
- "rand_util_nacl.cc",
- ]
-
- if (use_partition_alloc) {
- # Add stuff that doesn't work in NaCl.
- sources += [
- # PartitionAlloc uses SpinLock, which doesn't work in NaCl (see below).
- "allocator/partition_allocator/address_space_randomization.cc",
- "allocator/partition_allocator/address_space_randomization.h",
- "allocator/partition_allocator/oom.h",
- "allocator/partition_allocator/page_allocator.cc",
- "allocator/partition_allocator/page_allocator.h",
- "allocator/partition_allocator/page_allocator_internal.h",
- "allocator/partition_allocator/partition_alloc.cc",
- "allocator/partition_allocator/partition_alloc.h",
- "allocator/partition_allocator/partition_alloc_constants.h",
- "allocator/partition_allocator/partition_bucket.cc",
- "allocator/partition_allocator/partition_bucket.h",
- "allocator/partition_allocator/partition_cookie.h",
- "allocator/partition_allocator/partition_direct_map_extent.h",
- "allocator/partition_allocator/partition_freelist_entry.h",
- "allocator/partition_allocator/partition_oom.cc",
- "allocator/partition_allocator/partition_oom.h",
- "allocator/partition_allocator/partition_page.cc",
- "allocator/partition_allocator/partition_page.h",
- "allocator/partition_allocator/partition_root_base.cc",
- "allocator/partition_allocator/partition_root_base.h",
- "allocator/partition_allocator/spin_lock.cc",
- "allocator/partition_allocator/spin_lock.h",
- ]
- if (is_win) {
- sources +=
- [ "allocator/partition_allocator/page_allocator_internals_win.h" ]
- } else if (is_posix || is_fuchsia) {
- sources +=
- [ "allocator/partition_allocator/page_allocator_internals_posix.h" ]
- }
- }
- }
-
- # Windows.
- if (is_win) {
- sources += [
- "memory/platform_shared_memory_region_win.cc",
- "memory/shared_memory_handle_win.cc",
- "memory/shared_memory_win.cc",
- "power_monitor/power_monitor_device_source_win.cc",
- "profiler/win32_stack_frame_unwinder.cc",
- "profiler/win32_stack_frame_unwinder.h",
- "time/time_win.cc",
- ]
-
- sources -= [
- "file_descriptor_store.cc",
- "file_descriptor_store.h",
- "memory/shared_memory_helper.cc",
- "memory/shared_memory_helper.h",
- "strings/string16.cc",
- ]
-
- deps += [
- "//base/trace_event/etw_manifest:chrome_events_win",
- "//base/win:base_win_buildflags",
- ]
-
- data_deps += [ "//build/win:runtime_libs" ]
-
- if (com_init_check_hook_disabled) {
- defines += [ "COM_INIT_CHECK_HOOK_DISABLED" ]
- }
-
- # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
- configs += [ "//build/config/compiler:no_size_t_to_int_warning" ]
-
- libs = [
- "cfgmgr32.lib",
- "powrprof.lib",
- "propsys.lib",
- "setupapi.lib",
- "userenv.lib",
- "winmm.lib",
- ]
- all_dependent_configs += [
- ":base_win_linker_flags",
- "//tools/win/DebugVisualizers:chrome",
- ]
- }
-
- # Desktop Mac.
- if (is_mac) {
- sources -= [ "profiler/native_stack_sampler_posix.cc" ]
- sources += [
- "mac/scoped_typeref.h",
- "memory/platform_shared_memory_region_mac.cc",
- "memory/shared_memory_handle_mac.cc",
- "memory/shared_memory_mac.cc",
- "power_monitor/power_monitor_device_source_mac.mm",
- "time/time_conversion_posix.cc",
- "time/time_exploded_posix.cc",
- "time/time_mac.cc",
- ]
-
- libs = [
- "ApplicationServices.framework",
- "AppKit.framework",
- "bsm",
- "CoreFoundation.framework",
- "IOKit.framework",
- "Security.framework",
- ]
- }
-
- # Mac or iOS.
- if (is_mac || is_ios) {
- sources -= [
- "native_library_posix.cc",
- "strings/sys_string_conversions_posix.cc",
- "synchronization/waitable_event_posix.cc",
- "synchronization/waitable_event_watcher_posix.cc",
- "threading/platform_thread_internal_posix.cc",
- ]
- } else {
- # Non-Mac/ios.
- sources -= [
- "files/file_path_watcher_fsevents.cc",
- "files/file_path_watcher_fsevents.h",
- "files/file_path_watcher_kqueue.cc",
- "files/file_path_watcher_kqueue.h",
- ]
- }
-
- # Linux.
- if (is_linux) {
- # TODO(brettw) this will need to be parameterized at some point.
- linux_configs = []
- if (use_glib) {
- linux_configs += [ "//build/config/linux:glib" ]
- }
-
- defines += [ "USE_SYMBOLIZE" ]
-
- configs += linux_configs
- all_dependent_configs += linux_configs
-
- # These dependencies are not required on Android, and in the case
- # of xdg_mime must be excluded due to licensing restrictions.
- deps += [
- "//base/third_party/symbolize",
- "//base/third_party/xdg_mime",
- "//base/third_party/xdg_user_dirs",
- ]
- } else {
- # Non-Linux.
- sources -= [
- "nix/mime_util_xdg.cc",
- "nix/mime_util_xdg.h",
- "nix/xdg_util.cc",
- "nix/xdg_util.h",
- ]
-
- if (!is_android) {
- sources -= [
- "linux_util.cc",
- "linux_util.h",
- ]
- }
- }
-
- # iOS
- if (is_ios) {
- set_sources_assignment_filter([])
-
- sources -= [
- "files/file_path_watcher.cc",
- "files/file_path_watcher.h",
- "files/file_path_watcher_fsevents.cc",
- "files/file_path_watcher_fsevents.h",
- "files/file_path_watcher_kqueue.cc",
- "files/file_path_watcher_kqueue.h",
- "memory/discardable_shared_memory.cc",
- "memory/discardable_shared_memory.h",
- "process/kill.cc",
- "process/kill.h",
- "process/kill_posix.cc",
- "process/launch.cc",
- "process/launch.h",
- "process/launch_posix.cc",
- "process/memory.cc",
- "process/memory.h",
- "process/process_iterator.cc",
- "process/process_iterator.h",
- "process/process_metrics_posix.cc",
- "process/process_posix.cc",
- "sync_socket.h",
- "sync_socket_posix.cc",
- "synchronization/waitable_event_watcher.h",
- ]
- sources += [
- "base_paths_mac.h",
- "base_paths_mac.mm",
- "file_version_info_mac.h",
- "file_version_info_mac.mm",
- "files/file_util_mac.mm",
- "mac/bundle_locations.h",
- "mac/bundle_locations.mm",
- "mac/call_with_eh_frame.cc",
- "mac/call_with_eh_frame.h",
- "mac/foundation_util.h",
- "mac/foundation_util.mm",
- "mac/mac_logging.h",
- "mac/mac_logging.mm",
- "mac/mach_logging.cc",
- "mac/mach_logging.h",
- "mac/objc_release_properties.h",
- "mac/objc_release_properties.mm",
- "mac/scoped_block.h",
- "mac/scoped_mach_port.cc",
- "mac/scoped_mach_port.h",
- "mac/scoped_mach_vm.cc",
- "mac/scoped_mach_vm.h",
- "mac/scoped_nsautorelease_pool.h",
- "mac/scoped_nsautorelease_pool.mm",
- "mac/scoped_nsobject.h",
- "mac/scoped_nsobject.mm",
- "mac/scoped_objc_class_swizzler.h",
- "mac/scoped_objc_class_swizzler.mm",
- "mac/scoped_typeref.h",
- "message_loop/message_pump_mac.h",
- "message_loop/message_pump_mac.mm",
- "power_monitor/power_monitor_device_source_ios.mm",
- "process/memory_stubs.cc",
- "strings/sys_string_conversions_mac.mm",
- "synchronization/waitable_event_mac.cc",
- "threading/platform_thread_mac.mm",
- "time/time_conversion_posix.cc",
- "time/time_mac.cc",
- ]
-
- set_sources_assignment_filter(sources_assignment_filter)
- }
-
- if (dep_libevent) {
- deps += [ "//base/third_party/libevent" ]
- }
-
- if (use_libevent) {
- sources += [
- "message_loop/message_pump_libevent.cc",
- "message_loop/message_pump_libevent.h",
- ]
- }
-
- # Android and MacOS have their own custom shared memory handle
- # implementations. e.g. due to supporting both POSIX and native handles.
- if (is_posix && !is_android && !is_mac) {
- sources += [
- "memory/platform_shared_memory_region_posix.cc",
- "memory/shared_memory_handle_posix.cc",
- ]
- }
-
- if (is_posix && !is_mac && !is_nacl) {
- sources += [ "memory/shared_memory_posix.cc" ]
- }
-
- if (is_posix && !is_mac && !is_ios) {
- sources += [
- "time/time_conversion_posix.cc",
- "time/time_exploded_posix.cc",
- "time/time_now_posix.cc",
- ]
- }
-
- if ((is_posix && !is_mac && !is_ios && !is_android && !is_chromeos) ||
- is_fuchsia) {
- sources += [ "power_monitor/power_monitor_device_source_stub.cc" ]
- }
-
- if (!use_glib) {
- sources -= [
- "message_loop/message_pump_glib.cc",
- "message_loop/message_pump_glib.h",
- ]
- }
-
- if (using_sanitizer) {
- data += [ "//tools/valgrind/asan/" ]
- if (is_win) {
- data +=
- [ "//third_party/llvm-build/Release+Asserts/bin/llvm-symbolizer.exe" ]
- } else {
- data += [ "//third_party/llvm-build/Release+Asserts/bin/llvm-symbolizer" ]
- }
- }
-
- configs += [ "//build/config/compiler:wexit_time_destructors" ]
- if (!is_debug) {
- configs -= [ "//build/config/compiler:default_optimization" ]
- configs += [ "//build/config/compiler:optimize_max" ]
- }
-}
-
-# Build flags for Control Flow Integrity
-# https://www.chromium.org/developers/testing/control-flow-integrity
-buildflag_header("cfi_buildflags") {
- header = "cfi_buildflags.h"
-
- # buildflag entries added to this header must also must be manually added to
- # tools/gn/bootstrap/bootstrap.py
- flags = [
- # TODO(pcc): remove CFI_CAST_CHECK, see https://crbug.com/626794.
- "CFI_CAST_CHECK=$is_cfi && $use_cfi_cast",
- "CFI_ICALL_CHECK=$is_cfi && $use_cfi_icall",
- "CFI_ENFORCEMENT_TRAP=$is_cfi && !$use_cfi_diag",
- "CFI_ENFORCEMENT_DIAGNOSTIC=$is_cfi && $use_cfi_diag && !$use_cfi_recover",
- ]
-}
-
-buildflag_header("debugging_buildflags") {
- header = "debugging_buildflags.h"
- header_dir = "base/debug"
-
- # buildflag entries added to this header must also must be manually added to
- # tools/gn/bootstrap/bootstrap.py
- flags = [
- "ENABLE_LOCATION_SOURCE=$enable_location_source",
- "ENABLE_PROFILING=$enable_profiling",
- "CAN_UNWIND_WITH_FRAME_POINTERS=$can_unwind_with_frame_pointers",
- "UNSAFE_DEVELOPER_BUILD=$is_unsafe_developer_build",
- "CAN_UNWIND_WITH_CFI_TABLE=$can_unwind_with_cfi_table",
- ]
-}
-
-# Build flags for ProtectedMemory, temporary workaround for crbug.com/792777
-# TODO(vtsyrklevich): Remove once support for gold on Android/CrOs is dropped
-buildflag_header("protected_memory_buildflags") {
- header = "protected_memory_buildflags.h"
- header_dir = "base/memory"
-
- # buildflag entries added to this header must also must be manually added to
- # tools/gn/bootstrap/bootstrap.py
- flags = [ "USE_LLD=$use_lld" ]
-}
-
-buildflag_header("synchronization_buildflags") {
- header = "synchronization_buildflags.h"
- header_dir = "base/synchronization"
-
- flags =
- [ "ENABLE_MUTEX_PRIORITY_INHERITANCE=$enable_mutex_priority_inheritance" ]
-}
-
-buildflag_header("anchor_functions_buildflags") {
- header = "anchor_functions_buildflags.h"
- header_dir = "base/android/library_loader"
- _supports_code_ordering = current_cpu == "arm"
-
- # buildflag entries added to this header must also must be manually added to
- # tools/gn/bootstrap/bootstrap.py
- flags = [
- "USE_LLD=$use_lld",
- "SUPPORTS_CODE_ORDERING=$_supports_code_ordering",
- ]
-}
-
-buildflag_header("partition_alloc_buildflags") {
- header = "partition_alloc_buildflags.h"
- header_dir = "base"
-
- flags = [ "USE_PARTITION_ALLOC=$use_partition_alloc" ]
-}
-
-# This is the subset of files from base that should not be used with a dynamic
-# library. Note that this library cannot depend on base because base depends on
-# base_static.
-static_library("base_static") {
- sources = [
- "base_switches.cc",
- "base_switches.h",
- ]
-
- if (is_win) {
- public_deps = [
- "//base/win:pe_image",
- ]
-
- # Disable sanitizer coverage in win/pe_image.cc. It is called by the sandbox
- # before sanitizer coverage can initialize. http://crbug.com/484711
- configs -= [ "//build/config/sanitizers:default_sanitizer_flags" ]
- configs +=
- [ "//build/config/sanitizers:default_sanitizer_flags_but_coverage" ]
- }
-
- if (!is_debug) {
- configs -= [ "//build/config/compiler:default_optimization" ]
- configs += [ "//build/config/compiler:optimize_max" ]
- }
-}
-
-component("i18n") {
- output_name = "base_i18n"
- sources = [
- "i18n/base_i18n_export.h",
- "i18n/base_i18n_switches.cc",
- "i18n/base_i18n_switches.h",
- "i18n/bidi_line_iterator.cc",
- "i18n/bidi_line_iterator.h",
- "i18n/break_iterator.cc",
- "i18n/break_iterator.h",
- "i18n/case_conversion.cc",
- "i18n/case_conversion.h",
- "i18n/char_iterator.cc",
- "i18n/char_iterator.h",
- "i18n/character_encoding.cc",
- "i18n/character_encoding.h",
- "i18n/encoding_detection.cc",
- "i18n/encoding_detection.h",
- "i18n/file_util_icu.cc",
- "i18n/file_util_icu.h",
- "i18n/i18n_constants.cc",
- "i18n/i18n_constants.h",
- "i18n/icu_string_conversions.cc",
- "i18n/icu_string_conversions.h",
- "i18n/icu_util.cc",
- "i18n/icu_util.h",
- "i18n/message_formatter.cc",
- "i18n/message_formatter.h",
- "i18n/number_formatting.cc",
- "i18n/number_formatting.h",
- "i18n/rtl.cc",
- "i18n/rtl.h",
- "i18n/streaming_utf8_validator.cc",
- "i18n/streaming_utf8_validator.h",
- "i18n/string_compare.cc",
- "i18n/string_compare.h",
- "i18n/string_search.cc",
- "i18n/string_search.h",
- "i18n/time_formatting.cc",
- "i18n/time_formatting.h",
- "i18n/timezone.cc",
- "i18n/timezone.h",
- "i18n/unicodestring.h",
- "i18n/utf8_validator_tables.cc",
- "i18n/utf8_validator_tables.h",
- ]
- defines = [ "BASE_I18N_IMPLEMENTATION" ]
- configs += [ "//build/config/compiler:wexit_time_destructors" ]
- public_deps = [
- "//third_party/ced",
- "//third_party/icu",
- ]
- deps = [
- ":base",
- "//base/third_party/dynamic_annotations",
- ]
-
- if (!is_debug) {
- configs -= [ "//build/config/compiler:default_optimization" ]
- configs += [ "//build/config/compiler:optimize_max" ]
- }
-
- # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
- configs += [ "//build/config/compiler:no_size_t_to_int_warning" ]
-
- if (is_mac) {
- libs = [ "CoreFoundation.framework" ]
- }
-}
-
-test("base_perftests") {
- sources = [
- "message_loop/message_loop_perftest.cc",
- "message_loop/message_pump_perftest.cc",
-
- # "test/run_all_unittests.cc",
- "json/json_perftest.cc",
- "synchronization/waitable_event_perftest.cc",
- "threading/thread_perftest.cc",
- ]
- deps = [
- ":base",
- "//base/test:test_support",
- "//base/test:test_support_perf",
- "//testing/gtest",
- "//testing/perf",
- ]
-
- if (is_android) {
- deps += [ "//testing/android/native_test:native_test_native_code" ]
- }
-}
-
-test("base_i18n_perftests") {
- sources = [
- "i18n/streaming_utf8_validator_perftest.cc",
- ]
- deps = [
- ":base",
- ":i18n",
- "//base/test:test_support",
- "//base/test:test_support_perf",
- "//testing/gtest",
- ]
-}
-
-if (!is_ios) {
- executable("build_utf8_validator_tables") {
- sources = [
- "i18n/build_utf8_validator_tables.cc",
- ]
- deps = [
- ":base",
- "//build/config:exe_and_shlib_deps",
- "//build/win:default_exe_manifest",
- "//third_party/icu:icuuc",
- ]
- }
-
- executable("check_example") {
- sources = [
- "check_example.cc",
- ]
- deps = [
- ":base",
- "//build/config:exe_and_shlib_deps",
- "//build/win:default_exe_manifest",
- ]
- }
-}
-
-if (is_win) {
- # Target to manually rebuild pe_image_test.dll which is checked into
- # base/test/data/pe_image.
- shared_library("pe_image_test") {
- sources = [
- "win/pe_image_test.cc",
- ]
- ldflags = [
- "/DELAYLOAD:cfgmgr32.dll",
- "/DELAYLOAD:shell32.dll",
- "/SUBSYSTEM:WINDOWS",
- ]
- libs = [
- "cfgmgr32.lib",
- "shell32.lib",
- ]
- deps = [
- "//build/config:exe_and_shlib_deps",
- ]
- }
-
- loadable_module("scoped_handle_test_dll") {
- sources = [
- "win/scoped_handle_test_dll.cc",
- ]
- deps = [
- ":base",
- "//base/win:base_win_buildflags",
- ]
- }
-}
-
-if (is_win || is_mac) {
- if (current_cpu == "x64") {
- # Must be a shared library so that it can be unloaded during testing.
- shared_library("base_profiler_test_support_library") {
- sources = [
- "profiler/test_support_library.cc",
- ]
- deps = [
- "//build/config:exe_and_shlib_deps",
- ]
- }
- }
-}
-
-bundle_data("base_unittests_bundle_data") {
- testonly = true
- sources = [
- "test/data/file_util/binary_file.bin",
- "test/data/file_util/binary_file_diff.bin",
- "test/data/file_util/binary_file_same.bin",
- "test/data/file_util/blank_line.txt",
- "test/data/file_util/blank_line_crlf.txt",
- "test/data/file_util/crlf.txt",
- "test/data/file_util/different.txt",
- "test/data/file_util/different_first.txt",
- "test/data/file_util/different_last.txt",
- "test/data/file_util/empty1.txt",
- "test/data/file_util/empty2.txt",
- "test/data/file_util/first1.txt",
- "test/data/file_util/first2.txt",
- "test/data/file_util/original.txt",
- "test/data/file_util/same.txt",
- "test/data/file_util/same_length.txt",
- "test/data/file_util/shortened.txt",
- "test/data/json/bom_feff.json",
- "test/data/serializer_nested_test.json",
- "test/data/serializer_test.json",
- "test/data/serializer_test_nowhitespace.json",
- ]
- outputs = [
- "{{bundle_resources_dir}}/" +
- "{{source_root_relative_dir}}/{{source_file_part}}",
- ]
-}
-
-if (is_ios || is_mac) {
- source_set("base_unittests_arc") {
- testonly = true
- set_sources_assignment_filter([])
- sources = [
- "mac/bind_objc_block_unittest_arc.mm",
- "mac/scoped_nsobject_unittest_arc.mm",
- ]
- set_sources_assignment_filter(sources_assignment_filter)
- configs += [ "//build/config/compiler:enable_arc" ]
- deps = [
- ":base",
- "//testing/gtest",
- ]
- }
-}
-
-if (is_fuchsia) {
- fidl_library("test_fidl") {
- namespace = "base.fuchsia"
- namespace_path = "base/fuchsia"
-
- sources = [
- "fuchsia/test.fidl",
- ]
- }
-}
-
-test("base_unittests") {
- sources = [
- "allocator/allocator_interception_mac_unittest.mm",
- "allocator/malloc_zone_functions_mac_unittest.cc",
- "allocator/tcmalloc_unittest.cc",
- "android/application_status_listener_unittest.cc",
- "android/content_uri_utils_unittest.cc",
- "android/jni_android_unittest.cc",
- "android/jni_array_unittest.cc",
- "android/jni_string_unittest.cc",
- "android/library_loader/library_prefetcher_unittest.cc",
- "android/path_utils_unittest.cc",
- "android/scoped_java_ref_unittest.cc",
- "android/sys_utils_unittest.cc",
- "android/unguessable_token_android_unittest.cc",
- "at_exit_unittest.cc",
- "atomicops_unittest.cc",
- "barrier_closure_unittest.cc",
- "base64_unittest.cc",
- "base64url_unittest.cc",
- "big_endian_unittest.cc",
- "bind_unittest.cc",
- "bit_cast_unittest.cc",
- "bits_unittest.cc",
- "build_time_unittest.cc",
- "callback_helpers_unittest.cc",
- "callback_list_unittest.cc",
- "callback_unittest.cc",
- "cancelable_callback_unittest.cc",
- "command_line_unittest.cc",
- "component_export_unittest.cc",
- "containers/adapters_unittest.cc",
- "containers/circular_deque_unittest.cc",
- "containers/flat_map_unittest.cc",
- "containers/flat_set_unittest.cc",
- "containers/flat_tree_unittest.cc",
- "containers/hash_tables_unittest.cc",
- "containers/id_map_unittest.cc",
- "containers/linked_list_unittest.cc",
- "containers/mru_cache_unittest.cc",
- "containers/small_map_unittest.cc",
- "containers/span_unittest.cc",
- "containers/stack_container_unittest.cc",
- "containers/unique_ptr_adapters_unittest.cc",
- "containers/vector_buffer_unittest.cc",
- "cpu_unittest.cc",
- "debug/activity_analyzer_unittest.cc",
- "debug/activity_tracker_unittest.cc",
- "debug/alias_unittest.cc",
- "debug/crash_logging_unittest.cc",
- "debug/debugger_unittest.cc",
- "debug/elf_reader_linux_unittest.cc",
- "debug/leak_tracker_unittest.cc",
- "debug/proc_maps_linux_unittest.cc",
- "debug/stack_trace_unittest.cc",
- "debug/task_annotator_unittest.cc",
- "debug/thread_heap_usage_tracker_unittest.cc",
- "deferred_sequenced_task_runner_unittest.cc",
- "environment_unittest.cc",
- "feature_list_unittest.cc",
- "file_version_info_win_unittest.cc",
- "files/file_enumerator_unittest.cc",
- "files/file_path_unittest.cc",
- "files/file_path_watcher_unittest.cc",
- "files/file_proxy_unittest.cc",
- "files/file_unittest.cc",
- "files/file_util_unittest.cc",
- "files/important_file_writer_unittest.cc",
- "files/memory_mapped_file_unittest.cc",
- "files/scoped_temp_dir_unittest.cc",
- "gmock_unittest.cc",
- "guid_unittest.cc",
- "hash_unittest.cc",
- "i18n/bidi_line_iterator_unittest.cc",
- "i18n/break_iterator_unittest.cc",
- "i18n/case_conversion_unittest.cc",
- "i18n/char_iterator_unittest.cc",
- "i18n/character_encoding_unittest.cc",
- "i18n/file_util_icu_unittest.cc",
- "i18n/icu_string_conversions_unittest.cc",
- "i18n/message_formatter_unittest.cc",
- "i18n/number_formatting_unittest.cc",
- "i18n/rtl_unittest.cc",
- "i18n/streaming_utf8_validator_unittest.cc",
- "i18n/string_search_unittest.cc",
- "i18n/time_formatting_unittest.cc",
- "i18n/timezone_unittest.cc",
- "ios/crb_protocol_observers_unittest.mm",
- "ios/device_util_unittest.mm",
- "ios/weak_nsobject_unittest.mm",
- "json/json_parser_unittest.cc",
- "json/json_reader_unittest.cc",
- "json/json_value_converter_unittest.cc",
- "json/json_value_serializer_unittest.cc",
- "json/json_writer_unittest.cc",
- "json/string_escape_unittest.cc",
- "lazy_instance_unittest.cc",
- "logging_unittest.cc",
- "mac/bind_objc_block_unittest.mm",
- "mac/call_with_eh_frame_unittest.mm",
- "mac/dispatch_source_mach_unittest.cc",
- "mac/foundation_util_unittest.mm",
- "mac/mac_util_unittest.mm",
- "mac/mach_port_broker_unittest.cc",
- "mac/objc_release_properties_unittest.mm",
- "mac/scoped_nsobject_unittest.mm",
- "mac/scoped_objc_class_swizzler_unittest.mm",
- "mac/scoped_sending_event_unittest.mm",
- "md5_unittest.cc",
- "memory/aligned_memory_unittest.cc",
- "memory/discardable_shared_memory_unittest.cc",
- "memory/linked_ptr_unittest.cc",
- "memory/memory_coordinator_client_registry_unittest.cc",
- "memory/memory_pressure_listener_unittest.cc",
- "memory/memory_pressure_monitor_chromeos_unittest.cc",
- "memory/memory_pressure_monitor_mac_unittest.cc",
- "memory/memory_pressure_monitor_unittest.cc",
- "memory/memory_pressure_monitor_win_unittest.cc",
- "memory/platform_shared_memory_region_unittest.cc",
- "memory/protected_memory_unittest.cc",
- "memory/ptr_util_unittest.cc",
- "memory/ref_counted_memory_unittest.cc",
- "memory/ref_counted_unittest.cc",
- "memory/shared_memory_mac_unittest.cc",
- "memory/shared_memory_region_unittest.cc",
- "memory/shared_memory_unittest.cc",
- "memory/shared_memory_win_unittest.cc",
- "memory/singleton_unittest.cc",
- "memory/weak_ptr_unittest.cc",
- "message_loop/message_loop_task_runner_unittest.cc",
- "message_loop/message_loop_unittest.cc",
- "message_loop/message_pump_glib_unittest.cc",
- "message_loop/message_pump_io_ios_unittest.cc",
- "message_loop/message_pump_mac_unittest.mm",
- "metrics/bucket_ranges_unittest.cc",
- "metrics/field_trial_params_unittest.cc",
- "metrics/field_trial_unittest.cc",
- "metrics/histogram_base_unittest.cc",
- "metrics/histogram_delta_serialization_unittest.cc",
- "metrics/histogram_functions_unittest.cc",
- "metrics/histogram_macros_unittest.cc",
- "metrics/histogram_samples_unittest.cc",
- "metrics/histogram_snapshot_manager_unittest.cc",
- "metrics/histogram_unittest.cc",
- "metrics/metrics_hashes_unittest.cc",
- "metrics/persistent_histogram_allocator_unittest.cc",
- "metrics/persistent_histogram_storage_unittest.cc",
- "metrics/persistent_memory_allocator_unittest.cc",
- "metrics/persistent_sample_map_unittest.cc",
- "metrics/sample_map_unittest.cc",
- "metrics/sample_vector_unittest.cc",
- "metrics/single_sample_metrics_unittest.cc",
- "metrics/sparse_histogram_unittest.cc",
- "metrics/statistics_recorder_unittest.cc",
- "native_library_unittest.cc",
- "no_destructor_unittest.cc",
- "observer_list_unittest.cc",
- "optional_unittest.cc",
- "os_compat_android_unittest.cc",
- "path_service_unittest.cc",
- "pickle_unittest.cc",
- "power_monitor/power_monitor_unittest.cc",
- "process/launch_unittest_win.cc",
- "process/memory_unittest.cc",
- "process/memory_unittest_mac.h",
- "process/memory_unittest_mac.mm",
- "process/process_info_unittest.cc",
- "process/process_metrics_unittest.cc",
- "process/process_unittest.cc",
- "process/process_util_unittest.cc",
- "profiler/stack_sampling_profiler_unittest.cc",
- "rand_util_unittest.cc",
- "run_loop_unittest.cc",
- "safe_numerics_unittest.cc",
- "scoped_clear_errno_unittest.cc",
- "scoped_generic_unittest.cc",
- "scoped_native_library_unittest.cc",
- "security_unittest.cc",
- "sequence_checker_unittest.cc",
- "sequence_token_unittest.cc",
- "sequenced_task_runner_unittest.cc",
- "sha1_unittest.cc",
- "stl_util_unittest.cc",
- "strings/char_traits_unittest.cc",
- "strings/nullable_string16_unittest.cc",
- "strings/pattern_unittest.cc",
- "strings/safe_sprintf_unittest.cc",
- "strings/strcat_unittest.cc",
- "strings/string16_unittest.cc",
- "strings/string_number_conversions_unittest.cc",
- "strings/string_piece_unittest.cc",
- "strings/string_split_unittest.cc",
- "strings/string_tokenizer_unittest.cc",
- "strings/string_util_unittest.cc",
- "strings/stringize_macros_unittest.cc",
- "strings/stringprintf_unittest.cc",
- "strings/sys_string_conversions_mac_unittest.mm",
- "strings/sys_string_conversions_unittest.cc",
- "strings/utf_offset_string_conversions_unittest.cc",
- "strings/utf_string_conversions_unittest.cc",
- "supports_user_data_unittest.cc",
- "sync_socket_unittest.cc",
- "synchronization/atomic_flag_unittest.cc",
- "synchronization/condition_variable_unittest.cc",
- "synchronization/lock_unittest.cc",
- "synchronization/waitable_event_unittest.cc",
- "synchronization/waitable_event_watcher_unittest.cc",
- "sys_byteorder_unittest.cc",
- "sys_info_unittest.cc",
- "system_monitor/system_monitor_unittest.cc",
- "task/cancelable_task_tracker_unittest.cc",
- "task_runner_util_unittest.cc",
- "task_scheduler/delayed_task_manager_unittest.cc",
- "task_scheduler/lazy_task_runner_unittest.cc",
- "task_scheduler/priority_queue_unittest.cc",
- "task_scheduler/scheduler_lock_unittest.cc",
- "task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc",
- "task_scheduler/scheduler_worker_pool_impl_unittest.cc",
- "task_scheduler/scheduler_worker_pool_unittest.cc",
- "task_scheduler/scheduler_worker_stack_unittest.cc",
- "task_scheduler/scheduler_worker_unittest.cc",
- "task_scheduler/scoped_set_task_priority_for_current_thread_unittest.cc",
- "task_scheduler/sequence_sort_key_unittest.cc",
- "task_scheduler/sequence_unittest.cc",
- "task_scheduler/service_thread_unittest.cc",
- "task_scheduler/task_scheduler_impl_unittest.cc",
- "task_scheduler/task_tracker_unittest.cc",
- "task_scheduler/task_traits_unittest.cc",
- "task_scheduler/task_unittest.cc",
- "task_scheduler/test_task_factory.cc",
- "task_scheduler/test_task_factory.h",
- "task_scheduler/test_utils.cc",
- "task_scheduler/test_utils.h",
- "task_scheduler/tracked_ref_unittest.cc",
- "template_util_unittest.cc",
- "test/histogram_tester_unittest.cc",
- "test/mock_callback_unittest.cc",
- "test/scoped_feature_list_unittest.cc",
- "test/scoped_mock_time_message_loop_task_runner_unittest.cc",
- "test/scoped_task_environment_unittest.cc",
- "test/test_mock_time_task_runner_unittest.cc",
- "test/test_pending_task_unittest.cc",
- "test/test_reg_util_win_unittest.cc",
- "test/trace_event_analyzer_unittest.cc",
- "test/user_action_tester_unittest.cc",
- "thread_annotations_unittest.cc",
- "threading/platform_thread_unittest.cc",
- "threading/post_task_and_reply_impl_unittest.cc",
- "threading/scoped_blocking_call_unittest.cc",
- "threading/sequence_local_storage_map_unittest.cc",
- "threading/sequence_local_storage_slot_unittest.cc",
- "threading/sequenced_task_runner_handle_unittest.cc",
- "threading/simple_thread_unittest.cc",
- "threading/thread_checker_unittest.cc",
- "threading/thread_collision_warner_unittest.cc",
- "threading/thread_id_name_manager_unittest.cc",
- "threading/thread_local_storage_unittest.cc",
- "threading/thread_local_unittest.cc",
- "threading/thread_restrictions_unittest.cc",
- "threading/thread_task_runner_handle_unittest.cc",
- "threading/thread_unittest.cc",
- "threading/watchdog_unittest.cc",
- "time/pr_time_unittest.cc",
- "time/time_unittest.cc",
- "time/time_win_unittest.cc",
- "timer/hi_res_timer_manager_unittest.cc",
- "timer/mock_timer_unittest.cc",
- "timer/timer_unittest.cc",
- "tools_sanity_unittest.cc",
- "trace_event/blame_context_unittest.cc",
- "trace_event/event_name_filter_unittest.cc",
- "trace_event/heap_profiler_allocation_context_tracker_unittest.cc",
- "trace_event/heap_profiler_heap_dump_writer_unittest.cc",
- "trace_event/heap_profiler_stack_frame_deduplicator_unittest.cc",
- "trace_event/heap_profiler_type_name_deduplicator_unittest.cc",
- "trace_event/java_heap_dump_provider_android_unittest.cc",
- "trace_event/memory_allocator_dump_unittest.cc",
- "trace_event/memory_dump_manager_unittest.cc",
- "trace_event/memory_dump_scheduler_unittest.cc",
- "trace_event/memory_peak_detector_unittest.cc",
- "trace_event/memory_usage_estimator_unittest.cc",
- "trace_event/process_memory_dump_unittest.cc",
- "trace_event/trace_category_unittest.cc",
- "trace_event/trace_config_unittest.cc",
- "trace_event/trace_event_argument_unittest.cc",
- "trace_event/trace_event_filter_test_utils.cc",
- "trace_event/trace_event_filter_test_utils.h",
- "trace_event/trace_event_system_stats_monitor_unittest.cc",
- "trace_event/trace_event_unittest.cc",
- "tuple_unittest.cc",
- "unguessable_token_unittest.cc",
- "value_iterators_unittest.cc",
- "values_unittest.cc",
- "version_unittest.cc",
- "vlog_unittest.cc",
- "win/async_operation_unittest.cc",
- "win/com_init_check_hook_unittest.cc",
- "win/com_init_util_unittest.cc",
- "win/core_winrt_util_unittest.cc",
- "win/dllmain.cc",
- "win/enum_variant_unittest.cc",
- "win/event_trace_consumer_unittest.cc",
- "win/event_trace_controller_unittest.cc",
- "win/event_trace_provider_unittest.cc",
- "win/i18n_unittest.cc",
- "win/iunknown_impl_unittest.cc",
- "win/message_window_unittest.cc",
- "win/object_watcher_unittest.cc",
- "win/pe_image_unittest.cc",
- "win/registry_unittest.cc",
- "win/scoped_bstr_unittest.cc",
- "win/scoped_handle_unittest.cc",
- "win/scoped_hstring_unittest.cc",
- "win/scoped_process_information_unittest.cc",
- "win/scoped_variant_unittest.cc",
- "win/scoped_winrt_initializer_unittest.cc",
- "win/shortcut_unittest.cc",
- "win/startup_information_unittest.cc",
- "win/typed_event_handler_unittest.cc",
- "win/wait_chain_unittest.cc",
- "win/win_includes_unittest.cc",
- "win/win_util_unittest.cc",
- "win/windows_version_unittest.cc",
- "win/winrt_storage_util_unittest.cc",
- "win/wrapped_window_proc_unittest.cc",
- ]
-
- defines = []
-
- deps = [
- ":base",
- ":i18n",
- "//base/allocator:buildflags",
- "//base/test:native_library_test_utils",
- "//base/test:run_all_base_unittests",
- "//base/test:test_support",
- "//base/third_party/dynamic_annotations",
- "//testing/gmock",
- "//testing/gtest",
- "//third_party/icu",
- ]
-
- data_deps = [
- "//base/test:test_child_process",
- "//base/test:test_shared_library",
- ]
-
- if (is_ios || is_mac) {
- deps += [ ":base_unittests_arc" ]
- }
-
- public_deps = [
- ":base_unittests_bundle_data",
- ]
-
- data = [
- "test/data/",
- ]
-
- if (is_posix) {
- sources += [
- "files/dir_reader_posix_unittest.cc",
- "files/file_descriptor_watcher_posix_unittest.cc",
- "message_loop/message_loop_io_posix_unittest.cc",
- "posix/file_descriptor_shuffle_unittest.cc",
- "posix/unix_domain_socket_unittest.cc",
- "task_scheduler/task_tracker_posix_unittest.cc",
- ]
- }
-
- # Allow more direct string conversions on platforms with native utf8
- # strings
- if (is_mac || is_ios || is_chromeos || is_chromecast || is_fuchsia) {
- defines += [ "SYSTEM_NATIVE_UTF8" ]
- }
-
- if (is_android) {
- # Add unwind tables in base_unittests_apk test apk. The unwind tables are
- # generated from debug info in the binary. Removing "default_symbols" and
- # adding symbols config removes the "strip_debug" config that strips the
- # debug info, on base unittests apk.
- if (can_unwind_with_cfi_table) {
- configs -= [ "//build/config/compiler:default_symbols" ]
- if (symbol_level == 2) {
- configs += [ "//build/config/compiler:symbols" ]
- } else {
- configs += [ "//build/config/compiler:minimal_symbols" ]
- }
- add_unwind_tables_in_apk = true
- sources += [ "trace_event/cfi_backtrace_android_unittest.cc" ]
- }
- sources -= [
- "process/process_unittest.cc",
- "process/process_util_unittest.cc",
- ]
- deps += [
- ":base_java",
- ":base_java_unittest_support",
- "//base/test:test_support_java",
- ]
- }
-
- if (is_ios) {
- sources -= [
- "files/file_path_watcher_unittest.cc",
- "memory/discardable_shared_memory_unittest.cc",
- "memory/shared_memory_unittest.cc",
- "process/memory_unittest.cc",
- "process/process_unittest.cc",
- "process/process_util_unittest.cc",
- "sync_socket_unittest.cc",
- "synchronization/waitable_event_watcher_unittest.cc",
- ]
-
- # Pull in specific Mac files for iOS (which have been filtered out by file
- # name rules).
- set_sources_assignment_filter([])
- sources += [
- "mac/bind_objc_block_unittest.mm",
- "mac/foundation_util_unittest.mm",
- "mac/objc_release_properties_unittest.mm",
- "mac/scoped_nsobject_unittest.mm",
- "strings/sys_string_conversions_mac_unittest.mm",
- ]
- set_sources_assignment_filter(sources_assignment_filter)
-
- # TODO(GYP): dep on copy_test_data_ios action.
- }
-
- if (use_partition_alloc) {
- sources += [
- "allocator/partition_allocator/address_space_randomization_unittest.cc",
- "allocator/partition_allocator/page_allocator_unittest.cc",
- "allocator/partition_allocator/partition_alloc_unittest.cc",
- "allocator/partition_allocator/spin_lock_unittest.cc",
- ]
- }
-
- if (is_mac) {
- libs = [
- "CoreFoundation.framework",
- "Foundation.framework",
- ]
- if (current_cpu == "x64") {
- data_deps += [ ":base_profiler_test_support_library" ]
- }
- }
-
- if (is_linux) {
- if (is_desktop_linux) {
- sources += [ "nix/xdg_util_unittest.cc" ]
- }
-
- deps += [ "//base/test:malloc_wrapper" ]
- defines += [
- # This library is used by ElfReaderTest to test reading elf files.
- "MALLOC_WRAPPER_LIB=\"${shlib_prefix}malloc_wrapper${shlib_extension}\"",
- ]
-
- if (!is_component_build) {
- # Set rpath to find libmalloc_wrapper.so even in a non-component build.
- configs += [ "//build/config/gcc:rpath_for_built_shared_libraries" ]
- }
- }
-
- if (!use_glib) {
- sources -= [ "message_loop/message_pump_glib_unittest.cc" ]
- }
-
- if (use_libevent) {
- sources += [ "message_loop/message_pump_libevent_unittest.cc" ]
- deps += [ "//base/third_party/libevent" ]
- }
-
- if (is_fuchsia) {
- sources += [
- "files/dir_reader_posix_unittest.cc",
- "files/file_descriptor_watcher_posix_unittest.cc",
- "fuchsia/services_directory_unittest.cc",
- "message_loop/message_loop_io_posix_unittest.cc",
- "posix/file_descriptor_shuffle_unittest.cc",
- "task_scheduler/task_tracker_posix_unittest.cc",
- ]
-
- sources += [ "fuchsia/async_dispatcher_unittest.cc" ]
- deps += [
- ":test_fidl",
- "//third_party/fuchsia-sdk:async",
- "//third_party/fuchsia-sdk:async_default",
- "//third_party/fuchsia-sdk:fdio",
- ]
- }
-
- if (!is_fuchsia && !is_ios) {
- sources += [ "files/file_locking_unittest.cc" ]
- }
-
- if (is_android) {
- deps += [ "//testing/android/native_test:native_test_native_code" ]
- set_sources_assignment_filter([])
- sources += [
- "debug/elf_reader_linux_unittest.cc",
- "debug/proc_maps_linux_unittest.cc",
- "trace_event/trace_event_android_unittest.cc",
- ]
- set_sources_assignment_filter(sources_assignment_filter)
- }
-
- if (is_win) {
- deps += [ "//base:scoped_handle_test_dll" ]
- if (current_cpu == "x64") {
- sources += [ "profiler/win32_stack_frame_unwinder_unittest.cc" ]
- data_deps += [ ":base_profiler_test_support_library" ]
- }
- }
-
- if (use_allocator_shim) {
- sources += [
- "allocator/allocator_shim_unittest.cc",
- "sampling_heap_profiler/sampling_heap_profiler_unittest.cc",
- ]
- }
-
- # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
- configs += [ "//build/config/compiler:no_size_t_to_int_warning" ]
-
- # Symbols for crashes when running tests on swarming.
- if (symbol_level > 0) {
- if (is_win) {
- data += [ "$root_out_dir/base_unittests.exe.pdb" ]
- } else if (is_mac) {
- # TODO(crbug.com/330301): make this conditional on mac_strip_release.
- # data += [ "$root_out_dir/base_unittests.dSYM/" ]
- }
- }
-}
-
-action("build_date") {
- script = "//build/write_build_date_header.py"
-
- # Force recalculation if there's been a change.
- inputs = [
- "//build/util/LASTCHANGE",
- ]
- outputs = [
- "$target_gen_dir/generated_build_date.h",
- ]
-
- args =
- [ rebase_path("$target_gen_dir/generated_build_date.h", root_build_dir) ]
-
- if (is_official_build) {
- args += [ "official" ]
- } else {
- args += [ "default" ]
- }
-
- if (override_build_date != "N/A") {
- args += [ override_build_date ]
- }
-}
-
-if (enable_nocompile_tests) {
- nocompile_test("base_nocompile_tests") {
- sources = [
- "bind_unittest.nc",
- "callback_list_unittest.nc",
- "callback_unittest.nc",
- "containers/span_unittest.nc",
- "memory/ref_counted_unittest.nc",
- "memory/weak_ptr_unittest.nc",
- "metrics/field_trial_params_unittest.nc",
- "metrics/histogram_unittest.nc",
- "optional_unittest.nc",
- "strings/string16_unittest.nc",
- "task_scheduler/task_traits_unittest.nc",
- "thread_annotations_unittest.nc",
- ]
-
- deps = [
- ":base",
- "//base/test:run_all_unittests",
- "//testing/gtest",
- ]
- }
-}
-
-if (is_android) {
- generate_jni("base_jni_headers") {
- sources = [
- "android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java",
- "android/java/src/org/chromium/base/ApkAssets.java",
- "android/java/src/org/chromium/base/ApplicationStatus.java",
- "android/java/src/org/chromium/base/BuildInfo.java",
- "android/java/src/org/chromium/base/Callback.java",
- "android/java/src/org/chromium/base/CommandLine.java",
- "android/java/src/org/chromium/base/ContentUriUtils.java",
- "android/java/src/org/chromium/base/CpuFeatures.java",
- "android/java/src/org/chromium/base/EarlyTraceEvent.java",
- "android/java/src/org/chromium/base/EventLog.java",
- "android/java/src/org/chromium/base/FieldTrialList.java",
- "android/java/src/org/chromium/base/ImportantFileWriterAndroid.java",
- "android/java/src/org/chromium/base/JNIUtils.java",
- "android/java/src/org/chromium/base/JavaExceptionReporter.java",
- "android/java/src/org/chromium/base/JavaHandlerThread.java",
- "android/java/src/org/chromium/base/LocaleUtils.java",
- "android/java/src/org/chromium/base/MemoryPressureListener.java",
- "android/java/src/org/chromium/base/PathService.java",
- "android/java/src/org/chromium/base/PathUtils.java",
- "android/java/src/org/chromium/base/PowerMonitor.java",
- "android/java/src/org/chromium/base/SysUtils.java",
- "android/java/src/org/chromium/base/SystemMessageHandler.java",
- "android/java/src/org/chromium/base/ThreadUtils.java",
- "android/java/src/org/chromium/base/ThrowUncaughtException.java",
- "android/java/src/org/chromium/base/TimeUtils.java",
- "android/java/src/org/chromium/base/TimezoneUtils.java",
- "android/java/src/org/chromium/base/TraceEvent.java",
- "android/java/src/org/chromium/base/UnguessableToken.java",
- "android/java/src/org/chromium/base/library_loader/LibraryLoader.java",
- "android/java/src/org/chromium/base/metrics/RecordHistogram.java",
- "android/java/src/org/chromium/base/metrics/RecordUserAction.java",
- "android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java",
- "android/java/src/org/chromium/base/process_launcher/ChildProcessService.java",
- ]
-
- public_deps = [
- ":android_runtime_jni_headers",
- ]
-
- jni_package = "base"
- }
-
- generate_jar_jni("android_runtime_jni_headers") {
- jni_package = "base"
- classes = [ "java/lang/Runtime.class" ]
- }
-
- android_library("base_java") {
- srcjar_deps = [
- ":base_android_java_enums_srcjar",
- ":base_build_config_gen",
- ":base_java_aidl",
- ":base_native_libraries_gen",
- ]
-
- deps = [
- "//third_party/android_tools:android_support_annotations_java",
- "//third_party/android_tools:android_support_multidex_java",
- "//third_party/android_tools:android_support_v4_java",
- "//third_party/jsr-305:jsr_305_javalib",
- ]
-
- java_files = [
- "android/java/src/org/chromium/base/ActivityState.java",
- "android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java",
- "android/java/src/org/chromium/base/ApiCompatibilityUtils.java",
- "android/java/src/org/chromium/base/ApkAssets.java",
- "android/java/src/org/chromium/base/ApplicationStatus.java",
- "android/java/src/org/chromium/base/BaseSwitches.java",
- "android/java/src/org/chromium/base/BuildInfo.java",
- "android/java/src/org/chromium/base/Callback.java",
- "android/java/src/org/chromium/base/CollectionUtil.java",
- "android/java/src/org/chromium/base/CommandLine.java",
- "android/java/src/org/chromium/base/CommandLineInitUtil.java",
- "android/java/src/org/chromium/base/ContentUriUtils.java",
- "android/java/src/org/chromium/base/ContextUtils.java",
- "android/java/src/org/chromium/base/CpuFeatures.java",
- "android/java/src/org/chromium/base/DiscardableReferencePool.java",
- "android/java/src/org/chromium/base/EarlyTraceEvent.java",
- "android/java/src/org/chromium/base/EventLog.java",
- "android/java/src/org/chromium/base/FieldTrialList.java",
- "android/java/src/org/chromium/base/FileUtils.java",
- "android/java/src/org/chromium/base/ImportantFileWriterAndroid.java",
- "android/java/src/org/chromium/base/JNIUtils.java",
- "android/java/src/org/chromium/base/JavaExceptionReporter.java",
- "android/java/src/org/chromium/base/JavaHandlerThread.java",
- "android/java/src/org/chromium/base/LocaleUtils.java",
- "android/java/src/org/chromium/base/Log.java",
- "android/java/src/org/chromium/base/MemoryPressureListener.java",
- "android/java/src/org/chromium/base/NonThreadSafe.java",
- "android/java/src/org/chromium/base/ObserverList.java",
- "android/java/src/org/chromium/base/PackageUtils.java",
- "android/java/src/org/chromium/base/PathService.java",
- "android/java/src/org/chromium/base/PathUtils.java",
- "android/java/src/org/chromium/base/PowerMonitor.java",
- "android/java/src/org/chromium/base/Promise.java",
- "android/java/src/org/chromium/base/ResourceExtractor.java",
- "android/java/src/org/chromium/base/SecureRandomInitializer.java",
- "android/java/src/org/chromium/base/StreamUtil.java",
- "android/java/src/org/chromium/base/StrictModeContext.java",
- "android/java/src/org/chromium/base/Supplier.java",
- "android/java/src/org/chromium/base/SysUtils.java",
- "android/java/src/org/chromium/base/SystemMessageHandler.java",
- "android/java/src/org/chromium/base/ThreadUtils.java",
- "android/java/src/org/chromium/base/ThrowUncaughtException.java",
- "android/java/src/org/chromium/base/TimeUtils.java",
- "android/java/src/org/chromium/base/TimezoneUtils.java",
- "android/java/src/org/chromium/base/TraceEvent.java",
- "android/java/src/org/chromium/base/UnguessableToken.java",
- "android/java/src/org/chromium/base/VisibleForTesting.java",
- "android/java/src/org/chromium/base/annotations/AccessedByNative.java",
- "android/java/src/org/chromium/base/annotations/CalledByNative.java",
- "android/java/src/org/chromium/base/annotations/CalledByNativeUnchecked.java",
- "android/java/src/org/chromium/base/annotations/JNIAdditionalImport.java",
- "android/java/src/org/chromium/base/annotations/JNINamespace.java",
- "android/java/src/org/chromium/base/annotations/MainDex.java",
- "android/java/src/org/chromium/base/annotations/NativeCall.java",
- "android/java/src/org/chromium/base/annotations/NativeClassQualifiedName.java",
- "android/java/src/org/chromium/base/annotations/RemovableInRelease.java",
- "android/java/src/org/chromium/base/annotations/UsedByReflection.java",
- "android/java/src/org/chromium/base/library_loader/LegacyLinker.java",
- "android/java/src/org/chromium/base/library_loader/LibraryLoader.java",
- "android/java/src/org/chromium/base/library_loader/Linker.java",
- "android/java/src/org/chromium/base/library_loader/LoaderErrors.java",
- "android/java/src/org/chromium/base/library_loader/NativeLibraryPreloader.java",
- "android/java/src/org/chromium/base/library_loader/ProcessInitException.java",
- "android/java/src/org/chromium/base/metrics/CachedMetrics.java",
- "android/java/src/org/chromium/base/metrics/RecordHistogram.java",
- "android/java/src/org/chromium/base/metrics/RecordUserAction.java",
- "android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java",
- "android/java/src/org/chromium/base/multidex/ChromiumMultiDexInstaller.java",
- "android/java/src/org/chromium/base/process_launcher/ChildConnectionAllocator.java",
- "android/java/src/org/chromium/base/process_launcher/ChildProcessConnection.java",
- "android/java/src/org/chromium/base/process_launcher/ChildProcessConstants.java",
- "android/java/src/org/chromium/base/process_launcher/ChildProcessLauncher.java",
- "android/java/src/org/chromium/base/process_launcher/ChildProcessService.java",
- "android/java/src/org/chromium/base/process_launcher/ChildProcessServiceDelegate.java",
- "android/java/src/org/chromium/base/process_launcher/FileDescriptorInfo.java",
- "android/java/src/org/chromium/base/memory/MemoryPressureMonitor.java",
- "android/java/src/org/chromium/base/memory/MemoryPressureCallback.java",
- "android/java/src/org/chromium/base/memory/MemoryPressureUma.java",
- ]
-
- # New versions of BuildConfig.java and NativeLibraries.java
- # (with the actual correct values) will be created when creating an apk.
- jar_excluded_patterns = [
- "*/BuildConfig.class",
- "*/NativeLibraries.class",
- "*/NativeLibraries##*.class",
- ]
- }
-
- android_aidl("base_java_aidl") {
- import_include = [ "android/java/src" ]
- sources = [
- "android/java/src/org/chromium/base/process_launcher/ICallbackInt.aidl",
- "android/java/src/org/chromium/base/process_launcher/IChildProcessService.aidl",
- ]
- }
-
- android_library("base_javatests") {
- testonly = true
- deps = [
- ":base_java",
- ":base_java_test_support",
- "//third_party/android_support_test_runner:runner_java",
- "//third_party/junit:junit",
- ]
- java_files = [
- "android/javatests/src/org/chromium/base/AdvancedMockContextTest.java",
- "android/javatests/src/org/chromium/base/ApiCompatibilityUtilsTest.java",
- "android/javatests/src/org/chromium/base/CommandLineInitUtilTest.java",
- "android/javatests/src/org/chromium/base/CommandLineTest.java",
- "android/javatests/src/org/chromium/base/EarlyTraceEventTest.java",
-
- # TODO(nona): move to Junit once that is built for Android N.
- "android/javatests/src/org/chromium/base/LocaleUtilsTest.java",
- "android/javatests/src/org/chromium/base/ObserverListTest.java",
- "android/javatests/src/org/chromium/base/StrictModeContextTest.java",
- "android/javatests/src/org/chromium/base/metrics/RecordHistogramTest.java",
- ]
- }
-
- android_library("base_java_test_support") {
- testonly = true
- deps = [
- ":base_java",
- "//testing/android/reporter:reporter_java",
- "//third_party/android_support_test_runner:exposed_instrumentation_api_publish_java",
- "//third_party/android_support_test_runner:rules_java",
- "//third_party/android_support_test_runner:runner_java",
- "//third_party/android_tools:android_support_annotations_java",
- "//third_party/android_tools:android_support_chromium_java",
- "//third_party/android_tools:android_support_compat_java",
- "//third_party/hamcrest:hamcrest_core_java",
- "//third_party/junit",
- "//third_party/ub-uiautomator:ub_uiautomator_java",
- ]
-
- deps += android_extra_test_deps
-
- java_files = [
- "test/android/javatests/src/org/chromium/base/test/BaseJUnit4ClassRunner.java",
- "test/android/javatests/src/org/chromium/base/test/BaseChromiumAndroidJUnitRunner.java",
- "test/android/javatests/src/org/chromium/base/test/BaseChromiumRunnerCommon.java",
- "test/android/javatests/src/org/chromium/base/test/BaseTestResult.java",
- "test/android/javatests/src/org/chromium/base/test/ScreenshotOnFailureStatement.java",
- "test/android/javatests/src/org/chromium/base/test/SetUpTestRule.java",
- "test/android/javatests/src/org/chromium/base/test/SetUpStatement.java",
- "test/android/javatests/src/org/chromium/base/test/TestListInstrumentationRunListener.java",
- "test/android/javatests/src/org/chromium/base/test/TestTraceEvent.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterizedRunner.java",
- "test/android/javatests/src/org/chromium/base/test/params/BlockJUnit4RunnerDelegate.java",
- "test/android/javatests/src/org/chromium/base/test/params/BaseJUnit4RunnerDelegate.java",
- "test/android/javatests/src/org/chromium/base/test/params/MethodParamAnnotationRule.java",
- "test/android/javatests/src/org/chromium/base/test/params/MethodParamRule.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterAnnotations.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterizedFrameworkMethod.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterizedRunnerDelegate.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterizedRunnerDelegateCommon.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactory.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterProvider.java",
- "test/android/javatests/src/org/chromium/base/test/params/ParameterSet.java",
- "test/android/javatests/src/org/chromium/base/test/util/AdvancedMockContext.java",
- "test/android/javatests/src/org/chromium/base/test/util/AnnotationRule.java",
- "test/android/javatests/src/org/chromium/base/test/util/CallbackHelper.java",
- "test/android/javatests/src/org/chromium/base/test/util/CommandLineFlags.java",
- "test/android/javatests/src/org/chromium/base/test/util/DisableIf.java",
- "test/android/javatests/src/org/chromium/base/test/util/DisableIfSkipCheck.java",
- "test/android/javatests/src/org/chromium/base/test/util/AnnotationProcessingUtils.java",
- "test/android/javatests/src/org/chromium/base/test/util/DisabledTest.java",
- "test/android/javatests/src/org/chromium/base/test/util/EnormousTest.java",
- "test/android/javatests/src/org/chromium/base/test/util/Feature.java",
- "test/android/javatests/src/org/chromium/base/test/util/FlakyTest.java",
- "test/android/javatests/src/org/chromium/base/test/util/InMemorySharedPreferences.java",
- "test/android/javatests/src/org/chromium/base/test/util/InstrumentationUtils.java",
- "test/android/javatests/src/org/chromium/base/test/util/IntegrationTest.java",
- "test/android/javatests/src/org/chromium/base/test/util/Manual.java",
- "test/android/javatests/src/org/chromium/base/test/util/ManualSkipCheck.java",
- "test/android/javatests/src/org/chromium/base/test/util/Matchers.java",
- "test/android/javatests/src/org/chromium/base/test/util/MetricsUtils.java",
- "test/android/javatests/src/org/chromium/base/test/util/MinAndroidSdkLevel.java",
- "test/android/javatests/src/org/chromium/base/test/util/MinAndroidSdkLevelSkipCheck.java",
- "test/android/javatests/src/org/chromium/base/test/util/Restriction.java",
- "test/android/javatests/src/org/chromium/base/test/util/RestrictionSkipCheck.java",
- "test/android/javatests/src/org/chromium/base/test/util/RetryOnFailure.java",
- "test/android/javatests/src/org/chromium/base/test/util/ScalableTimeout.java",
- "test/android/javatests/src/org/chromium/base/test/util/SkipCheck.java",
- "test/android/javatests/src/org/chromium/base/test/util/TestFileUtil.java",
- "test/android/javatests/src/org/chromium/base/test/util/TestThread.java",
- "test/android/javatests/src/org/chromium/base/test/util/TimeoutScale.java",
- "test/android/javatests/src/org/chromium/base/test/util/UserActionTester.java",
- "test/android/javatests/src/org/chromium/base/test/util/UrlUtils.java",
- "test/android/javatests/src/org/chromium/base/test/util/parameter/CommandLineParameter.java",
- "test/android/javatests/src/org/chromium/base/test/util/parameter/SkipCommandLineParameterization.java",
- ]
- }
-
- android_library("base_java_process_launcher_test_support") {
- testonly = true
- deps = [
- ":base_java",
- ":base_java_test_support",
- ]
- java_files = [ "test/android/javatests/src/org/chromium/base/test/TestChildProcessConnection.java" ]
- }
-
- android_library("base_junit_test_support") {
- # Plaform checks are broken for Robolectric.
- bypass_platform_checks = true
- testonly = true
- java_files = [
- "android/junit/src/org/chromium/base/metrics/test/ShadowRecordHistogram.java",
- "test/android/junit/src/org/chromium/base/test/BaseRobolectricTestRunner.java",
- ]
- deps = [
- ":base_java",
- "//testing/android/junit:junit_test_support",
- "//third_party/robolectric:robolectric_all_java",
- ]
- }
-
- junit_binary("base_junit_tests") {
- java_files = [
- "android/junit/src/org/chromium/base/ApplicationStatusTest.java",
- "android/junit/src/org/chromium/base/DiscardableReferencePoolTest.java",
- "android/junit/src/org/chromium/base/LogTest.java",
- "android/junit/src/org/chromium/base/NonThreadSafeTest.java",
- "android/junit/src/org/chromium/base/PromiseTest.java",
- "android/junit/src/org/chromium/base/memory/MemoryPressureMonitorTest.java",
- "android/junit/src/org/chromium/base/process_launcher/ChildConnectionAllocatorTest.java",
- "android/junit/src/org/chromium/base/process_launcher/ChildProcessConnectionTest.java",
- "test/android/junit/src/org/chromium/base/test/SetUpStatementTest.java",
- "test/android/junit/src/org/chromium/base/test/TestListInstrumentationRunListenerTest.java",
- "test/android/junit/src/org/chromium/base/test/util/AnnotationProcessingUtilsTest.java",
- "test/android/junit/src/org/chromium/base/test/util/DisableIfTest.java",
- "test/android/junit/src/org/chromium/base/test/util/ManualSkipCheckTest.java",
- "test/android/junit/src/org/chromium/base/test/util/MinAndroidSdkLevelSkipCheckTest.java",
- "test/android/junit/src/org/chromium/base/test/util/RestrictionSkipCheckTest.java",
- "test/android/junit/src/org/chromium/base/test/util/SkipCheckTest.java",
- "test/android/junit/src/org/chromium/base/test/params/ExampleParameterizedTest.java",
- "test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerTest.java",
- "test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateCommonTest.java",
- "test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactoryTest.java",
- "test/android/junit/src/org/chromium/base/test/params/ParameterizedTestNameTest.java",
- ]
- deps = [
- ":base_java",
- ":base_java_process_launcher_test_support",
- ":base_java_test_support",
- ":base_junit_test_support",
- "//third_party/hamcrest:hamcrest_java",
- ]
- }
-
- java_cpp_enum("base_android_java_enums_srcjar") {
- sources = [
- "android/application_status_listener.h",
- "android/library_loader/library_load_from_apk_status_codes.h",
- "android/library_loader/library_loader_hooks.h",
- "memory/memory_pressure_listener.h",
- "metrics/histogram_base.h",
- "trace_event/trace_config.h",
- ]
- }
-
- generate_build_config_srcjar("base_build_config_gen") {
- use_final_fields = false
- }
-
- java_cpp_template("base_native_libraries_gen") {
- sources = [
- "android/java/templates/NativeLibraries.template",
- ]
- package_path = "org/chromium/base/library_loader"
- }
-
- android_library("base_java_unittest_support") {
- testonly = true
- deps = [
- ":base_java",
- ]
- java_files = [
- "test/android/java/src/org/chromium/base/ContentUriTestUtils.java",
- "test/android/java/src/org/chromium/base/JavaHandlerThreadHelpers.java",
- ]
- }
-}
-
-# Keep the list of fuzzer_tests in alphabetical order.
-fuzzer_test("base64_decode_fuzzer") {
- sources = [
- "base64_decode_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
-}
-
-fuzzer_test("base64_encode_fuzzer") {
- sources = [
- "base64_encode_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
-}
-
-fuzzer_test("base_json_correctness_fuzzer") {
- sources = [
- "json/json_correctness_fuzzer.cc",
- ]
- deps = [
- ":base",
- ]
- dict = "//testing/libfuzzer/fuzzers/dicts/json.dict"
-}
-
-fuzzer_test("base_json_reader_fuzzer") {
- sources = [
- "json/json_reader_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
- dict = "//testing/libfuzzer/fuzzers/dicts/json.dict"
-}
-
-fuzzer_test("base_json_string_escape_fuzzer") {
- sources = [
- "json/string_escape_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
-}
-
-fuzzer_test("string_number_conversions_fuzzer") {
- sources = [
- "strings/string_number_conversions_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
-}
-
-fuzzer_test("string_tokenizer_fuzzer") {
- sources = [
- "strings/string_tokenizer_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
-}
-
-fuzzer_test("utf_string_conversions_fuzzer") {
- sources = [
- "strings/utf_string_conversions_fuzzer.cc",
- ]
- deps = [
- "//base",
- ]
-}
-
-# TODO(dyaroshev): remove regression fuzzer, after we run it for a few days
-# and are confident that the transition was ok.
-fuzzer_test("utf_string_conversions_regression_fuzzer") {
- sources = [
- "strings/old_utf_string_conversions.cc",
- "strings/old_utf_string_conversions.h",
- "strings/utf_string_conversions_regression_fuzzer.cc",
- ]
- deps = [
- ":base",
- ]
-
- libfuzzer_options = [ "max_len=32" ]
-}
diff --git a/base/allocator/BUILD.gn b/base/allocator/BUILD.gn
deleted file mode 100644
index 636a342..0000000
--- a/base/allocator/BUILD.gn
+++ /dev/null
@@ -1,284 +0,0 @@
-# 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.
-
-import("//build/buildflag_header.gni")
-import("//build/config/allocator.gni")
-import("//build/config/compiler/compiler.gni")
-
-declare_args() {
- # Provide a way to force disable debugallocation in Debug builds,
- # e.g. for profiling (it's more rare to profile Debug builds,
- # but people sometimes need to do that).
- enable_debugallocation = is_debug
-}
-
-# This "allocator" meta-target will forward to the default allocator according
-# to the build settings.
-group("allocator") {
- public_deps = []
- deps = []
-
- if (use_allocator == "tcmalloc") {
- deps += [ ":tcmalloc" ]
- }
-}
-
-config("tcmalloc_flags") {
- defines = []
- if (enable_debugallocation) {
- defines += [
- # Use debugallocation for Debug builds to catch problems early
- # and cleanly, http://crbug.com/30715 .
- "TCMALLOC_FOR_DEBUGALLOCATION",
- ]
- }
- if (use_allocator_shim) {
- defines += [ "TCMALLOC_DONT_REPLACE_SYSTEM_ALLOC" ]
- }
- if (is_clang) {
- cflags = [
- # tcmalloc initializes some fields in the wrong order.
- "-Wno-reorder",
-
- # tcmalloc contains some unused local template specializations.
- "-Wno-unused-function",
-
- # tcmalloc uses COMPILE_ASSERT without static_assert but with typedefs.
- "-Wno-unused-local-typedefs",
-
- # for magic2_ in debugallocation.cc (only built in Debug builds) typedefs.
- "-Wno-unused-private-field",
- ]
- } else {
- cflags = []
- }
-
- if (is_linux || is_android) {
- # We enable all warnings by default, but upstream disables a few.
- # Keep "-Wno-*" flags in sync with upstream by comparing against:
- # http://code.google.com/p/google-perftools/source/browse/trunk/Makefile.am
- cflags += [
- "-Wno-sign-compare",
- "-Wno-unused-result",
- ]
- }
-}
-
-if (use_allocator == "tcmalloc") {
- # tcmalloc currently won't compile on Android.
- source_set("tcmalloc") {
- tcmalloc_dir = "//third_party/tcmalloc/chromium"
-
- # Don't check tcmalloc's includes. These files include various files like
- # base/foo.h and they actually refer to tcmalloc's forked copy of base
- # rather than the regular one, which confuses the header checker.
- check_includes = false
-
- sources = [
- # Generated for our configuration from tcmalloc's build
- # and checked in.
- "$tcmalloc_dir/src/config.h",
- "$tcmalloc_dir/src/config_android.h",
- "$tcmalloc_dir/src/config_linux.h",
- "$tcmalloc_dir/src/config_win.h",
-
- # tcmalloc native and forked files.
- "$tcmalloc_dir/src/base/abort.cc",
- "$tcmalloc_dir/src/base/abort.h",
- "$tcmalloc_dir/src/base/arm_instruction_set_select.h",
- "$tcmalloc_dir/src/base/atomicops-internals-arm-generic.h",
- "$tcmalloc_dir/src/base/atomicops-internals-arm-v6plus.h",
- "$tcmalloc_dir/src/base/atomicops-internals-linuxppc.h",
- "$tcmalloc_dir/src/base/atomicops-internals-macosx.h",
- "$tcmalloc_dir/src/base/atomicops-internals-windows.h",
- "$tcmalloc_dir/src/base/atomicops-internals-x86.cc",
- "$tcmalloc_dir/src/base/atomicops-internals-x86.h",
- "$tcmalloc_dir/src/base/atomicops.h",
- "$tcmalloc_dir/src/base/commandlineflags.h",
- "$tcmalloc_dir/src/base/cycleclock.h",
-
- # We don't list dynamic_annotations.c since its copy is already
- # present in the dynamic_annotations target.
- "$tcmalloc_dir/src/base/elf_mem_image.cc",
- "$tcmalloc_dir/src/base/elf_mem_image.h",
- "$tcmalloc_dir/src/base/linuxthreads.cc",
- "$tcmalloc_dir/src/base/linuxthreads.h",
- "$tcmalloc_dir/src/base/logging.cc",
- "$tcmalloc_dir/src/base/logging.h",
- "$tcmalloc_dir/src/base/low_level_alloc.cc",
- "$tcmalloc_dir/src/base/low_level_alloc.h",
- "$tcmalloc_dir/src/base/spinlock.cc",
- "$tcmalloc_dir/src/base/spinlock.h",
- "$tcmalloc_dir/src/base/spinlock_internal.cc",
- "$tcmalloc_dir/src/base/spinlock_internal.h",
- "$tcmalloc_dir/src/base/synchronization_profiling.h",
- "$tcmalloc_dir/src/base/sysinfo.cc",
- "$tcmalloc_dir/src/base/sysinfo.h",
- "$tcmalloc_dir/src/base/vdso_support.cc",
- "$tcmalloc_dir/src/base/vdso_support.h",
- "$tcmalloc_dir/src/central_freelist.cc",
- "$tcmalloc_dir/src/central_freelist.h",
- "$tcmalloc_dir/src/common.cc",
- "$tcmalloc_dir/src/common.h",
-
- # #included by debugallocation_shim.cc
- #"$tcmalloc_dir/src/debugallocation.cc",
- "$tcmalloc_dir/src/free_list.cc",
- "$tcmalloc_dir/src/free_list.h",
- "$tcmalloc_dir/src/gperftools/heap-profiler.h",
- "$tcmalloc_dir/src/gperftools/malloc_extension.h",
- "$tcmalloc_dir/src/gperftools/malloc_hook.h",
- "$tcmalloc_dir/src/gperftools/stacktrace.h",
- "$tcmalloc_dir/src/heap-profile-table.cc",
- "$tcmalloc_dir/src/heap-profile-table.h",
- "$tcmalloc_dir/src/heap-profiler.cc",
- "$tcmalloc_dir/src/internal_logging.cc",
- "$tcmalloc_dir/src/internal_logging.h",
- "$tcmalloc_dir/src/linked_list.h",
- "$tcmalloc_dir/src/malloc_extension.cc",
- "$tcmalloc_dir/src/malloc_hook-inl.h",
- "$tcmalloc_dir/src/malloc_hook.cc",
- "$tcmalloc_dir/src/maybe_threads.cc",
- "$tcmalloc_dir/src/maybe_threads.h",
- "$tcmalloc_dir/src/memory_region_map.cc",
- "$tcmalloc_dir/src/memory_region_map.h",
- "$tcmalloc_dir/src/page_heap.cc",
- "$tcmalloc_dir/src/page_heap.h",
- "$tcmalloc_dir/src/raw_printer.cc",
- "$tcmalloc_dir/src/raw_printer.h",
- "$tcmalloc_dir/src/sampler.cc",
- "$tcmalloc_dir/src/sampler.h",
- "$tcmalloc_dir/src/span.cc",
- "$tcmalloc_dir/src/span.h",
- "$tcmalloc_dir/src/stack_trace_table.cc",
- "$tcmalloc_dir/src/stack_trace_table.h",
- "$tcmalloc_dir/src/stacktrace.cc",
- "$tcmalloc_dir/src/static_vars.cc",
- "$tcmalloc_dir/src/static_vars.h",
- "$tcmalloc_dir/src/symbolize.cc",
- "$tcmalloc_dir/src/symbolize.h",
- "$tcmalloc_dir/src/system-alloc.cc",
- "$tcmalloc_dir/src/system-alloc.h",
-
- # #included by debugallocation_shim.cc
- #"$tcmalloc_dir/src/tcmalloc.cc",
- #"$tcmalloc_dir/src/tcmalloc.h",
- "$tcmalloc_dir/src/thread_cache.cc",
- "$tcmalloc_dir/src/thread_cache.h",
- "$tcmalloc_dir/src/windows/port.cc",
- "$tcmalloc_dir/src/windows/port.h",
- "debugallocation_shim.cc",
-
- # These are both #included by allocator_shim for maximal linking.
- #"generic_allocators.cc",
- #"win_allocator.cc",
- ]
-
- # Not included on mips64el.
- if (current_cpu == "mips64el") {
- sources -= [
- "$tcmalloc_dir/src/base/linuxthreads.cc",
- "$tcmalloc_dir/src/base/linuxthreads.h",
- ]
- }
-
- # Disable the heap checker in tcmalloc.
- defines = [ "NO_HEAP_CHECK" ]
-
- include_dirs = [
- ".",
- "$tcmalloc_dir/src/base",
- "$tcmalloc_dir/src",
- ]
-
- configs -= [ "//build/config/compiler:chromium_code" ]
- configs += [
- "//build/config/compiler:no_chromium_code",
- ":tcmalloc_flags",
- ]
-
- # Thumb mode disabled due to bug in clang integrated assembler
- # TODO(https://llvm.org/bugs/show_bug.cgi?id=31058)
- configs -= [ "//build/config/compiler:compiler_arm_thumb" ]
- configs += [ "//build/config/compiler:compiler_arm" ]
-
- # TODO(crbug.com/633719) Make tcmalloc work with AFDO on GCC if possible.
- if (!is_clang) {
- configs -= [ "//build/config/compiler:afdo" ]
- }
-
- deps = []
-
- if (enable_profiling) {
- sources += [
- "$tcmalloc_dir/src/base/thread_lister.c",
- "$tcmalloc_dir/src/base/thread_lister.h",
- "$tcmalloc_dir/src/profile-handler.cc",
- "$tcmalloc_dir/src/profile-handler.h",
- "$tcmalloc_dir/src/profiledata.cc",
- "$tcmalloc_dir/src/profiledata.h",
- "$tcmalloc_dir/src/profiler.cc",
- ]
- defines += [ "ENABLE_PROFILING=1" ]
- }
-
- if (is_linux || is_android) {
- sources -= [
- "$tcmalloc_dir/src/system-alloc.h",
- "$tcmalloc_dir/src/windows/port.cc",
- "$tcmalloc_dir/src/windows/port.h",
- ]
-
- # Compiling tcmalloc with -fvisibility=default is only necessary when
- # not using the allocator shim, which provides the correct visibility
- # annotations for those symbols which need to be exported (see
- # //base/allocator/allocator_shim_override_glibc_weak_symbols.h and
- # //base/allocator/allocator_shim_internals.h for the definition of
- # SHIM_ALWAYS_EXPORT).
- if (!use_allocator_shim) {
- configs -= [ "//build/config/gcc:symbol_visibility_hidden" ]
- configs += [ "//build/config/gcc:symbol_visibility_default" ]
- }
-
- ldflags = [
- # Don't let linker rip this symbol out, otherwise the heap&cpu
- # profilers will not initialize properly on startup.
- "-Wl,-uIsHeapProfilerRunning,-uProfilerStart",
-
- # Do the same for heap leak checker.
- "-Wl,-u_Z21InitialMallocHook_NewPKvj,-u_Z22InitialMallocHook_MMapPKvS0_jiiix,-u_Z22InitialMallocHook_SbrkPKvi",
- "-Wl,-u_Z21InitialMallocHook_NewPKvm,-u_Z22InitialMallocHook_MMapPKvS0_miiil,-u_Z22InitialMallocHook_SbrkPKvl",
- "-Wl,-u_ZN15HeapLeakChecker12IgnoreObjectEPKv,-u_ZN15HeapLeakChecker14UnIgnoreObjectEPKv",
- ]
- }
-
- # Make sure the allocation library is optimized as much as possible when
- # we"re in release mode.
- if (!is_debug) {
- configs -= [ "//build/config/compiler:default_optimization" ]
- configs += [ "//build/config/compiler:optimize_max" ]
- }
-
- deps += [ "//base/third_party/dynamic_annotations" ]
- }
-} # use_allocator == "tcmalloc"
-
-buildflag_header("buildflags") {
- header = "buildflags.h"
- flags = [ "USE_ALLOCATOR_SHIM=$use_allocator_shim" ]
-}
-
-# Used to shim malloc symbols on Android. see //base/allocator/README.md.
-config("wrap_malloc_symbols") {
- ldflags = [
- "-Wl,-wrap,calloc",
- "-Wl,-wrap,free",
- "-Wl,-wrap,malloc",
- "-Wl,-wrap,memalign",
- "-Wl,-wrap,posix_memalign",
- "-Wl,-wrap,pvalloc",
- "-Wl,-wrap,realloc",
- "-Wl,-wrap,valloc",
- ]
-}
diff --git a/base/allocator/allocator_shim_unittest.cc b/base/allocator/allocator_shim_unittest.cc
deleted file mode 100644
index 0a18eb2..0000000
--- a/base/allocator/allocator_shim_unittest.cc
+++ /dev/null
@@ -1,460 +0,0 @@
-// Copyright 2016 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 "base/allocator/allocator_shim.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include <memory>
-#include <new>
-#include <vector>
-
-#include "base/allocator/partition_allocator/partition_alloc.h"
-#include "base/atomicops.h"
-#include "base/process/process_metrics.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_MACOSX)
-#include <malloc/malloc.h>
-#include "base/allocator/allocator_interception_mac.h"
-#include "base/mac/mac_util.h"
-#include "third_party/apple_apsl/malloc.h"
-#else
-#include <malloc.h>
-#endif
-
-#if !defined(OS_WIN)
-#include <unistd.h>
-#endif
-
-// Some new Android NDKs (64 bit) does not expose (p)valloc anymore. These
-// functions are implemented at the shim-layer level.
-#if defined(OS_ANDROID)
-extern "C" {
-void* valloc(size_t size);
-void* pvalloc(size_t size);
-}
-#endif
-
-namespace base {
-namespace allocator {
-namespace {
-
-using testing::MockFunction;
-using testing::_;
-
-class AllocatorShimTest : public testing::Test {
- public:
- static const size_t kMaxSizeTracked = 2 * base::kSystemPageSize;
- AllocatorShimTest() : testing::Test() {}
-
- static size_t Hash(const void* ptr) {
- return reinterpret_cast<uintptr_t>(ptr) % kMaxSizeTracked;
- }
-
- static void* MockAlloc(const AllocatorDispatch* self,
- size_t size,
- void* context) {
- if (instance_ && size < kMaxSizeTracked)
- ++(instance_->allocs_intercepted_by_size[size]);
- return self->next->alloc_function(self->next, size, context);
- }
-
- static void* MockAllocZeroInit(const AllocatorDispatch* self,
- size_t n,
- size_t size,
- void* context) {
- const size_t real_size = n * size;
- if (instance_ && real_size < kMaxSizeTracked)
- ++(instance_->zero_allocs_intercepted_by_size[real_size]);
- return self->next->alloc_zero_initialized_function(self->next, n, size,
- context);
- }
-
- static void* MockAllocAligned(const AllocatorDispatch* self,
- size_t alignment,
- size_t size,
- void* context) {
- if (instance_) {
- if (size < kMaxSizeTracked)
- ++(instance_->aligned_allocs_intercepted_by_size[size]);
- if (alignment < kMaxSizeTracked)
- ++(instance_->aligned_allocs_intercepted_by_alignment[alignment]);
- }
- return self->next->alloc_aligned_function(self->next, alignment, size,
- context);
- }
-
- static void* MockRealloc(const AllocatorDispatch* self,
- void* address,
- size_t size,
- void* context) {
- if (instance_) {
- // Size 0xFEED a special sentinel for the NewHandlerConcurrency test.
- // Hitting it for the first time will cause a failure, causing the
- // invocation of the std::new_handler.
- if (size == 0xFEED) {
- if (!instance_->did_fail_realloc_0xfeed_once->Get()) {
- instance_->did_fail_realloc_0xfeed_once->Set(true);
- return nullptr;
- } else {
- return address;
- }
- }
-
- if (size < kMaxSizeTracked)
- ++(instance_->reallocs_intercepted_by_size[size]);
- ++instance_->reallocs_intercepted_by_addr[Hash(address)];
- }
- return self->next->realloc_function(self->next, address, size, context);
- }
-
- static void MockFree(const AllocatorDispatch* self,
- void* address,
- void* context) {
- if (instance_) {
- ++instance_->frees_intercepted_by_addr[Hash(address)];
- }
- self->next->free_function(self->next, address, context);
- }
-
- static size_t MockGetSizeEstimate(const AllocatorDispatch* self,
- void* address,
- void* context) {
- return self->next->get_size_estimate_function(self->next, address, context);
- }
-
- static unsigned MockBatchMalloc(const AllocatorDispatch* self,
- size_t size,
- void** results,
- unsigned num_requested,
- void* context) {
- if (instance_) {
- instance_->batch_mallocs_intercepted_by_size[size] =
- instance_->batch_mallocs_intercepted_by_size[size] + num_requested;
- }
- return self->next->batch_malloc_function(self->next, size, results,
- num_requested, context);
- }
-
- static void MockBatchFree(const AllocatorDispatch* self,
- void** to_be_freed,
- unsigned num_to_be_freed,
- void* context) {
- if (instance_) {
- for (unsigned i = 0; i < num_to_be_freed; ++i) {
- ++instance_->batch_frees_intercepted_by_addr[Hash(to_be_freed[i])];
- }
- }
- self->next->batch_free_function(self->next, to_be_freed, num_to_be_freed,
- context);
- }
-
- static void MockFreeDefiniteSize(const AllocatorDispatch* self,
- void* ptr,
- size_t size,
- void* context) {
- if (instance_) {
- ++instance_->frees_intercepted_by_addr[Hash(ptr)];
- ++instance_->free_definite_sizes_intercepted_by_size[size];
- }
- self->next->free_definite_size_function(self->next, ptr, size, context);
- }
-
- static void NewHandler() {
- if (!instance_)
- return;
- subtle::Barrier_AtomicIncrement(&instance_->num_new_handler_calls, 1);
- }
-
- int32_t GetNumberOfNewHandlerCalls() {
- return subtle::Acquire_Load(&instance_->num_new_handler_calls);
- }
-
- void SetUp() override {
- const size_t array_size = kMaxSizeTracked * sizeof(size_t);
- memset(&allocs_intercepted_by_size, 0, array_size);
- memset(&zero_allocs_intercepted_by_size, 0, array_size);
- memset(&aligned_allocs_intercepted_by_size, 0, array_size);
- memset(&aligned_allocs_intercepted_by_alignment, 0, array_size);
- memset(&reallocs_intercepted_by_size, 0, array_size);
- memset(&frees_intercepted_by_addr, 0, array_size);
- memset(&batch_mallocs_intercepted_by_size, 0, array_size);
- memset(&batch_frees_intercepted_by_addr, 0, array_size);
- memset(&free_definite_sizes_intercepted_by_size, 0, array_size);
- did_fail_realloc_0xfeed_once.reset(new ThreadLocalBoolean());
- subtle::Release_Store(&num_new_handler_calls, 0);
- instance_ = this;
-
-#if defined(OS_MACOSX)
- InitializeAllocatorShim();
-#endif
- }
-
- void TearDown() override {
- instance_ = nullptr;
-#if defined(OS_MACOSX)
- UninterceptMallocZonesForTesting();
-#endif
- }
-
- protected:
- size_t allocs_intercepted_by_size[kMaxSizeTracked];
- size_t zero_allocs_intercepted_by_size[kMaxSizeTracked];
- size_t aligned_allocs_intercepted_by_size[kMaxSizeTracked];
- size_t aligned_allocs_intercepted_by_alignment[kMaxSizeTracked];
- size_t reallocs_intercepted_by_size[kMaxSizeTracked];
- size_t reallocs_intercepted_by_addr[kMaxSizeTracked];
- size_t frees_intercepted_by_addr[kMaxSizeTracked];
- size_t batch_mallocs_intercepted_by_size[kMaxSizeTracked];
- size_t batch_frees_intercepted_by_addr[kMaxSizeTracked];
- size_t free_definite_sizes_intercepted_by_size[kMaxSizeTracked];
- std::unique_ptr<ThreadLocalBoolean> did_fail_realloc_0xfeed_once;
- subtle::Atomic32 num_new_handler_calls;
-
- private:
- static AllocatorShimTest* instance_;
-};
-
-struct TestStruct1 {
- uint32_t ignored;
- uint8_t ignored_2;
-};
-
-struct TestStruct2 {
- uint64_t ignored;
- uint8_t ignored_3;
-};
-
-class ThreadDelegateForNewHandlerTest : public PlatformThread::Delegate {
- public:
- ThreadDelegateForNewHandlerTest(WaitableEvent* event) : event_(event) {}
-
- void ThreadMain() override {
- event_->Wait();
- void* temp = malloc(1);
- void* res = realloc(temp, 0xFEED);
- EXPECT_EQ(temp, res);
- }
-
- private:
- WaitableEvent* event_;
-};
-
-AllocatorShimTest* AllocatorShimTest::instance_ = nullptr;
-
-AllocatorDispatch g_mock_dispatch = {
- &AllocatorShimTest::MockAlloc, /* alloc_function */
- &AllocatorShimTest::MockAllocZeroInit, /* alloc_zero_initialized_function */
- &AllocatorShimTest::MockAllocAligned, /* alloc_aligned_function */
- &AllocatorShimTest::MockRealloc, /* realloc_function */
- &AllocatorShimTest::MockFree, /* free_function */
- &AllocatorShimTest::MockGetSizeEstimate, /* get_size_estimate_function */
- &AllocatorShimTest::MockBatchMalloc, /* batch_malloc_function */
- &AllocatorShimTest::MockBatchFree, /* batch_free_function */
- &AllocatorShimTest::MockFreeDefiniteSize, /* free_definite_size_function */
- nullptr, /* next */
-};
-
-TEST_F(AllocatorShimTest, InterceptLibcSymbols) {
- InsertAllocatorDispatch(&g_mock_dispatch);
-
- void* alloc_ptr = malloc(19);
- ASSERT_NE(nullptr, alloc_ptr);
- ASSERT_GE(allocs_intercepted_by_size[19], 1u);
-
- void* zero_alloc_ptr = calloc(2, 23);
- ASSERT_NE(nullptr, zero_alloc_ptr);
- ASSERT_GE(zero_allocs_intercepted_by_size[2 * 23], 1u);
-
-#if !defined(OS_WIN)
- const size_t kPageSize = base::GetPageSize();
- void* posix_memalign_ptr = nullptr;
- int res = posix_memalign(&posix_memalign_ptr, 256, 59);
- ASSERT_EQ(0, res);
- ASSERT_NE(nullptr, posix_memalign_ptr);
- ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(posix_memalign_ptr) % 256);
- ASSERT_GE(aligned_allocs_intercepted_by_alignment[256], 1u);
- ASSERT_GE(aligned_allocs_intercepted_by_size[59], 1u);
-
- void* valloc_ptr = valloc(61);
- ASSERT_NE(nullptr, valloc_ptr);
- ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(valloc_ptr) % kPageSize);
- ASSERT_GE(aligned_allocs_intercepted_by_alignment[kPageSize], 1u);
- ASSERT_GE(aligned_allocs_intercepted_by_size[61], 1u);
-#endif // !OS_WIN
-
-#if !defined(OS_WIN) && !defined(OS_MACOSX)
- void* memalign_ptr = memalign(128, 53);
- ASSERT_NE(nullptr, memalign_ptr);
- ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(memalign_ptr) % 128);
- ASSERT_GE(aligned_allocs_intercepted_by_alignment[128], 1u);
- ASSERT_GE(aligned_allocs_intercepted_by_size[53], 1u);
-
- void* pvalloc_ptr = pvalloc(67);
- ASSERT_NE(nullptr, pvalloc_ptr);
- ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(pvalloc_ptr) % kPageSize);
- ASSERT_GE(aligned_allocs_intercepted_by_alignment[kPageSize], 1u);
- // pvalloc rounds the size up to the next page.
- ASSERT_GE(aligned_allocs_intercepted_by_size[kPageSize], 1u);
-#endif // !OS_WIN && !OS_MACOSX
-
- char* realloc_ptr = static_cast<char*>(malloc(10));
- strcpy(realloc_ptr, "foobar");
- void* old_realloc_ptr = realloc_ptr;
- realloc_ptr = static_cast<char*>(realloc(realloc_ptr, 73));
- ASSERT_GE(reallocs_intercepted_by_size[73], 1u);
- ASSERT_GE(reallocs_intercepted_by_addr[Hash(old_realloc_ptr)], 1u);
- ASSERT_EQ(0, strcmp(realloc_ptr, "foobar"));
-
- free(alloc_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(alloc_ptr)], 1u);
-
- free(zero_alloc_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(zero_alloc_ptr)], 1u);
-
-#if !defined(OS_WIN) && !defined(OS_MACOSX)
- free(memalign_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(memalign_ptr)], 1u);
-
- free(pvalloc_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(pvalloc_ptr)], 1u);
-#endif // !OS_WIN && !OS_MACOSX
-
-#if !defined(OS_WIN)
- free(posix_memalign_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(posix_memalign_ptr)], 1u);
-
- free(valloc_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(valloc_ptr)], 1u);
-#endif // !OS_WIN
-
- free(realloc_ptr);
- ASSERT_GE(frees_intercepted_by_addr[Hash(realloc_ptr)], 1u);
-
- RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
-
- void* non_hooked_ptr = malloc(4095);
- ASSERT_NE(nullptr, non_hooked_ptr);
- ASSERT_EQ(0u, allocs_intercepted_by_size[4095]);
- free(non_hooked_ptr);
-}
-
-#if defined(OS_MACOSX)
-TEST_F(AllocatorShimTest, InterceptLibcSymbolsBatchMallocFree) {
- InsertAllocatorDispatch(&g_mock_dispatch);
-
- unsigned count = 13;
- std::vector<void*> results;
- results.resize(count);
- unsigned result_count = malloc_zone_batch_malloc(malloc_default_zone(), 99,
- results.data(), count);
- ASSERT_EQ(count, result_count);
-
- // TODO(erikchen): On macOS 10.12+, batch_malloc in the default zone may
- // forward to another zone, which we've also shimmed, resulting in
- // MockBatchMalloc getting called twice as often as we'd expect. This
- // re-entrancy into the allocator shim is a bug that needs to be fixed.
- // https://crbug.com/693237.
- // ASSERT_EQ(count, batch_mallocs_intercepted_by_size[99]);
-
- std::vector<void*> results_copy(results);
- malloc_zone_batch_free(malloc_default_zone(), results.data(), count);
- for (void* result : results_copy) {
- ASSERT_GE(batch_frees_intercepted_by_addr[Hash(result)], 1u);
- }
- RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
-}
-
-TEST_F(AllocatorShimTest, InterceptLibcSymbolsFreeDefiniteSize) {
- InsertAllocatorDispatch(&g_mock_dispatch);
-
- void* alloc_ptr = malloc(19);
- ASSERT_NE(nullptr, alloc_ptr);
- ASSERT_GE(allocs_intercepted_by_size[19], 1u);
-
- ChromeMallocZone* default_zone =
- reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
- default_zone->free_definite_size(malloc_default_zone(), alloc_ptr, 19);
- ASSERT_GE(free_definite_sizes_intercepted_by_size[19], 1u);
- RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
-}
-#endif // defined(OS_MACOSX)
-
-TEST_F(AllocatorShimTest, InterceptCppSymbols) {
- InsertAllocatorDispatch(&g_mock_dispatch);
-
- TestStruct1* new_ptr = new TestStruct1;
- ASSERT_NE(nullptr, new_ptr);
- ASSERT_GE(allocs_intercepted_by_size[sizeof(TestStruct1)], 1u);
-
- TestStruct1* new_array_ptr = new TestStruct1[3];
- ASSERT_NE(nullptr, new_array_ptr);
- ASSERT_GE(allocs_intercepted_by_size[sizeof(TestStruct1) * 3], 1u);
-
- TestStruct2* new_nt_ptr = new (std::nothrow) TestStruct2;
- ASSERT_NE(nullptr, new_nt_ptr);
- ASSERT_GE(allocs_intercepted_by_size[sizeof(TestStruct2)], 1u);
-
- TestStruct2* new_array_nt_ptr = new TestStruct2[3];
- ASSERT_NE(nullptr, new_array_nt_ptr);
- ASSERT_GE(allocs_intercepted_by_size[sizeof(TestStruct2) * 3], 1u);
-
- delete new_ptr;
- ASSERT_GE(frees_intercepted_by_addr[Hash(new_ptr)], 1u);
-
- delete[] new_array_ptr;
- ASSERT_GE(frees_intercepted_by_addr[Hash(new_array_ptr)], 1u);
-
- delete new_nt_ptr;
- ASSERT_GE(frees_intercepted_by_addr[Hash(new_nt_ptr)], 1u);
-
- delete[] new_array_nt_ptr;
- ASSERT_GE(frees_intercepted_by_addr[Hash(new_array_nt_ptr)], 1u);
-
- RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
-}
-
-// This test exercises the case of concurrent OOM failure, which would end up
-// invoking std::new_handler concurrently. This is to cover the CallNewHandler()
-// paths of allocator_shim.cc and smoke-test its thread safey.
-// The test creates kNumThreads threads. Each of them mallocs some memory, and
-// then does a realloc(<new memory>, 0xFEED).
-// The shim intercepts such realloc and makes it fail only once on each thread.
-// We expect to see excactly kNumThreads invocations of the new_handler.
-TEST_F(AllocatorShimTest, NewHandlerConcurrency) {
- const int kNumThreads = 32;
- PlatformThreadHandle threads[kNumThreads];
-
- // The WaitableEvent here is used to attempt to trigger all the threads at
- // the same time, after they have been initialized.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- ThreadDelegateForNewHandlerTest mock_thread_main(&event);
-
- for (int i = 0; i < kNumThreads; ++i)
- PlatformThread::Create(0, &mock_thread_main, &threads[i]);
-
- std::set_new_handler(&AllocatorShimTest::NewHandler);
- SetCallNewHandlerOnMallocFailure(true); // It's going to fail on realloc().
- InsertAllocatorDispatch(&g_mock_dispatch);
- event.Signal();
- for (int i = 0; i < kNumThreads; ++i)
- PlatformThread::Join(threads[i]);
- RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
- ASSERT_EQ(kNumThreads, GetNumberOfNewHandlerCalls());
-}
-
-} // namespace
-} // namespace allocator
-} // namespace base
diff --git a/base/allocator/malloc_zone_functions_mac_unittest.cc b/base/allocator/malloc_zone_functions_mac_unittest.cc
deleted file mode 100644
index 09aa429..0000000
--- a/base/allocator/malloc_zone_functions_mac_unittest.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2017 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 "base/allocator/malloc_zone_functions_mac.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace allocator {
-
-class MallocZoneFunctionsTest : public testing::Test {
- protected:
- void TearDown() override { ClearAllMallocZonesForTesting(); }
-};
-
-TEST_F(MallocZoneFunctionsTest, TestDefaultZoneMallocFree) {
- ChromeMallocZone* malloc_zone =
- reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
- StoreMallocZone(malloc_zone);
- int* test = reinterpret_cast<int*>(
- g_malloc_zones[0].malloc(malloc_default_zone(), 33));
- test[0] = 1;
- test[1] = 2;
- g_malloc_zones[0].free(malloc_default_zone(), test);
-}
-
-TEST_F(MallocZoneFunctionsTest, IsZoneAlreadyStored) {
- ChromeMallocZone* malloc_zone =
- reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
- EXPECT_FALSE(IsMallocZoneAlreadyStored(malloc_zone));
- StoreMallocZone(malloc_zone);
- EXPECT_TRUE(IsMallocZoneAlreadyStored(malloc_zone));
-}
-
-TEST_F(MallocZoneFunctionsTest, CannotDoubleStoreZone) {
- ChromeMallocZone* malloc_zone =
- reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
- StoreMallocZone(malloc_zone);
- StoreMallocZone(malloc_zone);
- EXPECT_EQ(1, GetMallocZoneCountForTesting());
-}
-
-TEST_F(MallocZoneFunctionsTest, CannotStoreMoreThanMaxZones) {
- std::vector<ChromeMallocZone> zones;
- zones.resize(kMaxZoneCount * 2);
- for (int i = 0; i < kMaxZoneCount * 2; ++i) {
- ChromeMallocZone& zone = zones[i];
- memcpy(&zone, malloc_default_zone(), sizeof(ChromeMallocZone));
- StoreMallocZone(&zone);
- }
-
- int max_zone_count = kMaxZoneCount;
- EXPECT_EQ(max_zone_count, GetMallocZoneCountForTesting());
-}
-
-} // namespace allocator
-} // namespace base
diff --git a/base/allocator/partition_allocator/address_space_randomization_unittest.cc b/base/allocator/partition_allocator/address_space_randomization_unittest.cc
deleted file mode 100644
index a9fe1ce..0000000
--- a/base/allocator/partition_allocator/address_space_randomization_unittest.cc
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright 2017 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 "base/allocator/partition_allocator/address_space_randomization.h"
-
-#include "base/allocator/partition_allocator/page_allocator.h"
-#include "base/bit_cast.h"
-#include "base/bits.h"
-#include "base/sys_info.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include "base/win/windows_version.h"
-// VersionHelpers.h must be included after windows.h.
-#include <VersionHelpers.h>
-#endif
-
-namespace base {
-
-namespace {
-
-uintptr_t GetMask() {
- uintptr_t mask = internal::kASLRMask;
-#if defined(ARCH_CPU_64_BITS)
-// Sanitizers use their own kASLRMask constant.
-#if defined(OS_WIN) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
- if (!IsWindows8Point1OrGreater()) {
- mask = internal::kASLRMaskBefore8_10;
- }
-#endif // defined(OS_WIN) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR))
-#elif defined(ARCH_CPU_32_BITS)
-#if defined(OS_WIN)
- BOOL is_wow64 = FALSE;
- if (!IsWow64Process(GetCurrentProcess(), &is_wow64))
- is_wow64 = FALSE;
- if (!is_wow64) {
- mask = 0;
- }
-#endif // defined(OS_WIN)
-#endif // defined(ARCH_CPU_32_BITS)
- return mask;
-}
-
-const size_t kSamples = 100;
-
-uintptr_t GetAddressBits() {
- return reinterpret_cast<uintptr_t>(base::GetRandomPageBase());
-}
-
-uintptr_t GetRandomBits() {
- return GetAddressBits() - internal::kASLROffset;
-}
-
-} // namespace
-
-// Configurations without ASLR are tested here.
-TEST(AddressSpaceRandomizationTest, DisabledASLR) {
- uintptr_t mask = GetMask();
- if (!mask) {
-#if defined(OS_WIN) && defined(ARCH_CPU_32_BITS)
- // ASLR should be turned off on 32-bit Windows.
- EXPECT_EQ(nullptr, base::GetRandomPageBase());
-#else
- // Otherwise, nullptr is very unexpected.
- EXPECT_NE(nullptr, base::GetRandomPageBase());
-#endif
- }
-}
-
-TEST(AddressSpaceRandomizationTest, Alignment) {
- uintptr_t mask = GetMask();
- if (!mask)
- return;
-
- for (size_t i = 0; i < kSamples; ++i) {
- uintptr_t address = GetAddressBits();
- EXPECT_EQ(0ULL, (address & kPageAllocationGranularityOffsetMask));
- }
-}
-
-TEST(AddressSpaceRandomizationTest, Range) {
- uintptr_t mask = GetMask();
- if (!mask)
- return;
-
- uintptr_t min = internal::kASLROffset;
- uintptr_t max = internal::kASLROffset + internal::kASLRMask;
- for (size_t i = 0; i < kSamples; ++i) {
- uintptr_t address = GetAddressBits();
- EXPECT_LE(min, address);
- EXPECT_GE(max + mask, address);
- }
-}
-
-TEST(AddressSpaceRandomizationTest, Predictable) {
- uintptr_t mask = GetMask();
- if (!mask)
- return;
-
- const uintptr_t kInitialSeed = 0xfeed5eedULL;
- base::SetRandomPageBaseSeed(kInitialSeed);
-
- std::vector<uintptr_t> sequence;
- for (size_t i = 0; i < kSamples; ++i) {
- uintptr_t address = reinterpret_cast<uintptr_t>(base::GetRandomPageBase());
- sequence.push_back(address);
- }
-
- base::SetRandomPageBaseSeed(kInitialSeed);
-
- for (size_t i = 0; i < kSamples; ++i) {
- uintptr_t address = reinterpret_cast<uintptr_t>(base::GetRandomPageBase());
- EXPECT_EQ(address, sequence[i]);
- }
-}
-
-// This randomness test is adapted from V8's PRNG tests.
-
-// Chi squared for getting m 0s out of n bits.
-double ChiSquared(int m, int n) {
- double ys_minus_np1 = (m - n / 2.0);
- double chi_squared_1 = ys_minus_np1 * ys_minus_np1 * 2.0 / n;
- double ys_minus_np2 = ((n - m) - n / 2.0);
- double chi_squared_2 = ys_minus_np2 * ys_minus_np2 * 2.0 / n;
- return chi_squared_1 + chi_squared_2;
-}
-
-// Test for correlations between recent bits from the PRNG, or bits that are
-// biased.
-void RandomBitCorrelation(int random_bit) {
- uintptr_t mask = GetMask();
- if ((mask & (1ULL << random_bit)) == 0)
- return; // bit is always 0.
-
-#ifdef DEBUG
- constexpr int kHistory = 2;
- constexpr int kRepeats = 1000;
-#else
- constexpr int kHistory = 8;
- constexpr int kRepeats = 10000;
-#endif
- constexpr int kPointerBits = 8 * sizeof(void*);
- uintptr_t history[kHistory];
- // The predictor bit is either constant 0 or 1, or one of the bits from the
- // history.
- for (int predictor_bit = -2; predictor_bit < kPointerBits; predictor_bit++) {
- // The predicted bit is one of the bits from the PRNG.
- for (int ago = 0; ago < kHistory; ago++) {
- // We don't want to check whether each bit predicts itself.
- if (ago == 0 && predictor_bit == random_bit)
- continue;
-
- // Enter the new random value into the history.
- for (int i = ago; i >= 0; i--) {
- history[i] = GetRandomBits();
- }
-
- // Find out how many of the bits are the same as the prediction bit.
- int m = 0;
- for (int i = 0; i < kRepeats; i++) {
- uintptr_t random = GetRandomBits();
- for (int j = ago - 1; j >= 0; j--)
- history[j + 1] = history[j];
- history[0] = random;
-
- int predicted;
- if (predictor_bit >= 0) {
- predicted = (history[ago] >> predictor_bit) & 1;
- } else {
- predicted = predictor_bit == -2 ? 0 : 1;
- }
- int bit = (random >> random_bit) & 1;
- if (bit == predicted)
- m++;
- }
-
- // Chi squared analysis for k = 2 (2, states: same/not-same) and one
- // degree of freedom (k - 1).
- double chi_squared = ChiSquared(m, kRepeats);
- // For 1 degree of freedom this corresponds to 1 in a million. We are
- // running ~8000 tests, so that would be surprising.
- CHECK_GE(24, chi_squared);
- // If the predictor bit is a fixed 0 or 1 then it makes no sense to
- // repeat the test with a different age.
- if (predictor_bit < 0)
- break;
- }
- }
-}
-
-// Tests are fairly slow, so give each random bit its own test.
-#define TEST_RANDOM_BIT(BIT) \
- TEST(AddressSpaceRandomizationTest, RandomBitCorrelations##BIT) { \
- RandomBitCorrelation(BIT); \
- }
-
-// The first 12 bits on all platforms are always 0.
-TEST_RANDOM_BIT(12)
-TEST_RANDOM_BIT(13)
-TEST_RANDOM_BIT(14)
-TEST_RANDOM_BIT(15)
-TEST_RANDOM_BIT(16)
-TEST_RANDOM_BIT(17)
-TEST_RANDOM_BIT(18)
-TEST_RANDOM_BIT(19)
-TEST_RANDOM_BIT(20)
-TEST_RANDOM_BIT(21)
-TEST_RANDOM_BIT(22)
-TEST_RANDOM_BIT(23)
-TEST_RANDOM_BIT(24)
-TEST_RANDOM_BIT(25)
-TEST_RANDOM_BIT(26)
-TEST_RANDOM_BIT(27)
-TEST_RANDOM_BIT(28)
-TEST_RANDOM_BIT(29)
-TEST_RANDOM_BIT(30)
-TEST_RANDOM_BIT(31)
-#if defined(ARCH_CPU_64_BITS)
-TEST_RANDOM_BIT(32)
-TEST_RANDOM_BIT(33)
-TEST_RANDOM_BIT(34)
-TEST_RANDOM_BIT(35)
-TEST_RANDOM_BIT(36)
-TEST_RANDOM_BIT(37)
-TEST_RANDOM_BIT(38)
-TEST_RANDOM_BIT(39)
-TEST_RANDOM_BIT(40)
-TEST_RANDOM_BIT(41)
-TEST_RANDOM_BIT(42)
-TEST_RANDOM_BIT(43)
-TEST_RANDOM_BIT(44)
-TEST_RANDOM_BIT(45)
-TEST_RANDOM_BIT(46)
-TEST_RANDOM_BIT(47)
-TEST_RANDOM_BIT(48)
-// No platforms have more than 48 address bits.
-#endif // defined(ARCH_CPU_64_BITS)
-
-#undef TEST_RANDOM_BIT
-
-} // namespace base
diff --git a/base/allocator/partition_allocator/page_allocator_unittest.cc b/base/allocator/partition_allocator/page_allocator_unittest.cc
deleted file mode 100644
index ad14c06..0000000
--- a/base/allocator/partition_allocator/page_allocator_unittest.cc
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright 2018 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 "base/allocator/partition_allocator/page_allocator.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "base/allocator/partition_allocator/address_space_randomization.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
-#include <setjmp.h>
-#include <signal.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#endif // defined(OS_POSIX) && !defined(OS_FUCHSIA)
-
-#if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
-
-namespace base {
-
-namespace {
-
-// Any number of bytes that can be allocated with no trouble.
-constexpr size_t kEasyAllocSize =
- (1024 * 1024) & ~(kPageAllocationGranularity - 1);
-
-// A huge amount of memory, greater than or equal to the ASLR space.
-constexpr size_t kHugeMemoryAmount =
- std::max(internal::kASLRMask, std::size_t{2} * internal::kASLRMask);
-
-} // namespace
-
-TEST(PageAllocatorTest, Rounding) {
- EXPECT_EQ(0u, RoundUpToSystemPage(0u));
- EXPECT_EQ(kSystemPageSize, RoundUpToSystemPage(1));
- EXPECT_EQ(kSystemPageSize, RoundUpToSystemPage(kSystemPageSize - 1));
- EXPECT_EQ(kSystemPageSize, RoundUpToSystemPage(kSystemPageSize));
- EXPECT_EQ(2 * kSystemPageSize, RoundUpToSystemPage(kSystemPageSize + 1));
- EXPECT_EQ(0u, RoundDownToSystemPage(0u));
- EXPECT_EQ(0u, RoundDownToSystemPage(kSystemPageSize - 1));
- EXPECT_EQ(kSystemPageSize, RoundDownToSystemPage(kSystemPageSize));
- EXPECT_EQ(kSystemPageSize, RoundDownToSystemPage(kSystemPageSize + 1));
- EXPECT_EQ(kSystemPageSize, RoundDownToSystemPage(2 * kSystemPageSize - 1));
- EXPECT_EQ(0u, RoundUpToPageAllocationGranularity(0u));
- EXPECT_EQ(kPageAllocationGranularity, RoundUpToPageAllocationGranularity(1));
- EXPECT_EQ(kPageAllocationGranularity,
- RoundUpToPageAllocationGranularity(kPageAllocationGranularity - 1));
- EXPECT_EQ(kPageAllocationGranularity,
- RoundUpToPageAllocationGranularity(kPageAllocationGranularity));
- EXPECT_EQ(2 * kPageAllocationGranularity,
- RoundUpToPageAllocationGranularity(kPageAllocationGranularity + 1));
- EXPECT_EQ(0u, RoundDownToPageAllocationGranularity(0u));
- EXPECT_EQ(
- 0u, RoundDownToPageAllocationGranularity(kPageAllocationGranularity - 1));
- EXPECT_EQ(kPageAllocationGranularity,
- RoundDownToPageAllocationGranularity(kPageAllocationGranularity));
- EXPECT_EQ(kPageAllocationGranularity, RoundDownToPageAllocationGranularity(
- kPageAllocationGranularity + 1));
- EXPECT_EQ(
- kPageAllocationGranularity,
- RoundDownToPageAllocationGranularity(2 * kPageAllocationGranularity - 1));
-}
-
-// Test that failed page allocations invoke base::ReleaseReservation().
-// We detect this by making a reservation and ensuring that after failure, we
-// can make a new reservation.
-TEST(PageAllocatorTest, AllocFailure) {
- // Release any reservation made by another test.
- ReleaseReservation();
-
- // We can make a reservation.
- EXPECT_TRUE(ReserveAddressSpace(kEasyAllocSize));
-
- // We can't make another reservation until we trigger an allocation failure.
- EXPECT_FALSE(ReserveAddressSpace(kEasyAllocSize));
-
- size_t size = kHugeMemoryAmount;
- // Skip the test for sanitizers and platforms with ASLR turned off.
- if (size == 0)
- return;
-
- void* result = AllocPages(nullptr, size, kPageAllocationGranularity,
- PageInaccessible, PageTag::kChromium, false);
- if (result == nullptr) {
- // We triggered allocation failure. Our reservation should have been
- // released, and we should be able to make a new reservation.
- EXPECT_TRUE(ReserveAddressSpace(kEasyAllocSize));
- ReleaseReservation();
- return;
- }
- // We couldn't fail. Make sure reservation is still there.
- EXPECT_FALSE(ReserveAddressSpace(kEasyAllocSize));
-}
-
-// TODO(crbug.com/765801): Test failed on chromium.win/Win10 Tests x64.
-#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
-#define MAYBE_ReserveAddressSpace DISABLED_ReserveAddressSpace
-#else
-#define MAYBE_ReserveAddressSpace ReserveAddressSpace
-#endif // defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
-
-// Test that reserving address space can fail.
-TEST(PageAllocatorTest, MAYBE_ReserveAddressSpace) {
- // Release any reservation made by another test.
- ReleaseReservation();
-
- size_t size = kHugeMemoryAmount;
- // Skip the test for sanitizers and platforms with ASLR turned off.
- if (size == 0)
- return;
-
- bool success = ReserveAddressSpace(size);
- if (!success) {
- EXPECT_TRUE(ReserveAddressSpace(kEasyAllocSize));
- return;
- }
- // We couldn't fail. Make sure reservation is still there.
- EXPECT_FALSE(ReserveAddressSpace(kEasyAllocSize));
-}
-
-TEST(PageAllocatorTest, AllocAndFreePages) {
- void* buffer = AllocPages(nullptr, kPageAllocationGranularity,
- kPageAllocationGranularity, PageReadWrite,
- PageTag::kChromium, true);
- EXPECT_TRUE(buffer);
- int* buffer0 = reinterpret_cast<int*>(buffer);
- *buffer0 = 42;
- EXPECT_EQ(42, *buffer0);
- FreePages(buffer, kPageAllocationGranularity);
-}
-
-// Test permission setting on POSIX, where we can set a trap handler.
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
-
-namespace {
-sigjmp_buf g_continuation;
-
-void SignalHandler(int signal, siginfo_t* info, void*) {
- siglongjmp(g_continuation, 1);
-}
-} // namespace
-
-// On Mac, sometimes we get SIGBUS instead of SIGSEGV, so handle that too.
-#if defined(OS_MACOSX)
-#define EXTRA_FAULT_BEGIN_ACTION() \
- struct sigaction old_bus_action; \
- sigaction(SIGBUS, &action, &old_bus_action);
-#define EXTRA_FAULT_END_ACTION() sigaction(SIGBUS, &old_bus_action, nullptr);
-#else
-#define EXTRA_FAULT_BEGIN_ACTION()
-#define EXTRA_FAULT_END_ACTION()
-#endif
-
-// Install a signal handler so we can catch the fault we're about to trigger.
-#define FAULT_TEST_BEGIN() \
- struct sigaction action = {}; \
- struct sigaction old_action = {}; \
- action.sa_sigaction = SignalHandler; \
- sigemptyset(&action.sa_mask); \
- action.sa_flags = SA_SIGINFO; \
- sigaction(SIGSEGV, &action, &old_action); \
- EXTRA_FAULT_BEGIN_ACTION(); \
- int const save_sigs = 1; \
- if (!sigsetjmp(g_continuation, save_sigs)) {
-// Fault generating code goes here...
-
-// Handle when sigsetjmp returns nonzero (we are returning from our handler).
-#define FAULT_TEST_END() \
- } \
- else { \
- sigaction(SIGSEGV, &old_action, nullptr); \
- EXTRA_FAULT_END_ACTION(); \
- }
-
-TEST(PageAllocatorTest, InaccessiblePages) {
- void* buffer = AllocPages(nullptr, kPageAllocationGranularity,
- kPageAllocationGranularity, PageInaccessible,
- PageTag::kChromium, true);
- EXPECT_TRUE(buffer);
-
- FAULT_TEST_BEGIN();
-
- // Reading from buffer should fault.
- int* buffer0 = reinterpret_cast<int*>(buffer);
- int buffer0_contents = *buffer0;
- EXPECT_EQ(buffer0_contents, *buffer0);
- EXPECT_TRUE(false);
-
- FAULT_TEST_END();
-
- FreePages(buffer, kPageAllocationGranularity);
-}
-
-TEST(PageAllocatorTest, ReadExecutePages) {
- void* buffer = AllocPages(nullptr, kPageAllocationGranularity,
- kPageAllocationGranularity, PageReadExecute,
- PageTag::kChromium, true);
- EXPECT_TRUE(buffer);
- int* buffer0 = reinterpret_cast<int*>(buffer);
- // Reading from buffer should succeed.
- int buffer0_contents = *buffer0;
-
- FAULT_TEST_BEGIN();
-
- // Writing to buffer should fault.
- *buffer0 = ~buffer0_contents;
- EXPECT_TRUE(false);
-
- FAULT_TEST_END();
-
- // Make sure no write occurred.
- EXPECT_EQ(buffer0_contents, *buffer0);
- FreePages(buffer, kPageAllocationGranularity);
-}
-
-#endif // defined(OS_POSIX) && !defined(OS_FUCHSIA)
-
-} // namespace base
-
-#endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
diff --git a/base/allocator/partition_allocator/partition_alloc_unittest.cc b/base/allocator/partition_allocator/partition_alloc_unittest.cc
deleted file mode 100644
index 994f339..0000000
--- a/base/allocator/partition_allocator/partition_alloc_unittest.cc
+++ /dev/null
@@ -1,2129 +0,0 @@
-// 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 "base/allocator/partition_allocator/partition_alloc.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/allocator/partition_allocator/address_space_randomization.h"
-#include "base/bit_cast.h"
-#include "base/bits.h"
-#include "base/sys_info.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include <sys/mman.h>
-#if !defined(OS_FUCHSIA)
-#include <sys/resource.h>
-#endif
-#include <sys/time.h>
-#endif // defined(OS_POSIX)
-
-#if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
-
-// Because there is so much deep inspection of the internal objects,
-// explicitly annotating the namespaces for commonly expected objects makes the
-// code unreadable. Prefer using directives instead.
-using base::internal::PartitionBucket;
-using base::internal::PartitionPage;
-
-namespace {
-
-constexpr size_t kTestMaxAllocation = base::kSystemPageSize;
-
-bool IsLargeMemoryDevice() {
- // Treat any device with 2GiB or more of physical memory as a "large memory
- // device". We check for slightly less than 2GiB so that devices with a small
- // amount of memory not accessible to the OS still count as "large".
- return base::SysInfo::AmountOfPhysicalMemory() >= 2040LL * 1024 * 1024;
-}
-
-bool SetAddressSpaceLimit() {
-#if !defined(ARCH_CPU_64_BITS) || !defined(OS_POSIX)
- // 32 bits => address space is limited already.
- return true;
-#elif defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
- // macOS will accept, but not enforce, |RLIMIT_AS| changes. See
- // https://crbug.com/435269 and rdar://17576114.
- //
- // Note: This number must be not less than 6 GB, because with
- // sanitizer_coverage_flags=edge, it reserves > 5 GB of address space. See
- // https://crbug.com/674665.
- const size_t kAddressSpaceLimit = static_cast<size_t>(6144) * 1024 * 1024;
- struct rlimit limit;
- if (getrlimit(RLIMIT_AS, &limit) != 0)
- return false;
- if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur > kAddressSpaceLimit) {
- limit.rlim_cur = kAddressSpaceLimit;
- if (setrlimit(RLIMIT_AS, &limit) != 0)
- return false;
- }
- return true;
-#else
- return false;
-#endif
-}
-
-bool ClearAddressSpaceLimit() {
-#if !defined(ARCH_CPU_64_BITS) || !defined(OS_POSIX) || defined(OS_FUCHSIA)
- return true;
-#elif defined(OS_POSIX)
- struct rlimit limit;
- if (getrlimit(RLIMIT_AS, &limit) != 0)
- return false;
- limit.rlim_cur = limit.rlim_max;
- if (setrlimit(RLIMIT_AS, &limit) != 0)
- return false;
- return true;
-#else
- return false;
-#endif
-}
-
-} // namespace
-
-namespace base {
-
-// NOTE: Though this test actually excercises interfaces inside the ::base
-// namespace, the unittest is inside the ::base::internal spaces because a
-// portion of the test expectations require inspecting objects and behavior
-// in the ::base::internal namespace. An alternate formulation would be to
-// explicitly add using statements for each inspected type but this felt more
-// readable.
-namespace internal {
-
-const size_t kTestAllocSize = 16;
-#if !DCHECK_IS_ON()
-const size_t kPointerOffset = 0;
-const size_t kExtraAllocSize = 0;
-#else
-const size_t kPointerOffset = kCookieSize;
-const size_t kExtraAllocSize = kCookieSize * 2;
-#endif
-const size_t kRealAllocSize = kTestAllocSize + kExtraAllocSize;
-const size_t kTestBucketIndex = kRealAllocSize >> kBucketShift;
-
-const char* type_name = nullptr;
-
-class PartitionAllocTest : public testing::Test {
- protected:
- PartitionAllocTest() = default;
-
- ~PartitionAllocTest() override = default;
-
- void SetUp() override {
- allocator.init();
- generic_allocator.init();
- }
-
- PartitionPage* GetFullPage(size_t size) {
- size_t real_size = size + kExtraAllocSize;
- size_t bucket_index = real_size >> kBucketShift;
- PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
- size_t num_slots =
- (bucket->num_system_pages_per_slot_span * kSystemPageSize) / real_size;
- void* first = nullptr;
- void* last = nullptr;
- size_t i;
- for (i = 0; i < num_slots; ++i) {
- void* ptr = allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr);
- if (!i)
- first = PartitionCookieFreePointerAdjust(ptr);
- else if (i == num_slots - 1)
- last = PartitionCookieFreePointerAdjust(ptr);
- }
- EXPECT_EQ(PartitionPage::FromPointer(first),
- PartitionPage::FromPointer(last));
- if (bucket->num_system_pages_per_slot_span ==
- kNumSystemPagesPerPartitionPage)
- EXPECT_EQ(reinterpret_cast<size_t>(first) & kPartitionPageBaseMask,
- reinterpret_cast<size_t>(last) & kPartitionPageBaseMask);
- EXPECT_EQ(num_slots, static_cast<size_t>(
- bucket->active_pages_head->num_allocated_slots));
- EXPECT_EQ(nullptr, bucket->active_pages_head->freelist_head);
- EXPECT_TRUE(bucket->active_pages_head);
- EXPECT_TRUE(bucket->active_pages_head !=
- PartitionPage::get_sentinel_page());
- return bucket->active_pages_head;
- }
-
- void CycleFreeCache(size_t size) {
- size_t real_size = size + kExtraAllocSize;
- size_t bucket_index = real_size >> kBucketShift;
- PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
- DCHECK(!bucket->active_pages_head->num_allocated_slots);
-
- for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
- void* ptr = allocator.root()->Alloc(size, type_name);
- EXPECT_EQ(1, bucket->active_pages_head->num_allocated_slots);
- PartitionFree(ptr);
- EXPECT_EQ(0, bucket->active_pages_head->num_allocated_slots);
- EXPECT_NE(-1, bucket->active_pages_head->empty_cache_index);
- }
- }
-
- void CycleGenericFreeCache(size_t size) {
- for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
- void* ptr = generic_allocator.root()->Alloc(size, type_name);
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- PartitionBucket* bucket = page->bucket;
- EXPECT_EQ(1, bucket->active_pages_head->num_allocated_slots);
- generic_allocator.root()->Free(ptr);
- EXPECT_EQ(0, bucket->active_pages_head->num_allocated_slots);
- EXPECT_NE(-1, bucket->active_pages_head->empty_cache_index);
- }
- }
-
- void DoReturnNullTest(size_t allocSize, bool use_realloc) {
- // TODO(crbug.com/678782): Where necessary and possible, disable the
- // platform's OOM-killing behavior. OOM-killing makes this test flaky on
- // low-memory devices.
- if (!IsLargeMemoryDevice()) {
- LOG(WARNING)
- << "Skipping test on this device because of crbug.com/678782";
- return;
- }
-
- ASSERT_TRUE(SetAddressSpaceLimit());
-
- // Work out the number of allocations for 6 GB of memory.
- const int numAllocations = (6 * 1024 * 1024) / (allocSize / 1024);
-
- void** ptrs = reinterpret_cast<void**>(generic_allocator.root()->Alloc(
- numAllocations * sizeof(void*), type_name));
- int i;
-
- for (i = 0; i < numAllocations; ++i) {
- if (use_realloc) {
- ptrs[i] = PartitionAllocGenericFlags(
- generic_allocator.root(), PartitionAllocReturnNull, 1, type_name);
- ptrs[i] = PartitionReallocGenericFlags(generic_allocator.root(),
- PartitionAllocReturnNull,
- ptrs[i], allocSize, type_name);
- } else {
- ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
- PartitionAllocReturnNull,
- allocSize, type_name);
- }
- if (!i)
- EXPECT_TRUE(ptrs[0]);
- if (!ptrs[i]) {
- ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
- PartitionAllocReturnNull,
- allocSize, type_name);
- EXPECT_FALSE(ptrs[i]);
- break;
- }
- }
-
- // We shouldn't succeed in allocating all 6 GB of memory. If we do, then
- // we're not actually testing anything here.
- EXPECT_LT(i, numAllocations);
-
- // Free, reallocate and free again each block we allocated. We do this to
- // check that freeing memory also works correctly after a failed allocation.
- for (--i; i >= 0; --i) {
- generic_allocator.root()->Free(ptrs[i]);
- ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
- PartitionAllocReturnNull, allocSize,
- type_name);
- EXPECT_TRUE(ptrs[i]);
- generic_allocator.root()->Free(ptrs[i]);
- }
-
- generic_allocator.root()->Free(ptrs);
-
- EXPECT_TRUE(ClearAddressSpaceLimit());
- }
-
- SizeSpecificPartitionAllocator<kTestMaxAllocation> allocator;
- PartitionAllocatorGeneric generic_allocator;
-};
-
-class PartitionAllocDeathTest : public PartitionAllocTest {};
-
-namespace {
-
-void FreeFullPage(PartitionPage* page) {
- size_t size = page->bucket->slot_size;
- size_t num_slots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) / size;
- EXPECT_EQ(num_slots, static_cast<size_t>(abs(page->num_allocated_slots)));
- char* ptr = reinterpret_cast<char*>(PartitionPage::ToPointer(page));
- size_t i;
- for (i = 0; i < num_slots; ++i) {
- PartitionFree(ptr + kPointerOffset);
- ptr += size;
- }
-}
-
-#if defined(OS_LINUX)
-bool CheckPageInCore(void* ptr, bool in_core) {
- unsigned char ret = 0;
- EXPECT_EQ(0, mincore(ptr, kSystemPageSize, &ret));
- return in_core == (ret & 1);
-}
-
-#define CHECK_PAGE_IN_CORE(ptr, in_core) \
- EXPECT_TRUE(CheckPageInCore(ptr, in_core))
-#else
-#define CHECK_PAGE_IN_CORE(ptr, in_core) (void)(0)
-#endif // defined(OS_LINUX)
-
-class MockPartitionStatsDumper : public PartitionStatsDumper {
- public:
- MockPartitionStatsDumper()
- : total_resident_bytes(0),
- total_active_bytes(0),
- total_decommittable_bytes(0),
- total_discardable_bytes(0) {}
-
- void PartitionDumpTotals(const char* partition_name,
- const PartitionMemoryStats* stats) override {
- EXPECT_GE(stats->total_mmapped_bytes, stats->total_resident_bytes);
- EXPECT_EQ(total_resident_bytes, stats->total_resident_bytes);
- EXPECT_EQ(total_active_bytes, stats->total_active_bytes);
- EXPECT_EQ(total_decommittable_bytes, stats->total_decommittable_bytes);
- EXPECT_EQ(total_discardable_bytes, stats->total_discardable_bytes);
- }
-
- void PartitionsDumpBucketStats(
- const char* partition_name,
- const PartitionBucketMemoryStats* stats) override {
- (void)partition_name;
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->bucket_slot_size & kAllocationGranularityMask);
- bucket_stats.push_back(*stats);
- total_resident_bytes += stats->resident_bytes;
- total_active_bytes += stats->active_bytes;
- total_decommittable_bytes += stats->decommittable_bytes;
- total_discardable_bytes += stats->discardable_bytes;
- }
-
- bool IsMemoryAllocationRecorded() {
- return total_resident_bytes != 0 && total_active_bytes != 0;
- }
-
- const PartitionBucketMemoryStats* GetBucketStats(size_t bucket_size) {
- for (size_t i = 0; i < bucket_stats.size(); ++i) {
- if (bucket_stats[i].bucket_slot_size == bucket_size)
- return &bucket_stats[i];
- }
- return nullptr;
- }
-
- private:
- size_t total_resident_bytes;
- size_t total_active_bytes;
- size_t total_decommittable_bytes;
- size_t total_discardable_bytes;
-
- std::vector<PartitionBucketMemoryStats> bucket_stats;
-};
-
-} // namespace
-
-// Check that the most basic of allocate / free pairs work.
-TEST_F(PartitionAllocTest, Basic) {
- PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
- PartitionPage* seedPage = PartitionPage::get_sentinel_page();
-
- EXPECT_FALSE(bucket->empty_pages_head);
- EXPECT_FALSE(bucket->decommitted_pages_head);
- EXPECT_EQ(seedPage, bucket->active_pages_head);
- EXPECT_EQ(nullptr, bucket->active_pages_head->next_page);
-
- void* ptr = allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_TRUE(ptr);
- EXPECT_EQ(kPointerOffset,
- reinterpret_cast<size_t>(ptr) & kPartitionPageOffsetMask);
- // Check that the offset appears to include a guard page.
- EXPECT_EQ(kPartitionPageSize + kPointerOffset,
- reinterpret_cast<size_t>(ptr) & kSuperPageOffsetMask);
-
- PartitionFree(ptr);
- // Expect that the last active page gets noticed as empty but doesn't get
- // decommitted.
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_FALSE(bucket->decommitted_pages_head);
-}
-
-// Test multiple allocations, and freelist handling.
-TEST_F(PartitionAllocTest, MultiAlloc) {
- char* ptr1 = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- char* ptr2 = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- EXPECT_TRUE(ptr1);
- EXPECT_TRUE(ptr2);
- ptrdiff_t diff = ptr2 - ptr1;
- EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
-
- // Check that we re-use the just-freed slot.
- PartitionFree(ptr2);
- ptr2 = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- EXPECT_TRUE(ptr2);
- diff = ptr2 - ptr1;
- EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
- PartitionFree(ptr1);
- ptr1 = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- EXPECT_TRUE(ptr1);
- diff = ptr2 - ptr1;
- EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
-
- char* ptr3 = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- EXPECT_TRUE(ptr3);
- diff = ptr3 - ptr1;
- EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize * 2), diff);
-
- PartitionFree(ptr1);
- PartitionFree(ptr2);
- PartitionFree(ptr3);
-}
-
-// Test a bucket with multiple pages.
-TEST_F(PartitionAllocTest, MultiPages) {
- PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
-
- PartitionPage* page = GetFullPage(kTestAllocSize);
- FreeFullPage(page);
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_EQ(PartitionPage::get_sentinel_page(), bucket->active_pages_head);
- EXPECT_EQ(nullptr, page->next_page);
- EXPECT_EQ(0, page->num_allocated_slots);
-
- page = GetFullPage(kTestAllocSize);
- PartitionPage* page2 = GetFullPage(kTestAllocSize);
-
- EXPECT_EQ(page2, bucket->active_pages_head);
- EXPECT_EQ(nullptr, page2->next_page);
- EXPECT_EQ(reinterpret_cast<uintptr_t>(PartitionPage::ToPointer(page)) &
- kSuperPageBaseMask,
- reinterpret_cast<uintptr_t>(PartitionPage::ToPointer(page2)) &
- kSuperPageBaseMask);
-
- // Fully free the non-current page. This will leave us with no current
- // active page because one is empty and the other is full.
- FreeFullPage(page);
- EXPECT_EQ(0, page->num_allocated_slots);
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_EQ(PartitionPage::get_sentinel_page(), bucket->active_pages_head);
-
- // Allocate a new page, it should pull from the freelist.
- page = GetFullPage(kTestAllocSize);
- EXPECT_FALSE(bucket->empty_pages_head);
- EXPECT_EQ(page, bucket->active_pages_head);
-
- FreeFullPage(page);
- FreeFullPage(page2);
- EXPECT_EQ(0, page->num_allocated_slots);
- EXPECT_EQ(0, page2->num_allocated_slots);
- EXPECT_EQ(0, page2->num_unprovisioned_slots);
- EXPECT_NE(-1, page2->empty_cache_index);
-}
-
-// Test some finer aspects of internal page transitions.
-TEST_F(PartitionAllocTest, PageTransitions) {
- PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
-
- PartitionPage* page1 = GetFullPage(kTestAllocSize);
- EXPECT_EQ(page1, bucket->active_pages_head);
- EXPECT_EQ(nullptr, page1->next_page);
- PartitionPage* page2 = GetFullPage(kTestAllocSize);
- EXPECT_EQ(page2, bucket->active_pages_head);
- EXPECT_EQ(nullptr, page2->next_page);
-
- // Bounce page1 back into the non-full list then fill it up again.
- char* ptr =
- reinterpret_cast<char*>(PartitionPage::ToPointer(page1)) + kPointerOffset;
- PartitionFree(ptr);
- EXPECT_EQ(page1, bucket->active_pages_head);
- (void)allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_EQ(page1, bucket->active_pages_head);
- EXPECT_EQ(page2, bucket->active_pages_head->next_page);
-
- // Allocating another page at this point should cause us to scan over page1
- // (which is both full and NOT our current page), and evict it from the
- // freelist. Older code had a O(n^2) condition due to failure to do this.
- PartitionPage* page3 = GetFullPage(kTestAllocSize);
- EXPECT_EQ(page3, bucket->active_pages_head);
- EXPECT_EQ(nullptr, page3->next_page);
-
- // Work out a pointer into page2 and free it.
- ptr =
- reinterpret_cast<char*>(PartitionPage::ToPointer(page2)) + kPointerOffset;
- PartitionFree(ptr);
- // Trying to allocate at this time should cause us to cycle around to page2
- // and find the recently freed slot.
- char* newPtr = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- EXPECT_EQ(ptr, newPtr);
- EXPECT_EQ(page2, bucket->active_pages_head);
- EXPECT_EQ(page3, page2->next_page);
-
- // Work out a pointer into page1 and free it. This should pull the page
- // back into the list of available pages.
- ptr =
- reinterpret_cast<char*>(PartitionPage::ToPointer(page1)) + kPointerOffset;
- PartitionFree(ptr);
- // This allocation should be satisfied by page1.
- newPtr = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- EXPECT_EQ(ptr, newPtr);
- EXPECT_EQ(page1, bucket->active_pages_head);
- EXPECT_EQ(page2, page1->next_page);
-
- FreeFullPage(page3);
- FreeFullPage(page2);
- FreeFullPage(page1);
-
- // Allocating whilst in this state exposed a bug, so keep the test.
- ptr = reinterpret_cast<char*>(
- allocator.root()->Alloc(kTestAllocSize, type_name));
- PartitionFree(ptr);
-}
-
-// Test some corner cases relating to page transitions in the internal
-// free page list metadata bucket.
-TEST_F(PartitionAllocTest, FreePageListPageTransitions) {
- PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
-
- size_t numToFillFreeListPage =
- kPartitionPageSize / (sizeof(PartitionPage) + kExtraAllocSize);
- // The +1 is because we need to account for the fact that the current page
- // never gets thrown on the freelist.
- ++numToFillFreeListPage;
- auto pages = std::make_unique<PartitionPage* []>(numToFillFreeListPage);
-
- size_t i;
- for (i = 0; i < numToFillFreeListPage; ++i) {
- pages[i] = GetFullPage(kTestAllocSize);
- }
- EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->active_pages_head);
- for (i = 0; i < numToFillFreeListPage; ++i)
- FreeFullPage(pages[i]);
- EXPECT_EQ(PartitionPage::get_sentinel_page(), bucket->active_pages_head);
- EXPECT_TRUE(bucket->empty_pages_head);
-
- // Allocate / free in a different bucket size so we get control of a
- // different free page list. We need two pages because one will be the last
- // active page and not get freed.
- PartitionPage* page1 = GetFullPage(kTestAllocSize * 2);
- PartitionPage* page2 = GetFullPage(kTestAllocSize * 2);
- FreeFullPage(page1);
- FreeFullPage(page2);
-
- for (i = 0; i < numToFillFreeListPage; ++i) {
- pages[i] = GetFullPage(kTestAllocSize);
- }
- EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->active_pages_head);
-
- for (i = 0; i < numToFillFreeListPage; ++i)
- FreeFullPage(pages[i]);
- EXPECT_EQ(PartitionPage::get_sentinel_page(), bucket->active_pages_head);
- EXPECT_TRUE(bucket->empty_pages_head);
-}
-
-// Test a large series of allocations that cross more than one underlying
-// 64KB super page allocation.
-TEST_F(PartitionAllocTest, MultiPageAllocs) {
- // This is guaranteed to cross a super page boundary because the first
- // partition page "slot" will be taken up by a guard page.
- size_t numPagesNeeded = kNumPartitionPagesPerSuperPage;
- // The super page should begin and end in a guard so we one less page in
- // order to allocate a single page in the new super page.
- --numPagesNeeded;
-
- EXPECT_GT(numPagesNeeded, 1u);
- auto pages = std::make_unique<PartitionPage* []>(numPagesNeeded);
- uintptr_t firstSuperPageBase = 0;
- size_t i;
- for (i = 0; i < numPagesNeeded; ++i) {
- pages[i] = GetFullPage(kTestAllocSize);
- void* storagePtr = PartitionPage::ToPointer(pages[i]);
- if (!i)
- firstSuperPageBase =
- reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
- if (i == numPagesNeeded - 1) {
- uintptr_t secondSuperPageBase =
- reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
- uintptr_t secondSuperPageOffset =
- reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageOffsetMask;
- EXPECT_FALSE(secondSuperPageBase == firstSuperPageBase);
- // Check that we allocated a guard page for the second page.
- EXPECT_EQ(kPartitionPageSize, secondSuperPageOffset);
- }
- }
- for (i = 0; i < numPagesNeeded; ++i)
- FreeFullPage(pages[i]);
-}
-
-// Test the generic allocation functions that can handle arbitrary sizes and
-// reallocing etc.
-TEST_F(PartitionAllocTest, GenericAlloc) {
- void* ptr = generic_allocator.root()->Alloc(1, type_name);
- EXPECT_TRUE(ptr);
- generic_allocator.root()->Free(ptr);
- ptr = generic_allocator.root()->Alloc(kGenericMaxBucketed + 1, type_name);
- EXPECT_TRUE(ptr);
- generic_allocator.root()->Free(ptr);
-
- ptr = generic_allocator.root()->Alloc(1, type_name);
- EXPECT_TRUE(ptr);
- void* origPtr = ptr;
- char* charPtr = static_cast<char*>(ptr);
- *charPtr = 'A';
-
- // Change the size of the realloc, remaining inside the same bucket.
- void* newPtr = generic_allocator.root()->Realloc(ptr, 2, type_name);
- EXPECT_EQ(ptr, newPtr);
- newPtr = generic_allocator.root()->Realloc(ptr, 1, type_name);
- EXPECT_EQ(ptr, newPtr);
- newPtr =
- generic_allocator.root()->Realloc(ptr, kGenericSmallestBucket, type_name);
- EXPECT_EQ(ptr, newPtr);
-
- // Change the size of the realloc, switching buckets.
- newPtr = generic_allocator.root()->Realloc(ptr, kGenericSmallestBucket + 1,
- type_name);
- EXPECT_NE(newPtr, ptr);
- // Check that the realloc copied correctly.
- char* newCharPtr = static_cast<char*>(newPtr);
- EXPECT_EQ(*newCharPtr, 'A');
-#if DCHECK_IS_ON()
- // Subtle: this checks for an old bug where we copied too much from the
- // source of the realloc. The condition can be detected by a trashing of
- // the uninitialized value in the space of the upsized allocation.
- EXPECT_EQ(kUninitializedByte,
- static_cast<unsigned char>(*(newCharPtr + kGenericSmallestBucket)));
-#endif
- *newCharPtr = 'B';
- // The realloc moved. To check that the old allocation was freed, we can
- // do an alloc of the old allocation size and check that the old allocation
- // address is at the head of the freelist and reused.
- void* reusedPtr = generic_allocator.root()->Alloc(1, type_name);
- EXPECT_EQ(reusedPtr, origPtr);
- generic_allocator.root()->Free(reusedPtr);
-
- // Downsize the realloc.
- ptr = newPtr;
- newPtr = generic_allocator.root()->Realloc(ptr, 1, type_name);
- EXPECT_EQ(newPtr, origPtr);
- newCharPtr = static_cast<char*>(newPtr);
- EXPECT_EQ(*newCharPtr, 'B');
- *newCharPtr = 'C';
-
- // Upsize the realloc to outside the partition.
- ptr = newPtr;
- newPtr = generic_allocator.root()->Realloc(ptr, kGenericMaxBucketed + 1,
- type_name);
- EXPECT_NE(newPtr, ptr);
- newCharPtr = static_cast<char*>(newPtr);
- EXPECT_EQ(*newCharPtr, 'C');
- *newCharPtr = 'D';
-
- // Upsize and downsize the realloc, remaining outside the partition.
- ptr = newPtr;
- newPtr = generic_allocator.root()->Realloc(ptr, kGenericMaxBucketed * 10,
- type_name);
- newCharPtr = static_cast<char*>(newPtr);
- EXPECT_EQ(*newCharPtr, 'D');
- *newCharPtr = 'E';
- ptr = newPtr;
- newPtr = generic_allocator.root()->Realloc(ptr, kGenericMaxBucketed * 2,
- type_name);
- newCharPtr = static_cast<char*>(newPtr);
- EXPECT_EQ(*newCharPtr, 'E');
- *newCharPtr = 'F';
-
- // Downsize the realloc to inside the partition.
- ptr = newPtr;
- newPtr = generic_allocator.root()->Realloc(ptr, 1, type_name);
- EXPECT_NE(newPtr, ptr);
- EXPECT_EQ(newPtr, origPtr);
- newCharPtr = static_cast<char*>(newPtr);
- EXPECT_EQ(*newCharPtr, 'F');
-
- generic_allocator.root()->Free(newPtr);
-}
-
-// Test the generic allocation functions can handle some specific sizes of
-// interest.
-TEST_F(PartitionAllocTest, GenericAllocSizes) {
- void* ptr = generic_allocator.root()->Alloc(0, type_name);
- EXPECT_TRUE(ptr);
- generic_allocator.root()->Free(ptr);
-
- // kPartitionPageSize is interesting because it results in just one
- // allocation per page, which tripped up some corner cases.
- size_t size = kPartitionPageSize - kExtraAllocSize;
- ptr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr);
- void* ptr2 = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr2);
- generic_allocator.root()->Free(ptr);
- // Should be freeable at this point.
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_NE(-1, page->empty_cache_index);
- generic_allocator.root()->Free(ptr2);
-
- size = (((kPartitionPageSize * kMaxPartitionPagesPerSlotSpan) -
- kSystemPageSize) /
- 2) -
- kExtraAllocSize;
- ptr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr);
- memset(ptr, 'A', size);
- ptr2 = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr2);
- void* ptr3 = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr3);
- void* ptr4 = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr4);
-
- page = PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- PartitionPage* page2 =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr3));
- EXPECT_NE(page, page2);
-
- generic_allocator.root()->Free(ptr);
- generic_allocator.root()->Free(ptr3);
- generic_allocator.root()->Free(ptr2);
- // Should be freeable at this point.
- EXPECT_NE(-1, page->empty_cache_index);
- EXPECT_EQ(0, page->num_allocated_slots);
- EXPECT_EQ(0, page->num_unprovisioned_slots);
- void* newPtr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_EQ(ptr3, newPtr);
- newPtr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_EQ(ptr2, newPtr);
-#if defined(OS_LINUX) && !DCHECK_IS_ON()
- // On Linux, we have a guarantee that freelisting a page should cause its
- // contents to be nulled out. We check for null here to detect an bug we
- // had where a large slot size was causing us to not properly free all
- // resources back to the system.
- // We only run the check when asserts are disabled because when they are
- // enabled, the allocated area is overwritten with an "uninitialized"
- // byte pattern.
- EXPECT_EQ(0, *(reinterpret_cast<char*>(newPtr) + (size - 1)));
-#endif
- generic_allocator.root()->Free(newPtr);
- generic_allocator.root()->Free(ptr3);
- generic_allocator.root()->Free(ptr4);
-
- // Can we allocate a massive (512MB) size?
- // Allocate 512MB, but +1, to test for cookie writing alignment issues.
- // Test this only if the device has enough memory or it might fail due
- // to OOM.
- if (IsLargeMemoryDevice()) {
- ptr = generic_allocator.root()->Alloc(512 * 1024 * 1024 + 1, type_name);
- generic_allocator.root()->Free(ptr);
- }
-
- // Check a more reasonable, but still direct mapped, size.
- // Chop a system page and a byte off to test for rounding errors.
- size = 20 * 1024 * 1024;
- size -= kSystemPageSize;
- size -= 1;
- ptr = generic_allocator.root()->Alloc(size, type_name);
- char* charPtr = reinterpret_cast<char*>(ptr);
- *(charPtr + (size - 1)) = 'A';
- generic_allocator.root()->Free(ptr);
-
- // Can we free null?
- generic_allocator.root()->Free(nullptr);
-
- // Do we correctly get a null for a failed allocation?
- EXPECT_EQ(nullptr, PartitionAllocGenericFlags(
- generic_allocator.root(), PartitionAllocReturnNull,
- 3u * 1024 * 1024 * 1024, type_name));
-}
-
-// Test that we can fetch the real allocated size after an allocation.
-TEST_F(PartitionAllocTest, GenericAllocGetSize) {
- void* ptr;
- size_t requested_size, actual_size, predicted_size;
-
- EXPECT_TRUE(PartitionAllocSupportsGetSize());
-
- // Allocate something small.
- requested_size = 511 - kExtraAllocSize;
- predicted_size = generic_allocator.root()->ActualSize(requested_size);
- ptr = generic_allocator.root()->Alloc(requested_size, type_name);
- EXPECT_TRUE(ptr);
- actual_size = PartitionAllocGetSize(ptr);
- EXPECT_EQ(predicted_size, actual_size);
- EXPECT_LT(requested_size, actual_size);
- generic_allocator.root()->Free(ptr);
-
- // Allocate a size that should be a perfect match for a bucket, because it
- // is an exact power of 2.
- requested_size = (256 * 1024) - kExtraAllocSize;
- predicted_size = generic_allocator.root()->ActualSize(requested_size);
- ptr = generic_allocator.root()->Alloc(requested_size, type_name);
- EXPECT_TRUE(ptr);
- actual_size = PartitionAllocGetSize(ptr);
- EXPECT_EQ(predicted_size, actual_size);
- EXPECT_EQ(requested_size, actual_size);
- generic_allocator.root()->Free(ptr);
-
- // Allocate a size that is a system page smaller than a bucket. GetSize()
- // should return a larger size than we asked for now.
- size_t num = 64;
- while (num * kSystemPageSize >= 1024 * 1024) {
- num /= 2;
- }
- requested_size = num * kSystemPageSize - kSystemPageSize - kExtraAllocSize;
- predicted_size = generic_allocator.root()->ActualSize(requested_size);
- ptr = generic_allocator.root()->Alloc(requested_size, type_name);
- EXPECT_TRUE(ptr);
- actual_size = PartitionAllocGetSize(ptr);
- EXPECT_EQ(predicted_size, actual_size);
- EXPECT_EQ(requested_size + kSystemPageSize, actual_size);
- // Check that we can write at the end of the reported size too.
- char* charPtr = reinterpret_cast<char*>(ptr);
- *(charPtr + (actual_size - 1)) = 'A';
- generic_allocator.root()->Free(ptr);
-
- // Allocate something very large, and uneven.
- if (IsLargeMemoryDevice()) {
- requested_size = 512 * 1024 * 1024 - 1;
- predicted_size = generic_allocator.root()->ActualSize(requested_size);
- ptr = generic_allocator.root()->Alloc(requested_size, type_name);
- EXPECT_TRUE(ptr);
- actual_size = PartitionAllocGetSize(ptr);
- EXPECT_EQ(predicted_size, actual_size);
- EXPECT_LT(requested_size, actual_size);
- generic_allocator.root()->Free(ptr);
- }
-
- // Too large allocation.
- requested_size = kGenericMaxDirectMapped + 1;
- predicted_size = generic_allocator.root()->ActualSize(requested_size);
- EXPECT_EQ(requested_size, predicted_size);
-}
-
-// Test the realloc() contract.
-TEST_F(PartitionAllocTest, Realloc) {
- // realloc(0, size) should be equivalent to malloc().
- void* ptr =
- generic_allocator.root()->Realloc(nullptr, kTestAllocSize, type_name);
- memset(ptr, 'A', kTestAllocSize);
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- // realloc(ptr, 0) should be equivalent to free().
- void* ptr2 = generic_allocator.root()->Realloc(ptr, 0, type_name);
- EXPECT_EQ(nullptr, ptr2);
- EXPECT_EQ(PartitionCookieFreePointerAdjust(ptr), page->freelist_head);
-
- // Test that growing an allocation with realloc() copies everything from the
- // old allocation.
- size_t size = kSystemPageSize - kExtraAllocSize;
- EXPECT_EQ(size, generic_allocator.root()->ActualSize(size));
- ptr = generic_allocator.root()->Alloc(size, type_name);
- memset(ptr, 'A', size);
- ptr2 = generic_allocator.root()->Realloc(ptr, size + 1, type_name);
- EXPECT_NE(ptr, ptr2);
- char* charPtr2 = static_cast<char*>(ptr2);
- EXPECT_EQ('A', charPtr2[0]);
- EXPECT_EQ('A', charPtr2[size - 1]);
-#if DCHECK_IS_ON()
- EXPECT_EQ(kUninitializedByte, static_cast<unsigned char>(charPtr2[size]));
-#endif
-
- // Test that shrinking an allocation with realloc() also copies everything
- // from the old allocation.
- ptr = generic_allocator.root()->Realloc(ptr2, size - 1, type_name);
- EXPECT_NE(ptr2, ptr);
- char* charPtr = static_cast<char*>(ptr);
- EXPECT_EQ('A', charPtr[0]);
- EXPECT_EQ('A', charPtr[size - 2]);
-#if DCHECK_IS_ON()
- EXPECT_EQ(kUninitializedByte, static_cast<unsigned char>(charPtr[size - 1]));
-#endif
-
- generic_allocator.root()->Free(ptr);
-
- // Test that shrinking a direct mapped allocation happens in-place.
- size = kGenericMaxBucketed + 16 * kSystemPageSize;
- ptr = generic_allocator.root()->Alloc(size, type_name);
- size_t actual_size = PartitionAllocGetSize(ptr);
- ptr2 = generic_allocator.root()->Realloc(
- ptr, kGenericMaxBucketed + 8 * kSystemPageSize, type_name);
- EXPECT_EQ(ptr, ptr2);
- EXPECT_EQ(actual_size - 8 * kSystemPageSize, PartitionAllocGetSize(ptr2));
-
- // Test that a previously in-place shrunk direct mapped allocation can be
- // expanded up again within its original size.
- ptr = generic_allocator.root()->Realloc(ptr2, size - kSystemPageSize,
- type_name);
- EXPECT_EQ(ptr2, ptr);
- EXPECT_EQ(actual_size - kSystemPageSize, PartitionAllocGetSize(ptr));
-
- // Test that a direct mapped allocation is performed not in-place when the
- // new size is small enough.
- ptr2 = generic_allocator.root()->Realloc(ptr, kSystemPageSize, type_name);
- EXPECT_NE(ptr, ptr2);
-
- generic_allocator.root()->Free(ptr2);
-}
-
-// Tests the handing out of freelists for partial pages.
-TEST_F(PartitionAllocTest, PartialPageFreelists) {
- size_t big_size = allocator.root()->max_allocation - kExtraAllocSize;
- EXPECT_EQ(kSystemPageSize - kAllocationGranularity,
- big_size + kExtraAllocSize);
- size_t bucket_index = (big_size + kExtraAllocSize) >> kBucketShift;
- PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
- EXPECT_EQ(nullptr, bucket->empty_pages_head);
-
- void* ptr = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(ptr);
-
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- size_t totalSlots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
- (big_size + kExtraAllocSize);
- EXPECT_EQ(4u, totalSlots);
- // The freelist should have one entry, because we were able to exactly fit
- // one object slot and one freelist pointer (the null that the head points
- // to) into a system page.
- EXPECT_TRUE(page->freelist_head);
- EXPECT_EQ(1, page->num_allocated_slots);
- EXPECT_EQ(2, page->num_unprovisioned_slots);
-
- void* ptr2 = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(ptr2);
- EXPECT_FALSE(page->freelist_head);
- EXPECT_EQ(2, page->num_allocated_slots);
- EXPECT_EQ(2, page->num_unprovisioned_slots);
-
- void* ptr3 = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(ptr3);
- EXPECT_TRUE(page->freelist_head);
- EXPECT_EQ(3, page->num_allocated_slots);
- EXPECT_EQ(0, page->num_unprovisioned_slots);
-
- void* ptr4 = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(ptr4);
- EXPECT_FALSE(page->freelist_head);
- EXPECT_EQ(4, page->num_allocated_slots);
- EXPECT_EQ(0, page->num_unprovisioned_slots);
-
- void* ptr5 = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(ptr5);
-
- PartitionPage* page2 =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr5));
- EXPECT_EQ(1, page2->num_allocated_slots);
-
- // Churn things a little whilst there's a partial page freelist.
- PartitionFree(ptr);
- ptr = allocator.root()->Alloc(big_size, type_name);
- void* ptr6 = allocator.root()->Alloc(big_size, type_name);
-
- PartitionFree(ptr);
- PartitionFree(ptr2);
- PartitionFree(ptr3);
- PartitionFree(ptr4);
- PartitionFree(ptr5);
- PartitionFree(ptr6);
- EXPECT_NE(-1, page->empty_cache_index);
- EXPECT_NE(-1, page2->empty_cache_index);
- EXPECT_TRUE(page2->freelist_head);
- EXPECT_EQ(0, page2->num_allocated_slots);
-
- // And test a couple of sizes that do not cross kSystemPageSize with a single
- // allocation.
- size_t mediumSize = (kSystemPageSize / 2) - kExtraAllocSize;
- bucket_index = (mediumSize + kExtraAllocSize) >> kBucketShift;
- bucket = &allocator.root()->buckets()[bucket_index];
- EXPECT_EQ(nullptr, bucket->empty_pages_head);
-
- ptr = allocator.root()->Alloc(mediumSize, type_name);
- EXPECT_TRUE(ptr);
- page = PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(1, page->num_allocated_slots);
- totalSlots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
- (mediumSize + kExtraAllocSize);
- size_t firstPageSlots = kSystemPageSize / (mediumSize + kExtraAllocSize);
- EXPECT_EQ(2u, firstPageSlots);
- EXPECT_EQ(totalSlots - firstPageSlots, page->num_unprovisioned_slots);
-
- PartitionFree(ptr);
-
- size_t smallSize = (kSystemPageSize / 4) - kExtraAllocSize;
- bucket_index = (smallSize + kExtraAllocSize) >> kBucketShift;
- bucket = &allocator.root()->buckets()[bucket_index];
- EXPECT_EQ(nullptr, bucket->empty_pages_head);
-
- ptr = allocator.root()->Alloc(smallSize, type_name);
- EXPECT_TRUE(ptr);
- page = PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(1, page->num_allocated_slots);
- totalSlots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
- (smallSize + kExtraAllocSize);
- firstPageSlots = kSystemPageSize / (smallSize + kExtraAllocSize);
- EXPECT_EQ(totalSlots - firstPageSlots, page->num_unprovisioned_slots);
-
- PartitionFree(ptr);
- EXPECT_TRUE(page->freelist_head);
- EXPECT_EQ(0, page->num_allocated_slots);
-
- size_t verySmallSize = 32 - kExtraAllocSize;
- bucket_index = (verySmallSize + kExtraAllocSize) >> kBucketShift;
- bucket = &allocator.root()->buckets()[bucket_index];
- EXPECT_EQ(nullptr, bucket->empty_pages_head);
-
- ptr = allocator.root()->Alloc(verySmallSize, type_name);
- EXPECT_TRUE(ptr);
- page = PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(1, page->num_allocated_slots);
- totalSlots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
- (verySmallSize + kExtraAllocSize);
- firstPageSlots = kSystemPageSize / (verySmallSize + kExtraAllocSize);
- EXPECT_EQ(totalSlots - firstPageSlots, page->num_unprovisioned_slots);
-
- PartitionFree(ptr);
- EXPECT_TRUE(page->freelist_head);
- EXPECT_EQ(0, page->num_allocated_slots);
-
- // And try an allocation size (against the generic allocator) that is
- // larger than a system page.
- size_t pageAndAHalfSize =
- (kSystemPageSize + (kSystemPageSize / 2)) - kExtraAllocSize;
- ptr = generic_allocator.root()->Alloc(pageAndAHalfSize, type_name);
- EXPECT_TRUE(ptr);
- page = PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(1, page->num_allocated_slots);
- EXPECT_TRUE(page->freelist_head);
- totalSlots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
- (pageAndAHalfSize + kExtraAllocSize);
- EXPECT_EQ(totalSlots - 2, page->num_unprovisioned_slots);
- generic_allocator.root()->Free(ptr);
-
- // And then make sure than exactly the page size only faults one page.
- size_t pageSize = kSystemPageSize - kExtraAllocSize;
- ptr = generic_allocator.root()->Alloc(pageSize, type_name);
- EXPECT_TRUE(ptr);
- page = PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(1, page->num_allocated_slots);
- EXPECT_FALSE(page->freelist_head);
- totalSlots =
- (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
- (pageSize + kExtraAllocSize);
- EXPECT_EQ(totalSlots - 1, page->num_unprovisioned_slots);
- generic_allocator.root()->Free(ptr);
-}
-
-// Test some of the fragmentation-resistant properties of the allocator.
-TEST_F(PartitionAllocTest, PageRefilling) {
- PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
-
- // Grab two full pages and a non-full page.
- PartitionPage* page1 = GetFullPage(kTestAllocSize);
- PartitionPage* page2 = GetFullPage(kTestAllocSize);
- void* ptr = allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_TRUE(ptr);
- EXPECT_NE(page1, bucket->active_pages_head);
- EXPECT_NE(page2, bucket->active_pages_head);
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(1, page->num_allocated_slots);
-
- // Work out a pointer into page2 and free it; and then page1 and free it.
- char* ptr2 =
- reinterpret_cast<char*>(PartitionPage::ToPointer(page1)) + kPointerOffset;
- PartitionFree(ptr2);
- ptr2 =
- reinterpret_cast<char*>(PartitionPage::ToPointer(page2)) + kPointerOffset;
- PartitionFree(ptr2);
-
- // If we perform two allocations from the same bucket now, we expect to
- // refill both the nearly full pages.
- (void)allocator.root()->Alloc(kTestAllocSize, type_name);
- (void)allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_EQ(1, page->num_allocated_slots);
-
- FreeFullPage(page2);
- FreeFullPage(page1);
- PartitionFree(ptr);
-}
-
-// Basic tests to ensure that allocations work for partial page buckets.
-TEST_F(PartitionAllocTest, PartialPages) {
- // Find a size that is backed by a partial partition page.
- size_t size = sizeof(void*);
- PartitionBucket* bucket = nullptr;
- while (size < kTestMaxAllocation) {
- bucket = &allocator.root()->buckets()[size >> kBucketShift];
- if (bucket->num_system_pages_per_slot_span %
- kNumSystemPagesPerPartitionPage)
- break;
- size += sizeof(void*);
- }
- EXPECT_LT(size, kTestMaxAllocation);
-
- PartitionPage* page1 = GetFullPage(size);
- PartitionPage* page2 = GetFullPage(size);
- FreeFullPage(page2);
- FreeFullPage(page1);
-}
-
-// Test correct handling if our mapping collides with another.
-TEST_F(PartitionAllocTest, MappingCollision) {
- // The -2 is because the first and last partition pages in a super page are
- // guard pages.
- size_t numPartitionPagesNeeded = kNumPartitionPagesPerSuperPage - 2;
- auto firstSuperPagePages =
- std::make_unique<PartitionPage* []>(numPartitionPagesNeeded);
- auto secondSuperPagePages =
- std::make_unique<PartitionPage* []>(numPartitionPagesNeeded);
-
- size_t i;
- for (i = 0; i < numPartitionPagesNeeded; ++i)
- firstSuperPagePages[i] = GetFullPage(kTestAllocSize);
-
- char* pageBase =
- reinterpret_cast<char*>(PartitionPage::ToPointer(firstSuperPagePages[0]));
- EXPECT_EQ(kPartitionPageSize,
- reinterpret_cast<uintptr_t>(pageBase) & kSuperPageOffsetMask);
- pageBase -= kPartitionPageSize;
- // Map a single system page either side of the mapping for our allocations,
- // with the goal of tripping up alignment of the next mapping.
- void* map1 = AllocPages(pageBase - kPageAllocationGranularity,
- kPageAllocationGranularity,
- kPageAllocationGranularity, PageInaccessible);
- EXPECT_TRUE(map1);
- void* map2 = AllocPages(pageBase + kSuperPageSize, kPageAllocationGranularity,
- kPageAllocationGranularity, PageInaccessible);
- EXPECT_TRUE(map2);
-
- for (i = 0; i < numPartitionPagesNeeded; ++i)
- secondSuperPagePages[i] = GetFullPage(kTestAllocSize);
-
- FreePages(map1, kPageAllocationGranularity);
- FreePages(map2, kPageAllocationGranularity);
-
- pageBase = reinterpret_cast<char*>(
- PartitionPage::ToPointer(secondSuperPagePages[0]));
- EXPECT_EQ(kPartitionPageSize,
- reinterpret_cast<uintptr_t>(pageBase) & kSuperPageOffsetMask);
- pageBase -= kPartitionPageSize;
- // Map a single system page either side of the mapping for our allocations,
- // with the goal of tripping up alignment of the next mapping.
- map1 = AllocPages(pageBase - kPageAllocationGranularity,
- kPageAllocationGranularity, kPageAllocationGranularity,
- PageReadWrite);
- EXPECT_TRUE(map1);
- map2 = AllocPages(pageBase + kSuperPageSize, kPageAllocationGranularity,
- kPageAllocationGranularity, PageReadWrite);
- EXPECT_TRUE(map2);
- EXPECT_TRUE(
- SetSystemPagesAccess(map1, kPageAllocationGranularity, PageInaccessible));
- EXPECT_TRUE(
- SetSystemPagesAccess(map2, kPageAllocationGranularity, PageInaccessible));
-
- PartitionPage* pageInThirdSuperPage = GetFullPage(kTestAllocSize);
- FreePages(map1, kPageAllocationGranularity);
- FreePages(map2, kPageAllocationGranularity);
-
- EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(
- PartitionPage::ToPointer(pageInThirdSuperPage)) &
- kPartitionPageOffsetMask);
-
- // And make sure we really did get a page in a new superpage.
- EXPECT_NE(reinterpret_cast<uintptr_t>(
- PartitionPage::ToPointer(firstSuperPagePages[0])) &
- kSuperPageBaseMask,
- reinterpret_cast<uintptr_t>(
- PartitionPage::ToPointer(pageInThirdSuperPage)) &
- kSuperPageBaseMask);
- EXPECT_NE(reinterpret_cast<uintptr_t>(
- PartitionPage::ToPointer(secondSuperPagePages[0])) &
- kSuperPageBaseMask,
- reinterpret_cast<uintptr_t>(
- PartitionPage::ToPointer(pageInThirdSuperPage)) &
- kSuperPageBaseMask);
-
- FreeFullPage(pageInThirdSuperPage);
- for (i = 0; i < numPartitionPagesNeeded; ++i) {
- FreeFullPage(firstSuperPagePages[i]);
- FreeFullPage(secondSuperPagePages[i]);
- }
-}
-
-// Tests that pages in the free page cache do get freed as appropriate.
-TEST_F(PartitionAllocTest, FreeCache) {
- EXPECT_EQ(0U, allocator.root()->total_size_of_committed_pages);
-
- size_t big_size = allocator.root()->max_allocation - kExtraAllocSize;
- size_t bucket_index = (big_size + kExtraAllocSize) >> kBucketShift;
- PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
-
- void* ptr = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(ptr);
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- EXPECT_EQ(nullptr, bucket->empty_pages_head);
- EXPECT_EQ(1, page->num_allocated_slots);
- EXPECT_EQ(kPartitionPageSize,
- allocator.root()->total_size_of_committed_pages);
- PartitionFree(ptr);
- EXPECT_EQ(0, page->num_allocated_slots);
- EXPECT_NE(-1, page->empty_cache_index);
- EXPECT_TRUE(page->freelist_head);
-
- CycleFreeCache(kTestAllocSize);
-
- // Flushing the cache should have really freed the unused page.
- EXPECT_FALSE(page->freelist_head);
- EXPECT_EQ(-1, page->empty_cache_index);
- EXPECT_EQ(0, page->num_allocated_slots);
- PartitionBucket* cycle_free_cache_bucket =
- &allocator.root()->buckets()[kTestBucketIndex];
- EXPECT_EQ(
- cycle_free_cache_bucket->num_system_pages_per_slot_span * kSystemPageSize,
- allocator.root()->total_size_of_committed_pages);
-
- // Check that an allocation works ok whilst in this state (a free'd page
- // as the active pages head).
- ptr = allocator.root()->Alloc(big_size, type_name);
- EXPECT_FALSE(bucket->empty_pages_head);
- PartitionFree(ptr);
-
- // Also check that a page that is bouncing immediately between empty and
- // used does not get freed.
- for (size_t i = 0; i < kMaxFreeableSpans * 2; ++i) {
- ptr = allocator.root()->Alloc(big_size, type_name);
- EXPECT_TRUE(page->freelist_head);
- PartitionFree(ptr);
- EXPECT_TRUE(page->freelist_head);
- }
- EXPECT_EQ(kPartitionPageSize,
- allocator.root()->total_size_of_committed_pages);
-}
-
-// Tests for a bug we had with losing references to free pages.
-TEST_F(PartitionAllocTest, LostFreePagesBug) {
- size_t size = kPartitionPageSize - kExtraAllocSize;
-
- void* ptr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr);
- void* ptr2 = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr2);
-
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr));
- PartitionPage* page2 =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr2));
- PartitionBucket* bucket = page->bucket;
-
- EXPECT_EQ(nullptr, bucket->empty_pages_head);
- EXPECT_EQ(-1, page->num_allocated_slots);
- EXPECT_EQ(1, page2->num_allocated_slots);
-
- generic_allocator.root()->Free(ptr);
- generic_allocator.root()->Free(ptr2);
-
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_TRUE(bucket->empty_pages_head->next_page);
- EXPECT_EQ(0, page->num_allocated_slots);
- EXPECT_EQ(0, page2->num_allocated_slots);
- EXPECT_TRUE(page->freelist_head);
- EXPECT_TRUE(page2->freelist_head);
-
- CycleGenericFreeCache(kTestAllocSize);
-
- EXPECT_FALSE(page->freelist_head);
- EXPECT_FALSE(page2->freelist_head);
-
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_TRUE(bucket->empty_pages_head->next_page);
- EXPECT_EQ(PartitionPage::get_sentinel_page(), bucket->active_pages_head);
-
- // At this moment, we have two decommitted pages, on the empty list.
- ptr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr);
- generic_allocator.root()->Free(ptr);
-
- EXPECT_EQ(PartitionPage::get_sentinel_page(), bucket->active_pages_head);
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_TRUE(bucket->decommitted_pages_head);
-
- CycleGenericFreeCache(kTestAllocSize);
-
- // We're now set up to trigger a historical bug by scanning over the active
- // pages list. The current code gets into a different state, but we'll keep
- // the test as being an interesting corner case.
- ptr = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_TRUE(ptr);
- generic_allocator.root()->Free(ptr);
-
- EXPECT_TRUE(bucket->active_pages_head);
- EXPECT_TRUE(bucket->empty_pages_head);
- EXPECT_TRUE(bucket->decommitted_pages_head);
-}
-
-// Unit tests that check if an allocation fails in "return null" mode,
-// repeating it doesn't crash, and still returns null. The tests need to
-// stress memory subsystem limits to do so, hence they try to allocate
-// 6 GB of memory, each with a different per-allocation block sizes.
-//
-// On 64-bit systems we need to restrict the address space to force allocation
-// failure, so these tests run only on POSIX systems that provide setrlimit(),
-// and use it to limit address space to 6GB.
-//
-// Disable these tests on Android because, due to the allocation-heavy behavior,
-// they tend to get OOM-killed rather than pass.
-// TODO(https://crbug.com/779645): Fuchsia currently sets OS_POSIX, but does
-// not provide a working setrlimit().
-#if !defined(ARCH_CPU_64_BITS) || \
- (defined(OS_POSIX) && \
- !(defined(OS_FUCHSIA) || defined(OS_MACOSX) || defined(OS_ANDROID)))
-
-// This is defined as a separate test class because RepeatedReturnNull
-// test exhausts the process memory, and breaks any test in the same
-// class that runs after it.
-class PartitionAllocReturnNullTest : public PartitionAllocTest {};
-
-// Test "return null" for larger, direct-mapped allocations first. As a
-// direct-mapped allocation's pages are unmapped and freed on release, this
-// test is performd first for these "return null" tests in order to leave
-// sufficient unreserved virtual memory around for the later one(s).
-TEST_F(PartitionAllocReturnNullTest, RepeatedReturnNullDirect) {
- // A direct-mapped allocation size.
- DoReturnNullTest(32 * 1024 * 1024, false);
-}
-
-// Test "return null" with a 512 kB block size.
-TEST_F(PartitionAllocReturnNullTest, RepeatedReturnNull) {
- // A single-slot but non-direct-mapped allocation size.
- DoReturnNullTest(512 * 1024, false);
-}
-
-// Repeating the above tests using Realloc instead of Alloc.
-class PartitionReallocReturnNullTest : public PartitionAllocTest {};
-
-TEST_F(PartitionReallocReturnNullTest, RepeatedReturnNullDirect) {
- DoReturnNullTest(32 * 1024 * 1024, true);
-}
-
-TEST_F(PartitionReallocReturnNullTest, RepeatedReturnNull) {
- DoReturnNullTest(512 * 1024, true);
-}
-
-#endif // !defined(ARCH_CPU_64_BITS) || (defined(OS_POSIX) &&
- // !(defined(OS_FUCHSIA) || defined(OS_MACOSX) || defined(OS_ANDROID)))
-
-// Death tests misbehave on Android, http://crbug.com/643760.
-#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-
-// Make sure that malloc(-1) dies.
-// In the past, we had an integer overflow that would alias malloc(-1) to
-// malloc(0), which is not good.
-TEST_F(PartitionAllocDeathTest, LargeAllocs) {
- // Largest alloc.
- EXPECT_DEATH(
- generic_allocator.root()->Alloc(static_cast<size_t>(-1), type_name), "");
- // And the smallest allocation we expect to die.
- EXPECT_DEATH(
- generic_allocator.root()->Alloc(kGenericMaxDirectMapped + 1, type_name),
- "");
-}
-
-// Check that our immediate double-free detection works.
-TEST_F(PartitionAllocDeathTest, ImmediateDoubleFree) {
- void* ptr = generic_allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_TRUE(ptr);
- generic_allocator.root()->Free(ptr);
-
- EXPECT_DEATH(generic_allocator.root()->Free(ptr), "");
-}
-
-// Check that our refcount-based double-free detection works.
-TEST_F(PartitionAllocDeathTest, RefcountDoubleFree) {
- void* ptr = generic_allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_TRUE(ptr);
- void* ptr2 = generic_allocator.root()->Alloc(kTestAllocSize, type_name);
- EXPECT_TRUE(ptr2);
- generic_allocator.root()->Free(ptr);
- generic_allocator.root()->Free(ptr2);
- // This is not an immediate double-free so our immediate detection won't
- // fire. However, it does take the "refcount" of the partition page to -1,
- // which is illegal and should be trapped.
- EXPECT_DEATH(generic_allocator.root()->Free(ptr), "");
-}
-
-// Check that guard pages are present where expected.
-TEST_F(PartitionAllocDeathTest, GuardPages) {
-// PartitionAlloc adds kPartitionPageSize to the requested size
-// (for metadata), and then rounds that size to kPageAllocationGranularity.
-// To be able to reliably write one past a direct allocation, choose a size
-// that's
-// a) larger than kGenericMaxBucketed (to make the allocation direct)
-// b) aligned at kPageAllocationGranularity boundaries after
-// kPartitionPageSize has been added to it.
-// (On 32-bit, PartitionAlloc adds another kSystemPageSize to the
-// allocation size before rounding, but there it marks the memory right
-// after size as inaccessible, so it's fine to write 1 past the size we
-// hand to PartitionAlloc and we don't need to worry about allocation
-// granularities.)
-#define ALIGN(N, A) (((N) + (A)-1) / (A) * (A))
- const int kSize = ALIGN(kGenericMaxBucketed + 1 + kPartitionPageSize,
- kPageAllocationGranularity) -
- kPartitionPageSize;
-#undef ALIGN
- static_assert(kSize > kGenericMaxBucketed,
- "allocation not large enough for direct allocation");
- size_t size = kSize - kExtraAllocSize;
- void* ptr = generic_allocator.root()->Alloc(size, type_name);
-
- EXPECT_TRUE(ptr);
- char* charPtr = reinterpret_cast<char*>(ptr) - kPointerOffset;
-
- EXPECT_DEATH(*(charPtr - 1) = 'A', "");
- EXPECT_DEATH(*(charPtr + size + kExtraAllocSize) = 'A', "");
-
- generic_allocator.root()->Free(ptr);
-}
-
-// Check that a bad free() is caught where the free() refers to an unused
-// partition page of a large allocation.
-TEST_F(PartitionAllocDeathTest, FreeWrongPartitionPage) {
- // This large size will result in a direct mapped allocation with guard
- // pages at either end.
- void* ptr =
- generic_allocator.root()->Alloc(kPartitionPageSize * 2, type_name);
- EXPECT_TRUE(ptr);
- char* badPtr = reinterpret_cast<char*>(ptr) + kPartitionPageSize;
-
- EXPECT_DEATH(generic_allocator.root()->Free(badPtr), "");
-
- generic_allocator.root()->Free(ptr);
-}
-
-#endif // !defined(OS_ANDROID) && !defined(OS_IOS)
-
-// Tests that |PartitionDumpStatsGeneric| and |PartitionDumpStats| run without
-// crashing and return non-zero values when memory is allocated.
-TEST_F(PartitionAllocTest, DumpMemoryStats) {
- {
- void* ptr = allocator.root()->Alloc(kTestAllocSize, type_name);
- MockPartitionStatsDumper mockStatsDumper;
- allocator.root()->DumpStats("mock_allocator", false /* detailed dump */,
- &mockStatsDumper);
- EXPECT_TRUE(mockStatsDumper.IsMemoryAllocationRecorded());
- PartitionFree(ptr);
- }
-
- // This series of tests checks the active -> empty -> decommitted states.
- {
- {
- void* ptr =
- generic_allocator.root()->Alloc(2048 - kExtraAllocSize, type_name);
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(2048u, stats->bucket_slot_size);
- EXPECT_EQ(2048u, stats->active_bytes);
- EXPECT_EQ(kSystemPageSize, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(0u, stats->num_full_pages);
- EXPECT_EQ(1u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
- generic_allocator.root()->Free(ptr);
- }
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(2048u, stats->bucket_slot_size);
- EXPECT_EQ(0u, stats->active_bytes);
- EXPECT_EQ(kSystemPageSize, stats->resident_bytes);
- EXPECT_EQ(kSystemPageSize, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(0u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(1u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
- }
-
- // TODO(crbug.com/722911): Commenting this out causes this test to fail when
- // run singly (--gtest_filter=PartitionAllocTest.DumpMemoryStats), but not
- // when run with the others (--gtest_filter=PartitionAllocTest.*).
- CycleGenericFreeCache(kTestAllocSize);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(2048u, stats->bucket_slot_size);
- EXPECT_EQ(0u, stats->active_bytes);
- EXPECT_EQ(0u, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(0u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(1u, stats->num_decommitted_pages);
- }
- }
-
- // This test checks for correct empty page list accounting.
- {
- size_t size = kPartitionPageSize - kExtraAllocSize;
- void* ptr1 = generic_allocator.root()->Alloc(size, type_name);
- void* ptr2 = generic_allocator.root()->Alloc(size, type_name);
- generic_allocator.root()->Free(ptr1);
- generic_allocator.root()->Free(ptr2);
-
- CycleGenericFreeCache(kTestAllocSize);
-
- ptr1 = generic_allocator.root()->Alloc(size, type_name);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(kPartitionPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(kPartitionPageSize, stats->bucket_slot_size);
- EXPECT_EQ(kPartitionPageSize, stats->active_bytes);
- EXPECT_EQ(kPartitionPageSize, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(1u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(1u, stats->num_decommitted_pages);
- }
- generic_allocator.root()->Free(ptr1);
- }
-
- // This test checks for correct direct mapped accounting.
- {
- size_t size_smaller = kGenericMaxBucketed + 1;
- size_t size_bigger = (kGenericMaxBucketed * 2) + 1;
- size_t real_size_smaller =
- (size_smaller + kSystemPageOffsetMask) & kSystemPageBaseMask;
- size_t real_size_bigger =
- (size_bigger + kSystemPageOffsetMask) & kSystemPageBaseMask;
- void* ptr = generic_allocator.root()->Alloc(size_smaller, type_name);
- void* ptr2 = generic_allocator.root()->Alloc(size_bigger, type_name);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(real_size_smaller);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_TRUE(stats->is_direct_map);
- EXPECT_EQ(real_size_smaller, stats->bucket_slot_size);
- EXPECT_EQ(real_size_smaller, stats->active_bytes);
- EXPECT_EQ(real_size_smaller, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(1u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
-
- stats = dumper.GetBucketStats(real_size_bigger);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_TRUE(stats->is_direct_map);
- EXPECT_EQ(real_size_bigger, stats->bucket_slot_size);
- EXPECT_EQ(real_size_bigger, stats->active_bytes);
- EXPECT_EQ(real_size_bigger, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(1u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
- }
-
- generic_allocator.root()->Free(ptr2);
- generic_allocator.root()->Free(ptr);
-
- // Whilst we're here, allocate again and free with different ordering to
- // give a workout to our linked list code.
- ptr = generic_allocator.root()->Alloc(size_smaller, type_name);
- ptr2 = generic_allocator.root()->Alloc(size_bigger, type_name);
- generic_allocator.root()->Free(ptr);
- generic_allocator.root()->Free(ptr2);
- }
-
- // This test checks large-but-not-quite-direct allocations.
- {
- constexpr size_t requested_size = 16 * kSystemPageSize;
- void* ptr = generic_allocator.root()->Alloc(requested_size + 1, type_name);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- size_t slot_size =
- requested_size + (requested_size / kGenericNumBucketsPerOrder);
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(slot_size);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_FALSE(stats->is_direct_map);
- EXPECT_EQ(slot_size, stats->bucket_slot_size);
- EXPECT_EQ(requested_size + 1 + kExtraAllocSize, stats->active_bytes);
- EXPECT_EQ(slot_size, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(kSystemPageSize, stats->discardable_bytes);
- EXPECT_EQ(1u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
- }
-
- generic_allocator.root()->Free(ptr);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
-
- size_t slot_size =
- requested_size + (requested_size / kGenericNumBucketsPerOrder);
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(slot_size);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_FALSE(stats->is_direct_map);
- EXPECT_EQ(slot_size, stats->bucket_slot_size);
- EXPECT_EQ(0u, stats->active_bytes);
- EXPECT_EQ(slot_size, stats->resident_bytes);
- EXPECT_EQ(slot_size, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(1u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
- }
-
- void* ptr2 = generic_allocator.root()->Alloc(
- requested_size + kSystemPageSize + 1, type_name);
- EXPECT_EQ(ptr, ptr2);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- size_t slot_size =
- requested_size + (requested_size / kGenericNumBucketsPerOrder);
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(slot_size);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_FALSE(stats->is_direct_map);
- EXPECT_EQ(slot_size, stats->bucket_slot_size);
- EXPECT_EQ(requested_size + kSystemPageSize + 1 + kExtraAllocSize,
- stats->active_bytes);
- EXPECT_EQ(slot_size, stats->resident_bytes);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->discardable_bytes);
- EXPECT_EQ(1u, stats->num_full_pages);
- EXPECT_EQ(0u, stats->num_active_pages);
- EXPECT_EQ(0u, stats->num_empty_pages);
- EXPECT_EQ(0u, stats->num_decommitted_pages);
- }
-
- generic_allocator.root()->Free(ptr2);
- }
-}
-
-// Tests the API to purge freeable memory.
-TEST_F(PartitionAllocTest, Purge) {
- char* ptr = reinterpret_cast<char*>(
- generic_allocator.root()->Alloc(2048 - kExtraAllocSize, type_name));
- generic_allocator.root()->Free(ptr);
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(kSystemPageSize, stats->decommittable_bytes);
- EXPECT_EQ(kSystemPageSize, stats->resident_bytes);
- }
- generic_allocator.root()->PurgeMemory(PartitionPurgeDecommitEmptyPages);
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(0u, stats->resident_bytes);
- }
- // Calling purge again here is a good way of testing we didn't mess up the
- // state of the free cache ring.
- generic_allocator.root()->PurgeMemory(PartitionPurgeDecommitEmptyPages);
-
- char* bigPtr = reinterpret_cast<char*>(
- generic_allocator.root()->Alloc(256 * 1024, type_name));
- generic_allocator.root()->Free(bigPtr);
- generic_allocator.root()->PurgeMemory(PartitionPurgeDecommitEmptyPages);
-
- CHECK_PAGE_IN_CORE(ptr - kPointerOffset, false);
- CHECK_PAGE_IN_CORE(bigPtr - kPointerOffset, false);
-}
-
-// Tests that we prefer to allocate into a non-empty partition page over an
-// empty one. This is an important aspect of minimizing memory usage for some
-// allocation sizes, particularly larger ones.
-TEST_F(PartitionAllocTest, PreferActiveOverEmpty) {
- size_t size = (kSystemPageSize * 2) - kExtraAllocSize;
- // Allocate 3 full slot spans worth of 8192-byte allocations.
- // Each slot span for this size is 16384 bytes, or 1 partition page and 2
- // slots.
- void* ptr1 = generic_allocator.root()->Alloc(size, type_name);
- void* ptr2 = generic_allocator.root()->Alloc(size, type_name);
- void* ptr3 = generic_allocator.root()->Alloc(size, type_name);
- void* ptr4 = generic_allocator.root()->Alloc(size, type_name);
- void* ptr5 = generic_allocator.root()->Alloc(size, type_name);
- void* ptr6 = generic_allocator.root()->Alloc(size, type_name);
-
- PartitionPage* page1 =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr1));
- PartitionPage* page2 =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr3));
- PartitionPage* page3 =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr6));
- EXPECT_NE(page1, page2);
- EXPECT_NE(page2, page3);
- PartitionBucket* bucket = page1->bucket;
- EXPECT_EQ(page3, bucket->active_pages_head);
-
- // Free up the 2nd slot in each slot span.
- // This leaves the active list containing 3 pages, each with 1 used and 1
- // free slot. The active page will be the one containing ptr1.
- generic_allocator.root()->Free(ptr6);
- generic_allocator.root()->Free(ptr4);
- generic_allocator.root()->Free(ptr2);
- EXPECT_EQ(page1, bucket->active_pages_head);
-
- // Empty the middle page in the active list.
- generic_allocator.root()->Free(ptr3);
- EXPECT_EQ(page1, bucket->active_pages_head);
-
- // Empty the the first page in the active list -- also the current page.
- generic_allocator.root()->Free(ptr1);
-
- // A good choice here is to re-fill the third page since the first two are
- // empty. We used to fail that.
- void* ptr7 = generic_allocator.root()->Alloc(size, type_name);
- EXPECT_EQ(ptr6, ptr7);
- EXPECT_EQ(page3, bucket->active_pages_head);
-
- generic_allocator.root()->Free(ptr5);
- generic_allocator.root()->Free(ptr7);
-}
-
-// Tests the API to purge discardable memory.
-TEST_F(PartitionAllocTest, PurgeDiscardable) {
- // Free the second of two 4096 byte allocations and then purge.
- {
- void* ptr1 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- char* ptr2 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name));
- generic_allocator.root()->Free(ptr2);
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr1));
- EXPECT_EQ(2u, page->num_unprovisioned_slots);
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(kSystemPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(kSystemPageSize, stats->discardable_bytes);
- EXPECT_EQ(kSystemPageSize, stats->active_bytes);
- EXPECT_EQ(2 * kSystemPageSize, stats->resident_bytes);
- }
- CHECK_PAGE_IN_CORE(ptr2 - kPointerOffset, true);
- generic_allocator.root()->PurgeMemory(
- PartitionPurgeDiscardUnusedSystemPages);
- CHECK_PAGE_IN_CORE(ptr2 - kPointerOffset, false);
- EXPECT_EQ(3u, page->num_unprovisioned_slots);
-
- generic_allocator.root()->Free(ptr1);
- }
- // Free the first of two 4096 byte allocations and then purge.
- {
- char* ptr1 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name));
- void* ptr2 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- generic_allocator.root()->Free(ptr1);
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(kSystemPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
-#if defined(OS_WIN)
- EXPECT_EQ(0u, stats->discardable_bytes);
-#else
- EXPECT_EQ(kSystemPageSize, stats->discardable_bytes);
-#endif
- EXPECT_EQ(kSystemPageSize, stats->active_bytes);
- EXPECT_EQ(2 * kSystemPageSize, stats->resident_bytes);
- }
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- generic_allocator.root()->PurgeMemory(
- PartitionPurgeDiscardUnusedSystemPages);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, false);
-
- generic_allocator.root()->Free(ptr2);
- }
- {
- constexpr size_t requested_size = 2.25 * kSystemPageSize;
- char* ptr1 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- requested_size - kExtraAllocSize, type_name));
- void* ptr2 = generic_allocator.root()->Alloc(
- requested_size - kExtraAllocSize, type_name);
- void* ptr3 = generic_allocator.root()->Alloc(
- requested_size - kExtraAllocSize, type_name);
- void* ptr4 = generic_allocator.root()->Alloc(
- requested_size - kExtraAllocSize, type_name);
- memset(ptr1, 'A', requested_size - kExtraAllocSize);
- memset(ptr2, 'A', requested_size - kExtraAllocSize);
- generic_allocator.root()->Free(ptr2);
- generic_allocator.root()->Free(ptr1);
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(requested_size);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(2 * kSystemPageSize, stats->discardable_bytes);
- EXPECT_EQ(requested_size * 2, stats->active_bytes);
- EXPECT_EQ(9 * kSystemPageSize, stats->resident_bytes);
- }
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + kSystemPageSize, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 4), true);
- generic_allocator.root()->PurgeMemory(
- PartitionPurgeDiscardUnusedSystemPages);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + kSystemPageSize, false);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 4), true);
-
- generic_allocator.root()->Free(ptr3);
- generic_allocator.root()->Free(ptr4);
- }
-
-// When kSystemPageSize = 16384 (as on _MIPS_ARCH_LOONGSON), 64 *
-// kSystemPageSize (see the #else branch below) caused this test to OOM.
-// Therefore, for systems with 16 KiB pages, use 32 * kSystemPageSize.
-//
-// TODO(palmer): Refactor this to branch on page size instead of architecture,
-// for clarity of purpose and for applicability to more architectures.
-#if defined(_MIPS_ARCH_LOONGSON)
- {
- char* ptr1 = reinterpret_cast<char*>(PartitionAllocGeneric(
- generic_allocator.root(), (32 * kSystemPageSize) - kExtraAllocSize,
- type_name));
- memset(ptr1, 'A', (32 * kSystemPageSize) - kExtraAllocSize);
- PartitionFreeGeneric(generic_allocator.root(), ptr1);
- ptr1 = reinterpret_cast<char*>(PartitionAllocGeneric(
- generic_allocator.root(), (31 * kSystemPageSize) - kExtraAllocSize,
- type_name));
- {
- MockPartitionStatsDumper dumper;
- PartitionDumpStatsGeneric(generic_allocator.root(),
- "mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(32 * kSystemPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(kSystemPageSize, stats->discardable_bytes);
- EXPECT_EQ(31 * kSystemPageSize, stats->active_bytes);
- EXPECT_EQ(32 * kSystemPageSize, stats->resident_bytes);
- }
- CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 30), true);
- CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 31), true);
- PartitionPurgeMemoryGeneric(generic_allocator.root(),
- PartitionPurgeDiscardUnusedSystemPages);
- CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 30), true);
- CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 31), false);
-
- PartitionFreeGeneric(generic_allocator.root(), ptr1);
- }
-#else
- {
- char* ptr1 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- (64 * kSystemPageSize) - kExtraAllocSize, type_name));
- memset(ptr1, 'A', (64 * kSystemPageSize) - kExtraAllocSize);
- generic_allocator.root()->Free(ptr1);
- ptr1 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- (61 * kSystemPageSize) - kExtraAllocSize, type_name));
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(64 * kSystemPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(3 * kSystemPageSize, stats->discardable_bytes);
- EXPECT_EQ(61 * kSystemPageSize, stats->active_bytes);
- EXPECT_EQ(64 * kSystemPageSize, stats->resident_bytes);
- }
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 60), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 61), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 62), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 63), true);
- generic_allocator.root()->PurgeMemory(
- PartitionPurgeDiscardUnusedSystemPages);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 60), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 61), false);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 62), false);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 63), false);
-
- generic_allocator.root()->Free(ptr1);
- }
-#endif
- // This sub-test tests truncation of the provisioned slots in a trickier
- // case where the freelist is rewritten.
- generic_allocator.root()->PurgeMemory(PartitionPurgeDecommitEmptyPages);
- {
- char* ptr1 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name));
- void* ptr2 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- void* ptr3 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- void* ptr4 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- ptr1[0] = 'A';
- ptr1[kSystemPageSize] = 'A';
- ptr1[kSystemPageSize * 2] = 'A';
- ptr1[kSystemPageSize * 3] = 'A';
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr1));
- generic_allocator.root()->Free(ptr2);
- generic_allocator.root()->Free(ptr4);
- generic_allocator.root()->Free(ptr1);
- EXPECT_EQ(0u, page->num_unprovisioned_slots);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(kSystemPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
-#if defined(OS_WIN)
- EXPECT_EQ(kSystemPageSize, stats->discardable_bytes);
-#else
- EXPECT_EQ(2 * kSystemPageSize, stats->discardable_bytes);
-#endif
- EXPECT_EQ(kSystemPageSize, stats->active_bytes);
- EXPECT_EQ(4 * kSystemPageSize, stats->resident_bytes);
- }
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + kSystemPageSize, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
- generic_allocator.root()->PurgeMemory(
- PartitionPurgeDiscardUnusedSystemPages);
- EXPECT_EQ(1u, page->num_unprovisioned_slots);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + kSystemPageSize, false);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
-
- // Let's check we didn't brick the freelist.
- void* ptr1b = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- EXPECT_EQ(ptr1, ptr1b);
- void* ptr2b = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- EXPECT_EQ(ptr2, ptr2b);
- EXPECT_FALSE(page->freelist_head);
-
- generic_allocator.root()->Free(ptr1);
- generic_allocator.root()->Free(ptr2);
- generic_allocator.root()->Free(ptr3);
- }
- // This sub-test is similar, but tests a double-truncation.
- generic_allocator.root()->PurgeMemory(PartitionPurgeDecommitEmptyPages);
- {
- char* ptr1 = reinterpret_cast<char*>(generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name));
- void* ptr2 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- void* ptr3 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- void* ptr4 = generic_allocator.root()->Alloc(
- kSystemPageSize - kExtraAllocSize, type_name);
- ptr1[0] = 'A';
- ptr1[kSystemPageSize] = 'A';
- ptr1[kSystemPageSize * 2] = 'A';
- ptr1[kSystemPageSize * 3] = 'A';
- PartitionPage* page =
- PartitionPage::FromPointer(PartitionCookieFreePointerAdjust(ptr1));
- generic_allocator.root()->Free(ptr4);
- generic_allocator.root()->Free(ptr3);
- EXPECT_EQ(0u, page->num_unprovisioned_slots);
-
- {
- MockPartitionStatsDumper dumper;
- generic_allocator.root()->DumpStats("mock_generic_allocator",
- false /* detailed dump */, &dumper);
- EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
-
- const PartitionBucketMemoryStats* stats =
- dumper.GetBucketStats(kSystemPageSize);
- EXPECT_TRUE(stats);
- EXPECT_TRUE(stats->is_valid);
- EXPECT_EQ(0u, stats->decommittable_bytes);
- EXPECT_EQ(2 * kSystemPageSize, stats->discardable_bytes);
- EXPECT_EQ(2 * kSystemPageSize, stats->active_bytes);
- EXPECT_EQ(4 * kSystemPageSize, stats->resident_bytes);
- }
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + kSystemPageSize, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 2), true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 3), true);
- generic_allocator.root()->PurgeMemory(
- PartitionPurgeDiscardUnusedSystemPages);
- EXPECT_EQ(2u, page->num_unprovisioned_slots);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + kSystemPageSize, true);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 2), false);
- CHECK_PAGE_IN_CORE(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
-
- EXPECT_FALSE(page->freelist_head);
-
- generic_allocator.root()->Free(ptr1);
- generic_allocator.root()->Free(ptr2);
- }
-}
-
-TEST_F(PartitionAllocTest, ReallocMovesCookies) {
- // Resize so as to be sure to hit a "resize in place" case, and ensure that
- // use of the entire result is compatible with the debug mode's cookies, even
- // when the bucket size is large enough to span more than one partition page
- // and we can track the "raw" size. See https://crbug.com/709271
- static constexpr size_t kSize =
- base::kMaxSystemPagesPerSlotSpan * base::kSystemPageSize;
- void* ptr = generic_allocator.root()->Alloc(kSize + 1, type_name);
- EXPECT_TRUE(ptr);
-
- memset(ptr, 0xbd, kSize + 1);
- ptr = generic_allocator.root()->Realloc(ptr, kSize + 2, type_name);
- EXPECT_TRUE(ptr);
-
- memset(ptr, 0xbd, kSize + 2);
- generic_allocator.root()->Free(ptr);
-}
-
-TEST_F(PartitionAllocTest, SmallReallocDoesNotMoveTrailingCookie) {
- // For crbug.com/781473
- static constexpr size_t kSize = 264;
- void* ptr = generic_allocator.root()->Alloc(kSize, type_name);
- EXPECT_TRUE(ptr);
-
- ptr = generic_allocator.root()->Realloc(ptr, kSize + 16, type_name);
- EXPECT_TRUE(ptr);
-
- generic_allocator.root()->Free(ptr);
-}
-
-} // namespace internal
-} // namespace base
-
-#endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
diff --git a/base/allocator/partition_allocator/spin_lock_unittest.cc b/base/allocator/partition_allocator/spin_lock_unittest.cc
deleted file mode 100644
index 6a1fd6b..0000000
--- a/base/allocator/partition_allocator/spin_lock_unittest.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2017 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 "base/allocator/partition_allocator/spin_lock.h"
-
-#include <memory>
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-static const size_t kBufferSize = 16;
-
-static subtle::SpinLock g_lock;
-
-static void FillBuffer(volatile char* buffer, char fill_pattern) {
- for (size_t i = 0; i < kBufferSize; ++i)
- buffer[i] = fill_pattern;
-}
-
-static void ChangeAndCheckBuffer(volatile char* buffer) {
- FillBuffer(buffer, '\0');
- int total = 0;
- for (size_t i = 0; i < kBufferSize; ++i)
- total += buffer[i];
-
- EXPECT_EQ(0, total);
-
- // This will mess with the other thread's calculation if we accidentally get
- // concurrency.
- FillBuffer(buffer, '!');
-}
-
-static void ThreadMain(volatile char* buffer) {
- for (int i = 0; i < 500000; ++i) {
- subtle::SpinLock::Guard guard(g_lock);
- ChangeAndCheckBuffer(buffer);
- }
-}
-
-TEST(SpinLockTest, Torture) {
- char shared_buffer[kBufferSize];
-
- Thread thread1("thread1");
- Thread thread2("thread2");
-
- thread1.StartAndWaitForTesting();
- thread2.StartAndWaitForTesting();
-
- thread1.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&ThreadMain, Unretained(static_cast<char*>(shared_buffer))));
- thread2.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&ThreadMain, Unretained(static_cast<char*>(shared_buffer))));
-}
-
-} // namespace base
diff --git a/base/allocator/tcmalloc_unittest.cc b/base/allocator/tcmalloc_unittest.cc
deleted file mode 100644
index 4b5b664..0000000
--- a/base/allocator/tcmalloc_unittest.cc
+++ /dev/null
@@ -1,235 +0,0 @@
-// 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.
-
-#include <stddef.h>
-#include <stdio.h>
-
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/process/process_metrics.h"
-#include "base/sys_info.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(USE_TCMALLOC)
-namespace {
-
-using std::min;
-
-#ifdef NDEBUG
-// We wrap malloc and free in noinline functions to ensure that we test the real
-// implementation of the allocator. Otherwise, the compiler may specifically
-// recognize the calls to malloc and free in our tests and optimize them away.
-NOINLINE void* TCMallocDoMallocForTest(size_t size) {
- return malloc(size);
-}
-
-NOINLINE void TCMallocDoFreeForTest(void* ptr) {
- free(ptr);
-}
-#endif
-
-// Fill a buffer of the specified size with a predetermined pattern
-static void Fill(unsigned char* buffer, int n) {
- for (int i = 0; i < n; i++) {
- buffer[i] = (i & 0xff);
- }
-}
-
-// Check that the specified buffer has the predetermined pattern
-// generated by Fill()
-static bool Valid(unsigned char* buffer, int n) {
- for (int i = 0; i < n; i++) {
- if (buffer[i] != (i & 0xff)) {
- return false;
- }
- }
- return true;
-}
-
-// Return the next interesting size/delta to check. Returns -1 if no more.
-static int NextSize(int size) {
- if (size < 100)
- return size + 1;
-
- if (size < 100000) {
- // Find next power of two
- int power = 1;
- while (power < size)
- power <<= 1;
-
- // Yield (power-1, power, power+1)
- if (size < power - 1)
- return power - 1;
-
- if (size == power - 1)
- return power;
-
- CHECK_EQ(size, power);
- return power + 1;
- } else {
- return -1;
- }
-}
-
-static void TestCalloc(size_t n, size_t s, bool ok) {
- char* p = reinterpret_cast<char*>(calloc(n, s));
- if (!ok) {
- EXPECT_EQ(nullptr, p) << "calloc(n, s) should not succeed";
- } else {
- EXPECT_NE(reinterpret_cast<void*>(NULL), p)
- << "calloc(n, s) should succeed";
- for (size_t i = 0; i < n * s; i++) {
- EXPECT_EQ('\0', p[i]);
- }
- free(p);
- }
-}
-
-bool IsLowMemoryDevice() {
- return base::SysInfo::AmountOfPhysicalMemory() <= 256LL * 1024 * 1024;
-}
-
-} // namespace
-
-TEST(TCMallocTest, Malloc) {
- // Try allocating data with a bunch of alignments and sizes
- for (int size = 1; size < 1048576; size *= 2) {
- unsigned char* ptr = reinterpret_cast<unsigned char*>(malloc(size));
- // Should be 2 byte aligned
- EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & 1);
- Fill(ptr, size);
- EXPECT_TRUE(Valid(ptr, size));
- free(ptr);
- }
-}
-
-TEST(TCMallocTest, Calloc) {
- TestCalloc(0, 0, true);
- TestCalloc(0, 1, true);
- TestCalloc(1, 1, true);
- TestCalloc(1 << 10, 0, true);
- TestCalloc(1 << 20, 0, true);
- TestCalloc(0, 1 << 10, true);
- TestCalloc(0, 1 << 20, true);
- TestCalloc(1 << 20, 2, true);
- TestCalloc(2, 1 << 20, true);
- TestCalloc(1000, 1000, true);
-}
-
-#ifdef NDEBUG
-// This makes sure that reallocing a small number of bytes in either
-// direction doesn't cause us to allocate new memory. Tcmalloc in debug mode
-// does not follow this.
-TEST(TCMallocTest, ReallocSmallDelta) {
- int start_sizes[] = {100, 1000, 10000, 100000};
- int deltas[] = {1, -2, 4, -8, 16, -32, 64, -128};
-
- for (unsigned s = 0; s < sizeof(start_sizes) / sizeof(*start_sizes); ++s) {
- void* p = malloc(start_sizes[s]);
- ASSERT_TRUE(p);
- // The larger the start-size, the larger the non-reallocing delta.
- for (unsigned d = 0; d < s * 2; ++d) {
- void* new_p = realloc(p, start_sizes[s] + deltas[d]);
- ASSERT_EQ(p, new_p); // realloc should not allocate new memory
- }
- // Test again, but this time reallocing smaller first.
- for (unsigned d = 0; d < s * 2; ++d) {
- void* new_p = realloc(p, start_sizes[s] - deltas[d]);
- ASSERT_EQ(p, new_p); // realloc should not allocate new memory
- }
- free(p);
- }
-}
-#endif
-
-TEST(TCMallocTest, Realloc) {
- for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
- for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
- unsigned char* src = reinterpret_cast<unsigned char*>(malloc(src_size));
- Fill(src, src_size);
- unsigned char* dst =
- reinterpret_cast<unsigned char*>(realloc(src, dst_size));
- EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
- Fill(dst, dst_size);
- EXPECT_TRUE(Valid(dst, dst_size));
- if (dst != nullptr)
- free(dst);
- }
- }
-
- // The logic below tries to allocate kNumEntries * 9000 ~= 130 MB of memory.
- // This would cause the test to crash on low memory devices with no VM
- // overcommit (e.g., chromecast).
- if (IsLowMemoryDevice())
- return;
-
- // Now make sure realloc works correctly even when we overflow the
- // packed cache, so some entries are evicted from the cache.
- // The cache has 2^12 entries, keyed by page number.
- const int kNumEntries = 1 << 14;
- int** p = reinterpret_cast<int**>(malloc(sizeof(*p) * kNumEntries));
- int sum = 0;
- for (int i = 0; i < kNumEntries; i++) {
- // no page size is likely to be bigger than 8192?
- p[i] = reinterpret_cast<int*>(malloc(8192));
- p[i][1000] = i; // use memory deep in the heart of p
- }
- for (int i = 0; i < kNumEntries; i++) {
- p[i] = reinterpret_cast<int*>(realloc(p[i], 9000));
- }
- for (int i = 0; i < kNumEntries; i++) {
- sum += p[i][1000];
- free(p[i]);
- }
- EXPECT_EQ(kNumEntries / 2 * (kNumEntries - 1), sum); // assume kNE is even
- free(p);
-}
-
-#ifdef NDEBUG
-TEST(TCMallocFreeTest, BadPointerInFirstPageOfTheLargeObject) {
- const size_t kPageSize = base::GetPageSize();
- char* p =
- reinterpret_cast<char*>(TCMallocDoMallocForTest(10 * kPageSize + 1));
- for (unsigned offset = 1; offset < kPageSize; offset <<= 1) {
- ASSERT_DEATH(TCMallocDoFreeForTest(p + offset),
- "Pointer is not pointing to the start of a span");
- }
- TCMallocDoFreeForTest(p);
-}
-
-// TODO(ssid): Fix flakiness and enable the test, crbug.com/571549.
-TEST(TCMallocFreeTest, DISABLED_BadPageAlignedPointerInsideLargeObject) {
- const size_t kPageSize = base::GetPageSize();
- const size_t kMaxSize = 10 * kPageSize;
- char* p = reinterpret_cast<char*>(TCMallocDoMallocForTest(kMaxSize + 1));
-
- for (unsigned offset = kPageSize; offset < kMaxSize; offset += kPageSize) {
- // Only the first and last page of a span are in heap map. So for others
- // tcmalloc will give a general error of invalid pointer.
- ASSERT_DEATH(TCMallocDoFreeForTest(p + offset), "");
- }
- ASSERT_DEATH(TCMallocDoFreeForTest(p + kMaxSize),
- "Pointer is not pointing to the start of a span");
- TCMallocDoFreeForTest(p);
-}
-
-TEST(TCMallocFreeTest, DoubleFreeLargeObject) {
- const size_t kMaxSize = 10 * base::GetPageSize();
- char* p = reinterpret_cast<char*>(TCMallocDoMallocForTest(kMaxSize + 1));
- ASSERT_DEATH(TCMallocDoFreeForTest(p); TCMallocDoFreeForTest(p),
- "Object was not in-use");
-}
-
-TEST(TCMallocFreeTest, DoubleFreeSmallObject) {
- const size_t kPageSize = base::GetPageSize();
- for (size_t size = 1; size <= kPageSize; size <<= 1) {
- char* p = reinterpret_cast<char*>(TCMallocDoMallocForTest(size));
- ASSERT_DEATH(TCMallocDoFreeForTest(p); TCMallocDoFreeForTest(p),
- "Circular loop in list detected");
- }
-}
-#endif // NDEBUG
-
-#endif
diff --git a/base/at_exit_unittest.cc b/base/at_exit_unittest.cc
deleted file mode 100644
index 3de061f..0000000
--- a/base/at_exit_unittest.cc
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2011 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 "base/at_exit.h"
-#include "base/bind.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-int g_test_counter_1 = 0;
-int g_test_counter_2 = 0;
-
-void IncrementTestCounter1(void* unused) {
- ++g_test_counter_1;
-}
-
-void IncrementTestCounter2(void* unused) {
- ++g_test_counter_2;
-}
-
-void ZeroTestCounters() {
- g_test_counter_1 = 0;
- g_test_counter_2 = 0;
-}
-
-void ExpectCounter1IsZero(void* unused) {
- EXPECT_EQ(0, g_test_counter_1);
-}
-
-void ExpectParamIsNull(void* param) {
- EXPECT_EQ(nullptr, param);
-}
-
-void ExpectParamIsCounter(void* param) {
- EXPECT_EQ(&g_test_counter_1, param);
-}
-
-} // namespace
-
-class AtExitTest : public testing::Test {
- private:
- // Don't test the global AtExitManager, because asking it to process its
- // AtExit callbacks can ruin the global state that other tests may depend on.
- base::ShadowingAtExitManager exit_manager_;
-};
-
-TEST_F(AtExitTest, Basic) {
- ZeroTestCounters();
- base::AtExitManager::RegisterCallback(&IncrementTestCounter1, nullptr);
- base::AtExitManager::RegisterCallback(&IncrementTestCounter2, nullptr);
- base::AtExitManager::RegisterCallback(&IncrementTestCounter1, nullptr);
-
- EXPECT_EQ(0, g_test_counter_1);
- EXPECT_EQ(0, g_test_counter_2);
- base::AtExitManager::ProcessCallbacksNow();
- EXPECT_EQ(2, g_test_counter_1);
- EXPECT_EQ(1, g_test_counter_2);
-}
-
-TEST_F(AtExitTest, LIFOOrder) {
- ZeroTestCounters();
- base::AtExitManager::RegisterCallback(&IncrementTestCounter1, nullptr);
- base::AtExitManager::RegisterCallback(&ExpectCounter1IsZero, nullptr);
- base::AtExitManager::RegisterCallback(&IncrementTestCounter2, nullptr);
-
- EXPECT_EQ(0, g_test_counter_1);
- EXPECT_EQ(0, g_test_counter_2);
- base::AtExitManager::ProcessCallbacksNow();
- EXPECT_EQ(1, g_test_counter_1);
- EXPECT_EQ(1, g_test_counter_2);
-}
-
-TEST_F(AtExitTest, Param) {
- base::AtExitManager::RegisterCallback(&ExpectParamIsNull, nullptr);
- base::AtExitManager::RegisterCallback(&ExpectParamIsCounter,
- &g_test_counter_1);
- base::AtExitManager::ProcessCallbacksNow();
-}
-
-TEST_F(AtExitTest, Task) {
- ZeroTestCounters();
- base::AtExitManager::RegisterTask(base::Bind(&ExpectParamIsCounter,
- &g_test_counter_1));
- base::AtExitManager::ProcessCallbacksNow();
-}
diff --git a/base/atomicops_unittest.cc b/base/atomicops_unittest.cc
deleted file mode 100644
index 7298609..0000000
--- a/base/atomicops_unittest.cc
+++ /dev/null
@@ -1,248 +0,0 @@
-// Copyright (c) 2011 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 "base/atomicops.h"
-
-#include <stdint.h>
-#include <string.h>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-template <class AtomicType>
-static void TestAtomicIncrement() {
- // For now, we just test single threaded execution
-
- // use a guard value to make sure the NoBarrier_AtomicIncrement doesn't go
- // outside the expected address bounds. This is in particular to
- // test that some future change to the asm code doesn't cause the
- // 32-bit NoBarrier_AtomicIncrement doesn't do the wrong thing on 64-bit
- // machines.
- struct {
- AtomicType prev_word;
- AtomicType count;
- AtomicType next_word;
- } s;
-
- AtomicType prev_word_value, next_word_value;
- memset(&prev_word_value, 0xFF, sizeof(AtomicType));
- memset(&next_word_value, 0xEE, sizeof(AtomicType));
-
- s.prev_word = prev_word_value;
- s.count = 0;
- s.next_word = next_word_value;
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 1), 1);
- EXPECT_EQ(s.count, 1);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 2), 3);
- EXPECT_EQ(s.count, 3);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 3), 6);
- EXPECT_EQ(s.count, 6);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -3), 3);
- EXPECT_EQ(s.count, 3);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -2), 1);
- EXPECT_EQ(s.count, 1);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -1), 0);
- EXPECT_EQ(s.count, 0);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -1), -1);
- EXPECT_EQ(s.count, -1);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, -4), -5);
- EXPECT_EQ(s.count, -5);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-
- EXPECT_EQ(base::subtle::NoBarrier_AtomicIncrement(&s.count, 5), 0);
- EXPECT_EQ(s.count, 0);
- EXPECT_EQ(s.prev_word, prev_word_value);
- EXPECT_EQ(s.next_word, next_word_value);
-}
-
-
-#define NUM_BITS(T) (sizeof(T) * 8)
-
-
-template <class AtomicType>
-static void TestCompareAndSwap() {
- AtomicType value = 0;
- AtomicType prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 1);
- EXPECT_EQ(1, value);
- EXPECT_EQ(0, prev);
-
- // Verify that CAS will *not* change "value" if it doesn't match the
- // expected number. CAS will always return the actual value of the
- // variable from before any change.
- AtomicType fail = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 2);
- EXPECT_EQ(1, value);
- EXPECT_EQ(1, fail);
-
- // Use test value that has non-zero bits in both halves, more for testing
- // 64-bit implementation on 32-bit platforms.
- const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
- (NUM_BITS(AtomicType) - 2)) + 11;
- value = k_test_val;
- prev = base::subtle::NoBarrier_CompareAndSwap(&value, 0, 5);
- EXPECT_EQ(k_test_val, value);
- EXPECT_EQ(k_test_val, prev);
-
- value = k_test_val;
- prev = base::subtle::NoBarrier_CompareAndSwap(&value, k_test_val, 5);
- EXPECT_EQ(5, value);
- EXPECT_EQ(k_test_val, prev);
-}
-
-
-template <class AtomicType>
-static void TestAtomicExchange() {
- AtomicType value = 0;
- AtomicType new_value = base::subtle::NoBarrier_AtomicExchange(&value, 1);
- EXPECT_EQ(1, value);
- EXPECT_EQ(0, new_value);
-
- // Use test value that has non-zero bits in both halves, more for testing
- // 64-bit implementation on 32-bit platforms.
- const AtomicType k_test_val = (static_cast<uint64_t>(1) <<
- (NUM_BITS(AtomicType) - 2)) + 11;
- value = k_test_val;
- new_value = base::subtle::NoBarrier_AtomicExchange(&value, k_test_val);
- EXPECT_EQ(k_test_val, value);
- EXPECT_EQ(k_test_val, new_value);
-
- value = k_test_val;
- new_value = base::subtle::NoBarrier_AtomicExchange(&value, 5);
- EXPECT_EQ(5, value);
- EXPECT_EQ(k_test_val, new_value);
-}
-
-
-template <class AtomicType>
-static void TestAtomicIncrementBounds() {
- // Test at rollover boundary between int_max and int_min
- AtomicType test_val = (static_cast<uint64_t>(1) <<
- (NUM_BITS(AtomicType) - 1));
- AtomicType value = -1 ^ test_val;
- AtomicType new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1);
- EXPECT_EQ(test_val, value);
- EXPECT_EQ(value, new_value);
-
- base::subtle::NoBarrier_AtomicIncrement(&value, -1);
- EXPECT_EQ(-1 ^ test_val, value);
-
- // Test at 32-bit boundary for 64-bit atomic type.
- test_val = static_cast<uint64_t>(1) << (NUM_BITS(AtomicType) / 2);
- value = test_val - 1;
- new_value = base::subtle::NoBarrier_AtomicIncrement(&value, 1);
- EXPECT_EQ(test_val, value);
- EXPECT_EQ(value, new_value);
-
- base::subtle::NoBarrier_AtomicIncrement(&value, -1);
- EXPECT_EQ(test_val - 1, value);
-}
-
-// Return an AtomicType with the value 0xa5a5a5..
-template <class AtomicType>
-static AtomicType TestFillValue() {
- AtomicType val = 0;
- memset(&val, 0xa5, sizeof(AtomicType));
- return val;
-}
-
-// This is a simple sanity check that values are correct. Not testing
-// atomicity
-template <class AtomicType>
-static void TestStore() {
- const AtomicType kVal1 = TestFillValue<AtomicType>();
- const AtomicType kVal2 = static_cast<AtomicType>(-1);
-
- AtomicType value;
-
- base::subtle::NoBarrier_Store(&value, kVal1);
- EXPECT_EQ(kVal1, value);
- base::subtle::NoBarrier_Store(&value, kVal2);
- EXPECT_EQ(kVal2, value);
-
- base::subtle::Acquire_Store(&value, kVal1);
- EXPECT_EQ(kVal1, value);
- base::subtle::Acquire_Store(&value, kVal2);
- EXPECT_EQ(kVal2, value);
-
- base::subtle::Release_Store(&value, kVal1);
- EXPECT_EQ(kVal1, value);
- base::subtle::Release_Store(&value, kVal2);
- EXPECT_EQ(kVal2, value);
-}
-
-// This is a simple sanity check that values are correct. Not testing
-// atomicity
-template <class AtomicType>
-static void TestLoad() {
- const AtomicType kVal1 = TestFillValue<AtomicType>();
- const AtomicType kVal2 = static_cast<AtomicType>(-1);
-
- AtomicType value;
-
- value = kVal1;
- EXPECT_EQ(kVal1, base::subtle::NoBarrier_Load(&value));
- value = kVal2;
- EXPECT_EQ(kVal2, base::subtle::NoBarrier_Load(&value));
-
- value = kVal1;
- EXPECT_EQ(kVal1, base::subtle::Acquire_Load(&value));
- value = kVal2;
- EXPECT_EQ(kVal2, base::subtle::Acquire_Load(&value));
-
- value = kVal1;
- EXPECT_EQ(kVal1, base::subtle::Release_Load(&value));
- value = kVal2;
- EXPECT_EQ(kVal2, base::subtle::Release_Load(&value));
-}
-
-TEST(AtomicOpsTest, Inc) {
- TestAtomicIncrement<base::subtle::Atomic32>();
- TestAtomicIncrement<base::subtle::AtomicWord>();
-}
-
-TEST(AtomicOpsTest, CompareAndSwap) {
- TestCompareAndSwap<base::subtle::Atomic32>();
- TestCompareAndSwap<base::subtle::AtomicWord>();
-}
-
-TEST(AtomicOpsTest, Exchange) {
- TestAtomicExchange<base::subtle::Atomic32>();
- TestAtomicExchange<base::subtle::AtomicWord>();
-}
-
-TEST(AtomicOpsTest, IncrementBounds) {
- TestAtomicIncrementBounds<base::subtle::Atomic32>();
- TestAtomicIncrementBounds<base::subtle::AtomicWord>();
-}
-
-TEST(AtomicOpsTest, Store) {
- TestStore<base::subtle::Atomic32>();
- TestStore<base::subtle::AtomicWord>();
-}
-
-TEST(AtomicOpsTest, Load) {
- TestLoad<base::subtle::Atomic32>();
- TestLoad<base::subtle::AtomicWord>();
-}
diff --git a/base/barrier_closure_unittest.cc b/base/barrier_closure_unittest.cc
deleted file mode 100644
index 819f6ac..0000000
--- a/base/barrier_closure_unittest.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 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 "base/barrier_closure.h"
-
-#include "base/bind.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-void Increment(int* count) { (*count)++; }
-
-TEST(BarrierClosureTest, RunImmediatelyForZeroClosures) {
- int count = 0;
- base::Closure done_closure(base::Bind(&Increment, base::Unretained(&count)));
-
- base::Closure barrier_closure = base::BarrierClosure(0, done_closure);
- EXPECT_EQ(1, count);
-}
-
-TEST(BarrierClosureTest, RunAfterNumClosures) {
- int count = 0;
- base::Closure done_closure(base::Bind(&Increment, base::Unretained(&count)));
-
- base::Closure barrier_closure = base::BarrierClosure(2, done_closure);
- EXPECT_EQ(0, count);
-
- barrier_closure.Run();
- EXPECT_EQ(0, count);
-
- barrier_closure.Run();
- EXPECT_EQ(1, count);
-}
-
-class DestructionIndicator {
- public:
- // Sets |*destructed| to true in destructor.
- DestructionIndicator(bool* destructed) : destructed_(destructed) {
- *destructed_ = false;
- }
-
- ~DestructionIndicator() { *destructed_ = true; }
-
- void DoNothing() {}
-
- private:
- bool* destructed_;
-};
-
-TEST(BarrierClosureTest, ReleasesDoneClosureWhenDone) {
- bool done_destructed = false;
- base::Closure barrier_closure = base::BarrierClosure(
- 1,
- base::BindOnce(&DestructionIndicator::DoNothing,
- base::Owned(new DestructionIndicator(&done_destructed))));
- EXPECT_FALSE(done_destructed);
- barrier_closure.Run();
- EXPECT_TRUE(done_destructed);
-}
-
-void ResetBarrierClosure(base::Closure* closure) {
- *closure = base::Closure();
-}
-
-// Tests a case when |done_closure| resets a |barrier_closure|.
-// |barrier_closure| is a Closure holding the |done_closure|. |done_closure|
-// holds a pointer back to the |barrier_closure|. When |barrier_closure| is
-// Run() it calls ResetBarrierClosure() which erases the |barrier_closure| while
-// still inside of its Run(). The Run() implementation (in base::BarrierClosure)
-// must not try use itself after executing ResetBarrierClosure() or this test
-// would crash inside Run().
-TEST(BarrierClosureTest, KeepingClosureAliveUntilDone) {
- base::Closure barrier_closure;
- base::Closure done_closure =
- base::Bind(ResetBarrierClosure, &barrier_closure);
- barrier_closure = base::BarrierClosure(1, done_closure);
- barrier_closure.Run();
-}
-
-} // namespace
diff --git a/base/base64_unittest.cc b/base/base64_unittest.cc
deleted file mode 100644
index 91651f4..0000000
--- a/base/base64_unittest.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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.
-
-#include "base/base64.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(Base64Test, Basic) {
- const std::string kText = "hello world";
- const std::string kBase64Text = "aGVsbG8gd29ybGQ=";
-
- std::string encoded;
- std::string decoded;
- bool ok;
-
- Base64Encode(kText, &encoded);
- EXPECT_EQ(kBase64Text, encoded);
-
- ok = Base64Decode(encoded, &decoded);
- EXPECT_TRUE(ok);
- EXPECT_EQ(kText, decoded);
-}
-
-TEST(Base64Test, InPlace) {
- const std::string kText = "hello world";
- const std::string kBase64Text = "aGVsbG8gd29ybGQ=";
- std::string text(kText);
-
- Base64Encode(text, &text);
- EXPECT_EQ(kBase64Text, text);
-
- bool ok = Base64Decode(text, &text);
- EXPECT_TRUE(ok);
- EXPECT_EQ(text, kText);
-}
-
-} // namespace base
diff --git a/base/base64url_unittest.cc b/base/base64url_unittest.cc
deleted file mode 100644
index 45aa4a8..0000000
--- a/base/base64url_unittest.cc
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2015 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 "base/base64url.h"
-
-#include "base/macros.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-TEST(Base64UrlTest, EncodeIncludePaddingPolicy) {
- std::string output;
- Base64UrlEncode("hello?world", Base64UrlEncodePolicy::INCLUDE_PADDING,
- &output);
-
- // Base64 version: aGVsbG8/d29ybGQ=
- EXPECT_EQ("aGVsbG8_d29ybGQ=", output);
-
- // Test for behavior for very short and empty strings.
- Base64UrlEncode("??", Base64UrlEncodePolicy::INCLUDE_PADDING, &output);
- EXPECT_EQ("Pz8=", output);
-
- Base64UrlEncode("", Base64UrlEncodePolicy::INCLUDE_PADDING, &output);
- EXPECT_EQ("", output);
-}
-
-TEST(Base64UrlTest, EncodeOmitPaddingPolicy) {
- std::string output;
- Base64UrlEncode("hello?world", Base64UrlEncodePolicy::OMIT_PADDING, &output);
-
- // base64 version: aGVsbG8/d29ybGQ=
- EXPECT_EQ("aGVsbG8_d29ybGQ", output);
-
- // Test for behavior for very short and empty strings.
- Base64UrlEncode("??", Base64UrlEncodePolicy::OMIT_PADDING, &output);
- EXPECT_EQ("Pz8", output);
-
- Base64UrlEncode("", Base64UrlEncodePolicy::OMIT_PADDING, &output);
- EXPECT_EQ("", output);
-}
-
-TEST(Base64UrlTest, DecodeRequirePaddingPolicy) {
- std::string output;
- ASSERT_TRUE(Base64UrlDecode("aGVsbG8_d29ybGQ=",
- Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
-
- EXPECT_EQ("hello?world", output);
-
- ASSERT_FALSE(Base64UrlDecode(
- "aGVsbG8_d29ybGQ", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
-
- // Test for behavior for very short and empty strings.
- ASSERT_TRUE(
- Base64UrlDecode("Pz8=", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
- EXPECT_EQ("??", output);
-
- ASSERT_TRUE(
- Base64UrlDecode("", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
- EXPECT_EQ("", output);
-}
-
-TEST(Base64UrlTest, DecodeIgnorePaddingPolicy) {
- std::string output;
- ASSERT_TRUE(Base64UrlDecode("aGVsbG8_d29ybGQ",
- Base64UrlDecodePolicy::IGNORE_PADDING, &output));
-
- EXPECT_EQ("hello?world", output);
-
- // Including the padding is accepted as well.
- ASSERT_TRUE(Base64UrlDecode("aGVsbG8_d29ybGQ=",
- Base64UrlDecodePolicy::IGNORE_PADDING, &output));
-
- EXPECT_EQ("hello?world", output);
-}
-
-TEST(Base64UrlTest, DecodeDisallowPaddingPolicy) {
- std::string output;
- ASSERT_FALSE(Base64UrlDecode(
- "aGVsbG8_d29ybGQ=", Base64UrlDecodePolicy::DISALLOW_PADDING, &output));
-
- // The policy will allow the input when padding has been omitted.
- ASSERT_TRUE(Base64UrlDecode(
- "aGVsbG8_d29ybGQ", Base64UrlDecodePolicy::DISALLOW_PADDING, &output));
-
- EXPECT_EQ("hello?world", output);
-}
-
-TEST(Base64UrlTest, DecodeDisallowsBase64Alphabet) {
- std::string output;
-
- // The "/" character is part of the conventional base64 alphabet, but has been
- // substituted with "_" in the base64url alphabet.
- ASSERT_FALSE(Base64UrlDecode(
- "aGVsbG8/d29ybGQ=", Base64UrlDecodePolicy::REQUIRE_PADDING, &output));
-}
-
-TEST(Base64UrlTest, DecodeDisallowsPaddingOnly) {
- std::string output;
-
- ASSERT_FALSE(Base64UrlDecode(
- "=", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
- ASSERT_FALSE(Base64UrlDecode(
- "==", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
- ASSERT_FALSE(Base64UrlDecode(
- "===", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
- ASSERT_FALSE(Base64UrlDecode(
- "====", Base64UrlDecodePolicy::IGNORE_PADDING, &output));
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/big_endian_unittest.cc b/base/big_endian_unittest.cc
deleted file mode 100644
index 4e1e7ce..0000000
--- a/base/big_endian_unittest.cc
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2014 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 "base/big_endian.h"
-
-#include <stdint.h>
-
-#include "base/strings/string_piece.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(BigEndianReaderTest, ReadsValues) {
- char data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF,
- 0x1A, 0x2B, 0x3C, 0x4D, 0x5E };
- char buf[2];
- uint8_t u8;
- uint16_t u16;
- uint32_t u32;
- uint64_t u64;
- base::StringPiece piece;
- BigEndianReader reader(data, sizeof(data));
-
- EXPECT_TRUE(reader.Skip(2));
- EXPECT_EQ(data + 2, reader.ptr());
- EXPECT_EQ(reader.remaining(), static_cast<int>(sizeof(data)) - 2);
- EXPECT_TRUE(reader.ReadBytes(buf, sizeof(buf)));
- EXPECT_EQ(0x2, buf[0]);
- EXPECT_EQ(0x3, buf[1]);
- EXPECT_TRUE(reader.ReadU8(&u8));
- EXPECT_EQ(0x4, u8);
- EXPECT_TRUE(reader.ReadU16(&u16));
- EXPECT_EQ(0x0506, u16);
- EXPECT_TRUE(reader.ReadU32(&u32));
- EXPECT_EQ(0x0708090Au, u32);
- EXPECT_TRUE(reader.ReadU64(&u64));
- EXPECT_EQ(0x0B0C0D0E0F1A2B3Cllu, u64);
- base::StringPiece expected(reader.ptr(), 2);
- EXPECT_TRUE(reader.ReadPiece(&piece, 2));
- EXPECT_EQ(2u, piece.size());
- EXPECT_EQ(expected.data(), piece.data());
-}
-
-TEST(BigEndianReaderTest, RespectsLength) {
- char data[8];
- char buf[2];
- uint8_t u8;
- uint16_t u16;
- uint32_t u32;
- uint64_t u64;
- base::StringPiece piece;
- BigEndianReader reader(data, sizeof(data));
- // 8 left
- EXPECT_FALSE(reader.Skip(9));
- EXPECT_TRUE(reader.Skip(1));
- // 7 left
- EXPECT_FALSE(reader.ReadU64(&u64));
- EXPECT_TRUE(reader.Skip(4));
- // 3 left
- EXPECT_FALSE(reader.ReadU32(&u32));
- EXPECT_FALSE(reader.ReadPiece(&piece, 4));
- EXPECT_TRUE(reader.Skip(2));
- // 1 left
- EXPECT_FALSE(reader.ReadU16(&u16));
- EXPECT_FALSE(reader.ReadBytes(buf, 2));
- EXPECT_TRUE(reader.Skip(1));
- // 0 left
- EXPECT_FALSE(reader.ReadU8(&u8));
- EXPECT_EQ(0, reader.remaining());
-}
-
-TEST(BigEndianWriterTest, WritesValues) {
- char expected[] = { 0, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE,
- 0xF, 0x1A, 0x2B, 0x3C };
- char data[sizeof(expected)];
- char buf[] = { 0x2, 0x3 };
- memset(data, 0, sizeof(data));
- BigEndianWriter writer(data, sizeof(data));
-
- EXPECT_TRUE(writer.Skip(2));
- EXPECT_TRUE(writer.WriteBytes(buf, sizeof(buf)));
- EXPECT_TRUE(writer.WriteU8(0x4));
- EXPECT_TRUE(writer.WriteU16(0x0506));
- EXPECT_TRUE(writer.WriteU32(0x0708090A));
- EXPECT_TRUE(writer.WriteU64(0x0B0C0D0E0F1A2B3Cllu));
- EXPECT_EQ(0, memcmp(expected, data, sizeof(expected)));
-}
-
-TEST(BigEndianWriterTest, RespectsLength) {
- char data[8];
- char buf[2];
- uint8_t u8 = 0;
- uint16_t u16 = 0;
- uint32_t u32 = 0;
- uint64_t u64 = 0;
- BigEndianWriter writer(data, sizeof(data));
- // 8 left
- EXPECT_FALSE(writer.Skip(9));
- EXPECT_TRUE(writer.Skip(1));
- // 7 left
- EXPECT_FALSE(writer.WriteU64(u64));
- EXPECT_TRUE(writer.Skip(4));
- // 3 left
- EXPECT_FALSE(writer.WriteU32(u32));
- EXPECT_TRUE(writer.Skip(2));
- // 1 left
- EXPECT_FALSE(writer.WriteU16(u16));
- EXPECT_FALSE(writer.WriteBytes(buf, 2));
- EXPECT_TRUE(writer.Skip(1));
- // 0 left
- EXPECT_FALSE(writer.WriteU8(u8));
- EXPECT_EQ(0, writer.remaining());
-}
-
-} // namespace base
diff --git a/base/bind_unittest.cc b/base/bind_unittest.cc
deleted file mode 100644
index 5162a08..0000000
--- a/base/bind_unittest.cc
+++ /dev/null
@@ -1,1496 +0,0 @@
-// 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.
-
-#include "base/bind.h"
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/test/bind_test_util.h"
-#include "base/test/gtest_util.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::_;
-using ::testing::Mock;
-using ::testing::ByMove;
-using ::testing::Return;
-using ::testing::StrictMock;
-
-namespace base {
-namespace {
-
-class IncompleteType;
-
-class NoRef {
- public:
- NoRef() = default;
-
- MOCK_METHOD0(VoidMethod0, void());
- MOCK_CONST_METHOD0(VoidConstMethod0, void());
-
- MOCK_METHOD0(IntMethod0, int());
- MOCK_CONST_METHOD0(IntConstMethod0, int());
-
- MOCK_METHOD1(VoidMethodWithIntArg, void(int));
- MOCK_METHOD0(UniquePtrMethod0, std::unique_ptr<int>());
-
- private:
- // Particularly important in this test to ensure no copies are made.
- DISALLOW_COPY_AND_ASSIGN(NoRef);
-};
-
-class HasRef : public NoRef {
- public:
- HasRef() = default;
-
- MOCK_CONST_METHOD0(AddRef, void());
- MOCK_CONST_METHOD0(Release, bool());
-
- private:
- // Particularly important in this test to ensure no copies are made.
- DISALLOW_COPY_AND_ASSIGN(HasRef);
-};
-
-class HasRefPrivateDtor : public HasRef {
- private:
- ~HasRefPrivateDtor() = default;
-};
-
-static const int kParentValue = 1;
-static const int kChildValue = 2;
-
-class Parent {
- public:
- void AddRef() const {}
- void Release() const {}
- virtual void VirtualSet() { value = kParentValue; }
- void NonVirtualSet() { value = kParentValue; }
- int value;
-};
-
-class Child : public Parent {
- public:
- void VirtualSet() override { value = kChildValue; }
- void NonVirtualSet() { value = kChildValue; }
-};
-
-class NoRefParent {
- public:
- virtual void VirtualSet() { value = kParentValue; }
- void NonVirtualSet() { value = kParentValue; }
- int value;
-};
-
-class NoRefChild : public NoRefParent {
- void VirtualSet() override { value = kChildValue; }
- void NonVirtualSet() { value = kChildValue; }
-};
-
-// Used for probing the number of copies and moves that occur if a type must be
-// coerced during argument forwarding in the Run() methods.
-struct DerivedCopyMoveCounter {
- DerivedCopyMoveCounter(int* copies,
- int* assigns,
- int* move_constructs,
- int* move_assigns)
- : copies_(copies),
- assigns_(assigns),
- move_constructs_(move_constructs),
- move_assigns_(move_assigns) {}
- int* copies_;
- int* assigns_;
- int* move_constructs_;
- int* move_assigns_;
-};
-
-// Used for probing the number of copies and moves in an argument.
-class CopyMoveCounter {
- public:
- CopyMoveCounter(int* copies,
- int* assigns,
- int* move_constructs,
- int* move_assigns)
- : copies_(copies),
- assigns_(assigns),
- move_constructs_(move_constructs),
- move_assigns_(move_assigns) {}
-
- CopyMoveCounter(const CopyMoveCounter& other)
- : copies_(other.copies_),
- assigns_(other.assigns_),
- move_constructs_(other.move_constructs_),
- move_assigns_(other.move_assigns_) {
- (*copies_)++;
- }
-
- CopyMoveCounter(CopyMoveCounter&& other)
- : copies_(other.copies_),
- assigns_(other.assigns_),
- move_constructs_(other.move_constructs_),
- move_assigns_(other.move_assigns_) {
- (*move_constructs_)++;
- }
-
- // Probing for copies from coercion.
- explicit CopyMoveCounter(const DerivedCopyMoveCounter& other)
- : copies_(other.copies_),
- assigns_(other.assigns_),
- move_constructs_(other.move_constructs_),
- move_assigns_(other.move_assigns_) {
- (*copies_)++;
- }
-
- // Probing for moves from coercion.
- explicit CopyMoveCounter(DerivedCopyMoveCounter&& other)
- : copies_(other.copies_),
- assigns_(other.assigns_),
- move_constructs_(other.move_constructs_),
- move_assigns_(other.move_assigns_) {
- (*move_constructs_)++;
- }
-
- const CopyMoveCounter& operator=(const CopyMoveCounter& rhs) {
- copies_ = rhs.copies_;
- assigns_ = rhs.assigns_;
- move_constructs_ = rhs.move_constructs_;
- move_assigns_ = rhs.move_assigns_;
-
- (*assigns_)++;
-
- return *this;
- }
-
- const CopyMoveCounter& operator=(CopyMoveCounter&& rhs) {
- copies_ = rhs.copies_;
- assigns_ = rhs.assigns_;
- move_constructs_ = rhs.move_constructs_;
- move_assigns_ = rhs.move_assigns_;
-
- (*move_assigns_)++;
-
- return *this;
- }
-
- int copies() const {
- return *copies_;
- }
-
- private:
- int* copies_;
- int* assigns_;
- int* move_constructs_;
- int* move_assigns_;
-};
-
-// Used for probing the number of copies in an argument. The instance is a
-// copyable and non-movable type.
-class CopyCounter {
- public:
- CopyCounter(int* copies, int* assigns)
- : counter_(copies, assigns, nullptr, nullptr) {}
- CopyCounter(const CopyCounter& other) = default;
- CopyCounter& operator=(const CopyCounter& other) = default;
-
- explicit CopyCounter(const DerivedCopyMoveCounter& other) : counter_(other) {}
-
- int copies() const { return counter_.copies(); }
-
- private:
- CopyMoveCounter counter_;
-};
-
-// Used for probing the number of moves in an argument. The instance is a
-// non-copyable and movable type.
-class MoveCounter {
- public:
- MoveCounter(int* move_constructs, int* move_assigns)
- : counter_(nullptr, nullptr, move_constructs, move_assigns) {}
- MoveCounter(MoveCounter&& other) : counter_(std::move(other.counter_)) {}
- MoveCounter& operator=(MoveCounter&& other) {
- counter_ = std::move(other.counter_);
- return *this;
- }
-
- explicit MoveCounter(DerivedCopyMoveCounter&& other)
- : counter_(std::move(other)) {}
-
- private:
- CopyMoveCounter counter_;
-};
-
-class DeleteCounter {
- public:
- explicit DeleteCounter(int* deletes)
- : deletes_(deletes) {
- }
-
- ~DeleteCounter() {
- (*deletes_)++;
- }
-
- void VoidMethod0() {}
-
- private:
- int* deletes_;
-};
-
-template <typename T>
-T PassThru(T scoper) {
- return scoper;
-}
-
-// Some test functions that we can Bind to.
-template <typename T>
-T PolymorphicIdentity(T t) {
- return t;
-}
-
-template <typename... Ts>
-struct VoidPolymorphic {
- static void Run(Ts... t) {}
-};
-
-int Identity(int n) {
- return n;
-}
-
-int ArrayGet(const int array[], int n) {
- return array[n];
-}
-
-int Sum(int a, int b, int c, int d, int e, int f) {
- return a + b + c + d + e + f;
-}
-
-const char* CStringIdentity(const char* s) {
- return s;
-}
-
-int GetCopies(const CopyMoveCounter& counter) {
- return counter.copies();
-}
-
-int UnwrapNoRefParent(NoRefParent p) {
- return p.value;
-}
-
-int UnwrapNoRefParentPtr(NoRefParent* p) {
- return p->value;
-}
-
-int UnwrapNoRefParentConstRef(const NoRefParent& p) {
- return p.value;
-}
-
-void RefArgSet(int &n) {
- n = 2;
-}
-
-void PtrArgSet(int *n) {
- *n = 2;
-}
-
-int FunctionWithWeakFirstParam(WeakPtr<NoRef> o, int n) {
- return n;
-}
-
-int FunctionWithScopedRefptrFirstParam(const scoped_refptr<HasRef>& o, int n) {
- return n;
-}
-
-void TakesACallback(const Closure& callback) {
- callback.Run();
-}
-
-int Noexcept() noexcept {
- return 42;
-}
-
-class BindTest : public ::testing::Test {
- public:
- BindTest() {
- const_has_ref_ptr_ = &has_ref_;
- const_no_ref_ptr_ = &no_ref_;
- static_func_mock_ptr = &static_func_mock_;
- }
-
- ~BindTest() override = default;
-
- static void VoidFunc0() {
- static_func_mock_ptr->VoidMethod0();
- }
-
- static int IntFunc0() { return static_func_mock_ptr->IntMethod0(); }
- int NoexceptMethod() noexcept { return 42; }
- int ConstNoexceptMethod() const noexcept { return 42; }
-
- protected:
- StrictMock<NoRef> no_ref_;
- StrictMock<HasRef> has_ref_;
- const HasRef* const_has_ref_ptr_;
- const NoRef* const_no_ref_ptr_;
- StrictMock<NoRef> static_func_mock_;
-
- // Used by the static functions to perform expectations.
- static StrictMock<NoRef>* static_func_mock_ptr;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(BindTest);
-};
-
-StrictMock<NoRef>* BindTest::static_func_mock_ptr;
-StrictMock<NoRef>* g_func_mock_ptr;
-
-void VoidFunc0() {
- g_func_mock_ptr->VoidMethod0();
-}
-
-int IntFunc0() {
- return g_func_mock_ptr->IntMethod0();
-}
-
-TEST_F(BindTest, BasicTest) {
- Callback<int(int, int, int)> cb = Bind(&Sum, 32, 16, 8);
- EXPECT_EQ(92, cb.Run(13, 12, 11));
-
- Callback<int(int, int, int, int, int, int)> c1 = Bind(&Sum);
- EXPECT_EQ(69, c1.Run(14, 13, 12, 11, 10, 9));
-
- Callback<int(int, int, int)> c2 = Bind(c1, 32, 16, 8);
- EXPECT_EQ(86, c2.Run(11, 10, 9));
-
- Callback<int()> c3 = Bind(c2, 4, 2, 1);
- EXPECT_EQ(63, c3.Run());
-}
-
-// Test that currying the rvalue result of another Bind() works correctly.
-// - rvalue should be usable as argument to Bind().
-// - multiple runs of resulting Callback remain valid.
-TEST_F(BindTest, CurryingRvalueResultOfBind) {
- int n = 0;
- RepeatingClosure cb = BindRepeating(&TakesACallback,
- BindRepeating(&PtrArgSet, &n));
-
- // If we implement Bind() such that the return value has auto_ptr-like
- // semantics, the second call here will fail because ownership of
- // the internal BindState<> would have been transfered to a *temporary*
- // constructon of a Callback object on the first call.
- cb.Run();
- EXPECT_EQ(2, n);
-
- n = 0;
- cb.Run();
- EXPECT_EQ(2, n);
-}
-
-TEST_F(BindTest, RepeatingCallbackBasicTest) {
- RepeatingCallback<int(int)> c0 = BindRepeating(&Sum, 1, 2, 4, 8, 16);
-
- // RepeatingCallback can run via a lvalue-reference.
- EXPECT_EQ(63, c0.Run(32));
-
- // It is valid to call a RepeatingCallback more than once.
- EXPECT_EQ(54, c0.Run(23));
-
- // BindRepeating can handle a RepeatingCallback as the target functor.
- RepeatingCallback<int()> c1 = BindRepeating(c0, 11);
-
- // RepeatingCallback can run via a rvalue-reference.
- EXPECT_EQ(42, std::move(c1).Run());
-
- // BindRepeating can handle a rvalue-reference of RepeatingCallback.
- EXPECT_EQ(32, BindRepeating(std::move(c0), 1).Run());
-}
-
-TEST_F(BindTest, OnceCallbackBasicTest) {
- OnceCallback<int(int)> c0 = BindOnce(&Sum, 1, 2, 4, 8, 16);
-
- // OnceCallback can run via a rvalue-reference.
- EXPECT_EQ(63, std::move(c0).Run(32));
-
- // After running via the rvalue-reference, the value of the OnceCallback
- // is undefined. The implementation simply clears the instance after the
- // invocation.
- EXPECT_TRUE(c0.is_null());
-
- c0 = BindOnce(&Sum, 2, 3, 5, 7, 11);
-
- // BindOnce can handle a rvalue-reference of OnceCallback as the target
- // functor.
- OnceCallback<int()> c1 = BindOnce(std::move(c0), 13);
- EXPECT_EQ(41, std::move(c1).Run());
-
- RepeatingCallback<int(int)> c2 = BindRepeating(&Sum, 2, 3, 5, 7, 11);
- EXPECT_EQ(41, BindOnce(c2, 13).Run());
-}
-
-// IgnoreResult adapter test.
-// - Function with return value.
-// - Method with return value.
-// - Const Method with return.
-// - Method with return value bound to WeakPtr<>.
-// - Const Method with return bound to WeakPtr<>.
-TEST_F(BindTest, IgnoreResultForRepeating) {
- EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337));
- EXPECT_CALL(has_ref_, AddRef()).Times(2);
- EXPECT_CALL(has_ref_, Release()).Times(2);
- EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(10));
- EXPECT_CALL(has_ref_, IntConstMethod0()).WillOnce(Return(11));
- EXPECT_CALL(no_ref_, IntMethod0()).WillOnce(Return(12));
- EXPECT_CALL(no_ref_, IntConstMethod0()).WillOnce(Return(13));
-
- RepeatingClosure normal_func_cb = BindRepeating(IgnoreResult(&IntFunc0));
- normal_func_cb.Run();
-
- RepeatingClosure non_void_method_cb =
- BindRepeating(IgnoreResult(&HasRef::IntMethod0), &has_ref_);
- non_void_method_cb.Run();
-
- RepeatingClosure non_void_const_method_cb =
- BindRepeating(IgnoreResult(&HasRef::IntConstMethod0), &has_ref_);
- non_void_const_method_cb.Run();
-
- WeakPtrFactory<NoRef> weak_factory(&no_ref_);
- WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
-
- RepeatingClosure non_void_weak_method_cb =
- BindRepeating(IgnoreResult(&NoRef::IntMethod0),
- weak_factory.GetWeakPtr());
- non_void_weak_method_cb.Run();
-
- RepeatingClosure non_void_weak_const_method_cb =
- BindRepeating(IgnoreResult(&NoRef::IntConstMethod0),
- weak_factory.GetWeakPtr());
- non_void_weak_const_method_cb.Run();
-
- weak_factory.InvalidateWeakPtrs();
- non_void_weak_const_method_cb.Run();
- non_void_weak_method_cb.Run();
-}
-
-TEST_F(BindTest, IgnoreResultForOnce) {
- EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337));
- EXPECT_CALL(has_ref_, AddRef()).Times(2);
- EXPECT_CALL(has_ref_, Release()).Times(2);
- EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(10));
- EXPECT_CALL(has_ref_, IntConstMethod0()).WillOnce(Return(11));
-
- OnceClosure normal_func_cb = BindOnce(IgnoreResult(&IntFunc0));
- std::move(normal_func_cb).Run();
-
- OnceClosure non_void_method_cb =
- BindOnce(IgnoreResult(&HasRef::IntMethod0), &has_ref_);
- std::move(non_void_method_cb).Run();
-
- OnceClosure non_void_const_method_cb =
- BindOnce(IgnoreResult(&HasRef::IntConstMethod0), &has_ref_);
- std::move(non_void_const_method_cb).Run();
-
- WeakPtrFactory<NoRef> weak_factory(&no_ref_);
- WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
-
- OnceClosure non_void_weak_method_cb =
- BindOnce(IgnoreResult(&NoRef::IntMethod0),
- weak_factory.GetWeakPtr());
- OnceClosure non_void_weak_const_method_cb =
- BindOnce(IgnoreResult(&NoRef::IntConstMethod0),
- weak_factory.GetWeakPtr());
-
- weak_factory.InvalidateWeakPtrs();
- std::move(non_void_weak_const_method_cb).Run();
- std::move(non_void_weak_method_cb).Run();
-}
-
-// Functions that take reference parameters.
-// - Forced reference parameter type still stores a copy.
-// - Forced const reference parameter type still stores a copy.
-TEST_F(BindTest, ReferenceArgumentBindingForRepeating) {
- int n = 1;
- int& ref_n = n;
- const int& const_ref_n = n;
-
- RepeatingCallback<int()> ref_copies_cb = BindRepeating(&Identity, ref_n);
- EXPECT_EQ(n, ref_copies_cb.Run());
- n++;
- EXPECT_EQ(n - 1, ref_copies_cb.Run());
-
- RepeatingCallback<int()> const_ref_copies_cb =
- BindRepeating(&Identity, const_ref_n);
- EXPECT_EQ(n, const_ref_copies_cb.Run());
- n++;
- EXPECT_EQ(n - 1, const_ref_copies_cb.Run());
-}
-
-TEST_F(BindTest, ReferenceArgumentBindingForOnce) {
- int n = 1;
- int& ref_n = n;
- const int& const_ref_n = n;
-
- OnceCallback<int()> ref_copies_cb = BindOnce(&Identity, ref_n);
- n++;
- EXPECT_EQ(n - 1, std::move(ref_copies_cb).Run());
-
- OnceCallback<int()> const_ref_copies_cb =
- BindOnce(&Identity, const_ref_n);
- n++;
- EXPECT_EQ(n - 1, std::move(const_ref_copies_cb).Run());
-}
-
-// Check that we can pass in arrays and have them be stored as a pointer.
-// - Array of values stores a pointer.
-// - Array of const values stores a pointer.
-TEST_F(BindTest, ArrayArgumentBindingForRepeating) {
- int array[4] = {1, 1, 1, 1};
- const int (*const_array_ptr)[4] = &array;
-
- RepeatingCallback<int()> array_cb = BindRepeating(&ArrayGet, array, 1);
- EXPECT_EQ(1, array_cb.Run());
-
- RepeatingCallback<int()> const_array_cb =
- BindRepeating(&ArrayGet, *const_array_ptr, 1);
- EXPECT_EQ(1, const_array_cb.Run());
-
- array[1] = 3;
- EXPECT_EQ(3, array_cb.Run());
- EXPECT_EQ(3, const_array_cb.Run());
-}
-
-TEST_F(BindTest, ArrayArgumentBindingForOnce) {
- int array[4] = {1, 1, 1, 1};
- const int (*const_array_ptr)[4] = &array;
-
- OnceCallback<int()> array_cb = BindOnce(&ArrayGet, array, 1);
- OnceCallback<int()> const_array_cb =
- BindOnce(&ArrayGet, *const_array_ptr, 1);
-
- array[1] = 3;
- EXPECT_EQ(3, std::move(array_cb).Run());
- EXPECT_EQ(3, std::move(const_array_cb).Run());
-}
-
-// WeakPtr() support.
-// - Method bound to WeakPtr<> to non-const object.
-// - Const method bound to WeakPtr<> to non-const object.
-// - Const method bound to WeakPtr<> to const object.
-// - Normal Function with WeakPtr<> as P1 can have return type and is
-// not canceled.
-TEST_F(BindTest, WeakPtrForRepeating) {
- EXPECT_CALL(no_ref_, VoidMethod0());
- EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
-
- WeakPtrFactory<NoRef> weak_factory(&no_ref_);
- WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
-
- RepeatingClosure method_cb =
- BindRepeating(&NoRef::VoidMethod0, weak_factory.GetWeakPtr());
- method_cb.Run();
-
- RepeatingClosure const_method_cb =
- BindRepeating(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
- const_method_cb.Run();
-
- RepeatingClosure const_method_const_ptr_cb =
- BindRepeating(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
- const_method_const_ptr_cb.Run();
-
- RepeatingCallback<int(int)> normal_func_cb =
- BindRepeating(&FunctionWithWeakFirstParam, weak_factory.GetWeakPtr());
- EXPECT_EQ(1, normal_func_cb.Run(1));
-
- weak_factory.InvalidateWeakPtrs();
- const_weak_factory.InvalidateWeakPtrs();
-
- method_cb.Run();
- const_method_cb.Run();
- const_method_const_ptr_cb.Run();
-
- // Still runs even after the pointers are invalidated.
- EXPECT_EQ(2, normal_func_cb.Run(2));
-}
-
-TEST_F(BindTest, WeakPtrForOnce) {
- WeakPtrFactory<NoRef> weak_factory(&no_ref_);
- WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
-
- OnceClosure method_cb =
- BindOnce(&NoRef::VoidMethod0, weak_factory.GetWeakPtr());
- OnceClosure const_method_cb =
- BindOnce(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
- OnceClosure const_method_const_ptr_cb =
- BindOnce(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
- Callback<int(int)> normal_func_cb =
- Bind(&FunctionWithWeakFirstParam, weak_factory.GetWeakPtr());
-
- weak_factory.InvalidateWeakPtrs();
- const_weak_factory.InvalidateWeakPtrs();
-
- std::move(method_cb).Run();
- std::move(const_method_cb).Run();
- std::move(const_method_const_ptr_cb).Run();
-
- // Still runs even after the pointers are invalidated.
- EXPECT_EQ(2, std::move(normal_func_cb).Run(2));
-}
-
-// ConstRef() wrapper support.
-// - Binding w/o ConstRef takes a copy.
-// - Binding a ConstRef takes a reference.
-// - Binding ConstRef to a function ConstRef does not copy on invoke.
-TEST_F(BindTest, ConstRefForRepeating) {
- int n = 1;
-
- RepeatingCallback<int()> copy_cb = BindRepeating(&Identity, n);
- RepeatingCallback<int()> const_ref_cb = BindRepeating(&Identity, ConstRef(n));
- EXPECT_EQ(n, copy_cb.Run());
- EXPECT_EQ(n, const_ref_cb.Run());
- n++;
- EXPECT_EQ(n - 1, copy_cb.Run());
- EXPECT_EQ(n, const_ref_cb.Run());
-
- int copies = 0;
- int assigns = 0;
- int move_constructs = 0;
- int move_assigns = 0;
- CopyMoveCounter counter(&copies, &assigns, &move_constructs, &move_assigns);
- RepeatingCallback<int()> all_const_ref_cb =
- BindRepeating(&GetCopies, ConstRef(counter));
- EXPECT_EQ(0, all_const_ref_cb.Run());
- EXPECT_EQ(0, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(0, move_constructs);
- EXPECT_EQ(0, move_assigns);
-}
-
-TEST_F(BindTest, ConstRefForOnce) {
- int n = 1;
-
- OnceCallback<int()> copy_cb = BindOnce(&Identity, n);
- OnceCallback<int()> const_ref_cb = BindOnce(&Identity, ConstRef(n));
- n++;
- EXPECT_EQ(n - 1, std::move(copy_cb).Run());
- EXPECT_EQ(n, std::move(const_ref_cb).Run());
-
- int copies = 0;
- int assigns = 0;
- int move_constructs = 0;
- int move_assigns = 0;
- CopyMoveCounter counter(&copies, &assigns, &move_constructs, &move_assigns);
- OnceCallback<int()> all_const_ref_cb =
- BindOnce(&GetCopies, ConstRef(counter));
- EXPECT_EQ(0, std::move(all_const_ref_cb).Run());
- EXPECT_EQ(0, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(0, move_constructs);
- EXPECT_EQ(0, move_assigns);
-}
-
-// Test Owned() support.
-TEST_F(BindTest, OwnedForRepeating) {
- int deletes = 0;
- DeleteCounter* counter = new DeleteCounter(&deletes);
-
- // If we don't capture, delete happens on Callback destruction/reset.
- // return the same value.
- RepeatingCallback<DeleteCounter*()> no_capture_cb =
- BindRepeating(&PolymorphicIdentity<DeleteCounter*>, Owned(counter));
- ASSERT_EQ(counter, no_capture_cb.Run());
- ASSERT_EQ(counter, no_capture_cb.Run());
- EXPECT_EQ(0, deletes);
- no_capture_cb.Reset(); // This should trigger a delete.
- EXPECT_EQ(1, deletes);
-
- deletes = 0;
- counter = new DeleteCounter(&deletes);
- RepeatingClosure own_object_cb =
- BindRepeating(&DeleteCounter::VoidMethod0, Owned(counter));
- own_object_cb.Run();
- EXPECT_EQ(0, deletes);
- own_object_cb.Reset();
- EXPECT_EQ(1, deletes);
-}
-
-TEST_F(BindTest, OwnedForOnce) {
- int deletes = 0;
- DeleteCounter* counter = new DeleteCounter(&deletes);
-
- // If we don't capture, delete happens on Callback destruction/reset.
- // return the same value.
- OnceCallback<DeleteCounter*()> no_capture_cb =
- BindOnce(&PolymorphicIdentity<DeleteCounter*>, Owned(counter));
- EXPECT_EQ(0, deletes);
- no_capture_cb.Reset(); // This should trigger a delete.
- EXPECT_EQ(1, deletes);
-
- deletes = 0;
- counter = new DeleteCounter(&deletes);
- OnceClosure own_object_cb =
- BindOnce(&DeleteCounter::VoidMethod0, Owned(counter));
- EXPECT_EQ(0, deletes);
- own_object_cb.Reset();
- EXPECT_EQ(1, deletes);
-}
-
-template <typename T>
-class BindVariantsTest : public ::testing::Test {
-};
-
-struct RepeatingTestConfig {
- template <typename Signature>
- using CallbackType = RepeatingCallback<Signature>;
- using ClosureType = RepeatingClosure;
-
- template <typename F, typename... Args>
- static CallbackType<MakeUnboundRunType<F, Args...>>
- Bind(F&& f, Args&&... args) {
- return BindRepeating(std::forward<F>(f), std::forward<Args>(args)...);
- }
-};
-
-struct OnceTestConfig {
- template <typename Signature>
- using CallbackType = OnceCallback<Signature>;
- using ClosureType = OnceClosure;
-
- template <typename F, typename... Args>
- static CallbackType<MakeUnboundRunType<F, Args...>>
- Bind(F&& f, Args&&... args) {
- return BindOnce(std::forward<F>(f), std::forward<Args>(args)...);
- }
-};
-
-using BindVariantsTestConfig = ::testing::Types<
- RepeatingTestConfig, OnceTestConfig>;
-TYPED_TEST_CASE(BindVariantsTest, BindVariantsTestConfig);
-
-template <typename TypeParam, typename Signature>
-using CallbackType = typename TypeParam::template CallbackType<Signature>;
-
-// Function type support.
-// - Normal function.
-// - Normal function bound with non-refcounted first argument.
-// - Method bound to non-const object.
-// - Method bound to scoped_refptr.
-// - Const method bound to non-const object.
-// - Const method bound to const object.
-// - Derived classes can be used with pointers to non-virtual base functions.
-// - Derived classes can be used with pointers to virtual base functions (and
-// preserve virtual dispatch).
-TYPED_TEST(BindVariantsTest, FunctionTypeSupport) {
- using ClosureType = typename TypeParam::ClosureType;
-
- StrictMock<HasRef> has_ref;
- StrictMock<NoRef> no_ref;
- StrictMock<NoRef> static_func_mock;
- const HasRef* const_has_ref_ptr = &has_ref;
- g_func_mock_ptr = &static_func_mock;
-
- EXPECT_CALL(static_func_mock, VoidMethod0());
- EXPECT_CALL(has_ref, AddRef()).Times(4);
- EXPECT_CALL(has_ref, Release()).Times(4);
- EXPECT_CALL(has_ref, VoidMethod0()).Times(2);
- EXPECT_CALL(has_ref, VoidConstMethod0()).Times(2);
-
- ClosureType normal_cb = TypeParam::Bind(&VoidFunc0);
- CallbackType<TypeParam, NoRef*()> normal_non_refcounted_cb =
- TypeParam::Bind(&PolymorphicIdentity<NoRef*>, &no_ref);
- std::move(normal_cb).Run();
- EXPECT_EQ(&no_ref, std::move(normal_non_refcounted_cb).Run());
-
- ClosureType method_cb = TypeParam::Bind(&HasRef::VoidMethod0, &has_ref);
- ClosureType method_refptr_cb =
- TypeParam::Bind(&HasRef::VoidMethod0, WrapRefCounted(&has_ref));
- ClosureType const_method_nonconst_obj_cb =
- TypeParam::Bind(&HasRef::VoidConstMethod0, &has_ref);
- ClosureType const_method_const_obj_cb =
- TypeParam::Bind(&HasRef::VoidConstMethod0, const_has_ref_ptr);
- std::move(method_cb).Run();
- std::move(method_refptr_cb).Run();
- std::move(const_method_nonconst_obj_cb).Run();
- std::move(const_method_const_obj_cb).Run();
-
- Child child;
- child.value = 0;
- ClosureType virtual_set_cb = TypeParam::Bind(&Parent::VirtualSet, &child);
- std::move(virtual_set_cb).Run();
- EXPECT_EQ(kChildValue, child.value);
-
- child.value = 0;
- ClosureType non_virtual_set_cb =
- TypeParam::Bind(&Parent::NonVirtualSet, &child);
- std::move(non_virtual_set_cb).Run();
- EXPECT_EQ(kParentValue, child.value);
-}
-
-// Return value support.
-// - Function with return value.
-// - Method with return value.
-// - Const method with return value.
-// - Move-only return value.
-TYPED_TEST(BindVariantsTest, ReturnValues) {
- StrictMock<NoRef> static_func_mock;
- StrictMock<HasRef> has_ref;
- g_func_mock_ptr = &static_func_mock;
- const HasRef* const_has_ref_ptr = &has_ref;
-
- EXPECT_CALL(static_func_mock, IntMethod0()).WillOnce(Return(1337));
- EXPECT_CALL(has_ref, AddRef()).Times(4);
- EXPECT_CALL(has_ref, Release()).Times(4);
- EXPECT_CALL(has_ref, IntMethod0()).WillOnce(Return(31337));
- EXPECT_CALL(has_ref, IntConstMethod0())
- .WillOnce(Return(41337))
- .WillOnce(Return(51337));
- EXPECT_CALL(has_ref, UniquePtrMethod0())
- .WillOnce(Return(ByMove(std::make_unique<int>(42))));
-
- CallbackType<TypeParam, int()> normal_cb = TypeParam::Bind(&IntFunc0);
- CallbackType<TypeParam, int()> method_cb =
- TypeParam::Bind(&HasRef::IntMethod0, &has_ref);
- CallbackType<TypeParam, int()> const_method_nonconst_obj_cb =
- TypeParam::Bind(&HasRef::IntConstMethod0, &has_ref);
- CallbackType<TypeParam, int()> const_method_const_obj_cb =
- TypeParam::Bind(&HasRef::IntConstMethod0, const_has_ref_ptr);
- CallbackType<TypeParam, std::unique_ptr<int>()> move_only_rv_cb =
- TypeParam::Bind(&HasRef::UniquePtrMethod0, &has_ref);
- EXPECT_EQ(1337, std::move(normal_cb).Run());
- EXPECT_EQ(31337, std::move(method_cb).Run());
- EXPECT_EQ(41337, std::move(const_method_nonconst_obj_cb).Run());
- EXPECT_EQ(51337, std::move(const_method_const_obj_cb).Run());
- EXPECT_EQ(42, *std::move(move_only_rv_cb).Run());
-}
-
-// Argument binding tests.
-// - Argument binding to primitive.
-// - Argument binding to primitive pointer.
-// - Argument binding to a literal integer.
-// - Argument binding to a literal string.
-// - Argument binding with template function.
-// - Argument binding to an object.
-// - Argument binding to pointer to incomplete type.
-// - Argument gets type converted.
-// - Pointer argument gets converted.
-// - Const Reference forces conversion.
-TYPED_TEST(BindVariantsTest, ArgumentBinding) {
- int n = 2;
-
- EXPECT_EQ(n, TypeParam::Bind(&Identity, n).Run());
- EXPECT_EQ(&n, TypeParam::Bind(&PolymorphicIdentity<int*>, &n).Run());
- EXPECT_EQ(3, TypeParam::Bind(&Identity, 3).Run());
- EXPECT_STREQ("hi", TypeParam::Bind(&CStringIdentity, "hi").Run());
- EXPECT_EQ(4, TypeParam::Bind(&PolymorphicIdentity<int>, 4).Run());
-
- NoRefParent p;
- p.value = 5;
- EXPECT_EQ(5, TypeParam::Bind(&UnwrapNoRefParent, p).Run());
-
- IncompleteType* incomplete_ptr = reinterpret_cast<IncompleteType*>(123);
- EXPECT_EQ(incomplete_ptr,
- TypeParam::Bind(&PolymorphicIdentity<IncompleteType*>,
- incomplete_ptr).Run());
-
- NoRefChild c;
- c.value = 6;
- EXPECT_EQ(6, TypeParam::Bind(&UnwrapNoRefParent, c).Run());
-
- c.value = 7;
- EXPECT_EQ(7, TypeParam::Bind(&UnwrapNoRefParentPtr, &c).Run());
-
- c.value = 8;
- EXPECT_EQ(8, TypeParam::Bind(&UnwrapNoRefParentConstRef, c).Run());
-}
-
-// Unbound argument type support tests.
-// - Unbound value.
-// - Unbound pointer.
-// - Unbound reference.
-// - Unbound const reference.
-// - Unbound unsized array.
-// - Unbound sized array.
-// - Unbound array-of-arrays.
-TYPED_TEST(BindVariantsTest, UnboundArgumentTypeSupport) {
- CallbackType<TypeParam, void(int)> unbound_value_cb =
- TypeParam::Bind(&VoidPolymorphic<int>::Run);
- CallbackType<TypeParam, void(int*)> unbound_pointer_cb =
- TypeParam::Bind(&VoidPolymorphic<int*>::Run);
- CallbackType<TypeParam, void(int&)> unbound_ref_cb =
- TypeParam::Bind(&VoidPolymorphic<int&>::Run);
- CallbackType<TypeParam, void(const int&)> unbound_const_ref_cb =
- TypeParam::Bind(&VoidPolymorphic<const int&>::Run);
- CallbackType<TypeParam, void(int[])> unbound_unsized_array_cb =
- TypeParam::Bind(&VoidPolymorphic<int[]>::Run);
- CallbackType<TypeParam, void(int[2])> unbound_sized_array_cb =
- TypeParam::Bind(&VoidPolymorphic<int[2]>::Run);
- CallbackType<TypeParam, void(int[][2])> unbound_array_of_arrays_cb =
- TypeParam::Bind(&VoidPolymorphic<int[][2]>::Run);
- CallbackType<TypeParam, void(int&)> unbound_ref_with_bound_arg =
- TypeParam::Bind(&VoidPolymorphic<int, int&>::Run, 1);
-}
-
-// Function with unbound reference parameter.
-// - Original parameter is modified by callback.
-TYPED_TEST(BindVariantsTest, UnboundReferenceSupport) {
- int n = 0;
- CallbackType<TypeParam, void(int&)> unbound_ref_cb =
- TypeParam::Bind(&RefArgSet);
- std::move(unbound_ref_cb).Run(n);
- EXPECT_EQ(2, n);
-}
-
-// Unretained() wrapper support.
-// - Method bound to Unretained() non-const object.
-// - Const method bound to Unretained() non-const object.
-// - Const method bound to Unretained() const object.
-TYPED_TEST(BindVariantsTest, Unretained) {
- StrictMock<NoRef> no_ref;
- const NoRef* const_no_ref_ptr = &no_ref;
-
- EXPECT_CALL(no_ref, VoidMethod0());
- EXPECT_CALL(no_ref, VoidConstMethod0()).Times(2);
-
- TypeParam::Bind(&NoRef::VoidMethod0, Unretained(&no_ref)).Run();
- TypeParam::Bind(&NoRef::VoidConstMethod0, Unretained(&no_ref)).Run();
- TypeParam::Bind(&NoRef::VoidConstMethod0, Unretained(const_no_ref_ptr)).Run();
-}
-
-TYPED_TEST(BindVariantsTest, ScopedRefptr) {
- StrictMock<HasRef> has_ref;
- EXPECT_CALL(has_ref, AddRef()).Times(1);
- EXPECT_CALL(has_ref, Release()).Times(1);
-
- const scoped_refptr<HasRef> refptr(&has_ref);
- CallbackType<TypeParam, int()> scoped_refptr_const_ref_cb =
- TypeParam::Bind(&FunctionWithScopedRefptrFirstParam,
- base::ConstRef(refptr), 1);
- EXPECT_EQ(1, std::move(scoped_refptr_const_ref_cb).Run());
-}
-
-TYPED_TEST(BindVariantsTest, UniquePtrReceiver) {
- std::unique_ptr<StrictMock<NoRef>> no_ref(new StrictMock<NoRef>);
- EXPECT_CALL(*no_ref, VoidMethod0()).Times(1);
- TypeParam::Bind(&NoRef::VoidMethod0, std::move(no_ref)).Run();
-}
-
-// Tests for Passed() wrapper support:
-// - Passed() can be constructed from a pointer to scoper.
-// - Passed() can be constructed from a scoper rvalue.
-// - Using Passed() gives Callback Ownership.
-// - Ownership is transferred from Callback to callee on the first Run().
-// - Callback supports unbound arguments.
-template <typename T>
-class BindMoveOnlyTypeTest : public ::testing::Test {
-};
-
-struct CustomDeleter {
- void operator()(DeleteCounter* c) { delete c; }
-};
-
-using MoveOnlyTypesToTest =
- ::testing::Types<std::unique_ptr<DeleteCounter>,
- std::unique_ptr<DeleteCounter, CustomDeleter>>;
-TYPED_TEST_CASE(BindMoveOnlyTypeTest, MoveOnlyTypesToTest);
-
-TYPED_TEST(BindMoveOnlyTypeTest, PassedToBoundCallback) {
- int deletes = 0;
-
- TypeParam ptr(new DeleteCounter(&deletes));
- Callback<TypeParam()> callback = Bind(&PassThru<TypeParam>, Passed(&ptr));
- EXPECT_FALSE(ptr.get());
- EXPECT_EQ(0, deletes);
-
- // If we never invoke the Callback, it retains ownership and deletes.
- callback.Reset();
- EXPECT_EQ(1, deletes);
-}
-
-TYPED_TEST(BindMoveOnlyTypeTest, PassedWithRvalue) {
- int deletes = 0;
- Callback<TypeParam()> callback = Bind(
- &PassThru<TypeParam>, Passed(TypeParam(new DeleteCounter(&deletes))));
- EXPECT_EQ(0, deletes);
-
- // If we never invoke the Callback, it retains ownership and deletes.
- callback.Reset();
- EXPECT_EQ(1, deletes);
-}
-
-// Check that ownership can be transferred back out.
-TYPED_TEST(BindMoveOnlyTypeTest, ReturnMoveOnlyType) {
- int deletes = 0;
- DeleteCounter* counter = new DeleteCounter(&deletes);
- Callback<TypeParam()> callback =
- Bind(&PassThru<TypeParam>, Passed(TypeParam(counter)));
- TypeParam result = callback.Run();
- ASSERT_EQ(counter, result.get());
- EXPECT_EQ(0, deletes);
-
- // Resetting does not delete since ownership was transferred.
- callback.Reset();
- EXPECT_EQ(0, deletes);
-
- // Ensure that we actually did get ownership.
- result.reset();
- EXPECT_EQ(1, deletes);
-}
-
-TYPED_TEST(BindMoveOnlyTypeTest, UnboundForwarding) {
- int deletes = 0;
- TypeParam ptr(new DeleteCounter(&deletes));
- // Test unbound argument forwarding.
- Callback<TypeParam(TypeParam)> cb_unbound = Bind(&PassThru<TypeParam>);
- cb_unbound.Run(std::move(ptr));
- EXPECT_EQ(1, deletes);
-}
-
-void VerifyVector(const std::vector<std::unique_ptr<int>>& v) {
- ASSERT_EQ(1u, v.size());
- EXPECT_EQ(12345, *v[0]);
-}
-
-std::vector<std::unique_ptr<int>> AcceptAndReturnMoveOnlyVector(
- std::vector<std::unique_ptr<int>> v) {
- VerifyVector(v);
- return v;
-}
-
-// Test that a vector containing move-only types can be used with Callback.
-TEST_F(BindTest, BindMoveOnlyVector) {
- using MoveOnlyVector = std::vector<std::unique_ptr<int>>;
-
- MoveOnlyVector v;
- v.push_back(WrapUnique(new int(12345)));
-
- // Early binding should work:
- base::Callback<MoveOnlyVector()> bound_cb =
- base::Bind(&AcceptAndReturnMoveOnlyVector, Passed(&v));
- MoveOnlyVector intermediate_result = bound_cb.Run();
- VerifyVector(intermediate_result);
-
- // As should passing it as an argument to Run():
- base::Callback<MoveOnlyVector(MoveOnlyVector)> unbound_cb =
- base::Bind(&AcceptAndReturnMoveOnlyVector);
- MoveOnlyVector final_result = unbound_cb.Run(std::move(intermediate_result));
- VerifyVector(final_result);
-}
-
-// Argument copy-constructor usage for non-reference copy-only parameters.
-// - Bound arguments are only copied once.
-// - Forwarded arguments are only copied once.
-// - Forwarded arguments with coercions are only copied twice (once for the
-// coercion, and one for the final dispatch).
-TEST_F(BindTest, ArgumentCopies) {
- int copies = 0;
- int assigns = 0;
-
- CopyCounter counter(&copies, &assigns);
- Bind(&VoidPolymorphic<CopyCounter>::Run, counter);
- EXPECT_EQ(1, copies);
- EXPECT_EQ(0, assigns);
-
- copies = 0;
- assigns = 0;
- Bind(&VoidPolymorphic<CopyCounter>::Run, CopyCounter(&copies, &assigns));
- EXPECT_EQ(1, copies);
- EXPECT_EQ(0, assigns);
-
- copies = 0;
- assigns = 0;
- Bind(&VoidPolymorphic<CopyCounter>::Run).Run(counter);
- EXPECT_EQ(2, copies);
- EXPECT_EQ(0, assigns);
-
- copies = 0;
- assigns = 0;
- Bind(&VoidPolymorphic<CopyCounter>::Run).Run(CopyCounter(&copies, &assigns));
- EXPECT_EQ(1, copies);
- EXPECT_EQ(0, assigns);
-
- copies = 0;
- assigns = 0;
- DerivedCopyMoveCounter derived(&copies, &assigns, nullptr, nullptr);
- Bind(&VoidPolymorphic<CopyCounter>::Run).Run(CopyCounter(derived));
- EXPECT_EQ(2, copies);
- EXPECT_EQ(0, assigns);
-
- copies = 0;
- assigns = 0;
- Bind(&VoidPolymorphic<CopyCounter>::Run)
- .Run(CopyCounter(
- DerivedCopyMoveCounter(&copies, &assigns, nullptr, nullptr)));
- EXPECT_EQ(2, copies);
- EXPECT_EQ(0, assigns);
-}
-
-// Argument move-constructor usage for move-only parameters.
-// - Bound arguments passed by move are not copied.
-TEST_F(BindTest, ArgumentMoves) {
- int move_constructs = 0;
- int move_assigns = 0;
-
- Bind(&VoidPolymorphic<const MoveCounter&>::Run,
- MoveCounter(&move_constructs, &move_assigns));
- EXPECT_EQ(1, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- // TODO(tzik): Support binding move-only type into a non-reference parameter
- // of a variant of Callback.
-
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<MoveCounter>::Run)
- .Run(MoveCounter(&move_constructs, &move_assigns));
- EXPECT_EQ(1, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<MoveCounter>::Run)
- .Run(MoveCounter(DerivedCopyMoveCounter(
- nullptr, nullptr, &move_constructs, &move_assigns)));
- EXPECT_EQ(2, move_constructs);
- EXPECT_EQ(0, move_assigns);
-}
-
-// Argument constructor usage for non-reference movable-copyable
-// parameters.
-// - Bound arguments passed by move are not copied.
-// - Forwarded arguments are only copied once.
-// - Forwarded arguments with coercions are only copied once and moved once.
-TEST_F(BindTest, ArgumentCopiesAndMoves) {
- int copies = 0;
- int assigns = 0;
- int move_constructs = 0;
- int move_assigns = 0;
-
- CopyMoveCounter counter(&copies, &assigns, &move_constructs, &move_assigns);
- Bind(&VoidPolymorphic<CopyMoveCounter>::Run, counter);
- EXPECT_EQ(1, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(0, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- copies = 0;
- assigns = 0;
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<CopyMoveCounter>::Run,
- CopyMoveCounter(&copies, &assigns, &move_constructs, &move_assigns));
- EXPECT_EQ(0, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(1, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- copies = 0;
- assigns = 0;
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<CopyMoveCounter>::Run).Run(counter);
- EXPECT_EQ(1, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(1, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- copies = 0;
- assigns = 0;
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<CopyMoveCounter>::Run)
- .Run(CopyMoveCounter(&copies, &assigns, &move_constructs, &move_assigns));
- EXPECT_EQ(0, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(1, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- DerivedCopyMoveCounter derived_counter(&copies, &assigns, &move_constructs,
- &move_assigns);
- copies = 0;
- assigns = 0;
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<CopyMoveCounter>::Run)
- .Run(CopyMoveCounter(derived_counter));
- EXPECT_EQ(1, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(1, move_constructs);
- EXPECT_EQ(0, move_assigns);
-
- copies = 0;
- assigns = 0;
- move_constructs = 0;
- move_assigns = 0;
- Bind(&VoidPolymorphic<CopyMoveCounter>::Run)
- .Run(CopyMoveCounter(DerivedCopyMoveCounter(
- &copies, &assigns, &move_constructs, &move_assigns)));
- EXPECT_EQ(0, copies);
- EXPECT_EQ(0, assigns);
- EXPECT_EQ(2, move_constructs);
- EXPECT_EQ(0, move_assigns);
-}
-
-TEST_F(BindTest, CapturelessLambda) {
- EXPECT_FALSE(internal::IsCallableObject<void>::value);
- EXPECT_FALSE(internal::IsCallableObject<int>::value);
- EXPECT_FALSE(internal::IsCallableObject<void (*)()>::value);
- EXPECT_FALSE(internal::IsCallableObject<void (NoRef::*)()>::value);
-
- auto f = []() {};
- EXPECT_TRUE(internal::IsCallableObject<decltype(f)>::value);
-
- int i = 0;
- auto g = [i]() { (void)i; };
- EXPECT_TRUE(internal::IsCallableObject<decltype(g)>::value);
-
- auto h = [](int, double) { return 'k'; };
- EXPECT_TRUE((std::is_same<
- char(int, double),
- internal::ExtractCallableRunType<decltype(h)>>::value));
-
- EXPECT_EQ(42, Bind([] { return 42; }).Run());
- EXPECT_EQ(42, Bind([](int i) { return i * 7; }, 6).Run());
-
- int x = 1;
- base::Callback<void(int)> cb =
- Bind([](int* x, int i) { *x *= i; }, Unretained(&x));
- cb.Run(6);
- EXPECT_EQ(6, x);
- cb.Run(7);
- EXPECT_EQ(42, x);
-}
-
-TEST_F(BindTest, EmptyFunctor) {
- struct NonEmptyFunctor {
- int operator()() const { return x; }
- int x = 42;
- };
-
- struct EmptyFunctor {
- int operator()() { return 42; }
- };
-
- struct EmptyFunctorConst {
- int operator()() const { return 42; }
- };
-
- EXPECT_TRUE(internal::IsCallableObject<NonEmptyFunctor>::value);
- EXPECT_TRUE(internal::IsCallableObject<EmptyFunctor>::value);
- EXPECT_TRUE(internal::IsCallableObject<EmptyFunctorConst>::value);
- EXPECT_EQ(42, BindOnce(EmptyFunctor()).Run());
- EXPECT_EQ(42, BindOnce(EmptyFunctorConst()).Run());
- EXPECT_EQ(42, BindRepeating(EmptyFunctorConst()).Run());
-}
-
-TEST_F(BindTest, CapturingLambdaForTesting) {
- int x = 6;
- EXPECT_EQ(42, BindLambdaForTesting([=](int y) { return x * y; }).Run(7));
-
- auto f = [x](std::unique_ptr<int> y) { return x * *y; };
- EXPECT_EQ(42, BindLambdaForTesting(f).Run(std::make_unique<int>(7)));
-}
-
-TEST_F(BindTest, Cancellation) {
- EXPECT_CALL(no_ref_, VoidMethodWithIntArg(_)).Times(2);
-
- WeakPtrFactory<NoRef> weak_factory(&no_ref_);
- RepeatingCallback<void(int)> cb =
- BindRepeating(&NoRef::VoidMethodWithIntArg, weak_factory.GetWeakPtr());
- RepeatingClosure cb2 = BindRepeating(cb, 8);
- OnceClosure cb3 = BindOnce(cb, 8);
-
- OnceCallback<void(int)> cb4 =
- BindOnce(&NoRef::VoidMethodWithIntArg, weak_factory.GetWeakPtr());
- EXPECT_FALSE(cb4.IsCancelled());
-
- OnceClosure cb5 = BindOnce(std::move(cb4), 8);
-
- EXPECT_FALSE(cb.IsCancelled());
- EXPECT_FALSE(cb2.IsCancelled());
- EXPECT_FALSE(cb3.IsCancelled());
- EXPECT_FALSE(cb5.IsCancelled());
-
- cb.Run(6);
- cb2.Run();
-
- weak_factory.InvalidateWeakPtrs();
-
- EXPECT_TRUE(cb.IsCancelled());
- EXPECT_TRUE(cb2.IsCancelled());
- EXPECT_TRUE(cb3.IsCancelled());
- EXPECT_TRUE(cb5.IsCancelled());
-
- cb.Run(6);
- cb2.Run();
- std::move(cb3).Run();
- std::move(cb5).Run();
-}
-
-TEST_F(BindTest, OnceCallback) {
- // Check if Callback variants have declarations of conversions as expected.
- // Copy constructor and assignment of RepeatingCallback.
- static_assert(std::is_constructible<
- RepeatingClosure, const RepeatingClosure&>::value,
- "RepeatingClosure should be copyable.");
- static_assert(
- std::is_assignable<RepeatingClosure, const RepeatingClosure&>::value,
- "RepeatingClosure should be copy-assignable.");
-
- // Move constructor and assignment of RepeatingCallback.
- static_assert(std::is_constructible<
- RepeatingClosure, RepeatingClosure&&>::value,
- "RepeatingClosure should be movable.");
- static_assert(std::is_assignable<RepeatingClosure, RepeatingClosure&&>::value,
- "RepeatingClosure should be move-assignable");
-
- // Conversions from OnceCallback to RepeatingCallback.
- static_assert(!std::is_constructible<
- RepeatingClosure, const OnceClosure&>::value,
- "OnceClosure should not be convertible to RepeatingClosure.");
- static_assert(
- !std::is_assignable<RepeatingClosure, const OnceClosure&>::value,
- "OnceClosure should not be convertible to RepeatingClosure.");
-
- // Destructive conversions from OnceCallback to RepeatingCallback.
- static_assert(!std::is_constructible<
- RepeatingClosure, OnceClosure&&>::value,
- "OnceClosure should not be convertible to RepeatingClosure.");
- static_assert(!std::is_assignable<RepeatingClosure, OnceClosure&&>::value,
- "OnceClosure should not be convertible to RepeatingClosure.");
-
- // Copy constructor and assignment of OnceCallback.
- static_assert(!std::is_constructible<
- OnceClosure, const OnceClosure&>::value,
- "OnceClosure should not be copyable.");
- static_assert(!std::is_assignable<OnceClosure, const OnceClosure&>::value,
- "OnceClosure should not be copy-assignable");
-
- // Move constructor and assignment of OnceCallback.
- static_assert(std::is_constructible<
- OnceClosure, OnceClosure&&>::value,
- "OnceClosure should be movable.");
- static_assert(std::is_assignable<OnceClosure, OnceClosure&&>::value,
- "OnceClosure should be move-assignable.");
-
- // Conversions from RepeatingCallback to OnceCallback.
- static_assert(std::is_constructible<
- OnceClosure, const RepeatingClosure&>::value,
- "RepeatingClosure should be convertible to OnceClosure.");
- static_assert(std::is_assignable<OnceClosure, const RepeatingClosure&>::value,
- "RepeatingClosure should be convertible to OnceClosure.");
-
- // Destructive conversions from RepeatingCallback to OnceCallback.
- static_assert(std::is_constructible<
- OnceClosure, RepeatingClosure&&>::value,
- "RepeatingClosure should be convertible to OnceClosure.");
- static_assert(std::is_assignable<OnceClosure, RepeatingClosure&&>::value,
- "RepeatingClosure should be covretible to OnceClosure.");
-
- OnceClosure cb = BindOnce(&VoidPolymorphic<>::Run);
- std::move(cb).Run();
-
- // RepeatingCallback should be convertible to OnceCallback.
- OnceClosure cb2 = BindRepeating(&VoidPolymorphic<>::Run);
- std::move(cb2).Run();
-
- RepeatingClosure cb3 = BindRepeating(&VoidPolymorphic<>::Run);
- cb = cb3;
- std::move(cb).Run();
-
- cb = std::move(cb2);
-
- OnceCallback<void(int)> cb4 =
- BindOnce(&VoidPolymorphic<std::unique_ptr<int>, int>::Run,
- std::make_unique<int>(0));
- BindOnce(std::move(cb4), 1).Run();
-}
-
-// Callback construction and assignment tests.
-// - Construction from an InvokerStorageHolder should not cause ref/deref.
-// - Assignment from other callback should only cause one ref
-//
-// TODO(ajwong): Is there actually a way to test this?
-
-#if defined(OS_WIN)
-int __fastcall FastCallFunc(int n) {
- return n;
-}
-
-int __stdcall StdCallFunc(int n) {
- return n;
-}
-
-// Windows specific calling convention support.
-// - Can bind a __fastcall function.
-// - Can bind a __stdcall function.
-TEST_F(BindTest, WindowsCallingConventions) {
- Callback<int()> fastcall_cb = Bind(&FastCallFunc, 1);
- EXPECT_EQ(1, fastcall_cb.Run());
-
- Callback<int()> stdcall_cb = Bind(&StdCallFunc, 2);
- EXPECT_EQ(2, stdcall_cb.Run());
-}
-#endif
-
-// Test unwrapping the various wrapping functions.
-
-TEST_F(BindTest, UnwrapUnretained) {
- int i = 0;
- auto unretained = Unretained(&i);
- EXPECT_EQ(&i, internal::Unwrap(unretained));
- EXPECT_EQ(&i, internal::Unwrap(std::move(unretained)));
-}
-
-TEST_F(BindTest, UnwrapConstRef) {
- int p = 0;
- auto const_ref = ConstRef(p);
- EXPECT_EQ(&p, &internal::Unwrap(const_ref));
- EXPECT_EQ(&p, &internal::Unwrap(std::move(const_ref)));
-}
-
-TEST_F(BindTest, UnwrapRetainedRef) {
- auto p = MakeRefCounted<RefCountedData<int>>();
- auto retained_ref = RetainedRef(p);
- EXPECT_EQ(p.get(), internal::Unwrap(retained_ref));
- EXPECT_EQ(p.get(), internal::Unwrap(std::move(retained_ref)));
-}
-
-TEST_F(BindTest, UnwrapOwned) {
- int* p = new int;
- auto owned = Owned(p);
- EXPECT_EQ(p, internal::Unwrap(owned));
- EXPECT_EQ(p, internal::Unwrap(std::move(owned)));
-}
-
-TEST_F(BindTest, UnwrapPassed) {
- int* p = new int;
- auto passed = Passed(WrapUnique(p));
- EXPECT_EQ(p, internal::Unwrap(passed).get());
-
- p = new int;
- EXPECT_EQ(p, internal::Unwrap(Passed(WrapUnique(p))).get());
-}
-
-TEST_F(BindTest, BindNoexcept) {
- EXPECT_EQ(42, base::BindOnce(&Noexcept).Run());
- EXPECT_EQ(
- 42,
- base::BindOnce(&BindTest::NoexceptMethod, base::Unretained(this)).Run());
- EXPECT_EQ(
- 42, base::BindOnce(&BindTest::ConstNoexceptMethod, base::Unretained(this))
- .Run());
-}
-
-// Test null callbacks cause a DCHECK.
-TEST(BindDeathTest, NullCallback) {
- base::Callback<void(int)> null_cb;
- ASSERT_TRUE(null_cb.is_null());
- EXPECT_DCHECK_DEATH(base::Bind(null_cb, 42));
-}
-
-} // namespace
-} // namespace base
diff --git a/base/bind_unittest.nc b/base/bind_unittest.nc
deleted file mode 100644
index d549d2e..0000000
--- a/base/bind_unittest.nc
+++ /dev/null
@@ -1,322 +0,0 @@
-// Copyright (c) 2011 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/test/bind_test_util.h"
-
-namespace base {
-
-// Do not put everything inside an anonymous namespace. If you do, many of the
-// helper function declarations will generate unused definition warnings.
-
-static const int kParentValue = 1;
-static const int kChildValue = 2;
-
-class NoRef {
- public:
- void VoidMethod0() {}
- void VoidConstMethod0() const {}
- int IntMethod0() { return 1; }
-};
-
-class HasRef : public NoRef, public base::RefCounted<HasRef> {
-};
-
-class Parent {
- public:
- void AddRef() const {}
- void Release() const {}
- virtual void VirtualSet() { value = kParentValue; }
- void NonVirtualSet() { value = kParentValue; }
- int value;
-};
-
-class Child : public Parent {
- public:
- virtual void VirtualSet() { value = kChildValue; }
- void NonVirtualSet() { value = kChildValue; }
-};
-
-class NoRefParent {
- public:
- virtual void VirtualSet() { value = kParentValue; }
- void NonVirtualSet() { value = kParentValue; }
- int value;
-};
-
-class NoRefChild : public NoRefParent {
- virtual void VirtualSet() { value = kChildValue; }
- void NonVirtualSet() { value = kChildValue; }
-};
-
-template <typename T>
-T PolymorphicIdentity(T t) {
- return t;
-}
-
-int UnwrapParentRef(Parent& p) {
- return p.value;
-}
-
-template <typename T>
-void VoidPolymorphic1(T t) {
-}
-
-void TakesMoveOnly(std::unique_ptr<int>) {
-}
-
-struct NonEmptyFunctor {
- int x;
- void operator()() const {}
-};
-
-// TODO(hans): Remove .* and update the static_assert expectations once we roll
-// past Clang r313315. https://crbug.com/765692.
-
-#if defined(NCTEST_METHOD_ON_CONST_OBJECT) // [r"fatal error: static_assert failed .*\"Bound argument \|i\| of type \|Arg\| cannot be forwarded as \|Unwrapped\| to the bound functor, which declares it as \|Param\|\.\""]
-
-// Method bound to const-object.
-//
-// Only const methods should be allowed to work with const objects.
-void WontCompile() {
- HasRef has_ref;
- const HasRef* const_has_ref_ptr_ = &has_ref;
- Callback<void()> method_to_const_cb =
- Bind(&HasRef::VoidMethod0, const_has_ref_ptr_);
- method_to_const_cb.Run();
-}
-
-#elif defined(NCTEST_METHOD_BIND_NEEDS_REFCOUNTED_OBJECT) // [r"fatal error: static_assert failed \"Receivers may not be raw pointers\."]
-
-
-// Method bound to non-refcounted object.
-//
-// We require refcounts unless you have Unretained().
-void WontCompile() {
- NoRef no_ref;
- Callback<void()> no_ref_cb =
- Bind(&NoRef::VoidMethod0, &no_ref);
- no_ref_cb.Run();
-}
-
-#elif defined(NCTEST_CONST_METHOD_NEEDS_REFCOUNTED_OBJECT) // [r"fatal error: static_assert failed \"Receivers may not be raw pointers\."]
-
-// Const Method bound to non-refcounted object.
-//
-// We require refcounts unless you have Unretained().
-void WontCompile() {
- NoRef no_ref;
- Callback<void()> no_ref_const_cb =
- Bind(&NoRef::VoidConstMethod0, &no_ref);
- no_ref_const_cb.Run();
-}
-
-#elif defined(NCTEST_CONST_POINTER) // [r"fatal error: static_assert failed .*\"Bound argument \|i\| of type \|Arg\| cannot be forwarded as \|Unwrapped\| to the bound functor, which declares it as \|Param\|\.\""]
-
-// Const argument used with non-const pointer parameter of same type.
-//
-// This is just a const-correctness check.
-void WontCompile() {
- const NoRef* const_no_ref_ptr;
- Callback<NoRef*()> pointer_same_cb =
- Bind(&PolymorphicIdentity<NoRef*>, const_no_ref_ptr);
- pointer_same_cb.Run();
-}
-
-#elif defined(NCTEST_CONST_POINTER_SUBTYPE) // [r"fatal error: static_assert failed .*\"Bound argument \|i\| of type \|Arg\| cannot be forwarded as \|Unwrapped\| to the bound functor, which declares it as \|Param\|\.\""]
-
-// Const argument used with non-const pointer parameter of super type.
-//
-// This is just a const-correctness check.
-void WontCompile() {
- const NoRefChild* const_child_ptr;
- Callback<NoRefParent*()> pointer_super_cb =
- Bind(&PolymorphicIdentity<NoRefParent*>, const_child_ptr);
- pointer_super_cb.Run();
-}
-
-#elif defined(DISABLED_NCTEST_DISALLOW_NON_CONST_REF_PARAM) // [r"fatal error: no member named 'AddRef' in 'base::NoRef'"]
-// TODO(dcheng): I think there's a type safety promotion issue here where we can
-// pass a const ref to a non const-ref function, or vice versa accidentally. Or
-// we make a copy accidentally. Check.
-
-// Functions with reference parameters, unsupported.
-//
-// First, non-const reference parameters are disallowed by the Google
-// style guide. Second, since we are doing argument forwarding it becomes
-// very tricky to avoid copies, maintain const correctness, and not
-// accidentally have the function be modifying a temporary, or a copy.
-void WontCompile() {
- Parent p;
- Callback<int(Parent&)> ref_arg_cb = Bind(&UnwrapParentRef);
- ref_arg_cb.Run(p);
-}
-
-#elif defined(NCTEST_DISALLOW_BIND_TO_NON_CONST_REF_PARAM) // [r"fatal error: static_assert failed .*\"Bound argument \|i\| of type \|Arg\| cannot be forwarded as \|Unwrapped\| to the bound functor, which declares it as \|Param\|\.\""]
-
-// Binding functions with reference parameters, unsupported.
-//
-// See comment in NCTEST_DISALLOW_NON_CONST_REF_PARAM
-void WontCompile() {
- Parent p;
- Callback<int()> ref_cb = Bind(&UnwrapParentRef, p);
- ref_cb.Run();
-}
-
-#elif defined(NCTEST_NO_IMPLICIT_ARRAY_PTR_CONVERSION) // [r"fatal error: static_assert failed .*\"First bound argument to a method cannot be an array\.\""]
-
-// A method should not be bindable with an array of objects.
-//
-// This is likely not wanted behavior. We specifically check for it though
-// because it is possible, depending on how you implement prebinding, to
-// implicitly convert an array type to a pointer type.
-void WontCompile() {
- HasRef p[10];
- Callback<void()> method_bound_to_array_cb =
- Bind(&HasRef::VoidMethod0, p);
- method_bound_to_array_cb.Run();
-}
-
-#elif defined(NCTEST_NO_RVALUE_RAW_PTR_FOR_REFCOUNTED_TYPES) // [r"fatal error: static_assert failed .*\"A parameter is a refcounted type and needs scoped_refptr\.\""]
-
-// Refcounted types should not be bound as a raw pointer.
-void WontCompile() {
- HasRef for_raw_ptr;
- int a;
- Callback<void()> ref_count_as_raw_ptr_a =
- Bind(&VoidPolymorphic1<int*>, &a);
- Callback<void()> ref_count_as_raw_ptr =
- Bind(&VoidPolymorphic1<HasRef*>, &for_raw_ptr);
-}
-
-#elif defined(NCTEST_NO_LVALUE_RAW_PTR_FOR_REFCOUNTED_TYPES) // [r"fatal error: static_assert failed .*\"A parameter is a refcounted type and needs scoped_refptr\.\""]
-
-// Refcounted types should not be bound as a raw pointer.
-void WontCompile() {
- HasRef* for_raw_ptr = nullptr;
- Callback<void()> ref_count_as_raw_ptr =
- Bind(&VoidPolymorphic1<HasRef*>, for_raw_ptr);
-}
-
-#elif defined(NCTEST_NO_RVALUE_CONST_RAW_PTR_FOR_REFCOUNTED_TYPES) // [r"fatal error: static_assert failed .*\"A parameter is a refcounted type and needs scoped_refptr\.\""]
-
-// Refcounted types should not be bound as a raw pointer.
-void WontCompile() {
- const HasRef for_raw_ptr;
- Callback<void()> ref_count_as_raw_ptr =
- Bind(&VoidPolymorphic1<const HasRef*>, &for_raw_ptr);
-}
-
-#elif defined(NCTEST_NO_LVALUE_CONST_RAW_PTR_FOR_REFCOUNTED_TYPES) // [r"fatal error: static_assert failed .*\"A parameter is a refcounted type and needs scoped_refptr\.\""]
-
-// Refcounted types should not be bound as a raw pointer.
-void WontCompile() {
- const HasRef* for_raw_ptr = nullptr;
- Callback<void()> ref_count_as_raw_ptr =
- Bind(&VoidPolymorphic1<const HasRef*>, for_raw_ptr);
-}
-
-#elif defined(NCTEST_WEAKPTR_BIND_MUST_RETURN_VOID) // [r"fatal error: static_assert failed .*\"weak_ptrs can only bind to methods without return values\""]
-
-// WeakPtrs cannot be bound to methods with return types.
-void WontCompile() {
- NoRef no_ref;
- WeakPtrFactory<NoRef> weak_factory(&no_ref);
- Callback<int()> weak_ptr_with_non_void_return_type =
- Bind(&NoRef::IntMethod0, weak_factory.GetWeakPtr());
- weak_ptr_with_non_void_return_type.Run();
-}
-
-#elif defined(NCTEST_DISALLOW_ASSIGN_DIFFERENT_TYPES) // [r"fatal error: no viable conversion from 'Callback<MakeUnboundRunType<void \(\*\)\(int\)>>' to 'Callback<void \(\)>'"]
-
-// Bind result cannot be assigned to Callbacks with a mismatching type.
-void WontCompile() {
- Closure callback_mismatches_bind_type = Bind(&VoidPolymorphic1<int>);
-}
-
-#elif defined(NCTEST_DISALLOW_CAPTURING_LAMBDA) // [r"fatal error: implicit instantiation of undefined template 'base::internal::FunctorTraits<\(lambda at (\.\./)+base/bind_unittest.nc:[0-9]+:[0-9]+\), void>'"]
-
-void WontCompile() {
- int i = 0, j = 0;
- Bind([i,&j]() {j = i;});
-}
-
-#elif defined(NCTEST_DISALLOW_ONCECALLBACK_RUN_ON_LVALUE) // [r"static_assert failed .*\"OnceCallback::Run\(\) may only be invoked on a non-const rvalue, i\.e\. std::move\(callback\)\.Run\(\)\.\""]
-
-void WontCompile() {
- OnceClosure cb = Bind([] {});
- cb.Run();
-}
-
-#elif defined(NCTEST_DISALLOW_ONCECALLBACK_RUN_ON_CONST_LVALUE) // [r"static_assert failed .*\"OnceCallback::Run\(\) may only be invoked on a non-const rvalue, i\.e\. std::move\(callback\)\.Run\(\)\.\""]
-
-void WontCompile() {
- const OnceClosure cb = Bind([] {});
- cb.Run();
-}
-
-#elif defined(NCTEST_DISALLOW_ONCECALLBACK_RUN_ON_CONST_RVALUE) // [r"static_assert failed .*\"OnceCallback::Run\(\) may only be invoked on a non-const rvalue, i\.e\. std::move\(callback\)\.Run\(\)\.\""]
-
-void WontCompile() {
- const OnceClosure cb = Bind([] {});
- std::move(cb).Run();
-}
-
-#elif defined(NCTEST_DISALLOW_BIND_ONCECALLBACK) // [r"fatal error: static_assert failed .*\"BindRepeating cannot bind OnceCallback. Use BindOnce with std::move\(\)\.\""]
-
-void WontCompile() {
- Bind(BindOnce([](int) {}), 42);
-}
-
-#elif defined(NCTEST_DISALLOW_BINDONCE_LVALUE_ONCECALLBACK) // [r"fatal error: static_assert failed .*\"BindOnce requires non-const rvalue for OnceCallback binding\."]
-void WontCompile() {
- auto cb = BindOnce([](int) {});
- BindOnce(cb, 42);
-}
-
-#elif defined(NCTEST_DISALLOW_BINDONCE_RVALUE_CONST_ONCECALLBACK) // [r"fatal error: static_assert failed .*\"BindOnce requires non-const rvalue for OnceCallback binding\."]
-
-void WontCompile() {
- const auto cb = BindOnce([](int) {});
- BindOnce(std::move(cb), 42);
-}
-
-#elif defined(NCTEST_BINDONCE_MOVEONLY_TYPE_BY_VALUE) // [r"fatal error: static_assert failed .*\"Bound argument \|i\| is move-only but will be bound by copy\. Ensure \|Arg\| is mutable and bound using std::move\(\)\.\""]
-
-void WontCompile() {
- std::unique_ptr<int> x;
- BindOnce(&TakesMoveOnly, x);
-}
-
-#elif defined(NCTEST_BIND_MOVEONLY_TYPE_BY_VALUE) // [r"Bound argument \|i\| is move-only but will be forwarded by copy\. Ensure \|Arg\| is bound using base::Passed\(\), not std::move\(\)."]
-
-void WontCompile() {
- std::unique_ptr<int> x;
- Bind(&TakesMoveOnly, x);
-}
-
-#elif defined(NCTEST_BIND_MOVEONLY_TYPE_WITH_STDMOVE) // [r"Bound argument \|i\| is move-only but will be forwarded by copy\. Ensure \|Arg\| is bound using base::Passed\(\), not std::move\(\)."]
-
-void WontCompile() {
- std::unique_ptr<int> x;
- Bind(&TakesMoveOnly, std::move(x));
-}
-
-#elif defined(NCTEST_BIND_NON_EMPTY_FUNCTOR) // [r"fatal error: implicit instantiation of undefined template 'base::internal::FunctorTraits<base::NonEmptyFunctor, void>'"]
-
-void WontCompile() {
- Bind(NonEmptyFunctor());
-}
-
-#endif
-
-} // namespace base
diff --git a/base/bit_cast_unittest.cc b/base/bit_cast_unittest.cc
deleted file mode 100644
index f36d3fe..0000000
--- a/base/bit_cast_unittest.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2016 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 "base/bit_cast.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-TEST(BitCastTest, FloatIntFloat) {
- float f = 3.1415926f;
- int i = bit_cast<int32_t>(f);
- float f2 = bit_cast<float>(i);
- EXPECT_EQ(f, f2);
-}
-
-struct A {
- int x;
-};
-
-TEST(BitCastTest, StructureInt) {
- A a = { 1 };
- int b = bit_cast<int>(a);
- EXPECT_EQ(1, b);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/bits_unittest.cc b/base/bits_unittest.cc
deleted file mode 100644
index ceaad3f..0000000
--- a/base/bits_unittest.cc
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright (c) 2009 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 file contains the unit tests for the bit utilities.
-
-#include "base/bits.h"
-#include "build_config.h"
-
-#include <stddef.h>
-
-#include <limits>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace bits {
-
-TEST(BitsTest, Log2Floor) {
- EXPECT_EQ(-1, Log2Floor(0));
- EXPECT_EQ(0, Log2Floor(1));
- EXPECT_EQ(1, Log2Floor(2));
- EXPECT_EQ(1, Log2Floor(3));
- EXPECT_EQ(2, Log2Floor(4));
- for (int i = 3; i < 31; ++i) {
- unsigned int value = 1U << i;
- EXPECT_EQ(i, Log2Floor(value));
- EXPECT_EQ(i, Log2Floor(value + 1));
- EXPECT_EQ(i, Log2Floor(value + 2));
- EXPECT_EQ(i - 1, Log2Floor(value - 1));
- EXPECT_EQ(i - 1, Log2Floor(value - 2));
- }
- EXPECT_EQ(31, Log2Floor(0xffffffffU));
-}
-
-TEST(BitsTest, Log2Ceiling) {
- EXPECT_EQ(-1, Log2Ceiling(0));
- EXPECT_EQ(0, Log2Ceiling(1));
- EXPECT_EQ(1, Log2Ceiling(2));
- EXPECT_EQ(2, Log2Ceiling(3));
- EXPECT_EQ(2, Log2Ceiling(4));
- for (int i = 3; i < 31; ++i) {
- unsigned int value = 1U << i;
- EXPECT_EQ(i, Log2Ceiling(value));
- EXPECT_EQ(i + 1, Log2Ceiling(value + 1));
- EXPECT_EQ(i + 1, Log2Ceiling(value + 2));
- EXPECT_EQ(i, Log2Ceiling(value - 1));
- EXPECT_EQ(i, Log2Ceiling(value - 2));
- }
- EXPECT_EQ(32, Log2Ceiling(0xffffffffU));
-}
-
-TEST(BitsTest, Align) {
- const size_t kSizeTMax = std::numeric_limits<size_t>::max();
- EXPECT_EQ(0ul, Align(0, 4));
- EXPECT_EQ(4ul, Align(1, 4));
- EXPECT_EQ(4096ul, Align(1, 4096));
- EXPECT_EQ(4096ul, Align(4096, 4096));
- EXPECT_EQ(4096ul, Align(4095, 4096));
- EXPECT_EQ(8192ul, Align(4097, 4096));
- EXPECT_EQ(kSizeTMax - 31, Align(kSizeTMax - 62, 32));
- EXPECT_EQ(kSizeTMax / 2 + 1, Align(1, kSizeTMax / 2 + 1));
-}
-
-TEST(BitsTest, CountLeadingZeroBits8) {
- EXPECT_EQ(8u, CountLeadingZeroBits(uint8_t{0}));
- EXPECT_EQ(7u, CountLeadingZeroBits(uint8_t{1}));
- for (uint8_t shift = 0; shift <= 7; shift++) {
- EXPECT_EQ(7u - shift,
- CountLeadingZeroBits(static_cast<uint8_t>(1 << shift)));
- }
- EXPECT_EQ(4u, CountLeadingZeroBits(uint8_t{0x0f}));
-}
-
-TEST(BitsTest, CountLeadingZeroBits16) {
- EXPECT_EQ(16u, CountLeadingZeroBits(uint16_t{0}));
- EXPECT_EQ(15u, CountLeadingZeroBits(uint16_t{1}));
- for (uint16_t shift = 0; shift <= 15; shift++) {
- EXPECT_EQ(15u - shift,
- CountLeadingZeroBits(static_cast<uint16_t>(1 << shift)));
- }
- EXPECT_EQ(4u, CountLeadingZeroBits(uint16_t{0x0f0f}));
-}
-
-TEST(BitsTest, CountLeadingZeroBits32) {
- EXPECT_EQ(32u, CountLeadingZeroBits(uint32_t{0}));
- EXPECT_EQ(31u, CountLeadingZeroBits(uint32_t{1}));
- for (uint32_t shift = 0; shift <= 31; shift++) {
- EXPECT_EQ(31u - shift, CountLeadingZeroBits(uint32_t{1} << shift));
- }
- EXPECT_EQ(4u, CountLeadingZeroBits(uint32_t{0x0f0f0f0f}));
-}
-
-TEST(BitsTest, CountTrailingeZeroBits8) {
- EXPECT_EQ(8u, CountTrailingZeroBits(uint8_t{0}));
- EXPECT_EQ(7u, CountTrailingZeroBits(uint8_t{128}));
- for (uint8_t shift = 0; shift <= 7; shift++) {
- EXPECT_EQ(shift, CountTrailingZeroBits(static_cast<uint8_t>(1 << shift)));
- }
- EXPECT_EQ(4u, CountTrailingZeroBits(uint8_t{0xf0}));
-}
-
-TEST(BitsTest, CountTrailingeZeroBits16) {
- EXPECT_EQ(16u, CountTrailingZeroBits(uint16_t{0}));
- EXPECT_EQ(15u, CountTrailingZeroBits(uint16_t{32768}));
- for (uint16_t shift = 0; shift <= 15; shift++) {
- EXPECT_EQ(shift, CountTrailingZeroBits(static_cast<uint16_t>(1 << shift)));
- }
- EXPECT_EQ(4u, CountTrailingZeroBits(uint16_t{0xf0f0}));
-}
-
-TEST(BitsTest, CountTrailingeZeroBits32) {
- EXPECT_EQ(32u, CountTrailingZeroBits(uint32_t{0}));
- EXPECT_EQ(31u, CountTrailingZeroBits(uint32_t{1} << 31));
- for (uint32_t shift = 0; shift <= 31; shift++) {
- EXPECT_EQ(shift, CountTrailingZeroBits(uint32_t{1} << shift));
- }
- EXPECT_EQ(4u, CountTrailingZeroBits(uint32_t{0xf0f0f0f0}));
-}
-
-#if defined(ARCH_CPU_64_BITS)
-
-TEST(BitsTest, CountLeadingZeroBits64) {
- EXPECT_EQ(64u, CountLeadingZeroBits(uint64_t{0}));
- EXPECT_EQ(63u, CountLeadingZeroBits(uint64_t{1}));
- for (uint64_t shift = 0; shift <= 63; shift++) {
- EXPECT_EQ(63u - shift, CountLeadingZeroBits(uint64_t{1} << shift));
- }
- EXPECT_EQ(4u, CountLeadingZeroBits(uint64_t{0x0f0f0f0f0f0f0f0f}));
-}
-
-TEST(BitsTest, CountTrailingeZeroBits64) {
- EXPECT_EQ(64u, CountTrailingZeroBits(uint64_t{0}));
- EXPECT_EQ(63u, CountTrailingZeroBits(uint64_t{1} << 63));
- for (uint64_t shift = 0; shift <= 31; shift++) {
- EXPECT_EQ(shift, CountTrailingZeroBits(uint64_t{1} << shift));
- }
- EXPECT_EQ(4u, CountTrailingZeroBits(uint64_t{0xf0f0f0f0f0f0f0f0}));
-}
-
-#endif // ARCH_CPU_64_BITS
-
-TEST(BitsTest, CountLeadingZeroBitsSizeT) {
-#if defined(ARCH_CPU_64_BITS)
- EXPECT_EQ(64u, CountLeadingZeroBitsSizeT(size_t{0}));
- EXPECT_EQ(63u, CountLeadingZeroBitsSizeT(size_t{1}));
- EXPECT_EQ(32u, CountLeadingZeroBitsSizeT(size_t{1} << 31));
- EXPECT_EQ(1u, CountLeadingZeroBitsSizeT(size_t{1} << 62));
- EXPECT_EQ(0u, CountLeadingZeroBitsSizeT(size_t{1} << 63));
-#else
- EXPECT_EQ(32u, CountLeadingZeroBitsSizeT(size_t{0}));
- EXPECT_EQ(31u, CountLeadingZeroBitsSizeT(size_t{1}));
- EXPECT_EQ(1u, CountLeadingZeroBitsSizeT(size_t{1} << 30));
- EXPECT_EQ(0u, CountLeadingZeroBitsSizeT(size_t{1} << 31));
-#endif // ARCH_CPU_64_BITS
-}
-
-TEST(BitsTest, CountTrailingZeroBitsSizeT) {
-#if defined(ARCH_CPU_64_BITS)
- EXPECT_EQ(64u, CountTrailingZeroBitsSizeT(size_t{0}));
- EXPECT_EQ(63u, CountTrailingZeroBitsSizeT(size_t{1} << 63));
- EXPECT_EQ(31u, CountTrailingZeroBitsSizeT(size_t{1} << 31));
- EXPECT_EQ(1u, CountTrailingZeroBitsSizeT(size_t{2}));
- EXPECT_EQ(0u, CountTrailingZeroBitsSizeT(size_t{1}));
-#else
- EXPECT_EQ(32u, CountTrailingZeroBitsSizeT(size_t{0}));
- EXPECT_EQ(31u, CountTrailingZeroBitsSizeT(size_t{1} << 31));
- EXPECT_EQ(1u, CountTrailingZeroBitsSizeT(size_t{2}));
- EXPECT_EQ(0u, CountTrailingZeroBitsSizeT(size_t{1}));
-#endif // ARCH_CPU_64_BITS
-}
-
-TEST(BitsTest, PowerOfTwo) {
- EXPECT_FALSE(IsPowerOfTwo(-1));
- EXPECT_FALSE(IsPowerOfTwo(0));
- EXPECT_TRUE(IsPowerOfTwo(1));
- EXPECT_TRUE(IsPowerOfTwo(2));
- // Unsigned 64 bit cases.
- for (uint32_t i = 2; i < 64; i++) {
- const uint64_t val = uint64_t{1} << i;
- EXPECT_FALSE(IsPowerOfTwo(val - 1));
- EXPECT_TRUE(IsPowerOfTwo(val));
- EXPECT_FALSE(IsPowerOfTwo(val + 1));
- }
- // Signed 64 bit cases.
- for (uint32_t i = 2; i < 63; i++) {
- const int64_t val = int64_t{1} << i;
- EXPECT_FALSE(IsPowerOfTwo(val - 1));
- EXPECT_TRUE(IsPowerOfTwo(val));
- EXPECT_FALSE(IsPowerOfTwo(val + 1));
- }
- // Signed integers with only the last bit set are negative, not powers of two.
- EXPECT_FALSE(IsPowerOfTwo(int64_t{1} << 63));
-}
-
-} // namespace bits
-} // namespace base
diff --git a/base/callback_helpers_unittest.cc b/base/callback_helpers_unittest.cc
deleted file mode 100644
index 1c1102d..0000000
--- a/base/callback_helpers_unittest.cc
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 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 "base/callback_helpers.h"
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-void Increment(int* value) {
- (*value)++;
-}
-
-TEST(CallbackHelpersTest, TestResetAndReturn) {
- int run_count = 0;
-
- base::Closure cb = base::Bind(&Increment, &run_count);
- EXPECT_EQ(0, run_count);
- base::ResetAndReturn(&cb).Run();
- EXPECT_EQ(1, run_count);
- EXPECT_FALSE(cb);
-
- run_count = 0;
-
- base::OnceClosure cb2 = base::BindOnce(&Increment, &run_count);
- EXPECT_EQ(0, run_count);
- base::ResetAndReturn(&cb2).Run();
- EXPECT_EQ(1, run_count);
- EXPECT_FALSE(cb2);
-}
-
-TEST(CallbackHelpersTest, TestScopedClosureRunnerExitScope) {
- int run_count = 0;
- {
- base::ScopedClosureRunner runner(base::Bind(&Increment, &run_count));
- EXPECT_EQ(0, run_count);
- }
- EXPECT_EQ(1, run_count);
-}
-
-TEST(CallbackHelpersTest, TestScopedClosureRunnerRelease) {
- int run_count = 0;
- base::OnceClosure c;
- {
- base::ScopedClosureRunner runner(base::Bind(&Increment, &run_count));
- c = runner.Release();
- EXPECT_EQ(0, run_count);
- }
- EXPECT_EQ(0, run_count);
- std::move(c).Run();
- EXPECT_EQ(1, run_count);
-}
-
-TEST(CallbackHelpersTest, TestScopedClosureRunnerReplaceClosure) {
- int run_count_1 = 0;
- int run_count_2 = 0;
- {
- base::ScopedClosureRunner runner;
- runner.ReplaceClosure(base::Bind(&Increment, &run_count_1));
- runner.ReplaceClosure(base::Bind(&Increment, &run_count_2));
- EXPECT_EQ(0, run_count_1);
- EXPECT_EQ(0, run_count_2);
- }
- EXPECT_EQ(0, run_count_1);
- EXPECT_EQ(1, run_count_2);
-}
-
-TEST(CallbackHelpersTest, TestScopedClosureRunnerRunAndReset) {
- int run_count_3 = 0;
- {
- base::ScopedClosureRunner runner(base::Bind(&Increment, &run_count_3));
- EXPECT_EQ(0, run_count_3);
- runner.RunAndReset();
- EXPECT_EQ(1, run_count_3);
- }
- EXPECT_EQ(1, run_count_3);
-}
-
-TEST(CallbackHelpersTest, TestScopedClosureRunnerMoveConstructor) {
- int run_count = 0;
- {
- std::unique_ptr<base::ScopedClosureRunner> runner(
- new base::ScopedClosureRunner(base::Bind(&Increment, &run_count)));
- base::ScopedClosureRunner runner2(std::move(*runner));
- runner.reset();
- EXPECT_EQ(0, run_count);
- }
- EXPECT_EQ(1, run_count);
-}
-
-TEST(CallbackHelpersTest, TestScopedClosureRunnerMoveAssignment) {
- int run_count_1 = 0;
- int run_count_2 = 0;
- {
- base::ScopedClosureRunner runner(base::Bind(&Increment, &run_count_1));
- {
- base::ScopedClosureRunner runner2(base::Bind(&Increment, &run_count_2));
- runner = std::move(runner2);
- EXPECT_EQ(0, run_count_1);
- EXPECT_EQ(0, run_count_2);
- }
- EXPECT_EQ(0, run_count_1);
- EXPECT_EQ(0, run_count_2);
- }
- EXPECT_EQ(0, run_count_1);
- EXPECT_EQ(1, run_count_2);
-}
-
-TEST(CallbackHelpersTest, TestAdaptCallbackForRepeating) {
- int count = 0;
- base::OnceCallback<void(int*)> cb =
- base::BindOnce([](int* count) { ++*count; });
-
- base::RepeatingCallback<void(int*)> wrapped =
- base::AdaptCallbackForRepeating(std::move(cb));
-
- EXPECT_EQ(0, count);
- wrapped.Run(&count);
- EXPECT_EQ(1, count);
- wrapped.Run(&count);
- EXPECT_EQ(1, count);
-}
-
-} // namespace
diff --git a/base/callback_list_unittest.cc b/base/callback_list_unittest.cc
deleted file mode 100644
index 6eb5ff7..0000000
--- a/base/callback_list_unittest.cc
+++ /dev/null
@@ -1,339 +0,0 @@
-// Copyright 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 "base/callback_list.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/macros.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class Listener {
- public:
- Listener() : total_(0), scaler_(1) {}
- explicit Listener(int scaler) : total_(0), scaler_(scaler) {}
- void IncrementTotal() { total_++; }
- void IncrementByMultipleOfScaler(int x) { total_ += x * scaler_; }
-
- int total() const { return total_; }
-
- private:
- int total_;
- int scaler_;
- DISALLOW_COPY_AND_ASSIGN(Listener);
-};
-
-class Remover {
- public:
- Remover() : total_(0) {}
- void IncrementTotalAndRemove() {
- total_++;
- removal_subscription_.reset();
- }
- void SetSubscriptionToRemove(
- std::unique_ptr<CallbackList<void(void)>::Subscription> sub) {
- removal_subscription_ = std::move(sub);
- }
-
- int total() const { return total_; }
-
- private:
- int total_;
- std::unique_ptr<CallbackList<void(void)>::Subscription> removal_subscription_;
- DISALLOW_COPY_AND_ASSIGN(Remover);
-};
-
-class Adder {
- public:
- explicit Adder(CallbackList<void(void)>* cb_reg)
- : added_(false),
- total_(0),
- cb_reg_(cb_reg) {
- }
- void AddCallback() {
- if (!added_) {
- added_ = true;
- subscription_ =
- cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this)));
- }
- }
- void IncrementTotal() { total_++; }
-
- bool added() const { return added_; }
-
- int total() const { return total_; }
-
- private:
- bool added_;
- int total_;
- CallbackList<void(void)>* cb_reg_;
- std::unique_ptr<CallbackList<void(void)>::Subscription> subscription_;
- DISALLOW_COPY_AND_ASSIGN(Adder);
-};
-
-class Summer {
- public:
- Summer() : value_(0) {}
-
- void AddOneParam(int a) { value_ = a; }
- void AddTwoParam(int a, int b) { value_ = a + b; }
- void AddThreeParam(int a, int b, int c) { value_ = a + b + c; }
- void AddFourParam(int a, int b, int c, int d) { value_ = a + b + c + d; }
- void AddFiveParam(int a, int b, int c, int d, int e) {
- value_ = a + b + c + d + e;
- }
- void AddSixParam(int a, int b, int c, int d, int e , int f) {
- value_ = a + b + c + d + e + f;
- }
-
- int value() const { return value_; }
-
- private:
- int value_;
- DISALLOW_COPY_AND_ASSIGN(Summer);
-};
-
-class Counter {
- public:
- Counter() : value_(0) {}
-
- void Increment() { value_++; }
-
- int value() const { return value_; }
-
- private:
- int value_;
- DISALLOW_COPY_AND_ASSIGN(Counter);
-};
-
-// Sanity check that we can instantiate a CallbackList for each arity.
-TEST(CallbackListTest, ArityTest) {
- Summer s;
-
- CallbackList<void(int)> c1;
- std::unique_ptr<CallbackList<void(int)>::Subscription> subscription1 =
- c1.Add(Bind(&Summer::AddOneParam, Unretained(&s)));
-
- c1.Notify(1);
- EXPECT_EQ(1, s.value());
-
- CallbackList<void(int, int)> c2;
- std::unique_ptr<CallbackList<void(int, int)>::Subscription> subscription2 =
- c2.Add(Bind(&Summer::AddTwoParam, Unretained(&s)));
-
- c2.Notify(1, 2);
- EXPECT_EQ(3, s.value());
-
- CallbackList<void(int, int, int)> c3;
- std::unique_ptr<CallbackList<void(int, int, int)>::Subscription>
- subscription3 = c3.Add(Bind(&Summer::AddThreeParam, Unretained(&s)));
-
- c3.Notify(1, 2, 3);
- EXPECT_EQ(6, s.value());
-
- CallbackList<void(int, int, int, int)> c4;
- std::unique_ptr<CallbackList<void(int, int, int, int)>::Subscription>
- subscription4 = c4.Add(Bind(&Summer::AddFourParam, Unretained(&s)));
-
- c4.Notify(1, 2, 3, 4);
- EXPECT_EQ(10, s.value());
-
- CallbackList<void(int, int, int, int, int)> c5;
- std::unique_ptr<CallbackList<void(int, int, int, int, int)>::Subscription>
- subscription5 = c5.Add(Bind(&Summer::AddFiveParam, Unretained(&s)));
-
- c5.Notify(1, 2, 3, 4, 5);
- EXPECT_EQ(15, s.value());
-
- CallbackList<void(int, int, int, int, int, int)> c6;
- std::unique_ptr<
- CallbackList<void(int, int, int, int, int, int)>::Subscription>
- subscription6 = c6.Add(Bind(&Summer::AddSixParam, Unretained(&s)));
-
- c6.Notify(1, 2, 3, 4, 5, 6);
- EXPECT_EQ(21, s.value());
-}
-
-// Sanity check that closures added to the list will be run, and those removed
-// from the list will not be run.
-TEST(CallbackListTest, BasicTest) {
- CallbackList<void(void)> cb_reg;
- Listener a, b, c;
-
- std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
- cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
- std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
- cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
-
- EXPECT_TRUE(a_subscription.get());
- EXPECT_TRUE(b_subscription.get());
-
- cb_reg.Notify();
-
- EXPECT_EQ(1, a.total());
- EXPECT_EQ(1, b.total());
-
- b_subscription.reset();
-
- std::unique_ptr<CallbackList<void(void)>::Subscription> c_subscription =
- cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c)));
-
- cb_reg.Notify();
-
- EXPECT_EQ(2, a.total());
- EXPECT_EQ(1, b.total());
- EXPECT_EQ(1, c.total());
-
- a_subscription.reset();
- b_subscription.reset();
- c_subscription.reset();
-}
-
-// Sanity check that callbacks with details added to the list will be run, with
-// the correct details, and those removed from the list will not be run.
-TEST(CallbackListTest, BasicTestWithParams) {
- CallbackList<void(int)> cb_reg;
- Listener a(1), b(-1), c(1);
-
- std::unique_ptr<CallbackList<void(int)>::Subscription> a_subscription =
- cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a)));
- std::unique_ptr<CallbackList<void(int)>::Subscription> b_subscription =
- cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b)));
-
- EXPECT_TRUE(a_subscription.get());
- EXPECT_TRUE(b_subscription.get());
-
- cb_reg.Notify(10);
-
- EXPECT_EQ(10, a.total());
- EXPECT_EQ(-10, b.total());
-
- b_subscription.reset();
-
- std::unique_ptr<CallbackList<void(int)>::Subscription> c_subscription =
- cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c)));
-
- cb_reg.Notify(10);
-
- EXPECT_EQ(20, a.total());
- EXPECT_EQ(-10, b.total());
- EXPECT_EQ(10, c.total());
-
- a_subscription.reset();
- b_subscription.reset();
- c_subscription.reset();
-}
-
-// Test the a callback can remove itself or a different callback from the list
-// during iteration without invalidating the iterator.
-TEST(CallbackListTest, RemoveCallbacksDuringIteration) {
- CallbackList<void(void)> cb_reg;
- Listener a, b;
- Remover remover_1, remover_2;
-
- std::unique_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
- cb_reg.Add(
- Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_1)));
- std::unique_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
- cb_reg.Add(
- Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_2)));
- std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
- cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
- std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
- cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
-
- // |remover_1| will remove itself.
- remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
- // |remover_2| will remove a.
- remover_2.SetSubscriptionToRemove(std::move(a_subscription));
-
- cb_reg.Notify();
-
- // |remover_1| runs once (and removes itself), |remover_2| runs once (and
- // removes a), |a| never runs, and |b| runs once.
- EXPECT_EQ(1, remover_1.total());
- EXPECT_EQ(1, remover_2.total());
- EXPECT_EQ(0, a.total());
- EXPECT_EQ(1, b.total());
-
- cb_reg.Notify();
-
- // Only |remover_2| and |b| run this time.
- EXPECT_EQ(1, remover_1.total());
- EXPECT_EQ(2, remover_2.total());
- EXPECT_EQ(0, a.total());
- EXPECT_EQ(2, b.total());
-}
-
-// Test that a callback can add another callback to the list durning iteration
-// without invalidating the iterator. The newly added callback should be run on
-// the current iteration as will all other callbacks in the list.
-TEST(CallbackListTest, AddCallbacksDuringIteration) {
- CallbackList<void(void)> cb_reg;
- Adder a(&cb_reg);
- Listener b;
- std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
- cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a)));
- std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
- cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
-
- cb_reg.Notify();
-
- EXPECT_EQ(1, a.total());
- EXPECT_EQ(1, b.total());
- EXPECT_TRUE(a.added());
-
- cb_reg.Notify();
-
- EXPECT_EQ(2, a.total());
- EXPECT_EQ(2, b.total());
-}
-
-// Sanity check: notifying an empty list is a no-op.
-TEST(CallbackListTest, EmptyList) {
- CallbackList<void(void)> cb_reg;
-
- cb_reg.Notify();
-}
-
-TEST(CallbackList, RemovalCallback) {
- Counter remove_count;
- CallbackList<void(void)> cb_reg;
- cb_reg.set_removal_callback(
- Bind(&Counter::Increment, Unretained(&remove_count)));
-
- std::unique_ptr<CallbackList<void(void)>::Subscription> subscription =
- cb_reg.Add(DoNothing());
-
- // Removing a subscription outside of iteration signals the callback.
- EXPECT_EQ(0, remove_count.value());
- subscription.reset();
- EXPECT_EQ(1, remove_count.value());
-
- // Configure two subscriptions to remove themselves.
- Remover remover_1, remover_2;
- std::unique_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
- cb_reg.Add(
- Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_1)));
- std::unique_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
- cb_reg.Add(
- Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_2)));
- remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
- remover_2.SetSubscriptionToRemove(std::move(remover_2_sub));
-
- // The callback should be signaled exactly once.
- EXPECT_EQ(1, remove_count.value());
- cb_reg.Notify();
- EXPECT_EQ(2, remove_count.value());
- EXPECT_TRUE(cb_reg.empty());
-}
-
-} // namespace
-} // namespace base
diff --git a/base/callback_list_unittest.nc b/base/callback_list_unittest.nc
deleted file mode 100644
index 7347f76..0000000
--- a/base/callback_list_unittest.nc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 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.
-
-// This is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/callback_list.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/macros.h"
-
-namespace base {
-
-class Foo {
- public:
- Foo() {}
- ~Foo() {}
-};
-
-class FooListener {
- public:
- FooListener() {}
-
- void GotAScopedFoo(std::unique_ptr<Foo> f) { foo_ = std::move(f); }
-
- std::unique_ptr<Foo> foo_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(FooListener);
-};
-
-
-#if defined(NCTEST_MOVE_ONLY_TYPE_PARAMETER) // [r"fatal error: call to (implicitly-)?deleted( copy)? constructor"]
-
-// Callbacks run with a move-only typed parameter.
-//
-// CallbackList does not support move-only typed parameters. Notify() is
-// designed to take zero or more parameters, and run each registered callback
-// with them. With move-only types, the parameter will be set to NULL after the
-// first callback has been run.
-void WontCompile() {
- FooListener f;
- CallbackList<void(std::unique_ptr<Foo>)> c1;
- std::unique_ptr<CallbackList<void(std::unique_ptr<Foo>)>::Subscription> sub =
- c1.Add(Bind(&FooListener::GotAScopedFoo, Unretained(&f)));
- c1.Notify(std::unique_ptr<Foo>(new Foo()));
-}
-
-#endif
-
-} // namespace base
diff --git a/base/callback_unittest.cc b/base/callback_unittest.cc
deleted file mode 100644
index c07d3ee..0000000
--- a/base/callback_unittest.cc
+++ /dev/null
@@ -1,187 +0,0 @@
-// 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.
-
-#include "base/callback.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/callback_helpers.h"
-#include "base/callback_internal.h"
-#include "base/memory/ref_counted.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-void NopInvokeFunc() {}
-
-// White-box testpoints to inject into a Callback<> object for checking
-// comparators and emptiness APIs. Use a BindState that is specialized
-// based on a type we declared in the anonymous namespace above to remove any
-// chance of colliding with another instantiation and breaking the
-// one-definition-rule.
-struct FakeBindState : internal::BindStateBase {
- FakeBindState() : BindStateBase(&NopInvokeFunc, &Destroy, &IsCancelled) {}
-
- private:
- ~FakeBindState() = default;
- static void Destroy(const internal::BindStateBase* self) {
- delete static_cast<const FakeBindState*>(self);
- }
- static bool IsCancelled(const internal::BindStateBase*) {
- return false;
- }
-};
-
-namespace {
-
-class CallbackTest : public ::testing::Test {
- public:
- CallbackTest()
- : callback_a_(new FakeBindState()), callback_b_(new FakeBindState()) {}
-
- ~CallbackTest() override = default;
-
- protected:
- Callback<void()> callback_a_;
- const Callback<void()> callback_b_; // Ensure APIs work with const.
- Callback<void()> null_callback_;
-};
-
-// Ensure we can create unbound callbacks. We need this to be able to store
-// them in class members that can be initialized later.
-TEST_F(CallbackTest, DefaultConstruction) {
- Callback<void()> c0;
- Callback<void(int)> c1;
- Callback<void(int,int)> c2;
- Callback<void(int,int,int)> c3;
- Callback<void(int,int,int,int)> c4;
- Callback<void(int,int,int,int,int)> c5;
- Callback<void(int,int,int,int,int,int)> c6;
-
- EXPECT_TRUE(c0.is_null());
- EXPECT_TRUE(c1.is_null());
- EXPECT_TRUE(c2.is_null());
- EXPECT_TRUE(c3.is_null());
- EXPECT_TRUE(c4.is_null());
- EXPECT_TRUE(c5.is_null());
- EXPECT_TRUE(c6.is_null());
-}
-
-TEST_F(CallbackTest, IsNull) {
- EXPECT_TRUE(null_callback_.is_null());
- EXPECT_FALSE(callback_a_.is_null());
- EXPECT_FALSE(callback_b_.is_null());
-}
-
-TEST_F(CallbackTest, Equals) {
- EXPECT_TRUE(callback_a_.Equals(callback_a_));
- EXPECT_FALSE(callback_a_.Equals(callback_b_));
- EXPECT_FALSE(callback_b_.Equals(callback_a_));
-
- // We should compare based on instance, not type.
- Callback<void()> callback_c(new FakeBindState());
- Callback<void()> callback_a2 = callback_a_;
- EXPECT_TRUE(callback_a_.Equals(callback_a2));
- EXPECT_FALSE(callback_a_.Equals(callback_c));
-
- // Empty, however, is always equal to empty.
- Callback<void()> empty2;
- EXPECT_TRUE(null_callback_.Equals(empty2));
-}
-
-TEST_F(CallbackTest, Reset) {
- // Resetting should bring us back to empty.
- ASSERT_FALSE(callback_a_.is_null());
- ASSERT_FALSE(callback_a_.Equals(null_callback_));
-
- callback_a_.Reset();
-
- EXPECT_TRUE(callback_a_.is_null());
- EXPECT_TRUE(callback_a_.Equals(null_callback_));
-}
-
-TEST_F(CallbackTest, Move) {
- // Moving should reset the callback.
- ASSERT_FALSE(callback_a_.is_null());
- ASSERT_FALSE(callback_a_.Equals(null_callback_));
-
- auto tmp = std::move(callback_a_);
-
- EXPECT_TRUE(callback_a_.is_null());
- EXPECT_TRUE(callback_a_.Equals(null_callback_));
-}
-
-struct TestForReentrancy {
- TestForReentrancy()
- : cb_already_run(false),
- cb(Bind(&TestForReentrancy::AssertCBIsNull, Unretained(this))) {
- }
- void AssertCBIsNull() {
- ASSERT_TRUE(cb.is_null());
- cb_already_run = true;
- }
- bool cb_already_run;
- Closure cb;
-};
-
-TEST_F(CallbackTest, ResetAndReturn) {
- TestForReentrancy tfr;
- ASSERT_FALSE(tfr.cb.is_null());
- ASSERT_FALSE(tfr.cb_already_run);
- ResetAndReturn(&tfr.cb).Run();
- ASSERT_TRUE(tfr.cb.is_null());
- ASSERT_TRUE(tfr.cb_already_run);
-}
-
-TEST_F(CallbackTest, NullAfterMoveRun) {
- Closure cb = Bind([] {});
- ASSERT_TRUE(cb);
- std::move(cb).Run();
- ASSERT_FALSE(cb);
-
- const Closure cb2 = Bind([] {});
- ASSERT_TRUE(cb2);
- std::move(cb2).Run();
- ASSERT_TRUE(cb2);
-
- OnceClosure cb3 = BindOnce([] {});
- ASSERT_TRUE(cb3);
- std::move(cb3).Run();
- ASSERT_FALSE(cb3);
-}
-
-class CallbackOwner : public base::RefCounted<CallbackOwner> {
- public:
- explicit CallbackOwner(bool* deleted) {
- callback_ = Bind(&CallbackOwner::Unused, this);
- deleted_ = deleted;
- }
- void Reset() {
- callback_.Reset();
- // We are deleted here if no-one else had a ref to us.
- }
-
- private:
- friend class base::RefCounted<CallbackOwner>;
- virtual ~CallbackOwner() {
- *deleted_ = true;
- }
- void Unused() {
- FAIL() << "Should never be called";
- }
-
- Closure callback_;
- bool* deleted_;
-};
-
-TEST_F(CallbackTest, CallbackHasLastRefOnContainingObject) {
- bool deleted = false;
- CallbackOwner* owner = new CallbackOwner(&deleted);
- owner->Reset();
- ASSERT_TRUE(deleted);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/callback_unittest.nc b/base/callback_unittest.nc
deleted file mode 100644
index 3261529..0000000
--- a/base/callback_unittest.nc
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2011 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/callback.h"
-
-namespace base {
-
-class Parent {
-};
-
-class Child : Parent {
-};
-
-#if defined(NCTEST_EQUALS_REQUIRES_SAMETYPE) // [r"fatal error: no viable conversion from 'RepeatingCallback<int \(\)>' to 'const RepeatingCallback<void \(\)>'"]
-
-// Attempting to call comparison function on two callbacks of different type.
-//
-// This should be a compile time failure because each callback type should be
-// considered distinct.
-void WontCompile() {
- Closure c1;
- Callback<int()> c2;
- c1.Equals(c2);
-}
-
-#elif defined(NCTEST_CONSTRUCTION_FROM_SUBTYPE) // [r"fatal error: no viable conversion from 'Callback<base::Parent \(\)>' to 'Callback<base::Child \(\)>'"]
-
-// Construction of Callback<A> from Callback<B> if A is supertype of B.
-//
-// While this is technically safe, most people aren't used to it when coding
-// C++ so if this is happening, it is almost certainly an error.
-void WontCompile() {
- Callback<Parent()> cb_a;
- Callback<Child()> cb_b = cb_a;
-}
-
-#elif defined(NCTEST_ASSIGNMENT_FROM_SUBTYPE) // [r"fatal error: no viable overloaded '='"]
-
-// Assignment of Callback<A> from Callback<B> if A is supertype of B.
-// See explanation for NCTEST_CONSTRUCTION_FROM_SUBTYPE
-void WontCompile() {
- Callback<Parent()> cb_a;
- Callback<Child()> cb_b;
- cb_a = cb_b;
-}
-
-#endif
-
-} // namespace base
diff --git a/base/cancelable_callback_unittest.cc b/base/cancelable_callback_unittest.cc
deleted file mode 100644
index 373498c..0000000
--- a/base/cancelable_callback_unittest.cc
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright (c) 2011 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 "base/cancelable_callback.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class TestRefCounted : public RefCountedThreadSafe<TestRefCounted> {
- private:
- friend class RefCountedThreadSafe<TestRefCounted>;
- ~TestRefCounted() = default;
- ;
-};
-
-void Increment(int* count) { (*count)++; }
-void IncrementBy(int* count, int n) { (*count) += n; }
-void RefCountedParam(const scoped_refptr<TestRefCounted>& ref_counted) {}
-
-void OnMoveOnlyReceived(int* value, std::unique_ptr<int> result) {
- *value = *result;
-}
-
-// Cancel().
-// - Callback can be run multiple times.
-// - After Cancel(), Run() completes but has no effect.
-TEST(CancelableCallbackTest, Cancel) {
- int count = 0;
- CancelableClosure cancelable(
- base::Bind(&Increment, base::Unretained(&count)));
-
- base::Closure callback = cancelable.callback();
- callback.Run();
- EXPECT_EQ(1, count);
-
- callback.Run();
- EXPECT_EQ(2, count);
-
- cancelable.Cancel();
- callback.Run();
- EXPECT_EQ(2, count);
-}
-
-// Cancel() called multiple times.
-// - Cancel() cancels all copies of the wrapped callback.
-// - Calling Cancel() more than once has no effect.
-// - After Cancel(), callback() returns a null callback.
-TEST(CancelableCallbackTest, MultipleCancel) {
- int count = 0;
- CancelableClosure cancelable(
- base::Bind(&Increment, base::Unretained(&count)));
-
- base::Closure callback1 = cancelable.callback();
- base::Closure callback2 = cancelable.callback();
- cancelable.Cancel();
-
- callback1.Run();
- EXPECT_EQ(0, count);
-
- callback2.Run();
- EXPECT_EQ(0, count);
-
- // Calling Cancel() again has no effect.
- cancelable.Cancel();
-
- // callback() of a cancelled callback is null.
- base::Closure callback3 = cancelable.callback();
- EXPECT_TRUE(callback3.is_null());
-}
-
-// CancelableCallback destroyed before callback is run.
-// - Destruction of CancelableCallback cancels outstanding callbacks.
-TEST(CancelableCallbackTest, CallbackCanceledOnDestruction) {
- int count = 0;
- base::Closure callback;
-
- {
- CancelableClosure cancelable(
- base::Bind(&Increment, base::Unretained(&count)));
-
- callback = cancelable.callback();
- callback.Run();
- EXPECT_EQ(1, count);
- }
-
- callback.Run();
- EXPECT_EQ(1, count);
-}
-
-// Cancel() called on bound closure with a RefCounted parameter.
-// - Cancel drops wrapped callback (and, implicitly, its bound arguments).
-TEST(CancelableCallbackTest, CancelDropsCallback) {
- scoped_refptr<TestRefCounted> ref_counted = new TestRefCounted;
- EXPECT_TRUE(ref_counted->HasOneRef());
-
- CancelableClosure cancelable(base::Bind(RefCountedParam, ref_counted));
- EXPECT_FALSE(cancelable.IsCancelled());
- EXPECT_TRUE(ref_counted.get());
- EXPECT_FALSE(ref_counted->HasOneRef());
-
- // There is only one reference to |ref_counted| after the Cancel().
- cancelable.Cancel();
- EXPECT_TRUE(cancelable.IsCancelled());
- EXPECT_TRUE(ref_counted.get());
- EXPECT_TRUE(ref_counted->HasOneRef());
-}
-
-// Reset().
-// - Reset() replaces the existing wrapped callback with a new callback.
-// - Reset() deactivates outstanding callbacks.
-TEST(CancelableCallbackTest, Reset) {
- int count = 0;
- CancelableClosure cancelable(
- base::Bind(&Increment, base::Unretained(&count)));
-
- base::Closure callback = cancelable.callback();
- callback.Run();
- EXPECT_EQ(1, count);
-
- callback.Run();
- EXPECT_EQ(2, count);
-
- cancelable.Reset(
- base::Bind(&IncrementBy, base::Unretained(&count), 3));
- EXPECT_FALSE(cancelable.IsCancelled());
-
- // The stale copy of the cancelable callback is non-null.
- ASSERT_FALSE(callback.is_null());
-
- // The stale copy of the cancelable callback is no longer active.
- callback.Run();
- EXPECT_EQ(2, count);
-
- base::Closure callback2 = cancelable.callback();
- ASSERT_FALSE(callback2.is_null());
-
- callback2.Run();
- EXPECT_EQ(5, count);
-}
-
-// IsCanceled().
-// - Cancel() transforms the CancelableCallback into a cancelled state.
-TEST(CancelableCallbackTest, IsNull) {
- CancelableClosure cancelable;
- EXPECT_TRUE(cancelable.IsCancelled());
-
- int count = 0;
- cancelable.Reset(base::Bind(&Increment,
- base::Unretained(&count)));
- EXPECT_FALSE(cancelable.IsCancelled());
-
- cancelable.Cancel();
- EXPECT_TRUE(cancelable.IsCancelled());
-}
-
-// CancelableCallback posted to a MessageLoop with PostTask.
-// - Callbacks posted to a MessageLoop can be cancelled.
-TEST(CancelableCallbackTest, PostTask) {
- MessageLoop loop;
-
- int count = 0;
- CancelableClosure cancelable(base::Bind(&Increment,
- base::Unretained(&count)));
-
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, cancelable.callback());
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(1, count);
-
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, cancelable.callback());
-
- // Cancel before running the message loop.
- cancelable.Cancel();
- RunLoop().RunUntilIdle();
-
- // Callback never ran due to cancellation; count is the same.
- EXPECT_EQ(1, count);
-}
-
-// CancelableCallback can be used with move-only types.
-TEST(CancelableCallbackTest, MoveOnlyType) {
- const int kExpectedResult = 42;
-
- int result = 0;
- CancelableCallback<void(std::unique_ptr<int>)> cb(
- base::Bind(&OnMoveOnlyReceived, base::Unretained(&result)));
- cb.callback().Run(base::WrapUnique(new int(kExpectedResult)));
-
- EXPECT_EQ(kExpectedResult, result);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/command_line_unittest.cc b/base/command_line_unittest.cc
deleted file mode 100644
index 2396830..0000000
--- a/base/command_line_unittest.cc
+++ /dev/null
@@ -1,440 +0,0 @@
-// 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.
-
-#include "base/command_line.h"
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// To test Windows quoting behavior, we use a string that has some backslashes
-// and quotes.
-// Consider the command-line argument: q\"bs1\bs2\\bs3q\\\"
-// Here it is with C-style escapes.
-static const CommandLine::StringType kTrickyQuoted =
- FILE_PATH_LITERAL("q\\\"bs1\\bs2\\\\bs3q\\\\\\\"");
-// It should be parsed by Windows as: q"bs1\bs2\\bs3q\"
-// Here that is with C-style escapes.
-static const CommandLine::StringType kTricky =
- FILE_PATH_LITERAL("q\"bs1\\bs2\\\\bs3q\\\"");
-
-TEST(CommandLineTest, CommandLineConstructor) {
- const CommandLine::CharType* argv[] = {
- FILE_PATH_LITERAL("program"),
- FILE_PATH_LITERAL("--foo="),
- FILE_PATH_LITERAL("-bAr"),
- FILE_PATH_LITERAL("-spaetzel=pierogi"),
- FILE_PATH_LITERAL("-baz"),
- FILE_PATH_LITERAL("flim"),
- FILE_PATH_LITERAL("--other-switches=--dog=canine --cat=feline"),
- FILE_PATH_LITERAL("-spaetzle=Crepe"),
- FILE_PATH_LITERAL("-=loosevalue"),
- FILE_PATH_LITERAL("-"),
- FILE_PATH_LITERAL("FLAN"),
- FILE_PATH_LITERAL("a"),
- FILE_PATH_LITERAL("--input-translation=45--output-rotation"),
- FILE_PATH_LITERAL("--"),
- FILE_PATH_LITERAL("--"),
- FILE_PATH_LITERAL("--not-a-switch"),
- FILE_PATH_LITERAL("\"in the time of submarines...\""),
- FILE_PATH_LITERAL("unquoted arg-with-space")};
- CommandLine cl(arraysize(argv), argv);
-
- EXPECT_FALSE(cl.GetCommandLineString().empty());
- EXPECT_FALSE(cl.HasSwitch("cruller"));
- EXPECT_FALSE(cl.HasSwitch("flim"));
- EXPECT_FALSE(cl.HasSwitch("program"));
- EXPECT_FALSE(cl.HasSwitch("dog"));
- EXPECT_FALSE(cl.HasSwitch("cat"));
- EXPECT_FALSE(cl.HasSwitch("output-rotation"));
- EXPECT_FALSE(cl.HasSwitch("not-a-switch"));
- EXPECT_FALSE(cl.HasSwitch("--"));
-
- EXPECT_EQ(FilePath(FILE_PATH_LITERAL("program")).value(),
- cl.GetProgram().value());
-
- EXPECT_TRUE(cl.HasSwitch("foo"));
-#if defined(OS_WIN)
- EXPECT_TRUE(cl.HasSwitch("bar"));
-#else
- EXPECT_FALSE(cl.HasSwitch("bar"));
-#endif
- EXPECT_TRUE(cl.HasSwitch("baz"));
- EXPECT_TRUE(cl.HasSwitch("spaetzle"));
- EXPECT_TRUE(cl.HasSwitch("other-switches"));
- EXPECT_TRUE(cl.HasSwitch("input-translation"));
-
- EXPECT_EQ("Crepe", cl.GetSwitchValueASCII("spaetzle"));
- EXPECT_EQ("", cl.GetSwitchValueASCII("foo"));
- EXPECT_EQ("", cl.GetSwitchValueASCII("bar"));
- EXPECT_EQ("", cl.GetSwitchValueASCII("cruller"));
- EXPECT_EQ("--dog=canine --cat=feline", cl.GetSwitchValueASCII(
- "other-switches"));
- EXPECT_EQ("45--output-rotation", cl.GetSwitchValueASCII("input-translation"));
-
- const CommandLine::StringVector& args = cl.GetArgs();
- ASSERT_EQ(8U, args.size());
-
- std::vector<CommandLine::StringType>::const_iterator iter = args.begin();
- EXPECT_EQ(FILE_PATH_LITERAL("flim"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("-"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("FLAN"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("a"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("--"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("--not-a-switch"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("\"in the time of submarines...\""), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("unquoted arg-with-space"), *iter);
- ++iter;
- EXPECT_TRUE(iter == args.end());
-}
-
-TEST(CommandLineTest, CommandLineFromString) {
-#if defined(OS_WIN)
- CommandLine cl = CommandLine::FromString(
- L"program --foo= -bAr /Spaetzel=pierogi /Baz flim "
- L"--other-switches=\"--dog=canine --cat=feline\" "
- L"-spaetzle=Crepe -=loosevalue FLAN "
- L"--input-translation=\"45\"--output-rotation "
- L"--quotes=" + kTrickyQuoted + L" "
- L"-- -- --not-a-switch "
- L"\"in the time of submarines...\"");
-
- EXPECT_FALSE(cl.GetCommandLineString().empty());
- EXPECT_FALSE(cl.HasSwitch("cruller"));
- EXPECT_FALSE(cl.HasSwitch("flim"));
- EXPECT_FALSE(cl.HasSwitch("program"));
- EXPECT_FALSE(cl.HasSwitch("dog"));
- EXPECT_FALSE(cl.HasSwitch("cat"));
- EXPECT_FALSE(cl.HasSwitch("output-rotation"));
- EXPECT_FALSE(cl.HasSwitch("not-a-switch"));
- EXPECT_FALSE(cl.HasSwitch("--"));
-
- EXPECT_EQ(FilePath(FILE_PATH_LITERAL("program")).value(),
- cl.GetProgram().value());
-
- EXPECT_TRUE(cl.HasSwitch("foo"));
- EXPECT_TRUE(cl.HasSwitch("bar"));
- EXPECT_TRUE(cl.HasSwitch("baz"));
- EXPECT_TRUE(cl.HasSwitch("spaetzle"));
- EXPECT_TRUE(cl.HasSwitch("other-switches"));
- EXPECT_TRUE(cl.HasSwitch("input-translation"));
- EXPECT_TRUE(cl.HasSwitch("quotes"));
-
- EXPECT_EQ("Crepe", cl.GetSwitchValueASCII("spaetzle"));
- EXPECT_EQ("", cl.GetSwitchValueASCII("foo"));
- EXPECT_EQ("", cl.GetSwitchValueASCII("bar"));
- EXPECT_EQ("", cl.GetSwitchValueASCII("cruller"));
- EXPECT_EQ("--dog=canine --cat=feline", cl.GetSwitchValueASCII(
- "other-switches"));
- EXPECT_EQ("45--output-rotation", cl.GetSwitchValueASCII("input-translation"));
- EXPECT_EQ(kTricky, cl.GetSwitchValueNative("quotes"));
-
- const CommandLine::StringVector& args = cl.GetArgs();
- ASSERT_EQ(5U, args.size());
-
- std::vector<CommandLine::StringType>::const_iterator iter = args.begin();
- EXPECT_EQ(FILE_PATH_LITERAL("flim"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("FLAN"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("--"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("--not-a-switch"), *iter);
- ++iter;
- EXPECT_EQ(FILE_PATH_LITERAL("in the time of submarines..."), *iter);
- ++iter;
- EXPECT_TRUE(iter == args.end());
-
- // Check that a generated string produces an equivalent command line.
- CommandLine cl_duplicate = CommandLine::FromString(cl.GetCommandLineString());
- EXPECT_EQ(cl.GetCommandLineString(), cl_duplicate.GetCommandLineString());
-#endif
-}
-
-// Tests behavior with an empty input string.
-TEST(CommandLineTest, EmptyString) {
-#if defined(OS_WIN)
- CommandLine cl_from_string = CommandLine::FromString(L"");
- EXPECT_TRUE(cl_from_string.GetCommandLineString().empty());
- EXPECT_TRUE(cl_from_string.GetProgram().empty());
- EXPECT_EQ(1U, cl_from_string.argv().size());
- EXPECT_TRUE(cl_from_string.GetArgs().empty());
-#endif
- CommandLine cl_from_argv(0, nullptr);
- EXPECT_TRUE(cl_from_argv.GetCommandLineString().empty());
- EXPECT_TRUE(cl_from_argv.GetProgram().empty());
- EXPECT_EQ(1U, cl_from_argv.argv().size());
- EXPECT_TRUE(cl_from_argv.GetArgs().empty());
-}
-
-TEST(CommandLineTest, GetArgumentsString) {
- static const FilePath::CharType kPath1[] =
- FILE_PATH_LITERAL("C:\\Some File\\With Spaces.ggg");
- static const FilePath::CharType kPath2[] =
- FILE_PATH_LITERAL("C:\\no\\spaces.ggg");
-
- static const char kFirstArgName[] = "first-arg";
- static const char kSecondArgName[] = "arg2";
- static const char kThirdArgName[] = "arg with space";
- static const char kFourthArgName[] = "nospace";
- static const char kFifthArgName[] = "%1";
-
- CommandLine cl(CommandLine::NO_PROGRAM);
- cl.AppendSwitchPath(kFirstArgName, FilePath(kPath1));
- cl.AppendSwitchPath(kSecondArgName, FilePath(kPath2));
- cl.AppendArg(kThirdArgName);
- cl.AppendArg(kFourthArgName);
- cl.AppendArg(kFifthArgName);
-
-#if defined(OS_WIN)
- CommandLine::StringType expected_first_arg(UTF8ToUTF16(kFirstArgName));
- CommandLine::StringType expected_second_arg(UTF8ToUTF16(kSecondArgName));
- CommandLine::StringType expected_third_arg(UTF8ToUTF16(kThirdArgName));
- CommandLine::StringType expected_fourth_arg(UTF8ToUTF16(kFourthArgName));
- CommandLine::StringType expected_fifth_arg(UTF8ToUTF16(kFifthArgName));
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- CommandLine::StringType expected_first_arg(kFirstArgName);
- CommandLine::StringType expected_second_arg(kSecondArgName);
- CommandLine::StringType expected_third_arg(kThirdArgName);
- CommandLine::StringType expected_fourth_arg(kFourthArgName);
- CommandLine::StringType expected_fifth_arg(kFifthArgName);
-#endif
-
-#if defined(OS_WIN)
-#define QUOTE_ON_WIN FILE_PATH_LITERAL("\"")
-#else
-#define QUOTE_ON_WIN FILE_PATH_LITERAL("")
-#endif // OS_WIN
-
- CommandLine::StringType expected_str;
- expected_str.append(FILE_PATH_LITERAL("--"))
- .append(expected_first_arg)
- .append(FILE_PATH_LITERAL("="))
- .append(QUOTE_ON_WIN)
- .append(kPath1)
- .append(QUOTE_ON_WIN)
- .append(FILE_PATH_LITERAL(" "))
- .append(FILE_PATH_LITERAL("--"))
- .append(expected_second_arg)
- .append(FILE_PATH_LITERAL("="))
- .append(QUOTE_ON_WIN)
- .append(kPath2)
- .append(QUOTE_ON_WIN)
- .append(FILE_PATH_LITERAL(" "))
- .append(QUOTE_ON_WIN)
- .append(expected_third_arg)
- .append(QUOTE_ON_WIN)
- .append(FILE_PATH_LITERAL(" "))
- .append(expected_fourth_arg)
- .append(FILE_PATH_LITERAL(" "));
-
- CommandLine::StringType expected_str_no_quote_placeholders(expected_str);
- expected_str_no_quote_placeholders.append(expected_fifth_arg);
- EXPECT_EQ(expected_str_no_quote_placeholders, cl.GetArgumentsString());
-
-#if defined(OS_WIN)
- CommandLine::StringType expected_str_quote_placeholders(expected_str);
- expected_str_quote_placeholders.append(QUOTE_ON_WIN)
- .append(expected_fifth_arg)
- .append(QUOTE_ON_WIN);
- EXPECT_EQ(expected_str_quote_placeholders,
- cl.GetArgumentsStringWithPlaceholders());
-#endif
-}
-
-// Test methods for appending switches to a command line.
-TEST(CommandLineTest, AppendSwitches) {
- std::string switch1 = "switch1";
- std::string switch2 = "switch2";
- std::string value2 = "value";
- std::string switch3 = "switch3";
- std::string value3 = "a value with spaces";
- std::string switch4 = "switch4";
- std::string value4 = "\"a value with quotes\"";
- std::string switch5 = "quotes";
- CommandLine::StringType value5 = kTricky;
-
- CommandLine cl(FilePath(FILE_PATH_LITERAL("Program")));
-
- cl.AppendSwitch(switch1);
- cl.AppendSwitchASCII(switch2, value2);
- cl.AppendSwitchASCII(switch3, value3);
- cl.AppendSwitchASCII(switch4, value4);
- cl.AppendSwitchASCII(switch5, value4);
- cl.AppendSwitchNative(switch5, value5);
-
- EXPECT_TRUE(cl.HasSwitch(switch1));
- EXPECT_TRUE(cl.HasSwitch(switch2));
- EXPECT_EQ(value2, cl.GetSwitchValueASCII(switch2));
- EXPECT_TRUE(cl.HasSwitch(switch3));
- EXPECT_EQ(value3, cl.GetSwitchValueASCII(switch3));
- EXPECT_TRUE(cl.HasSwitch(switch4));
- EXPECT_EQ(value4, cl.GetSwitchValueASCII(switch4));
- EXPECT_TRUE(cl.HasSwitch(switch5));
- EXPECT_EQ(value5, cl.GetSwitchValueNative(switch5));
-
-#if defined(OS_WIN)
- EXPECT_EQ(L"Program "
- L"--switch1 "
- L"--switch2=value "
- L"--switch3=\"a value with spaces\" "
- L"--switch4=\"\\\"a value with quotes\\\"\" "
- // Even though the switches are unique, appending can add repeat
- // switches to argv.
- L"--quotes=\"\\\"a value with quotes\\\"\" "
- L"--quotes=\"" + kTrickyQuoted + L"\"",
- cl.GetCommandLineString());
-#endif
-}
-
-TEST(CommandLineTest, AppendSwitchesDashDash) {
- const CommandLine::CharType* raw_argv[] = { FILE_PATH_LITERAL("prog"),
- FILE_PATH_LITERAL("--"),
- FILE_PATH_LITERAL("--arg1") };
- CommandLine cl(arraysize(raw_argv), raw_argv);
-
- cl.AppendSwitch("switch1");
- cl.AppendSwitchASCII("switch2", "foo");
-
- cl.AppendArg("--arg2");
-
- EXPECT_EQ(FILE_PATH_LITERAL("prog --switch1 --switch2=foo -- --arg1 --arg2"),
- cl.GetCommandLineString());
- CommandLine::StringVector cl_argv = cl.argv();
- EXPECT_EQ(FILE_PATH_LITERAL("prog"), cl_argv[0]);
- EXPECT_EQ(FILE_PATH_LITERAL("--switch1"), cl_argv[1]);
- EXPECT_EQ(FILE_PATH_LITERAL("--switch2=foo"), cl_argv[2]);
- EXPECT_EQ(FILE_PATH_LITERAL("--"), cl_argv[3]);
- EXPECT_EQ(FILE_PATH_LITERAL("--arg1"), cl_argv[4]);
- EXPECT_EQ(FILE_PATH_LITERAL("--arg2"), cl_argv[5]);
-}
-
-// Tests that when AppendArguments is called that the program is set correctly
-// on the target CommandLine object and the switches from the source
-// CommandLine are added to the target.
-TEST(CommandLineTest, AppendArguments) {
- CommandLine cl1(FilePath(FILE_PATH_LITERAL("Program")));
- cl1.AppendSwitch("switch1");
- cl1.AppendSwitchASCII("switch2", "foo");
-
- CommandLine cl2(CommandLine::NO_PROGRAM);
- cl2.AppendArguments(cl1, true);
- EXPECT_EQ(cl1.GetProgram().value(), cl2.GetProgram().value());
- EXPECT_EQ(cl1.GetCommandLineString(), cl2.GetCommandLineString());
-
- CommandLine c1(FilePath(FILE_PATH_LITERAL("Program1")));
- c1.AppendSwitch("switch1");
- CommandLine c2(FilePath(FILE_PATH_LITERAL("Program2")));
- c2.AppendSwitch("switch2");
-
- c1.AppendArguments(c2, true);
- EXPECT_EQ(c1.GetProgram().value(), c2.GetProgram().value());
- EXPECT_TRUE(c1.HasSwitch("switch1"));
- EXPECT_TRUE(c1.HasSwitch("switch2"));
-}
-
-#if defined(OS_WIN)
-// Make sure that the command line string program paths are quoted as necessary.
-// This only makes sense on Windows and the test is basically here to guard
-// against regressions.
-TEST(CommandLineTest, ProgramQuotes) {
- // Check that quotes are not added for paths without spaces.
- const FilePath kProgram(L"Program");
- CommandLine cl_program(kProgram);
- EXPECT_EQ(kProgram.value(), cl_program.GetProgram().value());
- EXPECT_EQ(kProgram.value(), cl_program.GetCommandLineString());
-
- const FilePath kProgramPath(L"Program Path");
-
- // Check that quotes are not returned from GetProgram().
- CommandLine cl_program_path(kProgramPath);
- EXPECT_EQ(kProgramPath.value(), cl_program_path.GetProgram().value());
-
- // Check that quotes are added to command line string paths containing spaces.
- CommandLine::StringType cmd_string(cl_program_path.GetCommandLineString());
- EXPECT_EQ(L"\"Program Path\"", cmd_string);
-
- // Check the optional quoting of placeholders in programs.
- CommandLine cl_quote_placeholder(FilePath(L"%1"));
- EXPECT_EQ(L"%1", cl_quote_placeholder.GetCommandLineString());
- EXPECT_EQ(L"\"%1\"",
- cl_quote_placeholder.GetCommandLineStringWithPlaceholders());
-}
-#endif
-
-// Calling Init multiple times should not modify the previous CommandLine.
-TEST(CommandLineTest, Init) {
- // Call Init without checking output once so we know it's been called
- // whether or not the test runner does so.
- CommandLine::Init(0, nullptr);
- CommandLine* initial = CommandLine::ForCurrentProcess();
- EXPECT_FALSE(CommandLine::Init(0, nullptr));
- CommandLine* current = CommandLine::ForCurrentProcess();
- EXPECT_EQ(initial, current);
-}
-
-// Test that copies of CommandLine have a valid StringPiece map.
-TEST(CommandLineTest, Copy) {
- std::unique_ptr<CommandLine> initial(
- new CommandLine(CommandLine::NO_PROGRAM));
- initial->AppendSwitch("a");
- initial->AppendSwitch("bbbbbbbbbbbbbbb");
- initial->AppendSwitch("c");
- CommandLine copy_constructed(*initial);
- CommandLine assigned = *initial;
- CommandLine::SwitchMap switch_map = initial->GetSwitches();
- initial.reset();
- for (const auto& pair : switch_map)
- EXPECT_TRUE(copy_constructed.HasSwitch(pair.first));
- for (const auto& pair : switch_map)
- EXPECT_TRUE(assigned.HasSwitch(pair.first));
-}
-
-TEST(CommandLineTest, PrependSimpleWrapper) {
- CommandLine cl(FilePath(FILE_PATH_LITERAL("Program")));
- cl.AppendSwitch("a");
- cl.AppendSwitch("b");
- cl.PrependWrapper(FILE_PATH_LITERAL("wrapper --foo --bar"));
-
- EXPECT_EQ(6u, cl.argv().size());
- EXPECT_EQ(FILE_PATH_LITERAL("wrapper"), cl.argv()[0]);
- EXPECT_EQ(FILE_PATH_LITERAL("--foo"), cl.argv()[1]);
- EXPECT_EQ(FILE_PATH_LITERAL("--bar"), cl.argv()[2]);
- EXPECT_EQ(FILE_PATH_LITERAL("Program"), cl.argv()[3]);
- EXPECT_EQ(FILE_PATH_LITERAL("--a"), cl.argv()[4]);
- EXPECT_EQ(FILE_PATH_LITERAL("--b"), cl.argv()[5]);
-}
-
-TEST(CommandLineTest, PrependComplexWrapper) {
- CommandLine cl(FilePath(FILE_PATH_LITERAL("Program")));
- cl.AppendSwitch("a");
- cl.AppendSwitch("b");
- cl.PrependWrapper(
- FILE_PATH_LITERAL("wrapper --foo='hello world' --bar=\"let's go\""));
-
- EXPECT_EQ(6u, cl.argv().size());
- EXPECT_EQ(FILE_PATH_LITERAL("wrapper"), cl.argv()[0]);
- EXPECT_EQ(FILE_PATH_LITERAL("--foo='hello world'"), cl.argv()[1]);
- EXPECT_EQ(FILE_PATH_LITERAL("--bar=\"let's go\""), cl.argv()[2]);
- EXPECT_EQ(FILE_PATH_LITERAL("Program"), cl.argv()[3]);
- EXPECT_EQ(FILE_PATH_LITERAL("--a"), cl.argv()[4]);
- EXPECT_EQ(FILE_PATH_LITERAL("--b"), cl.argv()[5]);
-}
-
-} // namespace base
diff --git a/base/component_export_unittest.cc b/base/component_export_unittest.cc
deleted file mode 100644
index e994353..0000000
--- a/base/component_export_unittest.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2018 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 "base/component_export.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-using ComponentExportTest = testing::Test;
-
-#define IS_TEST_COMPONENT_A_IMPL 1
-#define IS_TEST_COMPONENT_B_IMPL
-#define IS_TEST_COMPONENT_C_IMPL 0
-#define IS_TEST_COMPONENT_D_IMPL 2
-#define IS_TEST_COMPONENT_E_IMPL xyz
-
-TEST(ComponentExportTest, ImportExport) {
- // Defined as 1. Treat as export.
- EXPECT_EQ(1, INSIDE_COMPONENT_IMPL(TEST_COMPONENT_A));
-
- // Defined, but empty. Treat as import.
- EXPECT_EQ(0, INSIDE_COMPONENT_IMPL(TEST_COMPONENT_B));
-
- // Defined, but 0. Treat as import.
- EXPECT_EQ(0, INSIDE_COMPONENT_IMPL(TEST_COMPONENT_C));
-
- // Defined, but some other arbitrary thing that isn't 1. Treat as import.
- EXPECT_EQ(0, INSIDE_COMPONENT_IMPL(TEST_COMPONENT_D));
- EXPECT_EQ(0, INSIDE_COMPONENT_IMPL(TEST_COMPONENT_E));
-
- // Undefined. Treat as import.
- EXPECT_EQ(0, INSIDE_COMPONENT_IMPL(TEST_COMPONENT_F));
-
- // And just for good measure, ensure that the macros evaluate properly in the
- // context of preprocessor #if blocks.
-#if INSIDE_COMPONENT_IMPL(TEST_COMPONENT_A)
- EXPECT_TRUE(true);
-#else
- EXPECT_TRUE(false);
-#endif
-
-#if !INSIDE_COMPONENT_IMPL(TEST_COMPONENT_B)
- EXPECT_TRUE(true);
-#else
- EXPECT_TRUE(false);
-#endif
-
-#if !INSIDE_COMPONENT_IMPL(TEST_COMPONENT_C)
- EXPECT_TRUE(true);
-#else
- EXPECT_TRUE(false);
-#endif
-
-#if !INSIDE_COMPONENT_IMPL(TEST_COMPONENT_D)
- EXPECT_TRUE(true);
-#else
- EXPECT_TRUE(false);
-#endif
-
-#if !INSIDE_COMPONENT_IMPL(TEST_COMPONENT_E)
- EXPECT_TRUE(true);
-#else
- EXPECT_TRUE(false);
-#endif
-
-#if !INSIDE_COMPONENT_IMPL(TEST_COMPONENT_F)
- EXPECT_TRUE(true);
-#else
- EXPECT_TRUE(false);
-#endif
-}
-
-#undef IS_TEST_COMPONENT_A_IMPL
-#undef IS_TEST_COMPONENT_B_IMPL
-#undef IS_TEST_COMPONENT_C_IMPL
-#undef IS_TEST_COMPONENT_D_IMPL
-#undef IS_TEST_COMPONENT_E_IMPL
-
-} // namespace
-} // namespace base
diff --git a/base/containers/adapters_unittest.cc b/base/containers/adapters_unittest.cc
deleted file mode 100644
index 92554b7..0000000
--- a/base/containers/adapters_unittest.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2014 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 "base/containers/adapters.h"
-
-#include <vector>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-TEST(AdaptersTest, Reversed) {
- std::vector<int> v;
- v.push_back(3);
- v.push_back(2);
- v.push_back(1);
- int j = 0;
- for (int& i : base::Reversed(v)) {
- EXPECT_EQ(++j, i);
- i += 100;
- }
- EXPECT_EQ(103, v[0]);
- EXPECT_EQ(102, v[1]);
- EXPECT_EQ(101, v[2]);
-}
-
-TEST(AdaptersTest, ReversedArray) {
- int v[3] = {3, 2, 1};
- int j = 0;
- for (int& i : base::Reversed(v)) {
- EXPECT_EQ(++j, i);
- i += 100;
- }
- EXPECT_EQ(103, v[0]);
- EXPECT_EQ(102, v[1]);
- EXPECT_EQ(101, v[2]);
-}
-
-TEST(AdaptersTest, ReversedConst) {
- std::vector<int> v;
- v.push_back(3);
- v.push_back(2);
- v.push_back(1);
- const std::vector<int>& cv = v;
- int j = 0;
- for (int i : base::Reversed(cv)) {
- EXPECT_EQ(++j, i);
- }
-}
-
-} // namespace
diff --git a/base/containers/circular_deque_unittest.cc b/base/containers/circular_deque_unittest.cc
deleted file mode 100644
index 0c168e0..0000000
--- a/base/containers/circular_deque_unittest.cc
+++ /dev/null
@@ -1,881 +0,0 @@
-// Copyright 2017 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 "base/containers/circular_deque.h"
-
-#include "base/test/copy_only_int.h"
-#include "base/test/move_only_int.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::internal::VectorBuffer;
-
-namespace base {
-
-namespace {
-
-circular_deque<int> MakeSequence(size_t max) {
- circular_deque<int> ret;
- for (size_t i = 0; i < max; i++)
- ret.push_back(i);
- return ret;
-}
-
-// Cycles through the queue, popping items from the back and pushing items
-// at the front to validate behavior across different configurations of the
-// queue in relation to the underlying buffer. The tester closure is run for
-// each cycle.
-template <class QueueT, class Tester>
-void CycleTest(circular_deque<QueueT>& queue, const Tester& tester) {
- size_t steps = queue.size() * 2;
- for (size_t i = 0; i < steps; i++) {
- tester(queue, i);
- queue.pop_back();
- queue.push_front(QueueT());
- }
-}
-
-class DestructorCounter {
- public:
- DestructorCounter(int* counter) : counter_(counter) {}
- ~DestructorCounter() { ++(*counter_); }
-
- private:
- int* counter_;
-};
-
-} // namespace
-
-TEST(CircularDeque, FillConstructor) {
- constexpr size_t num_elts = 9;
-
- std::vector<int> foo(15);
- EXPECT_EQ(15u, foo.size());
-
- // Fill with default constructor.
- {
- circular_deque<int> buf(num_elts);
-
- EXPECT_EQ(num_elts, buf.size());
- EXPECT_EQ(num_elts, static_cast<size_t>(buf.end() - buf.begin()));
-
- for (size_t i = 0; i < num_elts; i++)
- EXPECT_EQ(0, buf[i]);
- }
-
- // Fill with explicit value.
- {
- int value = 199;
- circular_deque<int> buf(num_elts, value);
-
- EXPECT_EQ(num_elts, buf.size());
- EXPECT_EQ(num_elts, static_cast<size_t>(buf.end() - buf.begin()));
-
- for (size_t i = 0; i < num_elts; i++)
- EXPECT_EQ(value, buf[i]);
- }
-}
-
-TEST(CircularDeque, CopyAndRangeConstructor) {
- int values[] = {1, 2, 3, 4, 5, 6};
- circular_deque<CopyOnlyInt> first(std::begin(values), std::end(values));
-
- circular_deque<CopyOnlyInt> second(first);
- EXPECT_EQ(6u, second.size());
- for (int i = 0; i < 6; i++)
- EXPECT_EQ(i + 1, second[i].data());
-}
-
-TEST(CircularDeque, MoveConstructor) {
- int values[] = {1, 2, 3, 4, 5, 6};
- circular_deque<MoveOnlyInt> first(std::begin(values), std::end(values));
-
- circular_deque<MoveOnlyInt> second(std::move(first));
- EXPECT_TRUE(first.empty());
- EXPECT_EQ(6u, second.size());
- for (int i = 0; i < 6; i++)
- EXPECT_EQ(i + 1, second[i].data());
-}
-
-TEST(CircularDeque, InitializerListConstructor) {
- circular_deque<int> empty({});
- ASSERT_TRUE(empty.empty());
-
- circular_deque<int> first({1, 2, 3, 4, 5, 6});
- EXPECT_EQ(6u, first.size());
- for (int i = 0; i < 6; i++)
- EXPECT_EQ(i + 1, first[i]);
-}
-
-TEST(CircularDeque, Destructor) {
- int destruct_count = 0;
-
- // Contiguous buffer.
- {
- circular_deque<DestructorCounter> q;
- q.resize(5, DestructorCounter(&destruct_count));
-
- EXPECT_EQ(1, destruct_count); // The temporary in the call to resize().
- destruct_count = 0;
- }
- EXPECT_EQ(5, destruct_count); // One call for each.
-
- // Force a wraparound buffer.
- {
- circular_deque<DestructorCounter> q;
- q.reserve(7);
- q.resize(5, DestructorCounter(&destruct_count));
-
- // Cycle throught some elements in our buffer to force a wraparound.
- destruct_count = 0;
- for (int i = 0; i < 4; i++) {
- q.emplace_back(&destruct_count);
- q.pop_front();
- }
- EXPECT_EQ(4, destruct_count); // One for each cycle.
- destruct_count = 0;
- }
- EXPECT_EQ(5, destruct_count); // One call for each.
-}
-
-TEST(CircularDeque, EqualsCopy) {
- circular_deque<int> first = {1, 2, 3, 4, 5, 6};
- circular_deque<int> copy;
- EXPECT_TRUE(copy.empty());
- copy = first;
- EXPECT_EQ(6u, copy.size());
- for (int i = 0; i < 6; i++) {
- EXPECT_EQ(i + 1, first[i]);
- EXPECT_EQ(i + 1, copy[i]);
- EXPECT_NE(&first[i], ©[i]);
- }
-}
-
-TEST(CircularDeque, EqualsMove) {
- circular_deque<int> first = {1, 2, 3, 4, 5, 6};
- circular_deque<int> move;
- EXPECT_TRUE(move.empty());
- move = std::move(first);
- EXPECT_TRUE(first.empty());
- EXPECT_EQ(6u, move.size());
- for (int i = 0; i < 6; i++)
- EXPECT_EQ(i + 1, move[i]);
-}
-
-// Tests that self-assignment is a no-op.
-TEST(CircularDeque, EqualsSelf) {
- circular_deque<int> q = {1, 2, 3, 4, 5, 6};
- q = *&q; // The *& defeats Clang's -Wself-assign warning.
- EXPECT_EQ(6u, q.size());
- for (int i = 0; i < 6; i++)
- EXPECT_EQ(i + 1, q[i]);
-}
-
-TEST(CircularDeque, EqualsInitializerList) {
- circular_deque<int> q;
- EXPECT_TRUE(q.empty());
- q = {1, 2, 3, 4, 5, 6};
- EXPECT_EQ(6u, q.size());
- for (int i = 0; i < 6; i++)
- EXPECT_EQ(i + 1, q[i]);
-}
-
-TEST(CircularDeque, AssignCountValue) {
- circular_deque<int> empty;
- empty.assign(0, 52);
- EXPECT_EQ(0u, empty.size());
-
- circular_deque<int> full;
- size_t count = 13;
- int value = 12345;
- full.assign(count, value);
- EXPECT_EQ(count, full.size());
-
- for (size_t i = 0; i < count; i++)
- EXPECT_EQ(value, full[i]);
-}
-
-TEST(CircularDeque, AssignIterator) {
- int range[8] = {11, 12, 13, 14, 15, 16, 17, 18};
-
- circular_deque<int> empty;
- empty.assign(std::begin(range), std::begin(range));
- EXPECT_TRUE(empty.empty());
-
- circular_deque<int> full;
- full.assign(std::begin(range), std::end(range));
- EXPECT_EQ(8u, full.size());
- for (size_t i = 0; i < 8; i++)
- EXPECT_EQ(range[i], full[i]);
-}
-
-TEST(CircularDeque, AssignInitializerList) {
- circular_deque<int> empty;
- empty.assign({});
- EXPECT_TRUE(empty.empty());
-
- circular_deque<int> full;
- full.assign({11, 12, 13, 14, 15, 16, 17, 18});
- EXPECT_EQ(8u, full.size());
- for (int i = 0; i < 8; i++)
- EXPECT_EQ(11 + i, full[i]);
-}
-
-// Tests [] and .at().
-TEST(CircularDeque, At) {
- circular_deque<int> q = MakeSequence(10);
- CycleTest(q, [](const circular_deque<int>& q, size_t cycle) {
- size_t expected_size = 10;
- EXPECT_EQ(expected_size, q.size());
-
- // A sequence of 0's.
- size_t index = 0;
- size_t num_zeros = std::min(expected_size, cycle);
- for (size_t i = 0; i < num_zeros; i++, index++) {
- EXPECT_EQ(0, q[index]);
- EXPECT_EQ(0, q.at(index));
- }
-
- // Followed by a sequence of increasing ints.
- size_t num_ints = expected_size - num_zeros;
- for (int i = 0; i < static_cast<int>(num_ints); i++, index++) {
- EXPECT_EQ(i, q[index]);
- EXPECT_EQ(i, q.at(index));
- }
- });
-}
-
-// This also tests the copy constructor with lots of different types of
-// input configurations.
-TEST(CircularDeque, FrontBackPushPop) {
- circular_deque<int> q = MakeSequence(10);
-
- int expected_front = 0;
- int expected_back = 9;
-
- // Go in one direction.
- for (int i = 0; i < 100; i++) {
- const circular_deque<int> const_q(q);
-
- EXPECT_EQ(expected_front, q.front());
- EXPECT_EQ(expected_back, q.back());
- EXPECT_EQ(expected_front, const_q.front());
- EXPECT_EQ(expected_back, const_q.back());
-
- expected_front++;
- expected_back++;
-
- q.pop_front();
- q.push_back(expected_back);
- }
-
- // Go back in reverse.
- for (int i = 0; i < 100; i++) {
- const circular_deque<int> const_q(q);
-
- EXPECT_EQ(expected_front, q.front());
- EXPECT_EQ(expected_back, q.back());
- EXPECT_EQ(expected_front, const_q.front());
- EXPECT_EQ(expected_back, const_q.back());
-
- expected_front--;
- expected_back--;
-
- q.pop_back();
- q.push_front(expected_front);
- }
-}
-
-TEST(CircularDeque, ReallocateWithSplitBuffer) {
- // Tests reallocating a deque with an internal buffer that looks like this:
- // 4 5 x x 0 1 2 3
- // end-^ ^-begin
- circular_deque<int> q;
- q.reserve(7); // Internal buffer is always 1 larger than requested.
- q.push_back(-1);
- q.push_back(-1);
- q.push_back(-1);
- q.push_back(-1);
- q.push_back(0);
- q.pop_front();
- q.pop_front();
- q.pop_front();
- q.pop_front();
- q.push_back(1);
- q.push_back(2);
- q.push_back(3);
- q.push_back(4);
- q.push_back(5);
-
- q.shrink_to_fit();
- EXPECT_EQ(6u, q.size());
-
- EXPECT_EQ(0, q[0]);
- EXPECT_EQ(1, q[1]);
- EXPECT_EQ(2, q[2]);
- EXPECT_EQ(3, q[3]);
- EXPECT_EQ(4, q[4]);
- EXPECT_EQ(5, q[5]);
-}
-
-TEST(CircularDeque, Swap) {
- circular_deque<int> a = MakeSequence(10);
- circular_deque<int> b = MakeSequence(100);
-
- a.swap(b);
- EXPECT_EQ(100u, a.size());
- for (int i = 0; i < 100; i++)
- EXPECT_EQ(i, a[i]);
-
- EXPECT_EQ(10u, b.size());
- for (int i = 0; i < 10; i++)
- EXPECT_EQ(i, b[i]);
-}
-
-TEST(CircularDeque, Iteration) {
- circular_deque<int> q = MakeSequence(10);
-
- int expected_front = 0;
- int expected_back = 9;
-
- // This loop causes various combinations of begin and end to be tested.
- for (int i = 0; i < 30; i++) {
- // Range-based for loop going forward.
- int current_expected = expected_front;
- for (int cur : q) {
- EXPECT_EQ(current_expected, cur);
- current_expected++;
- }
-
- // Manually test reverse iterators.
- current_expected = expected_back;
- for (auto cur = q.crbegin(); cur < q.crend(); cur++) {
- EXPECT_EQ(current_expected, *cur);
- current_expected--;
- }
-
- expected_front++;
- expected_back++;
-
- q.pop_front();
- q.push_back(expected_back);
- }
-
- // Go back in reverse.
- for (int i = 0; i < 100; i++) {
- const circular_deque<int> const_q(q);
-
- EXPECT_EQ(expected_front, q.front());
- EXPECT_EQ(expected_back, q.back());
- EXPECT_EQ(expected_front, const_q.front());
- EXPECT_EQ(expected_back, const_q.back());
-
- expected_front--;
- expected_back--;
-
- q.pop_back();
- q.push_front(expected_front);
- }
-}
-
-TEST(CircularDeque, IteratorComparisons) {
- circular_deque<int> q = MakeSequence(10);
-
- // This loop causes various combinations of begin and end to be tested.
- for (int i = 0; i < 30; i++) {
- EXPECT_LT(q.begin(), q.end());
- EXPECT_LE(q.begin(), q.end());
- EXPECT_LE(q.begin(), q.begin());
-
- EXPECT_GT(q.end(), q.begin());
- EXPECT_GE(q.end(), q.begin());
- EXPECT_GE(q.end(), q.end());
-
- EXPECT_EQ(q.begin(), q.begin());
- EXPECT_NE(q.begin(), q.end());
-
- q.push_front(10);
- q.pop_back();
- }
-}
-
-TEST(CircularDeque, IteratorIncDec) {
- circular_deque<int> q;
-
- // No-op offset computations with no capacity.
- EXPECT_EQ(q.end(), q.end() + 0);
- EXPECT_EQ(q.end(), q.end() - 0);
-
- q = MakeSequence(10);
-
- // Mutable preincrement, predecrement.
- {
- circular_deque<int>::iterator it = q.begin();
- circular_deque<int>::iterator op_result = ++it;
- EXPECT_EQ(1, *op_result);
- EXPECT_EQ(1, *it);
-
- op_result = --it;
- EXPECT_EQ(0, *op_result);
- EXPECT_EQ(0, *it);
- }
-
- // Const preincrement, predecrement.
- {
- circular_deque<int>::const_iterator it = q.begin();
- circular_deque<int>::const_iterator op_result = ++it;
- EXPECT_EQ(1, *op_result);
- EXPECT_EQ(1, *it);
-
- op_result = --it;
- EXPECT_EQ(0, *op_result);
- EXPECT_EQ(0, *it);
- }
-
- // Mutable postincrement, postdecrement.
- {
- circular_deque<int>::iterator it = q.begin();
- circular_deque<int>::iterator op_result = it++;
- EXPECT_EQ(0, *op_result);
- EXPECT_EQ(1, *it);
-
- op_result = it--;
- EXPECT_EQ(1, *op_result);
- EXPECT_EQ(0, *it);
- }
-
- // Const postincrement, postdecrement.
- {
- circular_deque<int>::const_iterator it = q.begin();
- circular_deque<int>::const_iterator op_result = it++;
- EXPECT_EQ(0, *op_result);
- EXPECT_EQ(1, *it);
-
- op_result = it--;
- EXPECT_EQ(1, *op_result);
- EXPECT_EQ(0, *it);
- }
-}
-
-TEST(CircularDeque, IteratorIntegerOps) {
- circular_deque<int> q = MakeSequence(10);
-
- int expected_front = 0;
- int expected_back = 9;
-
- for (int i = 0; i < 30; i++) {
- EXPECT_EQ(0, q.begin() - q.begin());
- EXPECT_EQ(0, q.end() - q.end());
- EXPECT_EQ(q.size(), static_cast<size_t>(q.end() - q.begin()));
-
- // +=
- circular_deque<int>::iterator eight = q.begin();
- eight += 8;
- EXPECT_EQ(8, eight - q.begin());
- EXPECT_EQ(expected_front + 8, *eight);
-
- // -=
- eight -= 8;
- EXPECT_EQ(q.begin(), eight);
-
- // +
- eight = eight + 8;
- EXPECT_EQ(8, eight - q.begin());
-
- // -
- eight = eight - 8;
- EXPECT_EQ(q.begin(), eight);
-
- expected_front++;
- expected_back++;
-
- q.pop_front();
- q.push_back(expected_back);
- }
-}
-
-TEST(CircularDeque, IteratorArrayAccess) {
- circular_deque<int> q = MakeSequence(10);
-
- circular_deque<int>::iterator begin = q.begin();
- EXPECT_EQ(0, begin[0]);
- EXPECT_EQ(9, begin[9]);
-
- circular_deque<int>::iterator end = q.end();
- EXPECT_EQ(0, end[-10]);
- EXPECT_EQ(9, end[-1]);
-
- begin[0] = 100;
- EXPECT_EQ(100, end[-10]);
-}
-
-TEST(CircularDeque, ReverseIterator) {
- circular_deque<int> q;
- q.push_back(4);
- q.push_back(3);
- q.push_back(2);
- q.push_back(1);
-
- circular_deque<int>::reverse_iterator iter = q.rbegin();
- EXPECT_EQ(1, *iter);
- iter++;
- EXPECT_EQ(2, *iter);
- ++iter;
- EXPECT_EQ(3, *iter);
- iter++;
- EXPECT_EQ(4, *iter);
- ++iter;
- EXPECT_EQ(q.rend(), iter);
-}
-
-TEST(CircularDeque, CapacityReserveShrink) {
- circular_deque<int> q;
-
- // A default constructed queue should have no capacity since it should waste
- // no space.
- EXPECT_TRUE(q.empty());
- EXPECT_EQ(0u, q.size());
- EXPECT_EQ(0u, q.capacity());
-
- size_t new_capacity = 100;
- q.reserve(new_capacity);
- EXPECT_EQ(new_capacity, q.capacity());
-
- // Adding that many items should not cause a resize.
- for (size_t i = 0; i < new_capacity; i++)
- q.push_back(i);
- EXPECT_EQ(new_capacity, q.size());
- EXPECT_EQ(new_capacity, q.capacity());
-
- // Shrink to fit to a smaller size.
- size_t capacity_2 = new_capacity / 2;
- q.resize(capacity_2);
- q.shrink_to_fit();
- EXPECT_EQ(capacity_2, q.size());
- EXPECT_EQ(capacity_2, q.capacity());
-}
-
-TEST(CircularDeque, CapacityAutoShrink) {
- size_t big_size = 1000u;
- circular_deque<int> q;
- q.resize(big_size);
-
- size_t big_capacity = q.capacity();
-
- // Delete 3/4 of the items.
- for (size_t i = 0; i < big_size / 4 * 3; i++)
- q.pop_back();
-
- // The capacity should have shrunk by deleting that many items.
- size_t medium_capacity = q.capacity();
- EXPECT_GT(big_capacity, medium_capacity);
-
- // Using resize to shrink should keep some extra capacity.
- q.resize(1);
- EXPECT_LT(1u, q.capacity());
-
- q.resize(0);
- EXPECT_LT(0u, q.capacity());
-
- // Using clear() should delete everything.
- q.clear();
- EXPECT_EQ(0u, q.capacity());
-}
-
-TEST(CircularDeque, ClearAndEmpty) {
- circular_deque<int> q;
- EXPECT_TRUE(q.empty());
-
- q.resize(10);
- EXPECT_EQ(10u, q.size());
- EXPECT_FALSE(q.empty());
-
- q.clear();
- EXPECT_EQ(0u, q.size());
- EXPECT_TRUE(q.empty());
-
- // clear() also should reset the capacity.
- EXPECT_EQ(0u, q.capacity());
-}
-
-TEST(CircularDeque, Resize) {
- circular_deque<int> q;
-
- // Resize with default constructor.
- size_t first_size = 10;
- q.resize(first_size);
- EXPECT_EQ(first_size, q.size());
- for (size_t i = 0; i < first_size; i++)
- EXPECT_EQ(0, q[i]);
-
- // Resize with different value.
- size_t second_expand = 10;
- q.resize(first_size + second_expand, 3);
- EXPECT_EQ(first_size + second_expand, q.size());
- for (size_t i = 0; i < first_size; i++)
- EXPECT_EQ(0, q[i]);
- for (size_t i = 0; i < second_expand; i++)
- EXPECT_EQ(3, q[i + first_size]);
-
- // Erase from the end and add to the beginning so resize is forced to cross
- // a circular buffer wrap boundary.
- q.shrink_to_fit();
- for (int i = 0; i < 5; i++) {
- q.pop_back();
- q.push_front(6);
- }
- q.resize(10);
-
- EXPECT_EQ(6, q[0]);
- EXPECT_EQ(6, q[1]);
- EXPECT_EQ(6, q[2]);
- EXPECT_EQ(6, q[3]);
- EXPECT_EQ(6, q[4]);
- EXPECT_EQ(0, q[5]);
- EXPECT_EQ(0, q[6]);
- EXPECT_EQ(0, q[7]);
- EXPECT_EQ(0, q[8]);
- EXPECT_EQ(0, q[9]);
-}
-
-// Tests destructor behavior of resize.
-TEST(CircularDeque, ResizeDelete) {
- int counter = 0;
- circular_deque<DestructorCounter> q;
- q.resize(10, DestructorCounter(&counter));
- // The one temporary when calling resize() should be deleted, that's it.
- EXPECT_EQ(1, counter);
-
- // The loops below assume the capacity will be set by resize().
- EXPECT_EQ(10u, q.capacity());
-
- // Delete some via resize(). This is done so that the wasted items are
- // still greater than the size() so that auto-shrinking is not triggered
- // (which will mess up our destructor counting).
- counter = 0;
- q.resize(8, DestructorCounter(&counter));
- // 2 deleted ones + the one temporary in the resize() call.
- EXPECT_EQ(3, counter);
-
- // Cycle through some items so two items will cross the boundary in the
- // 11-item buffer (one more than the capacity).
- // Before: x x x x x x x x . . .
- // After: x . . . x x x x x x x
- counter = 0;
- for (int i = 0; i < 4; i++) {
- q.emplace_back(&counter);
- q.pop_front();
- }
- EXPECT_EQ(4, counter); // Loop should have deleted 7 items.
-
- // Delete two items with resize, these should be on either side of the
- // buffer wrap point.
- counter = 0;
- q.resize(6, DestructorCounter(&counter));
- // 2 deleted ones + the one temporary in the resize() call.
- EXPECT_EQ(3, counter);
-}
-
-TEST(CircularDeque, InsertEraseSingle) {
- circular_deque<int> q;
- q.push_back(1);
- q.push_back(2);
-
- // Insert at the beginning.
- auto result = q.insert(q.begin(), 0);
- EXPECT_EQ(q.begin(), result);
- EXPECT_EQ(3u, q.size());
- EXPECT_EQ(0, q[0]);
- EXPECT_EQ(1, q[1]);
- EXPECT_EQ(2, q[2]);
-
- // Erase at the beginning.
- result = q.erase(q.begin());
- EXPECT_EQ(q.begin(), result);
- EXPECT_EQ(2u, q.size());
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(2, q[1]);
-
- // Insert at the end.
- result = q.insert(q.end(), 3);
- EXPECT_EQ(q.end() - 1, result);
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(2, q[1]);
- EXPECT_EQ(3, q[2]);
-
- // Erase at the end.
- result = q.erase(q.end() - 1);
- EXPECT_EQ(q.end(), result);
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(2, q[1]);
-
- // Insert in the middle.
- result = q.insert(q.begin() + 1, 10);
- EXPECT_EQ(q.begin() + 1, result);
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(10, q[1]);
- EXPECT_EQ(2, q[2]);
-
- // Erase in the middle.
- result = q.erase(q.begin() + 1);
- EXPECT_EQ(q.begin() + 1, result);
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(2, q[1]);
-}
-
-TEST(CircularDeque, InsertFill) {
- circular_deque<int> q;
-
- // Fill when empty.
- q.insert(q.begin(), 2, 1);
-
- // 0's at the beginning.
- q.insert(q.begin(), 2, 0);
-
- // 50's in the middle (now at offset 3).
- q.insert(q.begin() + 3, 2, 50);
-
- // 200's at the end.
- q.insert(q.end(), 2, 200);
-
- ASSERT_EQ(8u, q.size());
- EXPECT_EQ(0, q[0]);
- EXPECT_EQ(0, q[1]);
- EXPECT_EQ(1, q[2]);
- EXPECT_EQ(50, q[3]);
- EXPECT_EQ(50, q[4]);
- EXPECT_EQ(1, q[5]);
- EXPECT_EQ(200, q[6]);
- EXPECT_EQ(200, q[7]);
-}
-
-TEST(CircularDeque, InsertEraseRange) {
- circular_deque<int> q;
-
- // Erase nothing from an empty deque should work.
- q.erase(q.begin(), q.end());
-
- // Loop index used below to shift the used items in the buffer.
- for (int i = 0; i < 10; i++) {
- circular_deque<int> source;
-
- // Fill empty range.
- q.insert(q.begin(), source.begin(), source.end());
-
- // Have some stuff to insert.
- source.push_back(1);
- source.push_back(2);
-
- q.insert(q.begin(), source.begin(), source.end());
-
- // Shift the used items in the buffer by i which will place the two used
- // elements in different places in the buffer each time through this loop.
- for (int shift_i = 0; shift_i < i; shift_i++) {
- q.push_back(0);
- q.pop_front();
- }
-
- // Set the two items to notable values so we can check for them later.
- ASSERT_EQ(2u, q.size());
- q[0] = 100;
- q[1] = 101;
-
- // Insert at the beginning, middle (now at offset 3), and end.
- q.insert(q.begin(), source.begin(), source.end());
- q.insert(q.begin() + 3, source.begin(), source.end());
- q.insert(q.end(), source.begin(), source.end());
-
- ASSERT_EQ(8u, q.size());
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(2, q[1]);
- EXPECT_EQ(100, q[2]); // First inserted one.
- EXPECT_EQ(1, q[3]);
- EXPECT_EQ(2, q[4]);
- EXPECT_EQ(101, q[5]); // First inserted second one.
- EXPECT_EQ(1, q[6]);
- EXPECT_EQ(2, q[7]);
-
- // Now erase the inserted ranges. Try each subsection also with no items
- // being erased, which should be a no-op.
- auto result = q.erase(q.begin(), q.begin()); // No-op.
- EXPECT_EQ(q.begin(), result);
- result = q.erase(q.begin(), q.begin() + 2);
- EXPECT_EQ(q.begin(), result);
-
- result = q.erase(q.begin() + 1, q.begin() + 1); // No-op.
- EXPECT_EQ(q.begin() + 1, result);
- result = q.erase(q.begin() + 1, q.begin() + 3);
- EXPECT_EQ(q.begin() + 1, result);
-
- result = q.erase(q.end() - 2, q.end() - 2); // No-op.
- EXPECT_EQ(q.end() - 2, result);
- result = q.erase(q.end() - 2, q.end());
- EXPECT_EQ(q.end(), result);
-
- ASSERT_EQ(2u, q.size());
- EXPECT_EQ(100, q[0]);
- EXPECT_EQ(101, q[1]);
-
- // Erase everything.
- result = q.erase(q.begin(), q.end());
- EXPECT_EQ(q.end(), result);
- EXPECT_TRUE(q.empty());
- }
-}
-
-TEST(CircularDeque, EmplaceMoveOnly) {
- int values[] = {1, 3};
- circular_deque<MoveOnlyInt> q(std::begin(values), std::end(values));
-
- q.emplace(q.begin(), MoveOnlyInt(0));
- q.emplace(q.begin() + 2, MoveOnlyInt(2));
- q.emplace(q.end(), MoveOnlyInt(4));
-
- ASSERT_EQ(5u, q.size());
- EXPECT_EQ(0, q[0].data());
- EXPECT_EQ(1, q[1].data());
- EXPECT_EQ(2, q[2].data());
- EXPECT_EQ(3, q[3].data());
- EXPECT_EQ(4, q[4].data());
-}
-
-TEST(CircularDeque, EmplaceFrontBackReturnsReference) {
- circular_deque<int> q;
- q.reserve(2);
-
- int& front = q.emplace_front(1);
- int& back = q.emplace_back(2);
- ASSERT_EQ(2u, q.size());
- EXPECT_EQ(1, q[0]);
- EXPECT_EQ(2, q[1]);
-
- EXPECT_EQ(&front, &q.front());
- EXPECT_EQ(&back, &q.back());
-
- front = 3;
- back = 4;
-
- ASSERT_EQ(2u, q.size());
- EXPECT_EQ(3, q[0]);
- EXPECT_EQ(4, q[1]);
-
- EXPECT_EQ(&front, &q.front());
- EXPECT_EQ(&back, &q.back());
-}
-
-/*
-This test should assert in a debug build. It tries to dereference an iterator
-after mutating the container. Uncomment to double-check that this works.
-TEST(CircularDeque, UseIteratorAfterMutate) {
- circular_deque<int> q;
- q.push_back(0);
-
- auto old_begin = q.begin();
- EXPECT_EQ(0, *old_begin);
-
- q.push_back(1);
- EXPECT_EQ(0, *old_begin); // Should DCHECK.
-}
-*/
-
-} // namespace base
diff --git a/base/containers/flat_map_unittest.cc b/base/containers/flat_map_unittest.cc
deleted file mode 100644
index 87958bd..0000000
--- a/base/containers/flat_map_unittest.cc
+++ /dev/null
@@ -1,369 +0,0 @@
-// Copyright 2017 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 "base/containers/flat_map.h"
-
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/test/move_only_int.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// A flat_map is basically a interface to flat_tree. So several basic
-// operations are tested to make sure things are set up properly, but the bulk
-// of the tests are in flat_tree_unittests.cc.
-
-using ::testing::ElementsAre;
-
-namespace base {
-
-TEST(FlatMap, IncompleteType) {
- struct A {
- using Map = flat_map<A, A>;
- int data;
- Map set_with_incomplete_type;
- Map::iterator it;
- Map::const_iterator cit;
-
- // We do not declare operator< because clang complains that it's unused.
- };
-
- A a;
-}
-
-TEST(FlatMap, RangeConstructor) {
- flat_map<int, int>::value_type input_vals[] = {
- {1, 1}, {1, 2}, {1, 3}, {2, 1}, {2, 2}, {2, 3}, {3, 1}, {3, 2}, {3, 3}};
-
- flat_map<int, int> first(std::begin(input_vals), std::end(input_vals));
- EXPECT_THAT(first, ElementsAre(std::make_pair(1, 1), std::make_pair(2, 1),
- std::make_pair(3, 1)));
-
- flat_map<int, int> last(std::begin(input_vals), std::end(input_vals),
- KEEP_LAST_OF_DUPES);
- EXPECT_THAT(last, ElementsAre(std::make_pair(1, 3), std::make_pair(2, 3),
- std::make_pair(3, 3)));
-}
-
-TEST(FlatMap, MoveConstructor) {
- using pair = std::pair<MoveOnlyInt, MoveOnlyInt>;
-
- flat_map<MoveOnlyInt, MoveOnlyInt> original;
- original.insert(pair(MoveOnlyInt(1), MoveOnlyInt(1)));
- original.insert(pair(MoveOnlyInt(2), MoveOnlyInt(2)));
- original.insert(pair(MoveOnlyInt(3), MoveOnlyInt(3)));
- original.insert(pair(MoveOnlyInt(4), MoveOnlyInt(4)));
-
- flat_map<MoveOnlyInt, MoveOnlyInt> moved(std::move(original));
-
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(1)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(2)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(3)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(4)));
-}
-
-TEST(FlatMap, VectorConstructor) {
- using IntPair = std::pair<int, int>;
- using IntMap = flat_map<int, int>;
- {
- std::vector<IntPair> vect{{1, 1}, {1, 2}, {2, 1}};
- IntMap map(std::move(vect));
- EXPECT_THAT(map, ElementsAre(IntPair(1, 1), IntPair(2, 1)));
- }
- {
- std::vector<IntPair> vect{{1, 1}, {1, 2}, {2, 1}};
- IntMap map(std::move(vect), KEEP_LAST_OF_DUPES);
- EXPECT_THAT(map, ElementsAre(IntPair(1, 2), IntPair(2, 1)));
- }
-}
-
-TEST(FlatMap, InitializerListConstructor) {
- {
- flat_map<int, int> cont(
- {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {1, 2}, {10, 10}, {8, 8}});
- EXPECT_THAT(cont, ElementsAre(std::make_pair(1, 1), std::make_pair(2, 2),
- std::make_pair(3, 3), std::make_pair(4, 4),
- std::make_pair(5, 5), std::make_pair(8, 8),
- std::make_pair(10, 10)));
- }
- {
- flat_map<int, int> cont(
- {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {1, 2}, {10, 10}, {8, 8}},
- KEEP_LAST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(std::make_pair(1, 2), std::make_pair(2, 2),
- std::make_pair(3, 3), std::make_pair(4, 4),
- std::make_pair(5, 5), std::make_pair(8, 8),
- std::make_pair(10, 10)));
- }
-}
-
-TEST(FlatMap, InitializerListAssignment) {
- flat_map<int, int> cont;
- cont = {{1, 1}, {2, 2}};
- EXPECT_THAT(cont, ElementsAre(std::make_pair(1, 1), std::make_pair(2, 2)));
-}
-
-TEST(FlatMap, InsertFindSize) {
- base::flat_map<int, int> s;
- s.insert(std::make_pair(1, 1));
- s.insert(std::make_pair(1, 1));
- s.insert(std::make_pair(2, 2));
-
- EXPECT_EQ(2u, s.size());
- EXPECT_EQ(std::make_pair(1, 1), *s.find(1));
- EXPECT_EQ(std::make_pair(2, 2), *s.find(2));
- EXPECT_EQ(s.end(), s.find(7));
-}
-
-TEST(FlatMap, CopySwap) {
- base::flat_map<int, int> original;
- original.insert({1, 1});
- original.insert({2, 2});
- EXPECT_THAT(original,
- ElementsAre(std::make_pair(1, 1), std::make_pair(2, 2)));
-
- base::flat_map<int, int> copy(original);
- EXPECT_THAT(copy, ElementsAre(std::make_pair(1, 1), std::make_pair(2, 2)));
-
- copy.erase(copy.begin());
- copy.insert({10, 10});
- EXPECT_THAT(copy, ElementsAre(std::make_pair(2, 2), std::make_pair(10, 10)));
-
- original.swap(copy);
- EXPECT_THAT(original,
- ElementsAre(std::make_pair(2, 2), std::make_pair(10, 10)));
- EXPECT_THAT(copy, ElementsAre(std::make_pair(1, 1), std::make_pair(2, 2)));
-}
-
-// operator[](const Key&)
-TEST(FlatMap, SubscriptConstKey) {
- base::flat_map<std::string, int> m;
-
- // Default construct elements that don't exist yet.
- int& s = m["a"];
- EXPECT_EQ(0, s);
- EXPECT_EQ(1u, m.size());
-
- // The returned mapped reference should refer into the map.
- s = 22;
- EXPECT_EQ(22, m["a"]);
-
- // Overwrite existing elements.
- m["a"] = 44;
- EXPECT_EQ(44, m["a"]);
-}
-
-// operator[](Key&&)
-TEST(FlatMap, SubscriptMoveOnlyKey) {
- base::flat_map<MoveOnlyInt, int> m;
-
- // Default construct elements that don't exist yet.
- int& s = m[MoveOnlyInt(1)];
- EXPECT_EQ(0, s);
- EXPECT_EQ(1u, m.size());
-
- // The returned mapped reference should refer into the map.
- s = 22;
- EXPECT_EQ(22, m[MoveOnlyInt(1)]);
-
- // Overwrite existing elements.
- m[MoveOnlyInt(1)] = 44;
- EXPECT_EQ(44, m[MoveOnlyInt(1)]);
-}
-
-// insert_or_assign(K&&, M&&)
-TEST(FlatMap, InsertOrAssignMoveOnlyKey) {
- base::flat_map<MoveOnlyInt, MoveOnlyInt> m;
-
- // Initial insertion should return an iterator to the element and set the
- // second pair member to |true|. The inserted key and value should be moved
- // from.
- MoveOnlyInt key(1);
- MoveOnlyInt val(22);
- auto result = m.insert_or_assign(std::move(key), std::move(val));
- EXPECT_EQ(1, result.first->first.data());
- EXPECT_EQ(22, result.first->second.data());
- EXPECT_TRUE(result.second);
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(0, key.data()); // moved from
- EXPECT_EQ(0, val.data()); // moved from
-
- // Second call with same key should result in an assignment, overwriting the
- // old value. Assignment should be indicated by setting the second pair member
- // to |false|. Only the inserted value should be moved from, the key should be
- // left intact.
- key = MoveOnlyInt(1);
- val = MoveOnlyInt(44);
- result = m.insert_or_assign(std::move(key), std::move(val));
- EXPECT_EQ(1, result.first->first.data());
- EXPECT_EQ(44, result.first->second.data());
- EXPECT_FALSE(result.second);
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(1, key.data()); // not moved from
- EXPECT_EQ(0, val.data()); // moved from
-
- // Check that random insertion results in sorted range.
- base::flat_map<MoveOnlyInt, int> map;
- for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) {
- map.insert_or_assign(MoveOnlyInt(i), i);
- EXPECT_TRUE(std::is_sorted(map.begin(), map.end()));
- }
-}
-
-// insert_or_assign(const_iterator hint, K&&, M&&)
-TEST(FlatMap, InsertOrAssignMoveOnlyKeyWithHint) {
- base::flat_map<MoveOnlyInt, MoveOnlyInt> m;
-
- // Initial insertion should return an iterator to the element. The inserted
- // key and value should be moved from.
- MoveOnlyInt key(1);
- MoveOnlyInt val(22);
- auto result = m.insert_or_assign(m.end(), std::move(key), std::move(val));
- EXPECT_EQ(1, result->first.data());
- EXPECT_EQ(22, result->second.data());
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(0, key.data()); // moved from
- EXPECT_EQ(0, val.data()); // moved from
-
- // Second call with same key should result in an assignment, overwriting the
- // old value. Only the inserted value should be moved from, the key should be
- // left intact.
- key = MoveOnlyInt(1);
- val = MoveOnlyInt(44);
- result = m.insert_or_assign(m.end(), std::move(key), std::move(val));
- EXPECT_EQ(1, result->first.data());
- EXPECT_EQ(44, result->second.data());
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(1, key.data()); // not moved from
- EXPECT_EQ(0, val.data()); // moved from
-
- // Check that random insertion results in sorted range.
- base::flat_map<MoveOnlyInt, int> map;
- for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) {
- map.insert_or_assign(map.end(), MoveOnlyInt(i), i);
- EXPECT_TRUE(std::is_sorted(map.begin(), map.end()));
- }
-}
-
-// try_emplace(K&&, Args&&...)
-TEST(FlatMap, TryEmplaceMoveOnlyKey) {
- base::flat_map<MoveOnlyInt, std::pair<MoveOnlyInt, MoveOnlyInt>> m;
-
- // Trying to emplace into an empty map should succeed. Insertion should return
- // an iterator to the element and set the second pair member to |true|. The
- // inserted key and value should be moved from.
- MoveOnlyInt key(1);
- MoveOnlyInt val1(22);
- MoveOnlyInt val2(44);
- // Test piecewise construction of mapped_type.
- auto result = m.try_emplace(std::move(key), std::move(val1), std::move(val2));
- EXPECT_EQ(1, result.first->first.data());
- EXPECT_EQ(22, result.first->second.first.data());
- EXPECT_EQ(44, result.first->second.second.data());
- EXPECT_TRUE(result.second);
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(0, key.data()); // moved from
- EXPECT_EQ(0, val1.data()); // moved from
- EXPECT_EQ(0, val2.data()); // moved from
-
- // Second call with same key should result in a no-op, returning an iterator
- // to the existing element and returning false as the second pair member.
- // Key and values that were attempted to be inserted should be left intact.
- key = MoveOnlyInt(1);
- auto paired_val = std::make_pair(MoveOnlyInt(33), MoveOnlyInt(55));
- // Test construction of mapped_type from pair.
- result = m.try_emplace(std::move(key), std::move(paired_val));
- EXPECT_EQ(1, result.first->first.data());
- EXPECT_EQ(22, result.first->second.first.data());
- EXPECT_EQ(44, result.first->second.second.data());
- EXPECT_FALSE(result.second);
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(1, key.data()); // not moved from
- EXPECT_EQ(33, paired_val.first.data()); // not moved from
- EXPECT_EQ(55, paired_val.second.data()); // not moved from
-
- // Check that random insertion results in sorted range.
- base::flat_map<MoveOnlyInt, int> map;
- for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) {
- map.try_emplace(MoveOnlyInt(i), i);
- EXPECT_TRUE(std::is_sorted(map.begin(), map.end()));
- }
-}
-
-// try_emplace(const_iterator hint, K&&, Args&&...)
-TEST(FlatMap, TryEmplaceMoveOnlyKeyWithHint) {
- base::flat_map<MoveOnlyInt, std::pair<MoveOnlyInt, MoveOnlyInt>> m;
-
- // Trying to emplace into an empty map should succeed. Insertion should return
- // an iterator to the element. The inserted key and value should be moved
- // from.
- MoveOnlyInt key(1);
- MoveOnlyInt val1(22);
- MoveOnlyInt val2(44);
- // Test piecewise construction of mapped_type.
- auto result =
- m.try_emplace(m.end(), std::move(key), std::move(val1), std::move(val2));
- EXPECT_EQ(1, result->first.data());
- EXPECT_EQ(22, result->second.first.data());
- EXPECT_EQ(44, result->second.second.data());
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(0, key.data()); // moved from
- EXPECT_EQ(0, val1.data()); // moved from
- EXPECT_EQ(0, val2.data()); // moved from
-
- // Second call with same key should result in a no-op, returning an iterator
- // to the existing element. Key and values that were attempted to be inserted
- // should be left intact.
- key = MoveOnlyInt(1);
- val1 = MoveOnlyInt(33);
- val2 = MoveOnlyInt(55);
- auto paired_val = std::make_pair(MoveOnlyInt(33), MoveOnlyInt(55));
- // Test construction of mapped_type from pair.
- result = m.try_emplace(m.end(), std::move(key), std::move(paired_val));
- EXPECT_EQ(1, result->first.data());
- EXPECT_EQ(22, result->second.first.data());
- EXPECT_EQ(44, result->second.second.data());
- EXPECT_EQ(1u, m.size());
- EXPECT_EQ(1, key.data()); // not moved from
- EXPECT_EQ(33, paired_val.first.data()); // not moved from
- EXPECT_EQ(55, paired_val.second.data()); // not moved from
-
- // Check that random insertion results in sorted range.
- base::flat_map<MoveOnlyInt, int> map;
- for (int i : {3, 1, 5, 6, 8, 7, 0, 9, 4, 2}) {
- map.try_emplace(map.end(), MoveOnlyInt(i), i);
- EXPECT_TRUE(std::is_sorted(map.begin(), map.end()));
- }
-}
-
-TEST(FlatMap, UsingTransparentCompare) {
- using ExplicitInt = base::MoveOnlyInt;
- base::flat_map<ExplicitInt, int> m;
- const auto& m1 = m;
- int x = 0;
-
- // Check if we can use lookup functions without converting to key_type.
- // Correctness is checked in flat_tree tests.
- m.count(x);
- m1.count(x);
- m.find(x);
- m1.find(x);
- m.equal_range(x);
- m1.equal_range(x);
- m.lower_bound(x);
- m1.lower_bound(x);
- m.upper_bound(x);
- m1.upper_bound(x);
- m.erase(x);
-
- // Check if we broke overload resolution.
- m.emplace(ExplicitInt(0), 0);
- m.emplace(ExplicitInt(1), 0);
- m.erase(m.begin());
- m.erase(m.cbegin());
-}
-
-} // namespace base
diff --git a/base/containers/flat_set_unittest.cc b/base/containers/flat_set_unittest.cc
deleted file mode 100644
index 4596975..0000000
--- a/base/containers/flat_set_unittest.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2017 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 "base/containers/flat_set.h"
-
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/test/move_only_int.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// A flat_set is basically a interface to flat_tree. So several basic
-// operations are tested to make sure things are set up properly, but the bulk
-// of the tests are in flat_tree_unittests.cc.
-
-using ::testing::ElementsAre;
-
-namespace base {
-
-TEST(FlatSet, IncompleteType) {
- struct A {
- using Set = flat_set<A>;
- int data;
- Set set_with_incomplete_type;
- Set::iterator it;
- Set::const_iterator cit;
-
- // We do not declare operator< because clang complains that it's unused.
- };
-
- A a;
-}
-
-TEST(FlatSet, RangeConstructor) {
- flat_set<int>::value_type input_vals[] = {1, 1, 1, 2, 2, 2, 3, 3, 3};
-
- flat_set<int> cont(std::begin(input_vals), std::end(input_vals),
- base::KEEP_FIRST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(1, 2, 3));
-}
-
-TEST(FlatSet, MoveConstructor) {
- int input_range[] = {1, 2, 3, 4};
-
- flat_set<MoveOnlyInt> original(std::begin(input_range), std::end(input_range),
- base::KEEP_FIRST_OF_DUPES);
- flat_set<MoveOnlyInt> moved(std::move(original));
-
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(1)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(2)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(3)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(4)));
-}
-
-TEST(FlatSet, InitializerListConstructor) {
- flat_set<int> cont({1, 2, 3, 4, 5, 6, 10, 8}, KEEP_FIRST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 8, 10));
-}
-
-TEST(FlatSet, InsertFindSize) {
- base::flat_set<int> s;
- s.insert(1);
- s.insert(1);
- s.insert(2);
-
- EXPECT_EQ(2u, s.size());
- EXPECT_EQ(1, *s.find(1));
- EXPECT_EQ(2, *s.find(2));
- EXPECT_EQ(s.end(), s.find(7));
-}
-
-TEST(FlatSet, CopySwap) {
- base::flat_set<int> original;
- original.insert(1);
- original.insert(2);
- EXPECT_THAT(original, ElementsAre(1, 2));
-
- base::flat_set<int> copy(original);
- EXPECT_THAT(copy, ElementsAre(1, 2));
-
- copy.erase(copy.begin());
- copy.insert(10);
- EXPECT_THAT(copy, ElementsAre(2, 10));
-
- original.swap(copy);
- EXPECT_THAT(original, ElementsAre(2, 10));
- EXPECT_THAT(copy, ElementsAre(1, 2));
-}
-
-TEST(FlatSet, UsingTransparentCompare) {
- using ExplicitInt = base::MoveOnlyInt;
- base::flat_set<ExplicitInt> s;
- const auto& s1 = s;
- int x = 0;
-
- // Check if we can use lookup functions without converting to key_type.
- // Correctness is checked in flat_tree tests.
- s.count(x);
- s1.count(x);
- s.find(x);
- s1.find(x);
- s.equal_range(x);
- s1.equal_range(x);
- s.lower_bound(x);
- s1.lower_bound(x);
- s.upper_bound(x);
- s1.upper_bound(x);
- s.erase(x);
-
- // Check if we broke overload resolution.
- s.emplace(0);
- s.emplace(1);
- s.erase(s.begin());
- s.erase(s.cbegin());
-}
-
-} // namespace base
diff --git a/base/containers/flat_tree_unittest.cc b/base/containers/flat_tree_unittest.cc
deleted file mode 100644
index 5b788d5..0000000
--- a/base/containers/flat_tree_unittest.cc
+++ /dev/null
@@ -1,1385 +0,0 @@
-// Copyright 2017 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 "base/containers/flat_tree.h"
-
-// Following tests are ported and extended tests from libcpp for std::set.
-// They can be found here:
-// https://github.com/llvm-mirror/libcxx/tree/master/test/std/containers/associative/set
-//
-// Not ported tests:
-// * No tests with PrivateConstructor and std::less<> changed to std::less<T>
-// These tests have to do with C++14 std::less<>
-// http://en.cppreference.com/w/cpp/utility/functional/less_void
-// and add support for templated versions of lookup functions.
-// Because we use same implementation, we figured that it's OK just to check
-// compilation and this is what we do in flat_set_unittest/flat_map_unittest.
-// * No tests for max_size()
-// Has to do with allocator support.
-// * No tests with DefaultOnly.
-// Standard containers allocate each element in the separate node on the heap
-// and then manipulate these nodes. Flat containers store their elements in
-// contiguous memory and move them around, type is required to be movable.
-// * No tests for N3644.
-// This proposal suggests that all default constructed iterators compare
-// equal. Currently we use std::vector iterators and they don't implement
-// this.
-// * No tests with min_allocator and no tests counting allocations.
-// Flat sets currently don't support allocators.
-
-#include <forward_list>
-#include <functional>
-#include <iterator>
-#include <list>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/template_util.h"
-#include "base/test/move_only_int.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-template <class It>
-class InputIterator {
- public:
- using iterator_category = std::input_iterator_tag;
- using value_type = typename std::iterator_traits<It>::value_type;
- using difference_type = typename std::iterator_traits<It>::difference_type;
- using pointer = It;
- using reference = typename std::iterator_traits<It>::reference;
-
- InputIterator() : it_() {}
- explicit InputIterator(It it) : it_(it) {}
-
- reference operator*() const { return *it_; }
- pointer operator->() const { return it_; }
-
- InputIterator& operator++() {
- ++it_;
- return *this;
- }
- InputIterator operator++(int) {
- InputIterator tmp(*this);
- ++(*this);
- return tmp;
- }
-
- friend bool operator==(const InputIterator& lhs, const InputIterator& rhs) {
- return lhs.it_ == rhs.it_;
- }
- friend bool operator!=(const InputIterator& lhs, const InputIterator& rhs) {
- return !(lhs == rhs);
- }
-
- private:
- It it_;
-};
-
-template <typename It>
-InputIterator<It> MakeInputIterator(It it) {
- return InputIterator<It>(it);
-}
-
-class Emplaceable {
- public:
- Emplaceable() : Emplaceable(0, 0.0) {}
- Emplaceable(int i, double d) : int_(i), double_(d) {}
- Emplaceable(Emplaceable&& other) : int_(other.int_), double_(other.double_) {
- other.int_ = 0;
- other.double_ = 0.0;
- }
-
- Emplaceable& operator=(Emplaceable&& other) {
- int_ = other.int_;
- other.int_ = 0;
- double_ = other.double_;
- other.double_ = 0.0;
- return *this;
- }
-
- friend bool operator==(const Emplaceable& lhs, const Emplaceable& rhs) {
- return std::tie(lhs.int_, lhs.double_) == std::tie(rhs.int_, rhs.double_);
- }
-
- friend bool operator<(const Emplaceable& lhs, const Emplaceable& rhs) {
- return std::tie(lhs.int_, lhs.double_) < std::tie(rhs.int_, rhs.double_);
- }
-
- private:
- int int_;
- double double_;
-
- DISALLOW_COPY_AND_ASSIGN(Emplaceable);
-};
-
-struct TemplateConstructor {
- template <typename T>
- TemplateConstructor(const T&) {}
-
- friend bool operator<(const TemplateConstructor&,
- const TemplateConstructor&) {
- return false;
- }
-};
-
-class NonDefaultConstructibleCompare {
- public:
- explicit NonDefaultConstructibleCompare(int) {}
-
- template <typename T>
- bool operator()(const T& lhs, const T& rhs) const {
- return std::less<T>()(lhs, rhs);
- }
-};
-
-template <class PairType>
-struct LessByFirst {
- bool operator()(const PairType& lhs, const PairType& rhs) const {
- return lhs.first < rhs.first;
- }
-};
-
-// Common test trees.
-using IntTree =
- flat_tree<int, int, GetKeyFromValueIdentity<int>, std::less<int>>;
-using IntPair = std::pair<int, int>;
-using IntPairTree = flat_tree<IntPair,
- IntPair,
- GetKeyFromValueIdentity<IntPair>,
- LessByFirst<IntPair>>;
-using MoveOnlyTree = flat_tree<MoveOnlyInt,
- MoveOnlyInt,
- GetKeyFromValueIdentity<MoveOnlyInt>,
- std::less<MoveOnlyInt>>;
-using EmplaceableTree = flat_tree<Emplaceable,
- Emplaceable,
- GetKeyFromValueIdentity<Emplaceable>,
- std::less<Emplaceable>>;
-using ReversedTree =
- flat_tree<int, int, GetKeyFromValueIdentity<int>, std::greater<int>>;
-
-using TreeWithStrangeCompare = flat_tree<int,
- int,
- GetKeyFromValueIdentity<int>,
- NonDefaultConstructibleCompare>;
-
-using ::testing::ElementsAre;
-
-} // namespace
-
-TEST(FlatTree, IsMultipass) {
- static_assert(!is_multipass<std::istream_iterator<int>>(),
- "InputIterator is not multipass");
- static_assert(!is_multipass<std::ostream_iterator<int>>(),
- "OutputIterator is not multipass");
-
- static_assert(is_multipass<std::forward_list<int>::iterator>(),
- "ForwardIterator is multipass");
- static_assert(is_multipass<std::list<int>::iterator>(),
- "BidirectionalIterator is multipass");
- static_assert(is_multipass<std::vector<int>::iterator>(),
- "RandomAccessIterator is multipass");
-}
-
-TEST(FlatTree, LastUnique) {
- using Pair = std::pair<int, int>;
- using Vect = std::vector<Pair>;
-
- auto cmp = [](const Pair& lhs, const Pair& rhs) {
- return lhs.first == rhs.first;
- };
-
- // Empty case.
- Vect empty;
- EXPECT_EQ(empty.end(), LastUnique(empty.begin(), empty.end(), cmp));
-
- // Single element.
- Vect one;
- one.push_back(Pair(1, 1));
- EXPECT_EQ(one.end(), LastUnique(one.begin(), one.end(), cmp));
- ASSERT_EQ(1u, one.size());
- EXPECT_THAT(one, ElementsAre(Pair(1, 1)));
-
- // Two elements, already unique.
- Vect two_u;
- two_u.push_back(Pair(1, 1));
- two_u.push_back(Pair(2, 2));
- EXPECT_EQ(two_u.end(), LastUnique(two_u.begin(), two_u.end(), cmp));
- EXPECT_THAT(two_u, ElementsAre(Pair(1, 1), Pair(2, 2)));
-
- // Two elements, dupes.
- Vect two_d;
- two_d.push_back(Pair(1, 1));
- two_d.push_back(Pair(1, 2));
- auto last = LastUnique(two_d.begin(), two_d.end(), cmp);
- EXPECT_EQ(two_d.begin() + 1, last);
- two_d.erase(last, two_d.end());
- EXPECT_THAT(two_d, ElementsAre(Pair(1, 2)));
-
- // Non-dupes, dupes, non-dupes.
- Vect ndn;
- ndn.push_back(Pair(1, 1));
- ndn.push_back(Pair(2, 1));
- ndn.push_back(Pair(2, 2));
- ndn.push_back(Pair(2, 3));
- ndn.push_back(Pair(3, 1));
- last = LastUnique(ndn.begin(), ndn.end(), cmp);
- EXPECT_EQ(ndn.begin() + 3, last);
- ndn.erase(last, ndn.end());
- EXPECT_THAT(ndn, ElementsAre(Pair(1, 1), Pair(2, 3), Pair(3, 1)));
-
- // Dupes, non-dupes, dupes.
- Vect dnd;
- dnd.push_back(Pair(1, 1));
- dnd.push_back(Pair(1, 2));
- dnd.push_back(Pair(1, 3));
- dnd.push_back(Pair(2, 1));
- dnd.push_back(Pair(3, 1));
- dnd.push_back(Pair(3, 2));
- dnd.push_back(Pair(3, 3));
- last = LastUnique(dnd.begin(), dnd.end(), cmp);
- EXPECT_EQ(dnd.begin() + 3, last);
- dnd.erase(last, dnd.end());
- EXPECT_THAT(dnd, ElementsAre(Pair(1, 3), Pair(2, 1), Pair(3, 3)));
-}
-
-// ----------------------------------------------------------------------------
-// Class.
-
-// Check that flat_tree and its iterators can be instantiated with an
-// incomplete type.
-
-TEST(FlatTree, IncompleteType) {
- struct A {
- using Tree = flat_tree<A, A, GetKeyFromValueIdentity<A>, std::less<A>>;
- int data;
- Tree set_with_incomplete_type;
- Tree::iterator it;
- Tree::const_iterator cit;
-
- // We do not declare operator< because clang complains that it's unused.
- };
-
- A a;
-}
-
-TEST(FlatTree, Stability) {
- using Pair = std::pair<int, int>;
-
- using Tree =
- flat_tree<Pair, Pair, GetKeyFromValueIdentity<Pair>, LessByFirst<Pair>>;
-
- // Constructors are stable.
- Tree cont({{0, 0}, {1, 0}, {0, 1}, {2, 0}, {0, 2}, {1, 1}});
-
- auto AllOfSecondsAreZero = [&cont] {
- return std::all_of(cont.begin(), cont.end(),
- [](const Pair& elem) { return elem.second == 0; });
- };
-
- EXPECT_TRUE(AllOfSecondsAreZero()) << "constructor should be stable";
-
- // Should not replace existing.
- cont.insert(Pair(0, 2));
- cont.insert(Pair(1, 2));
- cont.insert(Pair(2, 2));
-
- EXPECT_TRUE(AllOfSecondsAreZero()) << "insert should be stable";
-
- cont.insert(Pair(3, 0));
- cont.insert(Pair(3, 2));
-
- EXPECT_TRUE(AllOfSecondsAreZero()) << "insert should be stable";
-}
-
-// ----------------------------------------------------------------------------
-// Types.
-
-// key_type
-// key_compare
-// value_type
-// value_compare
-// pointer
-// const_pointer
-// reference
-// const_reference
-// size_type
-// difference_type
-// iterator
-// const_iterator
-// reverse_iterator
-// const_reverse_iterator
-
-TEST(FlatTree, Types) {
- // These are guaranteed to be portable.
- static_assert((std::is_same<int, IntTree::key_type>::value), "");
- static_assert((std::is_same<int, IntTree::value_type>::value), "");
- static_assert((std::is_same<std::less<int>, IntTree::key_compare>::value),
- "");
- static_assert((std::is_same<int&, IntTree::reference>::value), "");
- static_assert((std::is_same<const int&, IntTree::const_reference>::value),
- "");
- static_assert((std::is_same<int*, IntTree::pointer>::value), "");
- static_assert((std::is_same<const int*, IntTree::const_pointer>::value), "");
-}
-
-// ----------------------------------------------------------------------------
-// Lifetime.
-
-// flat_tree()
-// flat_tree(const Compare& comp)
-
-TEST(FlatTree, DefaultConstructor) {
- {
- IntTree cont;
- EXPECT_THAT(cont, ElementsAre());
- }
-
- {
- TreeWithStrangeCompare cont(NonDefaultConstructibleCompare(0));
- EXPECT_THAT(cont, ElementsAre());
- }
-}
-
-// flat_tree(InputIterator first,
-// InputIterator last,
-// FlatContainerDupes dupe_handling,
-// const Compare& comp = Compare())
-
-TEST(FlatTree, RangeConstructor) {
- {
- IntPair input_vals[] = {{1, 1}, {1, 2}, {2, 1}, {2, 2}, {1, 3},
- {2, 3}, {3, 1}, {3, 2}, {3, 3}};
-
- IntPairTree first_of(MakeInputIterator(std::begin(input_vals)),
- MakeInputIterator(std::end(input_vals)));
- EXPECT_THAT(first_of,
- ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1)));
-
- IntPairTree last_of(MakeInputIterator(std::begin(input_vals)),
- MakeInputIterator(std::end(input_vals)),
- KEEP_LAST_OF_DUPES);
- EXPECT_THAT(last_of,
- ElementsAre(IntPair(1, 3), IntPair(2, 3), IntPair(3, 3)));
- }
- {
- TreeWithStrangeCompare::value_type input_vals[] = {1, 1, 1, 2, 2,
- 2, 3, 3, 3};
-
- TreeWithStrangeCompare cont(MakeInputIterator(std::begin(input_vals)),
- MakeInputIterator(std::end(input_vals)),
- KEEP_FIRST_OF_DUPES,
- NonDefaultConstructibleCompare(0));
- EXPECT_THAT(cont, ElementsAre(1, 2, 3));
- }
-}
-
-// flat_tree(const flat_tree& x)
-
-TEST(FlatTree, CopyConstructor) {
- IntTree original({1, 2, 3, 4});
- IntTree copied(original);
-
- EXPECT_THAT(copied, ElementsAre(1, 2, 3, 4));
-
- EXPECT_THAT(copied, ElementsAre(1, 2, 3, 4));
- EXPECT_THAT(original, ElementsAre(1, 2, 3, 4));
- EXPECT_EQ(original, copied);
-}
-
-// flat_tree(flat_tree&& x)
-
-TEST(FlatTree, MoveConstructor) {
- int input_range[] = {1, 2, 3, 4};
-
- MoveOnlyTree original(std::begin(input_range), std::end(input_range));
- MoveOnlyTree moved(std::move(original));
-
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(1)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(2)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(3)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(4)));
-}
-
-// flat_tree(std::vector<value_type>, FlatContainerDupes dupe_handling)
-
-TEST(FlatTree, VectorConstructor) {
- using Pair = std::pair<int, MoveOnlyInt>;
-
- // Construct an unsorted vector with a duplicate item in it. Sorted by the
- // first item, the second allows us to test for stability. Using a move
- // only type to ensure the vector is not copied.
- std::vector<Pair> storage;
- storage.push_back(Pair(2, MoveOnlyInt(0)));
- storage.push_back(Pair(1, MoveOnlyInt(0)));
- storage.push_back(Pair(2, MoveOnlyInt(1)));
-
- using Tree =
- flat_tree<Pair, Pair, GetKeyFromValueIdentity<Pair>, LessByFirst<Pair>>;
- Tree tree(std::move(storage));
-
- // The list should be two items long, with only the first "2" saved.
- ASSERT_EQ(2u, tree.size());
- const Pair& zeroth = *tree.begin();
- ASSERT_EQ(1, zeroth.first);
- ASSERT_EQ(0, zeroth.second.data());
-
- const Pair& first = *(tree.begin() + 1);
- ASSERT_EQ(2, first.first);
- ASSERT_EQ(0, first.second.data());
-
- // Test KEEP_LAST_OF_DUPES with a simple vector constructor.
- std::vector<IntPair> int_storage{{1, 1}, {1, 2}, {2, 1}};
- IntPairTree int_tree(std::move(int_storage), KEEP_LAST_OF_DUPES);
- EXPECT_THAT(int_tree, ElementsAre(IntPair(1, 2), IntPair(2, 1)));
-}
-
-// flat_tree(std::initializer_list<value_type> ilist,
-// FlatContainerDupes dupe_handling,
-// const Compare& comp = Compare())
-
-TEST(FlatTree, InitializerListConstructor) {
- {
- IntTree cont({1, 2, 3, 4, 5, 6, 10, 8});
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 8, 10));
- }
- {
- IntTree cont({1, 2, 3, 4, 5, 6, 10, 8});
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 8, 10));
- }
- {
- TreeWithStrangeCompare cont({1, 2, 3, 4, 5, 6, 10, 8}, KEEP_FIRST_OF_DUPES,
- NonDefaultConstructibleCompare(0));
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 8, 10));
- }
- {
- IntPairTree first_of({{1, 1}, {2, 1}, {1, 2}});
- EXPECT_THAT(first_of, ElementsAre(IntPair(1, 1), IntPair(2, 1)));
- }
- {
- IntPairTree last_of({{1, 1}, {2, 1}, {1, 2}}, KEEP_LAST_OF_DUPES);
- EXPECT_THAT(last_of, ElementsAre(IntPair(1, 2), IntPair(2, 1)));
- }
-}
-
-// ----------------------------------------------------------------------------
-// Assignments.
-
-// flat_tree& operator=(const flat_tree&)
-
-TEST(FlatTree, CopyAssignable) {
- IntTree original({1, 2, 3, 4});
- IntTree copied;
- copied = original;
-
- EXPECT_THAT(copied, ElementsAre(1, 2, 3, 4));
- EXPECT_THAT(original, ElementsAre(1, 2, 3, 4));
- EXPECT_EQ(original, copied);
-}
-
-// flat_tree& operator=(flat_tree&&)
-
-TEST(FlatTree, MoveAssignable) {
- int input_range[] = {1, 2, 3, 4};
-
- MoveOnlyTree original(std::begin(input_range), std::end(input_range));
- MoveOnlyTree moved;
- moved = std::move(original);
-
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(1)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(2)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(3)));
- EXPECT_EQ(1U, moved.count(MoveOnlyInt(4)));
-}
-
-// flat_tree& operator=(std::initializer_list<value_type> ilist)
-
-TEST(FlatTree, InitializerListAssignable) {
- IntTree cont({0});
- cont = {1, 2, 3, 4, 5, 6, 10, 8};
-
- EXPECT_EQ(0U, cont.count(0));
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 8, 10));
-}
-
-// --------------------------------------------------------------------------
-// Memory management.
-
-// void reserve(size_type new_capacity)
-
-TEST(FlatTree, Reserve) {
- IntTree cont({1, 2, 3});
-
- cont.reserve(5);
- EXPECT_LE(5U, cont.capacity());
-}
-
-// size_type capacity() const
-
-TEST(FlatTree, Capacity) {
- IntTree cont({1, 2, 3});
-
- EXPECT_LE(cont.size(), cont.capacity());
- cont.reserve(5);
- EXPECT_LE(cont.size(), cont.capacity());
-}
-
-// void shrink_to_fit()
-
-TEST(FlatTree, ShrinkToFit) {
- IntTree cont({1, 2, 3});
-
- IntTree::size_type capacity_before = cont.capacity();
- cont.shrink_to_fit();
- EXPECT_GE(capacity_before, cont.capacity());
-}
-
-// ----------------------------------------------------------------------------
-// Size management.
-
-// void clear()
-
-TEST(FlatTree, Clear) {
- IntTree cont({1, 2, 3, 4, 5, 6, 7, 8});
- cont.clear();
- EXPECT_THAT(cont, ElementsAre());
-}
-
-// size_type size() const
-
-TEST(FlatTree, Size) {
- IntTree cont;
-
- EXPECT_EQ(0U, cont.size());
- cont.insert(2);
- EXPECT_EQ(1U, cont.size());
- cont.insert(1);
- EXPECT_EQ(2U, cont.size());
- cont.insert(3);
- EXPECT_EQ(3U, cont.size());
- cont.erase(cont.begin());
- EXPECT_EQ(2U, cont.size());
- cont.erase(cont.begin());
- EXPECT_EQ(1U, cont.size());
- cont.erase(cont.begin());
- EXPECT_EQ(0U, cont.size());
-}
-
-// bool empty() const
-
-TEST(FlatTree, Empty) {
- IntTree cont;
-
- EXPECT_TRUE(cont.empty());
- cont.insert(1);
- EXPECT_FALSE(cont.empty());
- cont.clear();
- EXPECT_TRUE(cont.empty());
-}
-
-// ----------------------------------------------------------------------------
-// Iterators.
-
-// iterator begin()
-// const_iterator begin() const
-// iterator end()
-// const_iterator end() const
-//
-// reverse_iterator rbegin()
-// const_reverse_iterator rbegin() const
-// reverse_iterator rend()
-// const_reverse_iterator rend() const
-//
-// const_iterator cbegin() const
-// const_iterator cend() const
-// const_reverse_iterator crbegin() const
-// const_reverse_iterator crend() const
-
-TEST(FlatTree, Iterators) {
- IntTree cont({1, 2, 3, 4, 5, 6, 7, 8});
-
- auto size = static_cast<IntTree::difference_type>(cont.size());
-
- EXPECT_EQ(size, std::distance(cont.begin(), cont.end()));
- EXPECT_EQ(size, std::distance(cont.cbegin(), cont.cend()));
- EXPECT_EQ(size, std::distance(cont.rbegin(), cont.rend()));
- EXPECT_EQ(size, std::distance(cont.crbegin(), cont.crend()));
-
- {
- IntTree::iterator it = cont.begin();
- IntTree::const_iterator c_it = cont.cbegin();
- EXPECT_EQ(it, c_it);
- for (int j = 1; it != cont.end(); ++it, ++c_it, ++j) {
- EXPECT_EQ(j, *it);
- EXPECT_EQ(j, *c_it);
- }
- }
- {
- IntTree::reverse_iterator rit = cont.rbegin();
- IntTree::const_reverse_iterator c_rit = cont.crbegin();
- EXPECT_EQ(rit, c_rit);
- for (int j = static_cast<int>(size); rit != cont.rend();
- ++rit, ++c_rit, --j) {
- EXPECT_EQ(j, *rit);
- EXPECT_EQ(j, *c_rit);
- }
- }
-}
-
-// ----------------------------------------------------------------------------
-// Insert operations.
-
-// pair<iterator, bool> insert(const value_type& val)
-
-TEST(FlatTree, InsertLValue) {
- IntTree cont;
-
- int value = 2;
- std::pair<IntTree::iterator, bool> result = cont.insert(value);
- EXPECT_TRUE(result.second);
- EXPECT_EQ(cont.begin(), result.first);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(2, *result.first);
-
- value = 1;
- result = cont.insert(value);
- EXPECT_TRUE(result.second);
- EXPECT_EQ(cont.begin(), result.first);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(1, *result.first);
-
- value = 3;
- result = cont.insert(value);
- EXPECT_TRUE(result.second);
- EXPECT_EQ(std::prev(cont.end()), result.first);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, *result.first);
-
- value = 3;
- result = cont.insert(value);
- EXPECT_FALSE(result.second);
- EXPECT_EQ(std::prev(cont.end()), result.first);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, *result.first);
-}
-
-// pair<iterator, bool> insert(value_type&& val)
-
-TEST(FlatTree, InsertRValue) {
- MoveOnlyTree cont;
-
- std::pair<MoveOnlyTree::iterator, bool> result = cont.insert(MoveOnlyInt(2));
- EXPECT_TRUE(result.second);
- EXPECT_EQ(cont.begin(), result.first);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(2, result.first->data());
-
- result = cont.insert(MoveOnlyInt(1));
- EXPECT_TRUE(result.second);
- EXPECT_EQ(cont.begin(), result.first);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(1, result.first->data());
-
- result = cont.insert(MoveOnlyInt(3));
- EXPECT_TRUE(result.second);
- EXPECT_EQ(std::prev(cont.end()), result.first);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, result.first->data());
-
- result = cont.insert(MoveOnlyInt(3));
- EXPECT_FALSE(result.second);
- EXPECT_EQ(std::prev(cont.end()), result.first);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, result.first->data());
-}
-
-// iterator insert(const_iterator position_hint, const value_type& val)
-
-TEST(FlatTree, InsertPositionLValue) {
- IntTree cont;
-
- IntTree::iterator result = cont.insert(cont.cend(), 2);
- EXPECT_EQ(cont.begin(), result);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(2, *result);
-
- result = cont.insert(cont.cend(), 1);
- EXPECT_EQ(cont.begin(), result);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(1, *result);
-
- result = cont.insert(cont.cend(), 3);
- EXPECT_EQ(std::prev(cont.end()), result);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, *result);
-
- result = cont.insert(cont.cend(), 3);
- EXPECT_EQ(std::prev(cont.end()), result);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, *result);
-}
-
-// iterator insert(const_iterator position_hint, value_type&& val)
-
-TEST(FlatTree, InsertPositionRValue) {
- MoveOnlyTree cont;
-
- MoveOnlyTree::iterator result = cont.insert(cont.cend(), MoveOnlyInt(2));
- EXPECT_EQ(cont.begin(), result);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(2, result->data());
-
- result = cont.insert(cont.cend(), MoveOnlyInt(1));
- EXPECT_EQ(cont.begin(), result);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(1, result->data());
-
- result = cont.insert(cont.cend(), MoveOnlyInt(3));
- EXPECT_EQ(std::prev(cont.end()), result);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, result->data());
-
- result = cont.insert(cont.cend(), MoveOnlyInt(3));
- EXPECT_EQ(std::prev(cont.end()), result);
- EXPECT_EQ(3U, cont.size());
- EXPECT_EQ(3, result->data());
-}
-
-// template <class InputIterator>
-// void insert(InputIterator first, InputIterator last);
-
-TEST(FlatTree, InsertIterIter) {
- struct GetKeyFromIntIntPair {
- const int& operator()(const std::pair<int, int>& p) const {
- return p.first;
- }
- };
-
- using IntIntMap =
- flat_tree<int, IntPair, GetKeyFromIntIntPair, std::less<int>>;
-
- {
- IntIntMap cont;
- IntPair int_pairs[] = {{3, 1}, {1, 1}, {4, 1}, {2, 1}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs));
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- std::vector<IntPair> int_pairs;
- cont.insert(std::begin(int_pairs), std::end(int_pairs));
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{1, 1}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs));
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{1, 2}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs), KEEP_LAST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 2), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{5, 1}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs));
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1), IntPair(5, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{5, 1}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs), KEEP_LAST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1), IntPair(5, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{3, 2}, {1, 2}, {4, 2}, {2, 2}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs));
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{3, 2}, {1, 2}, {4, 2}, {2, 2}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs), KEEP_LAST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 2), IntPair(2, 2), IntPair(3, 2),
- IntPair(4, 2)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{3, 2}, {1, 2}, {4, 2}, {2, 2}, {7, 2}, {6, 2},
- {8, 2}, {5, 2}, {5, 3}, {6, 3}, {7, 3}, {8, 3}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs));
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 1), IntPair(2, 1), IntPair(3, 1),
- IntPair(4, 1), IntPair(5, 2), IntPair(6, 2),
- IntPair(7, 2), IntPair(8, 2)));
- }
-
- {
- IntIntMap cont({{1, 1}, {2, 1}, {3, 1}, {4, 1}});
- IntPair int_pairs[] = {{3, 2}, {1, 2}, {4, 2}, {2, 2}, {7, 2}, {6, 2},
- {8, 2}, {5, 2}, {5, 3}, {6, 3}, {7, 3}, {8, 3}};
- cont.insert(std::begin(int_pairs), std::end(int_pairs), KEEP_LAST_OF_DUPES);
- EXPECT_THAT(cont, ElementsAre(IntPair(1, 2), IntPair(2, 2), IntPair(3, 2),
- IntPair(4, 2), IntPair(5, 3), IntPair(6, 3),
- IntPair(7, 3), IntPair(8, 3)));
- }
-}
-
-// template <class... Args>
-// pair<iterator, bool> emplace(Args&&... args)
-
-TEST(FlatTree, Emplace) {
- {
- EmplaceableTree cont;
-
- std::pair<EmplaceableTree::iterator, bool> result = cont.emplace();
- EXPECT_TRUE(result.second);
- EXPECT_EQ(cont.begin(), result.first);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(Emplaceable(), *cont.begin());
-
- result = cont.emplace(2, 3.5);
- EXPECT_TRUE(result.second);
- EXPECT_EQ(std::next(cont.begin()), result.first);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(Emplaceable(2, 3.5), *result.first);
-
- result = cont.emplace(2, 3.5);
- EXPECT_FALSE(result.second);
- EXPECT_EQ(std::next(cont.begin()), result.first);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(Emplaceable(2, 3.5), *result.first);
- }
- {
- IntTree cont;
-
- std::pair<IntTree::iterator, bool> result = cont.emplace(2);
- EXPECT_TRUE(result.second);
- EXPECT_EQ(cont.begin(), result.first);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(2, *result.first);
- }
-}
-
-// template <class... Args>
-// iterator emplace_hint(const_iterator position_hint, Args&&... args)
-
-TEST(FlatTree, EmplacePosition) {
- {
- EmplaceableTree cont;
-
- EmplaceableTree::iterator result = cont.emplace_hint(cont.cend());
- EXPECT_EQ(cont.begin(), result);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(Emplaceable(), *cont.begin());
-
- result = cont.emplace_hint(cont.cend(), 2, 3.5);
- EXPECT_EQ(std::next(cont.begin()), result);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(Emplaceable(2, 3.5), *result);
-
- result = cont.emplace_hint(cont.cbegin(), 2, 3.5);
- EXPECT_EQ(std::next(cont.begin()), result);
- EXPECT_EQ(2U, cont.size());
- EXPECT_EQ(Emplaceable(2, 3.5), *result);
- }
- {
- IntTree cont;
-
- IntTree::iterator result = cont.emplace_hint(cont.cend(), 2);
- EXPECT_EQ(cont.begin(), result);
- EXPECT_EQ(1U, cont.size());
- EXPECT_EQ(2, *result);
- }
-}
-
-// ----------------------------------------------------------------------------
-// Erase operations.
-
-// iterator erase(const_iterator position_hint)
-
-TEST(FlatTree, ErasePosition) {
- {
- IntTree cont({1, 2, 3, 4, 5, 6, 7, 8});
-
- IntTree::iterator it = cont.erase(std::next(cont.cbegin(), 3));
- EXPECT_EQ(std::next(cont.begin(), 3), it);
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 5, 6, 7, 8));
-
- it = cont.erase(std::next(cont.cbegin(), 0));
- EXPECT_EQ(cont.begin(), it);
- EXPECT_THAT(cont, ElementsAre(2, 3, 5, 6, 7, 8));
-
- it = cont.erase(std::next(cont.cbegin(), 5));
- EXPECT_EQ(cont.end(), it);
- EXPECT_THAT(cont, ElementsAre(2, 3, 5, 6, 7));
-
- it = cont.erase(std::next(cont.cbegin(), 1));
- EXPECT_EQ(std::next(cont.begin()), it);
- EXPECT_THAT(cont, ElementsAre(2, 5, 6, 7));
-
- it = cont.erase(std::next(cont.cbegin(), 2));
- EXPECT_EQ(std::next(cont.begin(), 2), it);
- EXPECT_THAT(cont, ElementsAre(2, 5, 7));
-
- it = cont.erase(std::next(cont.cbegin(), 2));
- EXPECT_EQ(std::next(cont.begin(), 2), it);
- EXPECT_THAT(cont, ElementsAre(2, 5));
-
- it = cont.erase(std::next(cont.cbegin(), 0));
- EXPECT_EQ(std::next(cont.begin(), 0), it);
- EXPECT_THAT(cont, ElementsAre(5));
-
- it = cont.erase(cont.cbegin());
- EXPECT_EQ(cont.begin(), it);
- EXPECT_EQ(cont.end(), it);
- }
- // This is LWG #2059.
- // There is a potential ambiguity between erase with an iterator and erase
- // with a key, if key has a templated constructor.
- {
- using T = TemplateConstructor;
-
- flat_tree<T, T, GetKeyFromValueIdentity<T>, std::less<>> cont;
- T v(0);
-
- auto it = cont.find(v);
- if (it != cont.end())
- cont.erase(it);
- }
-}
-
-// iterator erase(const_iterator first, const_iterator last)
-
-TEST(FlatTree, EraseRange) {
- IntTree cont({1, 2, 3, 4, 5, 6, 7, 8});
-
- IntTree::iterator it =
- cont.erase(std::next(cont.cbegin(), 5), std::next(cont.cbegin(), 5));
- EXPECT_EQ(std::next(cont.begin(), 5), it);
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 7, 8));
-
- it = cont.erase(std::next(cont.cbegin(), 3), std::next(cont.cbegin(), 4));
- EXPECT_EQ(std::next(cont.begin(), 3), it);
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 5, 6, 7, 8));
-
- it = cont.erase(std::next(cont.cbegin(), 2), std::next(cont.cbegin(), 5));
- EXPECT_EQ(std::next(cont.begin(), 2), it);
- EXPECT_THAT(cont, ElementsAre(1, 2, 7, 8));
-
- it = cont.erase(std::next(cont.cbegin(), 0), std::next(cont.cbegin(), 2));
- EXPECT_EQ(std::next(cont.begin(), 0), it);
- EXPECT_THAT(cont, ElementsAre(7, 8));
-
- it = cont.erase(cont.cbegin(), cont.cend());
- EXPECT_EQ(cont.begin(), it);
- EXPECT_EQ(cont.end(), it);
-}
-
-// size_type erase(const key_type& key)
-
-TEST(FlatTree, EraseKey) {
- IntTree cont({1, 2, 3, 4, 5, 6, 7, 8});
-
- EXPECT_EQ(0U, cont.erase(9));
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 4, 5, 6, 7, 8));
-
- EXPECT_EQ(1U, cont.erase(4));
- EXPECT_THAT(cont, ElementsAre(1, 2, 3, 5, 6, 7, 8));
-
- EXPECT_EQ(1U, cont.erase(1));
- EXPECT_THAT(cont, ElementsAre(2, 3, 5, 6, 7, 8));
-
- EXPECT_EQ(1U, cont.erase(8));
- EXPECT_THAT(cont, ElementsAre(2, 3, 5, 6, 7));
-
- EXPECT_EQ(1U, cont.erase(3));
- EXPECT_THAT(cont, ElementsAre(2, 5, 6, 7));
-
- EXPECT_EQ(1U, cont.erase(6));
- EXPECT_THAT(cont, ElementsAre(2, 5, 7));
-
- EXPECT_EQ(1U, cont.erase(7));
- EXPECT_THAT(cont, ElementsAre(2, 5));
-
- EXPECT_EQ(1U, cont.erase(2));
- EXPECT_THAT(cont, ElementsAre(5));
-
- EXPECT_EQ(1U, cont.erase(5));
- EXPECT_THAT(cont, ElementsAre());
-}
-
-// ----------------------------------------------------------------------------
-// Comparators.
-
-// key_compare key_comp() const
-
-TEST(FlatTree, KeyComp) {
- ReversedTree cont({1, 2, 3, 4, 5});
-
- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.key_comp()));
- int new_elements[] = {6, 7, 8, 9, 10};
- std::copy(std::begin(new_elements), std::end(new_elements),
- std::inserter(cont, cont.end()));
- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.key_comp()));
-}
-
-// value_compare value_comp() const
-
-TEST(FlatTree, ValueComp) {
- ReversedTree cont({1, 2, 3, 4, 5});
-
- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.value_comp()));
- int new_elements[] = {6, 7, 8, 9, 10};
- std::copy(std::begin(new_elements), std::end(new_elements),
- std::inserter(cont, cont.end()));
- EXPECT_TRUE(std::is_sorted(cont.begin(), cont.end(), cont.value_comp()));
-}
-
-// ----------------------------------------------------------------------------
-// Search operations.
-
-// size_type count(const key_type& key) const
-
-TEST(FlatTree, Count) {
- const IntTree cont({5, 6, 7, 8, 9, 10, 11, 12});
-
- EXPECT_EQ(1U, cont.count(5));
- EXPECT_EQ(1U, cont.count(6));
- EXPECT_EQ(1U, cont.count(7));
- EXPECT_EQ(1U, cont.count(8));
- EXPECT_EQ(1U, cont.count(9));
- EXPECT_EQ(1U, cont.count(10));
- EXPECT_EQ(1U, cont.count(11));
- EXPECT_EQ(1U, cont.count(12));
- EXPECT_EQ(0U, cont.count(4));
-}
-
-// iterator find(const key_type& key)
-// const_iterator find(const key_type& key) const
-
-TEST(FlatTree, Find) {
- {
- IntTree cont({5, 6, 7, 8, 9, 10, 11, 12});
-
- EXPECT_EQ(cont.begin(), cont.find(5));
- EXPECT_EQ(std::next(cont.begin()), cont.find(6));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.find(7));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.find(8));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.find(9));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.find(10));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.find(11));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.find(12));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.find(4));
- }
- {
- const IntTree cont({5, 6, 7, 8, 9, 10, 11, 12});
-
- EXPECT_EQ(cont.begin(), cont.find(5));
- EXPECT_EQ(std::next(cont.begin()), cont.find(6));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.find(7));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.find(8));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.find(9));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.find(10));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.find(11));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.find(12));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.find(4));
- }
-}
-
-// pair<iterator, iterator> equal_range(const key_type& key)
-// pair<const_iterator, const_iterator> equal_range(const key_type& key) const
-
-TEST(FlatTree, EqualRange) {
- {
- IntTree cont({5, 7, 9, 11, 13, 15, 17, 19});
-
- std::pair<IntTree::iterator, IntTree::iterator> result =
- cont.equal_range(5);
- EXPECT_EQ(std::next(cont.begin(), 0), result.first);
- EXPECT_EQ(std::next(cont.begin(), 1), result.second);
- result = cont.equal_range(7);
- EXPECT_EQ(std::next(cont.begin(), 1), result.first);
- EXPECT_EQ(std::next(cont.begin(), 2), result.second);
- result = cont.equal_range(9);
- EXPECT_EQ(std::next(cont.begin(), 2), result.first);
- EXPECT_EQ(std::next(cont.begin(), 3), result.second);
- result = cont.equal_range(11);
- EXPECT_EQ(std::next(cont.begin(), 3), result.first);
- EXPECT_EQ(std::next(cont.begin(), 4), result.second);
- result = cont.equal_range(13);
- EXPECT_EQ(std::next(cont.begin(), 4), result.first);
- EXPECT_EQ(std::next(cont.begin(), 5), result.second);
- result = cont.equal_range(15);
- EXPECT_EQ(std::next(cont.begin(), 5), result.first);
- EXPECT_EQ(std::next(cont.begin(), 6), result.second);
- result = cont.equal_range(17);
- EXPECT_EQ(std::next(cont.begin(), 6), result.first);
- EXPECT_EQ(std::next(cont.begin(), 7), result.second);
- result = cont.equal_range(19);
- EXPECT_EQ(std::next(cont.begin(), 7), result.first);
- EXPECT_EQ(std::next(cont.begin(), 8), result.second);
- result = cont.equal_range(4);
- EXPECT_EQ(std::next(cont.begin(), 0), result.first);
- EXPECT_EQ(std::next(cont.begin(), 0), result.second);
- result = cont.equal_range(6);
- EXPECT_EQ(std::next(cont.begin(), 1), result.first);
- EXPECT_EQ(std::next(cont.begin(), 1), result.second);
- result = cont.equal_range(8);
- EXPECT_EQ(std::next(cont.begin(), 2), result.first);
- EXPECT_EQ(std::next(cont.begin(), 2), result.second);
- result = cont.equal_range(10);
- EXPECT_EQ(std::next(cont.begin(), 3), result.first);
- EXPECT_EQ(std::next(cont.begin(), 3), result.second);
- result = cont.equal_range(12);
- EXPECT_EQ(std::next(cont.begin(), 4), result.first);
- EXPECT_EQ(std::next(cont.begin(), 4), result.second);
- result = cont.equal_range(14);
- EXPECT_EQ(std::next(cont.begin(), 5), result.first);
- EXPECT_EQ(std::next(cont.begin(), 5), result.second);
- result = cont.equal_range(16);
- EXPECT_EQ(std::next(cont.begin(), 6), result.first);
- EXPECT_EQ(std::next(cont.begin(), 6), result.second);
- result = cont.equal_range(18);
- EXPECT_EQ(std::next(cont.begin(), 7), result.first);
- EXPECT_EQ(std::next(cont.begin(), 7), result.second);
- result = cont.equal_range(20);
- EXPECT_EQ(std::next(cont.begin(), 8), result.first);
- EXPECT_EQ(std::next(cont.begin(), 8), result.second);
- }
- {
- const IntTree cont({5, 7, 9, 11, 13, 15, 17, 19});
-
- std::pair<IntTree::const_iterator, IntTree::const_iterator> result =
- cont.equal_range(5);
- EXPECT_EQ(std::next(cont.begin(), 0), result.first);
- EXPECT_EQ(std::next(cont.begin(), 1), result.second);
- result = cont.equal_range(7);
- EXPECT_EQ(std::next(cont.begin(), 1), result.first);
- EXPECT_EQ(std::next(cont.begin(), 2), result.second);
- result = cont.equal_range(9);
- EXPECT_EQ(std::next(cont.begin(), 2), result.first);
- EXPECT_EQ(std::next(cont.begin(), 3), result.second);
- result = cont.equal_range(11);
- EXPECT_EQ(std::next(cont.begin(), 3), result.first);
- EXPECT_EQ(std::next(cont.begin(), 4), result.second);
- result = cont.equal_range(13);
- EXPECT_EQ(std::next(cont.begin(), 4), result.first);
- EXPECT_EQ(std::next(cont.begin(), 5), result.second);
- result = cont.equal_range(15);
- EXPECT_EQ(std::next(cont.begin(), 5), result.first);
- EXPECT_EQ(std::next(cont.begin(), 6), result.second);
- result = cont.equal_range(17);
- EXPECT_EQ(std::next(cont.begin(), 6), result.first);
- EXPECT_EQ(std::next(cont.begin(), 7), result.second);
- result = cont.equal_range(19);
- EXPECT_EQ(std::next(cont.begin(), 7), result.first);
- EXPECT_EQ(std::next(cont.begin(), 8), result.second);
- result = cont.equal_range(4);
- EXPECT_EQ(std::next(cont.begin(), 0), result.first);
- EXPECT_EQ(std::next(cont.begin(), 0), result.second);
- result = cont.equal_range(6);
- EXPECT_EQ(std::next(cont.begin(), 1), result.first);
- EXPECT_EQ(std::next(cont.begin(), 1), result.second);
- result = cont.equal_range(8);
- EXPECT_EQ(std::next(cont.begin(), 2), result.first);
- EXPECT_EQ(std::next(cont.begin(), 2), result.second);
- result = cont.equal_range(10);
- EXPECT_EQ(std::next(cont.begin(), 3), result.first);
- EXPECT_EQ(std::next(cont.begin(), 3), result.second);
- result = cont.equal_range(12);
- EXPECT_EQ(std::next(cont.begin(), 4), result.first);
- EXPECT_EQ(std::next(cont.begin(), 4), result.second);
- result = cont.equal_range(14);
- EXPECT_EQ(std::next(cont.begin(), 5), result.first);
- EXPECT_EQ(std::next(cont.begin(), 5), result.second);
- result = cont.equal_range(16);
- EXPECT_EQ(std::next(cont.begin(), 6), result.first);
- EXPECT_EQ(std::next(cont.begin(), 6), result.second);
- result = cont.equal_range(18);
- EXPECT_EQ(std::next(cont.begin(), 7), result.first);
- EXPECT_EQ(std::next(cont.begin(), 7), result.second);
- result = cont.equal_range(20);
- EXPECT_EQ(std::next(cont.begin(), 8), result.first);
- EXPECT_EQ(std::next(cont.begin(), 8), result.second);
- }
-}
-
-// iterator lower_bound(const key_type& key);
-// const_iterator lower_bound(const key_type& key) const;
-
-TEST(FlatTree, LowerBound) {
- {
- IntTree cont({5, 7, 9, 11, 13, 15, 17, 19});
-
- EXPECT_EQ(cont.begin(), cont.lower_bound(5));
- EXPECT_EQ(std::next(cont.begin()), cont.lower_bound(7));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.lower_bound(9));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.lower_bound(11));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.lower_bound(13));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.lower_bound(15));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.lower_bound(17));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.lower_bound(19));
- EXPECT_EQ(std::next(cont.begin(), 0), cont.lower_bound(4));
- EXPECT_EQ(std::next(cont.begin(), 1), cont.lower_bound(6));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.lower_bound(8));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.lower_bound(10));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.lower_bound(12));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.lower_bound(14));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.lower_bound(16));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.lower_bound(18));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.lower_bound(20));
- }
- {
- const IntTree cont({5, 7, 9, 11, 13, 15, 17, 19});
-
- EXPECT_EQ(cont.begin(), cont.lower_bound(5));
- EXPECT_EQ(std::next(cont.begin()), cont.lower_bound(7));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.lower_bound(9));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.lower_bound(11));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.lower_bound(13));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.lower_bound(15));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.lower_bound(17));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.lower_bound(19));
- EXPECT_EQ(std::next(cont.begin(), 0), cont.lower_bound(4));
- EXPECT_EQ(std::next(cont.begin(), 1), cont.lower_bound(6));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.lower_bound(8));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.lower_bound(10));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.lower_bound(12));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.lower_bound(14));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.lower_bound(16));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.lower_bound(18));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.lower_bound(20));
- }
-}
-
-// iterator upper_bound(const key_type& key)
-// const_iterator upper_bound(const key_type& key) const
-
-TEST(FlatTree, UpperBound) {
- {
- IntTree cont({5, 7, 9, 11, 13, 15, 17, 19});
-
- EXPECT_EQ(std::next(cont.begin(), 1), cont.upper_bound(5));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.upper_bound(7));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.upper_bound(9));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.upper_bound(11));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.upper_bound(13));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.upper_bound(15));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.upper_bound(17));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.upper_bound(19));
- EXPECT_EQ(std::next(cont.begin(), 0), cont.upper_bound(4));
- EXPECT_EQ(std::next(cont.begin(), 1), cont.upper_bound(6));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.upper_bound(8));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.upper_bound(10));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.upper_bound(12));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.upper_bound(14));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.upper_bound(16));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.upper_bound(18));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.upper_bound(20));
- }
- {
- const IntTree cont({5, 7, 9, 11, 13, 15, 17, 19});
-
- EXPECT_EQ(std::next(cont.begin(), 1), cont.upper_bound(5));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.upper_bound(7));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.upper_bound(9));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.upper_bound(11));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.upper_bound(13));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.upper_bound(15));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.upper_bound(17));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.upper_bound(19));
- EXPECT_EQ(std::next(cont.begin(), 0), cont.upper_bound(4));
- EXPECT_EQ(std::next(cont.begin(), 1), cont.upper_bound(6));
- EXPECT_EQ(std::next(cont.begin(), 2), cont.upper_bound(8));
- EXPECT_EQ(std::next(cont.begin(), 3), cont.upper_bound(10));
- EXPECT_EQ(std::next(cont.begin(), 4), cont.upper_bound(12));
- EXPECT_EQ(std::next(cont.begin(), 5), cont.upper_bound(14));
- EXPECT_EQ(std::next(cont.begin(), 6), cont.upper_bound(16));
- EXPECT_EQ(std::next(cont.begin(), 7), cont.upper_bound(18));
- EXPECT_EQ(std::next(cont.begin(), 8), cont.upper_bound(20));
- }
-}
-
-// ----------------------------------------------------------------------------
-// General operations.
-
-// void swap(flat_tree& other)
-// void swap(flat_tree& lhs, flat_tree& rhs)
-
-TEST(FlatTreeOurs, Swap) {
- IntTree x({1, 2, 3});
- IntTree y({4});
- swap(x, y);
- EXPECT_THAT(x, ElementsAre(4));
- EXPECT_THAT(y, ElementsAre(1, 2, 3));
-
- y.swap(x);
- EXPECT_THAT(x, ElementsAre(1, 2, 3));
- EXPECT_THAT(y, ElementsAre(4));
-}
-
-// bool operator==(const flat_tree& lhs, const flat_tree& rhs)
-// bool operator!=(const flat_tree& lhs, const flat_tree& rhs)
-// bool operator<(const flat_tree& lhs, const flat_tree& rhs)
-// bool operator>(const flat_tree& lhs, const flat_tree& rhs)
-// bool operator<=(const flat_tree& lhs, const flat_tree& rhs)
-// bool operator>=(const flat_tree& lhs, const flat_tree& rhs)
-
-TEST(FlatTree, Comparison) {
- // Provided comparator does not participate in comparison.
- ReversedTree biggest({3});
- ReversedTree smallest({1});
- ReversedTree middle({1, 2});
-
- EXPECT_EQ(biggest, biggest);
- EXPECT_NE(biggest, smallest);
- EXPECT_LT(smallest, middle);
- EXPECT_LE(smallest, middle);
- EXPECT_LE(middle, middle);
- EXPECT_GT(biggest, middle);
- EXPECT_GE(biggest, middle);
- EXPECT_GE(biggest, biggest);
-}
-
-TEST(FlatSet, EraseIf) {
- IntTree x;
- EraseIf(x, [](int) { return false; });
- EXPECT_THAT(x, ElementsAre());
-
- x = {1, 2, 3};
- EraseIf(x, [](int elem) { return !(elem & 1); });
- EXPECT_THAT(x, ElementsAre(1, 3));
-
- x = {1, 2, 3, 4};
- EraseIf(x, [](int elem) { return elem & 1; });
- EXPECT_THAT(x, ElementsAre(2, 4));
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/containers/hash_tables_unittest.cc b/base/containers/hash_tables_unittest.cc
deleted file mode 100644
index 6072e5d..0000000
--- a/base/containers/hash_tables_unittest.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 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 "base/containers/hash_tables.h"
-
-#include <stdint.h>
-#include <string>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-class HashPairTest : public testing::Test {
-};
-
-#define INSERT_PAIR_TEST(Type, value1, value2) \
- { \
- Type pair(value1, value2); \
- base::hash_map<Type, int> map; \
- map[pair] = 1; \
- }
-
-// Verify that a hash_map can be constructed for pairs of integers of various
-// sizes.
-TEST_F(HashPairTest, IntegerPairs) {
- typedef std::pair<int16_t, int16_t> Int16Int16Pair;
- typedef std::pair<int16_t, int32_t> Int16Int32Pair;
- typedef std::pair<int16_t, int64_t> Int16Int64Pair;
-
- INSERT_PAIR_TEST(Int16Int16Pair, 4, 6);
- INSERT_PAIR_TEST(Int16Int32Pair, 9, (1 << 29) + 378128932);
- INSERT_PAIR_TEST(Int16Int64Pair, 10,
- (INT64_C(1) << 60) + INT64_C(78931732321));
-
- typedef std::pair<int32_t, int16_t> Int32Int16Pair;
- typedef std::pair<int32_t, int32_t> Int32Int32Pair;
- typedef std::pair<int32_t, int64_t> Int32Int64Pair;
-
- INSERT_PAIR_TEST(Int32Int16Pair, 4, 6);
- INSERT_PAIR_TEST(Int32Int32Pair, 9, (1 << 29) + 378128932);
- INSERT_PAIR_TEST(Int32Int64Pair, 10,
- (INT64_C(1) << 60) + INT64_C(78931732321));
-
- typedef std::pair<int64_t, int16_t> Int64Int16Pair;
- typedef std::pair<int64_t, int32_t> Int64Int32Pair;
- typedef std::pair<int64_t, int64_t> Int64Int64Pair;
-
- INSERT_PAIR_TEST(Int64Int16Pair, 4, 6);
- INSERT_PAIR_TEST(Int64Int32Pair, 9, (1 << 29) + 378128932);
- INSERT_PAIR_TEST(Int64Int64Pair, 10,
- (INT64_C(1) << 60) + INT64_C(78931732321));
-}
-
-// Verify that base::hash_set<const char*> compares by pointer value, not as C
-// strings.
-TEST(HashTableTest, CharPointers) {
- std::string str1("hello");
- std::string str2("hello");
- base::hash_set<const char*> set;
-
- set.insert(str1.c_str());
- EXPECT_EQ(1u, set.count(str1.c_str()));
- EXPECT_EQ(0u, set.count(str2.c_str()));
-}
-
-} // namespace
diff --git a/base/containers/id_map_unittest.cc b/base/containers/id_map_unittest.cc
deleted file mode 100644
index 346b69f..0000000
--- a/base/containers/id_map_unittest.cc
+++ /dev/null
@@ -1,399 +0,0 @@
-// Copyright (c) 2011 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 "base/containers/id_map.h"
-
-#include <stdint.h>
-
-#include <memory>
-
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class TestObject {
-};
-
-class DestructorCounter {
- public:
- explicit DestructorCounter(int* counter) : counter_(counter) {}
- ~DestructorCounter() { ++(*counter_); }
-
- private:
- int* counter_;
-};
-
-} // namespace
-
-TEST(IDMapTest, Basic) {
- IDMap<TestObject*> map;
- EXPECT_TRUE(map.IsEmpty());
- EXPECT_EQ(0U, map.size());
-
- TestObject obj1;
- TestObject obj2;
-
- int32_t id1 = map.Add(&obj1);
- EXPECT_FALSE(map.IsEmpty());
- EXPECT_EQ(1U, map.size());
- EXPECT_EQ(&obj1, map.Lookup(id1));
-
- int32_t id2 = map.Add(&obj2);
- EXPECT_FALSE(map.IsEmpty());
- EXPECT_EQ(2U, map.size());
-
- EXPECT_EQ(&obj1, map.Lookup(id1));
- EXPECT_EQ(&obj2, map.Lookup(id2));
-
- map.Remove(id1);
- EXPECT_FALSE(map.IsEmpty());
- EXPECT_EQ(1U, map.size());
-
- map.Remove(id2);
- EXPECT_TRUE(map.IsEmpty());
- EXPECT_EQ(0U, map.size());
-
- map.AddWithID(&obj1, 1);
- map.AddWithID(&obj2, 2);
- EXPECT_EQ(&obj1, map.Lookup(1));
- EXPECT_EQ(&obj2, map.Lookup(2));
-
- EXPECT_EQ(&obj2, map.Replace(2, &obj1));
- EXPECT_EQ(&obj1, map.Lookup(2));
-
- EXPECT_EQ(0, map.iteration_depth());
-}
-
-TEST(IDMapTest, IteratorRemainsValidWhenRemovingCurrentElement) {
- IDMap<TestObject*> map;
-
- TestObject obj1;
- TestObject obj2;
- TestObject obj3;
-
- map.Add(&obj1);
- map.Add(&obj2);
- map.Add(&obj3);
-
- {
- IDMap<TestObject*>::const_iterator iter(&map);
-
- EXPECT_EQ(1, map.iteration_depth());
-
- while (!iter.IsAtEnd()) {
- map.Remove(iter.GetCurrentKey());
- iter.Advance();
- }
-
- // Test that while an iterator is still in scope, we get the map emptiness
- // right (http://crbug.com/35571).
- EXPECT_TRUE(map.IsEmpty());
- EXPECT_EQ(0U, map.size());
- }
-
- EXPECT_TRUE(map.IsEmpty());
- EXPECT_EQ(0U, map.size());
-
- EXPECT_EQ(0, map.iteration_depth());
-}
-
-TEST(IDMapTest, IteratorRemainsValidWhenRemovingOtherElements) {
- IDMap<TestObject*> map;
-
- const int kCount = 5;
- TestObject obj[kCount];
-
- for (int i = 0; i < kCount; i++)
- map.Add(&obj[i]);
-
- // IDMap has no predictable iteration order.
- int32_t ids_in_iteration_order[kCount];
- const TestObject* objs_in_iteration_order[kCount];
- int counter = 0;
- for (IDMap<TestObject*>::const_iterator iter(&map); !iter.IsAtEnd();
- iter.Advance()) {
- ids_in_iteration_order[counter] = iter.GetCurrentKey();
- objs_in_iteration_order[counter] = iter.GetCurrentValue();
- counter++;
- }
-
- counter = 0;
- for (IDMap<TestObject*>::const_iterator iter(&map); !iter.IsAtEnd();
- iter.Advance()) {
- EXPECT_EQ(1, map.iteration_depth());
-
- switch (counter) {
- case 0:
- EXPECT_EQ(ids_in_iteration_order[0], iter.GetCurrentKey());
- EXPECT_EQ(objs_in_iteration_order[0], iter.GetCurrentValue());
- map.Remove(ids_in_iteration_order[1]);
- break;
- case 1:
- EXPECT_EQ(ids_in_iteration_order[2], iter.GetCurrentKey());
- EXPECT_EQ(objs_in_iteration_order[2], iter.GetCurrentValue());
- map.Remove(ids_in_iteration_order[3]);
- break;
- case 2:
- EXPECT_EQ(ids_in_iteration_order[4], iter.GetCurrentKey());
- EXPECT_EQ(objs_in_iteration_order[4], iter.GetCurrentValue());
- map.Remove(ids_in_iteration_order[0]);
- break;
- default:
- FAIL() << "should not have that many elements";
- break;
- }
-
- counter++;
- }
-
- EXPECT_EQ(0, map.iteration_depth());
-}
-
-TEST(IDMapTest, CopyIterator) {
- IDMap<TestObject*> map;
-
- TestObject obj1;
- TestObject obj2;
- TestObject obj3;
-
- map.Add(&obj1);
- map.Add(&obj2);
- map.Add(&obj3);
-
- EXPECT_EQ(0, map.iteration_depth());
-
- {
- IDMap<TestObject*>::const_iterator iter1(&map);
- EXPECT_EQ(1, map.iteration_depth());
-
- // Make sure that copying the iterator correctly increments
- // map's iteration depth.
- IDMap<TestObject*>::const_iterator iter2(iter1);
- EXPECT_EQ(2, map.iteration_depth());
- }
-
- // Make sure after destroying all iterators the map's iteration depth
- // returns to initial state.
- EXPECT_EQ(0, map.iteration_depth());
-}
-
-TEST(IDMapTest, AssignIterator) {
- IDMap<TestObject*> map;
-
- TestObject obj1;
- TestObject obj2;
- TestObject obj3;
-
- map.Add(&obj1);
- map.Add(&obj2);
- map.Add(&obj3);
-
- EXPECT_EQ(0, map.iteration_depth());
-
- {
- IDMap<TestObject*>::const_iterator iter1(&map);
- EXPECT_EQ(1, map.iteration_depth());
-
- IDMap<TestObject*>::const_iterator iter2(&map);
- EXPECT_EQ(2, map.iteration_depth());
-
- // Make sure that assigning the iterator correctly updates
- // map's iteration depth (-1 for destruction, +1 for assignment).
- EXPECT_EQ(2, map.iteration_depth());
- }
-
- // Make sure after destroying all iterators the map's iteration depth
- // returns to initial state.
- EXPECT_EQ(0, map.iteration_depth());
-}
-
-TEST(IDMapTest, IteratorRemainsValidWhenClearing) {
- IDMap<TestObject*> map;
-
- const int kCount = 5;
- TestObject obj[kCount];
-
- for (int i = 0; i < kCount; i++)
- map.Add(&obj[i]);
-
- // IDMap has no predictable iteration order.
- int32_t ids_in_iteration_order[kCount];
- const TestObject* objs_in_iteration_order[kCount];
- int counter = 0;
- for (IDMap<TestObject*>::const_iterator iter(&map); !iter.IsAtEnd();
- iter.Advance()) {
- ids_in_iteration_order[counter] = iter.GetCurrentKey();
- objs_in_iteration_order[counter] = iter.GetCurrentValue();
- counter++;
- }
-
- counter = 0;
- for (IDMap<TestObject*>::const_iterator iter(&map); !iter.IsAtEnd();
- iter.Advance()) {
- switch (counter) {
- case 0:
- EXPECT_EQ(ids_in_iteration_order[0], iter.GetCurrentKey());
- EXPECT_EQ(objs_in_iteration_order[0], iter.GetCurrentValue());
- break;
- case 1:
- EXPECT_EQ(ids_in_iteration_order[1], iter.GetCurrentKey());
- EXPECT_EQ(objs_in_iteration_order[1], iter.GetCurrentValue());
- map.Clear();
- EXPECT_TRUE(map.IsEmpty());
- EXPECT_EQ(0U, map.size());
- break;
- default:
- FAIL() << "should not have that many elements";
- break;
- }
- counter++;
- }
-
- EXPECT_TRUE(map.IsEmpty());
- EXPECT_EQ(0U, map.size());
-}
-
-TEST(IDMapTest, OwningPointersDeletesThemOnRemove) {
- const int kCount = 3;
-
- int external_del_count = 0;
- DestructorCounter* external_obj[kCount];
- int map_external_ids[kCount];
-
- int owned_del_count = 0;
- int map_owned_ids[kCount];
-
- IDMap<DestructorCounter*> map_external;
- IDMap<std::unique_ptr<DestructorCounter>> map_owned;
-
- for (int i = 0; i < kCount; ++i) {
- external_obj[i] = new DestructorCounter(&external_del_count);
- map_external_ids[i] = map_external.Add(external_obj[i]);
-
- map_owned_ids[i] =
- map_owned.Add(std::make_unique<DestructorCounter>(&owned_del_count));
- }
-
- for (int i = 0; i < kCount; ++i) {
- EXPECT_EQ(external_del_count, 0);
- EXPECT_EQ(owned_del_count, i);
-
- map_external.Remove(map_external_ids[i]);
- map_owned.Remove(map_owned_ids[i]);
- }
-
- for (int i = 0; i < kCount; ++i) {
- delete external_obj[i];
- }
-
- EXPECT_EQ(external_del_count, kCount);
- EXPECT_EQ(owned_del_count, kCount);
-}
-
-TEST(IDMapTest, OwningPointersDeletesThemOnClear) {
- const int kCount = 3;
-
- int external_del_count = 0;
- DestructorCounter* external_obj[kCount];
-
- int owned_del_count = 0;
-
- IDMap<DestructorCounter*> map_external;
- IDMap<std::unique_ptr<DestructorCounter>> map_owned;
-
- for (int i = 0; i < kCount; ++i) {
- external_obj[i] = new DestructorCounter(&external_del_count);
- map_external.Add(external_obj[i]);
-
- map_owned.Add(std::make_unique<DestructorCounter>(&owned_del_count));
- }
-
- EXPECT_EQ(external_del_count, 0);
- EXPECT_EQ(owned_del_count, 0);
-
- map_external.Clear();
- map_owned.Clear();
-
- EXPECT_EQ(external_del_count, 0);
- EXPECT_EQ(owned_del_count, kCount);
-
- for (int i = 0; i < kCount; ++i) {
- delete external_obj[i];
- }
-
- EXPECT_EQ(external_del_count, kCount);
- EXPECT_EQ(owned_del_count, kCount);
-}
-
-TEST(IDMapTest, OwningPointersDeletesThemOnDestruct) {
- const int kCount = 3;
-
- int external_del_count = 0;
- DestructorCounter* external_obj[kCount];
-
- int owned_del_count = 0;
-
- {
- IDMap<DestructorCounter*> map_external;
- IDMap<std::unique_ptr<DestructorCounter>> map_owned;
-
- for (int i = 0; i < kCount; ++i) {
- external_obj[i] = new DestructorCounter(&external_del_count);
- map_external.Add(external_obj[i]);
-
- map_owned.Add(std::make_unique<DestructorCounter>(&owned_del_count));
- }
- }
-
- EXPECT_EQ(external_del_count, 0);
-
- for (int i = 0; i < kCount; ++i) {
- delete external_obj[i];
- }
-
- EXPECT_EQ(external_del_count, kCount);
- EXPECT_EQ(owned_del_count, kCount);
-}
-
-TEST(IDMapTest, Int64KeyType) {
- IDMap<TestObject*, int64_t> map;
- TestObject obj1;
- const int64_t kId1 = 999999999999999999;
-
- map.AddWithID(&obj1, kId1);
- EXPECT_EQ(&obj1, map.Lookup(kId1));
-
- IDMap<TestObject*, int64_t>::const_iterator iter(&map);
- ASSERT_FALSE(iter.IsAtEnd());
- EXPECT_EQ(kId1, iter.GetCurrentKey());
- EXPECT_EQ(&obj1, iter.GetCurrentValue());
- iter.Advance();
- ASSERT_TRUE(iter.IsAtEnd());
-
- map.Remove(kId1);
- EXPECT_TRUE(map.IsEmpty());
-}
-
-TEST(IDMapTest, RemovedValueHandling) {
- TestObject obj;
- IDMap<TestObject*> map;
- int key = map.Add(&obj);
-
- IDMap<TestObject*>::iterator itr(&map);
- map.Clear();
- EXPECT_DCHECK_DEATH(map.Remove(key));
- EXPECT_DCHECK_DEATH(map.Replace(key, &obj));
- EXPECT_FALSE(map.Lookup(key));
- EXPECT_FALSE(itr.IsAtEnd());
- EXPECT_FALSE(itr.GetCurrentValue());
-
- EXPECT_TRUE(map.IsEmpty());
- map.AddWithID(&obj, key);
- EXPECT_EQ(1u, map.size());
-}
-
-} // namespace base
diff --git a/base/containers/linked_list_unittest.cc b/base/containers/linked_list_unittest.cc
deleted file mode 100644
index 8e547ba..0000000
--- a/base/containers/linked_list_unittest.cc
+++ /dev/null
@@ -1,349 +0,0 @@
-// Copyright (c) 2009 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 "base/containers/linked_list.h"
-#include "base/macros.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class Node : public LinkNode<Node> {
- public:
- explicit Node(int id) : id_(id) {}
-
- int id() const { return id_; }
-
- private:
- int id_;
-};
-
-class MultipleInheritanceNodeBase {
- public:
- MultipleInheritanceNodeBase() : field_taking_up_space_(0) {}
- int field_taking_up_space_;
-};
-
-class MultipleInheritanceNode : public MultipleInheritanceNodeBase,
- public LinkNode<MultipleInheritanceNode> {
- public:
- MultipleInheritanceNode() = default;
-};
-
-class MovableNode : public LinkNode<MovableNode> {
- public:
- explicit MovableNode(int id) : id_(id) {}
-
- MovableNode(MovableNode&&) = default;
-
- int id() const { return id_; }
-
- private:
- int id_;
-};
-
-// Checks that when iterating |list| (either from head to tail, or from
-// tail to head, as determined by |forward|), we get back |node_ids|,
-// which is an array of size |num_nodes|.
-void ExpectListContentsForDirection(const LinkedList<Node>& list,
- int num_nodes, const int* node_ids, bool forward) {
- int i = 0;
- for (const LinkNode<Node>* node = (forward ? list.head() : list.tail());
- node != list.end();
- node = (forward ? node->next() : node->previous())) {
- ASSERT_LT(i, num_nodes);
- int index_of_id = forward ? i : num_nodes - i - 1;
- EXPECT_EQ(node_ids[index_of_id], node->value()->id());
- ++i;
- }
- EXPECT_EQ(num_nodes, i);
-}
-
-void ExpectListContents(const LinkedList<Node>& list,
- int num_nodes,
- const int* node_ids) {
- {
- SCOPED_TRACE("Iterating forward (from head to tail)");
- ExpectListContentsForDirection(list, num_nodes, node_ids, true);
- }
- {
- SCOPED_TRACE("Iterating backward (from tail to head)");
- ExpectListContentsForDirection(list, num_nodes, node_ids, false);
- }
-}
-
-TEST(LinkedList, Empty) {
- LinkedList<Node> list;
- EXPECT_EQ(list.end(), list.head());
- EXPECT_EQ(list.end(), list.tail());
- ExpectListContents(list, 0, nullptr);
-}
-
-TEST(LinkedList, Append) {
- LinkedList<Node> list;
- ExpectListContents(list, 0, nullptr);
-
- Node n1(1);
- list.Append(&n1);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n1, list.tail());
- {
- const int expected[] = {1};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- Node n2(2);
- list.Append(&n2);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n2, list.tail());
- {
- const int expected[] = {1, 2};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- Node n3(3);
- list.Append(&n3);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n3, list.tail());
- {
- const int expected[] = {1, 2, 3};
- ExpectListContents(list, arraysize(expected), expected);
- }
-}
-
-TEST(LinkedList, RemoveFromList) {
- LinkedList<Node> list;
-
- Node n1(1);
- Node n2(2);
- Node n3(3);
- Node n4(4);
- Node n5(5);
-
- list.Append(&n1);
- list.Append(&n2);
- list.Append(&n3);
- list.Append(&n4);
- list.Append(&n5);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n5, list.tail());
- {
- const int expected[] = {1, 2, 3, 4, 5};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- // Remove from the middle.
- n3.RemoveFromList();
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n5, list.tail());
- {
- const int expected[] = {1, 2, 4, 5};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- // Remove from the tail.
- n5.RemoveFromList();
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n4, list.tail());
- {
- const int expected[] = {1, 2, 4};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- // Remove from the head.
- n1.RemoveFromList();
-
- EXPECT_EQ(&n2, list.head());
- EXPECT_EQ(&n4, list.tail());
- {
- const int expected[] = {2, 4};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- // Empty the list.
- n2.RemoveFromList();
- n4.RemoveFromList();
-
- ExpectListContents(list, 0, nullptr);
- EXPECT_EQ(list.end(), list.head());
- EXPECT_EQ(list.end(), list.tail());
-
- // Fill the list once again.
- list.Append(&n1);
- list.Append(&n2);
- list.Append(&n3);
- list.Append(&n4);
- list.Append(&n5);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n5, list.tail());
- {
- const int expected[] = {1, 2, 3, 4, 5};
- ExpectListContents(list, arraysize(expected), expected);
- }
-}
-
-TEST(LinkedList, InsertBefore) {
- LinkedList<Node> list;
-
- Node n1(1);
- Node n2(2);
- Node n3(3);
- Node n4(4);
-
- list.Append(&n1);
- list.Append(&n2);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n2, list.tail());
- {
- const int expected[] = {1, 2};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- n3.InsertBefore(&n2);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n2, list.tail());
- {
- const int expected[] = {1, 3, 2};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- n4.InsertBefore(&n1);
-
- EXPECT_EQ(&n4, list.head());
- EXPECT_EQ(&n2, list.tail());
- {
- const int expected[] = {4, 1, 3, 2};
- ExpectListContents(list, arraysize(expected), expected);
- }
-}
-
-TEST(LinkedList, InsertAfter) {
- LinkedList<Node> list;
-
- Node n1(1);
- Node n2(2);
- Node n3(3);
- Node n4(4);
-
- list.Append(&n1);
- list.Append(&n2);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n2, list.tail());
- {
- const int expected[] = {1, 2};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- n3.InsertAfter(&n2);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n3, list.tail());
- {
- const int expected[] = {1, 2, 3};
- ExpectListContents(list, arraysize(expected), expected);
- }
-
- n4.InsertAfter(&n1);
-
- EXPECT_EQ(&n1, list.head());
- EXPECT_EQ(&n3, list.tail());
- {
- const int expected[] = {1, 4, 2, 3};
- ExpectListContents(list, arraysize(expected), expected);
- }
-}
-
-TEST(LinkedList, MultipleInheritanceNode) {
- MultipleInheritanceNode node;
- EXPECT_EQ(&node, node.value());
-}
-
-TEST(LinkedList, EmptyListIsEmpty) {
- LinkedList<Node> list;
- EXPECT_TRUE(list.empty());
-}
-
-TEST(LinkedList, NonEmptyListIsNotEmpty) {
- LinkedList<Node> list;
-
- Node n(1);
- list.Append(&n);
-
- EXPECT_FALSE(list.empty());
-}
-
-TEST(LinkedList, EmptiedListIsEmptyAgain) {
- LinkedList<Node> list;
-
- Node n(1);
- list.Append(&n);
- n.RemoveFromList();
-
- EXPECT_TRUE(list.empty());
-}
-
-TEST(LinkedList, NodesCanBeReused) {
- LinkedList<Node> list1;
- LinkedList<Node> list2;
-
- Node n(1);
- list1.Append(&n);
- n.RemoveFromList();
- list2.Append(&n);
-
- EXPECT_EQ(list2.head()->value(), &n);
-}
-
-TEST(LinkedList, RemovedNodeHasNullNextPrevious) {
- LinkedList<Node> list;
-
- Node n(1);
- list.Append(&n);
- n.RemoveFromList();
-
- EXPECT_EQ(nullptr, n.next());
- EXPECT_EQ(nullptr, n.previous());
-}
-
-TEST(LinkedList, NodeMoveConstructor) {
- LinkedList<MovableNode> list;
-
- MovableNode n1(1);
- MovableNode n2(2);
- MovableNode n3(3);
-
- list.Append(&n1);
- list.Append(&n2);
- list.Append(&n3);
-
- EXPECT_EQ(&n1, n2.previous());
- EXPECT_EQ(&n2, n1.next());
- EXPECT_EQ(&n3, n2.next());
- EXPECT_EQ(&n2, n3.previous());
- EXPECT_EQ(2, n2.id());
-
- MovableNode n2_new(std::move(n2));
-
- EXPECT_EQ(nullptr, n2.next());
- EXPECT_EQ(nullptr, n2.previous());
-
- EXPECT_EQ(&n1, n2_new.previous());
- EXPECT_EQ(&n2_new, n1.next());
- EXPECT_EQ(&n3, n2_new.next());
- EXPECT_EQ(&n2_new, n3.previous());
- EXPECT_EQ(2, n2_new.id());
-}
-
-} // namespace
-} // namespace base
diff --git a/base/containers/mru_cache_unittest.cc b/base/containers/mru_cache_unittest.cc
deleted file mode 100644
index 28e6f0d..0000000
--- a/base/containers/mru_cache_unittest.cc
+++ /dev/null
@@ -1,394 +0,0 @@
-// Copyright (c) 2011 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 "base/containers/mru_cache.h"
-
-#include <cstddef>
-#include <memory>
-
-#include "base/memory/ptr_util.h"
-#include "base/trace_event/memory_usage_estimator.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-int cached_item_live_count = 0;
-
-struct CachedItem {
- CachedItem() : value(0) {
- cached_item_live_count++;
- }
-
- explicit CachedItem(int new_value) : value(new_value) {
- cached_item_live_count++;
- }
-
- explicit CachedItem(const CachedItem& other) : value(other.value) {
- cached_item_live_count++;
- }
-
- ~CachedItem() {
- cached_item_live_count--;
- }
-
- int value;
-};
-
-} // namespace
-
-TEST(MRUCacheTest, Basic) {
- typedef base::MRUCache<int, CachedItem> Cache;
- Cache cache(Cache::NO_AUTO_EVICT);
-
- // Check failure conditions
- {
- CachedItem test_item;
- EXPECT_TRUE(cache.Get(0) == cache.end());
- EXPECT_TRUE(cache.Peek(0) == cache.end());
- }
-
- static const int kItem1Key = 5;
- CachedItem item1(10);
- Cache::iterator inserted_item = cache.Put(kItem1Key, item1);
- EXPECT_EQ(1U, cache.size());
-
- // Check that item1 was properly inserted.
- {
- Cache::iterator found = cache.Get(kItem1Key);
- EXPECT_TRUE(inserted_item == cache.begin());
- EXPECT_TRUE(found != cache.end());
-
- found = cache.Peek(kItem1Key);
- EXPECT_TRUE(found != cache.end());
-
- EXPECT_EQ(kItem1Key, found->first);
- EXPECT_EQ(item1.value, found->second.value);
- }
-
- static const int kItem2Key = 7;
- CachedItem item2(12);
- cache.Put(kItem2Key, item2);
- EXPECT_EQ(2U, cache.size());
-
- // Check that item1 is the oldest since item2 was added afterwards.
- {
- Cache::reverse_iterator oldest = cache.rbegin();
- ASSERT_TRUE(oldest != cache.rend());
- EXPECT_EQ(kItem1Key, oldest->first);
- EXPECT_EQ(item1.value, oldest->second.value);
- }
-
- // Check that item1 is still accessible by key.
- {
- Cache::iterator test_item = cache.Get(kItem1Key);
- ASSERT_TRUE(test_item != cache.end());
- EXPECT_EQ(kItem1Key, test_item->first);
- EXPECT_EQ(item1.value, test_item->second.value);
- }
-
- // Check that retrieving item1 pushed item2 to oldest.
- {
- Cache::reverse_iterator oldest = cache.rbegin();
- ASSERT_TRUE(oldest != cache.rend());
- EXPECT_EQ(kItem2Key, oldest->first);
- EXPECT_EQ(item2.value, oldest->second.value);
- }
-
- // Remove the oldest item and check that item1 is now the only member.
- {
- Cache::reverse_iterator next = cache.Erase(cache.rbegin());
-
- EXPECT_EQ(1U, cache.size());
-
- EXPECT_TRUE(next == cache.rbegin());
- EXPECT_EQ(kItem1Key, next->first);
- EXPECT_EQ(item1.value, next->second.value);
-
- cache.Erase(cache.begin());
- EXPECT_EQ(0U, cache.size());
- }
-
- // Check that Clear() works properly.
- cache.Put(kItem1Key, item1);
- cache.Put(kItem2Key, item2);
- EXPECT_EQ(2U, cache.size());
- cache.Clear();
- EXPECT_EQ(0U, cache.size());
-}
-
-TEST(MRUCacheTest, GetVsPeek) {
- typedef base::MRUCache<int, CachedItem> Cache;
- Cache cache(Cache::NO_AUTO_EVICT);
-
- static const int kItem1Key = 1;
- CachedItem item1(10);
- cache.Put(kItem1Key, item1);
-
- static const int kItem2Key = 2;
- CachedItem item2(20);
- cache.Put(kItem2Key, item2);
-
- // This should do nothing since the size is bigger than the number of items.
- cache.ShrinkToSize(100);
-
- // Check that item1 starts out as oldest
- {
- Cache::reverse_iterator iter = cache.rbegin();
- ASSERT_TRUE(iter != cache.rend());
- EXPECT_EQ(kItem1Key, iter->first);
- EXPECT_EQ(item1.value, iter->second.value);
- }
-
- // Check that Peek doesn't change ordering
- {
- Cache::iterator peekiter = cache.Peek(kItem1Key);
- ASSERT_TRUE(peekiter != cache.end());
-
- Cache::reverse_iterator iter = cache.rbegin();
- ASSERT_TRUE(iter != cache.rend());
- EXPECT_EQ(kItem1Key, iter->first);
- EXPECT_EQ(item1.value, iter->second.value);
- }
-}
-
-TEST(MRUCacheTest, KeyReplacement) {
- typedef base::MRUCache<int, CachedItem> Cache;
- Cache cache(Cache::NO_AUTO_EVICT);
-
- static const int kItem1Key = 1;
- CachedItem item1(10);
- cache.Put(kItem1Key, item1);
-
- static const int kItem2Key = 2;
- CachedItem item2(20);
- cache.Put(kItem2Key, item2);
-
- static const int kItem3Key = 3;
- CachedItem item3(30);
- cache.Put(kItem3Key, item3);
-
- static const int kItem4Key = 4;
- CachedItem item4(40);
- cache.Put(kItem4Key, item4);
-
- CachedItem item5(50);
- cache.Put(kItem3Key, item5);
-
- EXPECT_EQ(4U, cache.size());
- for (int i = 0; i < 3; ++i) {
- Cache::reverse_iterator iter = cache.rbegin();
- ASSERT_TRUE(iter != cache.rend());
- }
-
- // Make it so only the most important element is there.
- cache.ShrinkToSize(1);
-
- Cache::iterator iter = cache.begin();
- EXPECT_EQ(kItem3Key, iter->first);
- EXPECT_EQ(item5.value, iter->second.value);
-}
-
-// Make sure that the owning version release its pointers properly.
-TEST(MRUCacheTest, Owning) {
- using Cache = base::MRUCache<int, std::unique_ptr<CachedItem>>;
- Cache cache(Cache::NO_AUTO_EVICT);
-
- int initial_count = cached_item_live_count;
-
- // First insert and item and then overwrite it.
- static const int kItem1Key = 1;
- cache.Put(kItem1Key, WrapUnique(new CachedItem(20)));
- cache.Put(kItem1Key, WrapUnique(new CachedItem(22)));
-
- // There should still be one item, and one extra live item.
- Cache::iterator iter = cache.Get(kItem1Key);
- EXPECT_EQ(1U, cache.size());
- EXPECT_TRUE(iter != cache.end());
- EXPECT_EQ(initial_count + 1, cached_item_live_count);
-
- // Now remove it.
- cache.Erase(cache.begin());
- EXPECT_EQ(initial_count, cached_item_live_count);
-
- // Now try another cache that goes out of scope to make sure its pointers
- // go away.
- {
- Cache cache2(Cache::NO_AUTO_EVICT);
- cache2.Put(1, WrapUnique(new CachedItem(20)));
- cache2.Put(2, WrapUnique(new CachedItem(20)));
- }
-
- // There should be no objects leaked.
- EXPECT_EQ(initial_count, cached_item_live_count);
-
- // Check that Clear() also frees things correctly.
- {
- Cache cache2(Cache::NO_AUTO_EVICT);
- cache2.Put(1, WrapUnique(new CachedItem(20)));
- cache2.Put(2, WrapUnique(new CachedItem(20)));
- EXPECT_EQ(initial_count + 2, cached_item_live_count);
- cache2.Clear();
- EXPECT_EQ(initial_count, cached_item_live_count);
- }
-}
-
-TEST(MRUCacheTest, AutoEvict) {
- using Cache = base::MRUCache<int, std::unique_ptr<CachedItem>>;
- static const Cache::size_type kMaxSize = 3;
-
- int initial_count = cached_item_live_count;
-
- {
- Cache cache(kMaxSize);
-
- static const int kItem1Key = 1, kItem2Key = 2, kItem3Key = 3, kItem4Key = 4;
- cache.Put(kItem1Key, std::make_unique<CachedItem>(20));
- cache.Put(kItem2Key, std::make_unique<CachedItem>(21));
- cache.Put(kItem3Key, std::make_unique<CachedItem>(22));
- cache.Put(kItem4Key, std::make_unique<CachedItem>(23));
-
- // The cache should only have kMaxSize items in it even though we inserted
- // more.
- EXPECT_EQ(kMaxSize, cache.size());
- }
-
- // There should be no objects leaked.
- EXPECT_EQ(initial_count, cached_item_live_count);
-}
-
-TEST(MRUCacheTest, HashingMRUCache) {
- // Very simple test to make sure that the hashing cache works correctly.
- typedef base::HashingMRUCache<std::string, CachedItem> Cache;
- Cache cache(Cache::NO_AUTO_EVICT);
-
- CachedItem one(1);
- cache.Put("First", one);
-
- CachedItem two(2);
- cache.Put("Second", two);
-
- EXPECT_EQ(one.value, cache.Get("First")->second.value);
- EXPECT_EQ(two.value, cache.Get("Second")->second.value);
- cache.ShrinkToSize(1);
- EXPECT_EQ(two.value, cache.Get("Second")->second.value);
- EXPECT_TRUE(cache.Get("First") == cache.end());
-}
-
-TEST(MRUCacheTest, Swap) {
- typedef base::MRUCache<int, CachedItem> Cache;
- Cache cache1(Cache::NO_AUTO_EVICT);
-
- // Insert two items into cache1.
- static const int kItem1Key = 1;
- CachedItem item1(2);
- Cache::iterator inserted_item = cache1.Put(kItem1Key, item1);
- EXPECT_EQ(1U, cache1.size());
-
- static const int kItem2Key = 3;
- CachedItem item2(4);
- cache1.Put(kItem2Key, item2);
- EXPECT_EQ(2U, cache1.size());
-
- // Verify cache1's elements.
- {
- Cache::iterator iter = cache1.begin();
- ASSERT_TRUE(iter != cache1.end());
- EXPECT_EQ(kItem2Key, iter->first);
- EXPECT_EQ(item2.value, iter->second.value);
-
- ++iter;
- ASSERT_TRUE(iter != cache1.end());
- EXPECT_EQ(kItem1Key, iter->first);
- EXPECT_EQ(item1.value, iter->second.value);
- }
-
- // Create another cache2.
- Cache cache2(Cache::NO_AUTO_EVICT);
-
- // Insert three items into cache2.
- static const int kItem3Key = 5;
- CachedItem item3(6);
- inserted_item = cache2.Put(kItem3Key, item3);
- EXPECT_EQ(1U, cache2.size());
-
- static const int kItem4Key = 7;
- CachedItem item4(8);
- cache2.Put(kItem4Key, item4);
- EXPECT_EQ(2U, cache2.size());
-
- static const int kItem5Key = 9;
- CachedItem item5(10);
- cache2.Put(kItem5Key, item5);
- EXPECT_EQ(3U, cache2.size());
-
- // Verify cache2's elements.
- {
- Cache::iterator iter = cache2.begin();
- ASSERT_TRUE(iter != cache2.end());
- EXPECT_EQ(kItem5Key, iter->first);
- EXPECT_EQ(item5.value, iter->second.value);
-
- ++iter;
- ASSERT_TRUE(iter != cache2.end());
- EXPECT_EQ(kItem4Key, iter->first);
- EXPECT_EQ(item4.value, iter->second.value);
-
- ++iter;
- ASSERT_TRUE(iter != cache2.end());
- EXPECT_EQ(kItem3Key, iter->first);
- EXPECT_EQ(item3.value, iter->second.value);
- }
-
- // Swap cache1 and cache2 and verify cache2 has cache1's elements and cache1
- // has cache2's elements.
- cache2.Swap(cache1);
-
- EXPECT_EQ(3U, cache1.size());
- EXPECT_EQ(2U, cache2.size());
-
- // Verify cache1's elements.
- {
- Cache::iterator iter = cache1.begin();
- ASSERT_TRUE(iter != cache1.end());
- EXPECT_EQ(kItem5Key, iter->first);
- EXPECT_EQ(item5.value, iter->second.value);
-
- ++iter;
- ASSERT_TRUE(iter != cache1.end());
- EXPECT_EQ(kItem4Key, iter->first);
- EXPECT_EQ(item4.value, iter->second.value);
-
- ++iter;
- ASSERT_TRUE(iter != cache1.end());
- EXPECT_EQ(kItem3Key, iter->first);
- EXPECT_EQ(item3.value, iter->second.value);
- }
-
- // Verify cache2's elements.
- {
- Cache::iterator iter = cache2.begin();
- ASSERT_TRUE(iter != cache2.end());
- EXPECT_EQ(kItem2Key, iter->first);
- EXPECT_EQ(item2.value, iter->second.value);
-
- ++iter;
- ASSERT_TRUE(iter != cache2.end());
- EXPECT_EQ(kItem1Key, iter->first);
- EXPECT_EQ(item1.value, iter->second.value);
- }
-}
-
-TEST(MRUCacheTest, EstimateMemory) {
- base::MRUCache<std::string, int> cache(10);
-
- const std::string key(100u, 'a');
- cache.Put(key, 1);
-
- EXPECT_GT(trace_event::EstimateMemoryUsage(cache),
- trace_event::EstimateMemoryUsage(key));
-}
-
-} // namespace base
diff --git a/base/containers/small_map_unittest.cc b/base/containers/small_map_unittest.cc
deleted file mode 100644
index 6561851..0000000
--- a/base/containers/small_map_unittest.cc
+++ /dev/null
@@ -1,603 +0,0 @@
-// 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.
-
-#include "base/containers/small_map.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <functional>
-#include <map>
-#include <unordered_map>
-
-#include "base/logging.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(SmallMap, General) {
- small_map<std::unordered_map<int, int>> m;
-
- EXPECT_TRUE(m.empty());
-
- m[0] = 5;
-
- EXPECT_FALSE(m.empty());
- EXPECT_EQ(m.size(), 1u);
-
- m[9] = 2;
-
- EXPECT_FALSE(m.empty());
- EXPECT_EQ(m.size(), 2u);
-
- EXPECT_EQ(m[9], 2);
- EXPECT_EQ(m[0], 5);
- EXPECT_FALSE(m.UsingFullMap());
-
- small_map<std::unordered_map<int, int>>::iterator iter(m.begin());
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 0);
- EXPECT_EQ(iter->second, 5);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ((*iter).first, 9);
- EXPECT_EQ((*iter).second, 2);
- ++iter;
- EXPECT_TRUE(iter == m.end());
-
- m[8] = 23;
- m[1234] = 90;
- m[-5] = 6;
-
- EXPECT_EQ(m[ 9], 2);
- EXPECT_EQ(m[ 0], 5);
- EXPECT_EQ(m[1234], 90);
- EXPECT_EQ(m[ 8], 23);
- EXPECT_EQ(m[ -5], 6);
- EXPECT_EQ(m.size(), 5u);
- EXPECT_FALSE(m.empty());
- EXPECT_TRUE(m.UsingFullMap());
-
- iter = m.begin();
- for (int i = 0; i < 5; i++) {
- EXPECT_TRUE(iter != m.end());
- ++iter;
- }
- EXPECT_TRUE(iter == m.end());
-
- const small_map<std::unordered_map<int, int>>& ref = m;
- EXPECT_TRUE(ref.find(1234) != m.end());
- EXPECT_TRUE(ref.find(5678) == m.end());
-}
-
-TEST(SmallMap, PostFixIteratorIncrement) {
- small_map<std::unordered_map<int, int>> m;
- m[0] = 5;
- m[2] = 3;
-
- {
- small_map<std::unordered_map<int, int>>::iterator iter(m.begin());
- small_map<std::unordered_map<int, int>>::iterator last(iter++);
- ++last;
- EXPECT_TRUE(last == iter);
- }
-
- {
- small_map<std::unordered_map<int, int>>::const_iterator iter(m.begin());
- small_map<std::unordered_map<int, int>>::const_iterator last(iter++);
- ++last;
- EXPECT_TRUE(last == iter);
- }
-}
-
-// Based on the General testcase.
-TEST(SmallMap, CopyConstructor) {
- small_map<std::unordered_map<int, int>> src;
-
- {
- small_map<std::unordered_map<int, int>> m(src);
- EXPECT_TRUE(m.empty());
- }
-
- src[0] = 5;
-
- {
- small_map<std::unordered_map<int, int>> m(src);
- EXPECT_FALSE(m.empty());
- EXPECT_EQ(m.size(), 1u);
- }
-
- src[9] = 2;
-
- {
- small_map<std::unordered_map<int, int>> m(src);
- EXPECT_FALSE(m.empty());
- EXPECT_EQ(m.size(), 2u);
-
- EXPECT_EQ(m[9], 2);
- EXPECT_EQ(m[0], 5);
- EXPECT_FALSE(m.UsingFullMap());
- }
-
- src[8] = 23;
- src[1234] = 90;
- src[-5] = 6;
-
- {
- small_map<std::unordered_map<int, int>> m(src);
- EXPECT_EQ(m[ 9], 2);
- EXPECT_EQ(m[ 0], 5);
- EXPECT_EQ(m[1234], 90);
- EXPECT_EQ(m[ 8], 23);
- EXPECT_EQ(m[ -5], 6);
- EXPECT_EQ(m.size(), 5u);
- EXPECT_FALSE(m.empty());
- EXPECT_TRUE(m.UsingFullMap());
- }
-}
-
-template <class inner>
-static bool SmallMapIsSubset(small_map<inner> const& a,
- small_map<inner> const& b) {
- typename small_map<inner>::const_iterator it;
- for (it = a.begin(); it != a.end(); ++it) {
- typename small_map<inner>::const_iterator it_in_b = b.find(it->first);
- if (it_in_b == b.end() || it_in_b->second != it->second)
- return false;
- }
- return true;
-}
-
-template <class inner>
-static bool SmallMapEqual(small_map<inner> const& a,
- small_map<inner> const& b) {
- return SmallMapIsSubset(a, b) && SmallMapIsSubset(b, a);
-}
-
-TEST(SmallMap, AssignmentOperator) {
- small_map<std::unordered_map<int, int>> src_small;
- small_map<std::unordered_map<int, int>> src_large;
-
- src_small[1] = 20;
- src_small[2] = 21;
- src_small[3] = 22;
- EXPECT_FALSE(src_small.UsingFullMap());
-
- src_large[1] = 20;
- src_large[2] = 21;
- src_large[3] = 22;
- src_large[5] = 23;
- src_large[6] = 24;
- src_large[7] = 25;
- EXPECT_TRUE(src_large.UsingFullMap());
-
- // Assignments to empty.
- small_map<std::unordered_map<int, int>> dest_small;
- dest_small = src_small;
- EXPECT_TRUE(SmallMapEqual(dest_small, src_small));
- EXPECT_EQ(dest_small.UsingFullMap(),
- src_small.UsingFullMap());
-
- small_map<std::unordered_map<int, int>> dest_large;
- dest_large = src_large;
- EXPECT_TRUE(SmallMapEqual(dest_large, src_large));
- EXPECT_EQ(dest_large.UsingFullMap(),
- src_large.UsingFullMap());
-
- // Assignments which assign from full to small, and vice versa.
- dest_small = src_large;
- EXPECT_TRUE(SmallMapEqual(dest_small, src_large));
- EXPECT_EQ(dest_small.UsingFullMap(),
- src_large.UsingFullMap());
-
- dest_large = src_small;
- EXPECT_TRUE(SmallMapEqual(dest_large, src_small));
- EXPECT_EQ(dest_large.UsingFullMap(),
- src_small.UsingFullMap());
-
- // Double check that SmallMapEqual works:
- dest_large[42] = 666;
- EXPECT_FALSE(SmallMapEqual(dest_large, src_small));
-}
-
-TEST(SmallMap, Insert) {
- small_map<std::unordered_map<int, int>> sm;
-
- // loop through the transition from small map to map.
- for (int i = 1; i <= 10; ++i) {
- VLOG(1) << "Iteration " << i;
- // insert an element
- std::pair<small_map<std::unordered_map<int, int>>::iterator, bool> ret;
- ret = sm.insert(std::make_pair(i, 100*i));
- EXPECT_TRUE(ret.second);
- EXPECT_TRUE(ret.first == sm.find(i));
- EXPECT_EQ(ret.first->first, i);
- EXPECT_EQ(ret.first->second, 100*i);
-
- // try to insert it again with different value, fails, but we still get an
- // iterator back with the original value.
- ret = sm.insert(std::make_pair(i, -i));
- EXPECT_FALSE(ret.second);
- EXPECT_TRUE(ret.first == sm.find(i));
- EXPECT_EQ(ret.first->first, i);
- EXPECT_EQ(ret.first->second, 100*i);
-
- // check the state of the map.
- for (int j = 1; j <= i; ++j) {
- small_map<std::unordered_map<int, int>>::iterator it = sm.find(j);
- EXPECT_TRUE(it != sm.end());
- EXPECT_EQ(it->first, j);
- EXPECT_EQ(it->second, j * 100);
- }
- EXPECT_EQ(sm.size(), static_cast<size_t>(i));
- EXPECT_FALSE(sm.empty());
- }
-}
-
-TEST(SmallMap, InsertRange) {
- // loop through the transition from small map to map.
- for (int elements = 0; elements <= 10; ++elements) {
- VLOG(1) << "Elements " << elements;
- std::unordered_map<int, int> normal_map;
- for (int i = 1; i <= elements; ++i) {
- normal_map.insert(std::make_pair(i, 100*i));
- }
-
- small_map<std::unordered_map<int, int>> sm;
- sm.insert(normal_map.begin(), normal_map.end());
- EXPECT_EQ(normal_map.size(), sm.size());
- for (int i = 1; i <= elements; ++i) {
- VLOG(1) << "Iteration " << i;
- EXPECT_TRUE(sm.find(i) != sm.end());
- EXPECT_EQ(sm.find(i)->first, i);
- EXPECT_EQ(sm.find(i)->second, 100*i);
- }
- }
-}
-
-TEST(SmallMap, Erase) {
- small_map<std::unordered_map<std::string, int>> m;
- small_map<std::unordered_map<std::string, int>>::iterator iter;
-
- m["monday"] = 1;
- m["tuesday"] = 2;
- m["wednesday"] = 3;
-
- EXPECT_EQ(m["monday" ], 1);
- EXPECT_EQ(m["tuesday" ], 2);
- EXPECT_EQ(m["wednesday"], 3);
- EXPECT_EQ(m.count("tuesday"), 1u);
- EXPECT_FALSE(m.UsingFullMap());
-
- iter = m.begin();
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, "monday");
- EXPECT_EQ(iter->second, 1);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, "tuesday");
- EXPECT_EQ(iter->second, 2);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, "wednesday");
- EXPECT_EQ(iter->second, 3);
- ++iter;
- EXPECT_TRUE(iter == m.end());
-
- EXPECT_EQ(m.erase("tuesday"), 1u);
-
- EXPECT_EQ(m["monday" ], 1);
- EXPECT_EQ(m["wednesday"], 3);
- EXPECT_EQ(m.count("tuesday"), 0u);
- EXPECT_EQ(m.erase("tuesday"), 0u);
-
- iter = m.begin();
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, "monday");
- EXPECT_EQ(iter->second, 1);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, "wednesday");
- EXPECT_EQ(iter->second, 3);
- ++iter;
- EXPECT_TRUE(iter == m.end());
-
- m["thursday"] = 4;
- m["friday"] = 5;
- EXPECT_EQ(m.size(), 4u);
- EXPECT_FALSE(m.empty());
- EXPECT_FALSE(m.UsingFullMap());
-
- m["saturday"] = 6;
- EXPECT_TRUE(m.UsingFullMap());
-
- EXPECT_EQ(m.count("friday"), 1u);
- EXPECT_EQ(m.erase("friday"), 1u);
- EXPECT_TRUE(m.UsingFullMap());
- EXPECT_EQ(m.count("friday"), 0u);
- EXPECT_EQ(m.erase("friday"), 0u);
-
- EXPECT_EQ(m.size(), 4u);
- EXPECT_FALSE(m.empty());
- EXPECT_EQ(m.erase("monday"), 1u);
- EXPECT_EQ(m.size(), 3u);
- EXPECT_FALSE(m.empty());
-
- m.clear();
- EXPECT_FALSE(m.UsingFullMap());
- EXPECT_EQ(m.size(), 0u);
- EXPECT_TRUE(m.empty());
-}
-
-TEST(SmallMap, EraseReturnsIteratorFollowingRemovedElement) {
- small_map<std::unordered_map<std::string, int>> m;
- small_map<std::unordered_map<std::string, int>>::iterator iter;
-
- m["a"] = 0;
- m["b"] = 1;
- m["c"] = 2;
-
- // Erase first item.
- auto following_iter = m.erase(m.begin());
- EXPECT_EQ(m.begin(), following_iter);
- EXPECT_EQ(2u, m.size());
- EXPECT_EQ(m.count("a"), 0u);
- EXPECT_EQ(m.count("b"), 1u);
- EXPECT_EQ(m.count("c"), 1u);
-
- // Iterate to last item and erase it.
- ++following_iter;
- following_iter = m.erase(following_iter);
- ASSERT_EQ(1u, m.size());
- EXPECT_EQ(m.end(), following_iter);
- EXPECT_EQ(m.count("b"), 0u);
- EXPECT_EQ(m.count("c"), 1u);
-
- // Erase remaining item.
- following_iter = m.erase(m.begin());
- EXPECT_TRUE(m.empty());
- EXPECT_EQ(m.end(), following_iter);
-}
-
-TEST(SmallMap, NonHashMap) {
- small_map<std::map<int, int>, 4, std::equal_to<int>> m;
- EXPECT_TRUE(m.empty());
-
- m[9] = 2;
- m[0] = 5;
-
- EXPECT_EQ(m[9], 2);
- EXPECT_EQ(m[0], 5);
- EXPECT_EQ(m.size(), 2u);
- EXPECT_FALSE(m.empty());
- EXPECT_FALSE(m.UsingFullMap());
-
- small_map<std::map<int, int>, 4, std::equal_to<int>>::iterator iter(
- m.begin());
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 9);
- EXPECT_EQ(iter->second, 2);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 0);
- EXPECT_EQ(iter->second, 5);
- ++iter;
- EXPECT_TRUE(iter == m.end());
- --iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 0);
- EXPECT_EQ(iter->second, 5);
-
- m[8] = 23;
- m[1234] = 90;
- m[-5] = 6;
-
- EXPECT_EQ(m[ 9], 2);
- EXPECT_EQ(m[ 0], 5);
- EXPECT_EQ(m[1234], 90);
- EXPECT_EQ(m[ 8], 23);
- EXPECT_EQ(m[ -5], 6);
- EXPECT_EQ(m.size(), 5u);
- EXPECT_FALSE(m.empty());
- EXPECT_TRUE(m.UsingFullMap());
-
- iter = m.begin();
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, -5);
- EXPECT_EQ(iter->second, 6);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 0);
- EXPECT_EQ(iter->second, 5);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 8);
- EXPECT_EQ(iter->second, 23);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 9);
- EXPECT_EQ(iter->second, 2);
- ++iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 1234);
- EXPECT_EQ(iter->second, 90);
- ++iter;
- EXPECT_TRUE(iter == m.end());
- --iter;
- ASSERT_TRUE(iter != m.end());
- EXPECT_EQ(iter->first, 1234);
- EXPECT_EQ(iter->second, 90);
-}
-
-TEST(SmallMap, DefaultEqualKeyWorks) {
- // If these tests compile, they pass. The EXPECT calls are only there to avoid
- // unused variable warnings.
- small_map<std::unordered_map<int, int>> hm;
- EXPECT_EQ(0u, hm.size());
- small_map<std::map<int, int>> m;
- EXPECT_EQ(0u, m.size());
-}
-
-namespace {
-
-class unordered_map_add_item : public std::unordered_map<int, int> {
- public:
- unordered_map_add_item() = default;
- explicit unordered_map_add_item(const std::pair<int, int>& item) {
- insert(item);
- }
-};
-
-void InitMap(unordered_map_add_item* map_ctor) {
- new (map_ctor) unordered_map_add_item(std::make_pair(0, 0));
-}
-
-class unordered_map_add_item_initializer {
- public:
- explicit unordered_map_add_item_initializer(int item_to_add)
- : item_(item_to_add) {}
- unordered_map_add_item_initializer() : item_(0) {}
- void operator()(unordered_map_add_item* map_ctor) const {
- new (map_ctor) unordered_map_add_item(std::make_pair(item_, item_));
- }
-
- int item_;
-};
-
-} // anonymous namespace
-
-TEST(SmallMap, SubclassInitializationWithFunctionPointer) {
- small_map<unordered_map_add_item, 4, std::equal_to<int>,
- void (&)(unordered_map_add_item*)>
- m(InitMap);
-
- EXPECT_TRUE(m.empty());
-
- m[1] = 1;
- m[2] = 2;
- m[3] = 3;
- m[4] = 4;
-
- EXPECT_EQ(4u, m.size());
- EXPECT_EQ(0u, m.count(0));
-
- m[5] = 5;
- EXPECT_EQ(6u, m.size());
- // Our function adds an extra item when we convert to a map.
- EXPECT_EQ(1u, m.count(0));
-}
-
-TEST(SmallMap, SubclassInitializationWithFunctionObject) {
- small_map<unordered_map_add_item, 4, std::equal_to<int>,
- unordered_map_add_item_initializer>
- m(unordered_map_add_item_initializer(-1));
-
- EXPECT_TRUE(m.empty());
-
- m[1] = 1;
- m[2] = 2;
- m[3] = 3;
- m[4] = 4;
-
- EXPECT_EQ(4u, m.size());
- EXPECT_EQ(0u, m.count(-1));
-
- m[5] = 5;
- EXPECT_EQ(6u, m.size());
- // Our functor adds an extra item when we convert to a map.
- EXPECT_EQ(1u, m.count(-1));
-}
-
-namespace {
-
-// This class acts as a basic implementation of a move-only type. The canonical
-// example of such a type is scoped_ptr/unique_ptr.
-template <typename V>
-class MoveOnlyType {
- public:
- MoveOnlyType() : value_(0) {}
- explicit MoveOnlyType(V value) : value_(value) {}
-
- MoveOnlyType(MoveOnlyType&& other) {
- *this = std::move(other);
- }
-
- MoveOnlyType& operator=(MoveOnlyType&& other) {
- value_ = other.value_;
- other.value_ = 0;
- return *this;
- }
-
- MoveOnlyType(const MoveOnlyType&) = delete;
- MoveOnlyType& operator=(const MoveOnlyType&) = delete;
-
- V value() const { return value_; }
-
- private:
- V value_;
-};
-
-} // namespace
-
-TEST(SmallMap, MoveOnlyValueType) {
- small_map<std::map<int, MoveOnlyType<int>>, 2> m;
-
- m[0] = MoveOnlyType<int>(1);
- m[1] = MoveOnlyType<int>(2);
- m.erase(m.begin());
-
- // small_map will move m[1] to an earlier index in the internal array.
- EXPECT_EQ(m.size(), 1u);
- EXPECT_EQ(m[1].value(), 2);
-
- m[0] = MoveOnlyType<int>(1);
- // small_map must move the values from the array into the internal std::map.
- m[2] = MoveOnlyType<int>(3);
-
- EXPECT_EQ(m.size(), 3u);
- EXPECT_EQ(m[0].value(), 1);
- EXPECT_EQ(m[1].value(), 2);
- EXPECT_EQ(m[2].value(), 3);
-
- m.erase(m.begin());
-
- // small_map should also let internal std::map erase with a move-only type.
- EXPECT_EQ(m.size(), 2u);
- EXPECT_EQ(m[1].value(), 2);
- EXPECT_EQ(m[2].value(), 3);
-}
-
-TEST(SmallMap, Emplace) {
- small_map<std::map<size_t, MoveOnlyType<size_t>>> sm;
-
- // loop through the transition from small map to map.
- for (size_t i = 1; i <= 10; ++i) {
- // insert an element
- auto ret = sm.emplace(i, MoveOnlyType<size_t>(100 * i));
- EXPECT_TRUE(ret.second);
- EXPECT_TRUE(ret.first == sm.find(i));
- EXPECT_EQ(ret.first->first, i);
- EXPECT_EQ(ret.first->second.value(), 100 * i);
-
- // try to insert it again with different value, fails, but we still get an
- // iterator back with the original value.
- ret = sm.emplace(i, MoveOnlyType<size_t>(i));
- EXPECT_FALSE(ret.second);
- EXPECT_TRUE(ret.first == sm.find(i));
- EXPECT_EQ(ret.first->first, i);
- EXPECT_EQ(ret.first->second.value(), 100 * i);
-
- // check the state of the map.
- for (size_t j = 1; j <= i; ++j) {
- const auto it = sm.find(j);
- EXPECT_TRUE(it != sm.end());
- EXPECT_EQ(it->first, j);
- EXPECT_EQ(it->second.value(), j * 100);
- }
- EXPECT_EQ(sm.size(), i);
- EXPECT_FALSE(sm.empty());
- }
-}
-
-} // namespace base
diff --git a/base/containers/span_unittest.cc b/base/containers/span_unittest.cc
deleted file mode 100644
index de5e401..0000000
--- a/base/containers/span_unittest.cc
+++ /dev/null
@@ -1,1170 +0,0 @@
-// Copyright 2017 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 "base/containers/span.h"
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::ElementsAre;
-using ::testing::Eq;
-using ::testing::Pointwise;
-
-namespace base {
-
-TEST(SpanTest, DefaultConstructor) {
- span<int> dynamic_span;
- EXPECT_EQ(nullptr, dynamic_span.data());
- EXPECT_EQ(0u, dynamic_span.size());
-
- constexpr span<int, 0> static_span;
- static_assert(nullptr == static_span.data(), "");
- static_assert(0u == static_span.size(), "");
-}
-
-TEST(SpanTest, ConstructFromDataAndSize) {
- constexpr span<int> empty_span(nullptr, 0);
- EXPECT_TRUE(empty_span.empty());
- EXPECT_EQ(nullptr, empty_span.data());
-
- std::vector<int> vector = {1, 1, 2, 3, 5, 8};
-
- span<int> dynamic_span(vector.data(), vector.size());
- EXPECT_EQ(vector.data(), dynamic_span.data());
- EXPECT_EQ(vector.size(), dynamic_span.size());
-
- for (size_t i = 0; i < dynamic_span.size(); ++i)
- EXPECT_EQ(vector[i], dynamic_span[i]);
-
- span<int, 6> static_span(vector.data(), vector.size());
- EXPECT_EQ(vector.data(), static_span.data());
- EXPECT_EQ(vector.size(), static_span.size());
-
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(vector[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromPointerPair) {
- constexpr span<int> empty_span(nullptr, nullptr);
- EXPECT_TRUE(empty_span.empty());
- EXPECT_EQ(nullptr, empty_span.data());
-
- std::vector<int> vector = {1, 1, 2, 3, 5, 8};
-
- span<int> dynamic_span(vector.data(), vector.data() + vector.size() / 2);
- EXPECT_EQ(vector.data(), dynamic_span.data());
- EXPECT_EQ(vector.size() / 2, dynamic_span.size());
-
- for (size_t i = 0; i < dynamic_span.size(); ++i)
- EXPECT_EQ(vector[i], dynamic_span[i]);
-
- span<int, 3> static_span(vector.data(), vector.data() + vector.size() / 2);
- EXPECT_EQ(vector.data(), static_span.data());
- EXPECT_EQ(vector.size() / 2, static_span.size());
-
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(vector[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromConstexprArray) {
- static constexpr int kArray[] = {5, 4, 3, 2, 1};
-
- constexpr span<const int> dynamic_span(kArray);
- static_assert(kArray == dynamic_span.data(), "");
- static_assert(base::size(kArray) == dynamic_span.size(), "");
-
- static_assert(kArray[0] == dynamic_span[0], "");
- static_assert(kArray[1] == dynamic_span[1], "");
- static_assert(kArray[2] == dynamic_span[2], "");
- static_assert(kArray[3] == dynamic_span[3], "");
- static_assert(kArray[4] == dynamic_span[4], "");
-
- constexpr span<const int, base::size(kArray)> static_span(kArray);
- static_assert(kArray == static_span.data(), "");
- static_assert(base::size(kArray) == static_span.size(), "");
-
- static_assert(kArray[0] == static_span[0], "");
- static_assert(kArray[1] == static_span[1], "");
- static_assert(kArray[2] == static_span[2], "");
- static_assert(kArray[3] == static_span[3], "");
- static_assert(kArray[4] == static_span[4], "");
-}
-
-TEST(SpanTest, ConstructFromArray) {
- int array[] = {5, 4, 3, 2, 1};
-
- span<const int> const_span(array);
- EXPECT_EQ(array, const_span.data());
- EXPECT_EQ(arraysize(array), const_span.size());
- for (size_t i = 0; i < const_span.size(); ++i)
- EXPECT_EQ(array[i], const_span[i]);
-
- span<int> dynamic_span(array);
- EXPECT_EQ(array, dynamic_span.data());
- EXPECT_EQ(base::size(array), dynamic_span.size());
- for (size_t i = 0; i < dynamic_span.size(); ++i)
- EXPECT_EQ(array[i], dynamic_span[i]);
-
- span<int, base::size(array)> static_span(array);
- EXPECT_EQ(array, static_span.data());
- EXPECT_EQ(base::size(array), static_span.size());
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(array[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromStdArray) {
- // Note: Constructing a constexpr span from a constexpr std::array does not
- // work prior to C++17 due to non-constexpr std::array::data.
- std::array<int, 5> array = {{5, 4, 3, 2, 1}};
-
- span<const int> const_span(array);
- EXPECT_EQ(array.data(), const_span.data());
- EXPECT_EQ(array.size(), const_span.size());
- for (size_t i = 0; i < const_span.size(); ++i)
- EXPECT_EQ(array[i], const_span[i]);
-
- span<int> dynamic_span(array);
- EXPECT_EQ(array.data(), dynamic_span.data());
- EXPECT_EQ(array.size(), dynamic_span.size());
- for (size_t i = 0; i < dynamic_span.size(); ++i)
- EXPECT_EQ(array[i], dynamic_span[i]);
-
- span<int, base::size(array)> static_span(array);
- EXPECT_EQ(array.data(), static_span.data());
- EXPECT_EQ(array.size(), static_span.size());
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(array[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromInitializerList) {
- std::initializer_list<int> il = {1, 1, 2, 3, 5, 8};
-
- span<const int> const_span(il);
- EXPECT_EQ(il.begin(), const_span.data());
- EXPECT_EQ(il.size(), const_span.size());
-
- for (size_t i = 0; i < const_span.size(); ++i)
- EXPECT_EQ(il.begin()[i], const_span[i]);
-
- span<const int, 6> static_span(il);
- EXPECT_EQ(il.begin(), static_span.data());
- EXPECT_EQ(il.size(), static_span.size());
-
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(il.begin()[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromStdString) {
- std::string str = "foobar";
-
- span<const char> const_span(str);
- EXPECT_EQ(str.data(), const_span.data());
- EXPECT_EQ(str.size(), const_span.size());
-
- for (size_t i = 0; i < const_span.size(); ++i)
- EXPECT_EQ(str[i], const_span[i]);
-
- span<char> dynamic_span(str);
- EXPECT_EQ(str.data(), dynamic_span.data());
- EXPECT_EQ(str.size(), dynamic_span.size());
-
- for (size_t i = 0; i < dynamic_span.size(); ++i)
- EXPECT_EQ(str[i], dynamic_span[i]);
-
- span<char, 6> static_span(str);
- EXPECT_EQ(str.data(), static_span.data());
- EXPECT_EQ(str.size(), static_span.size());
-
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(str[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromConstContainer) {
- const std::vector<int> vector = {1, 1, 2, 3, 5, 8};
-
- span<const int> const_span(vector);
- EXPECT_EQ(vector.data(), const_span.data());
- EXPECT_EQ(vector.size(), const_span.size());
-
- for (size_t i = 0; i < const_span.size(); ++i)
- EXPECT_EQ(vector[i], const_span[i]);
-
- span<const int, 6> static_span(vector);
- EXPECT_EQ(vector.data(), static_span.data());
- EXPECT_EQ(vector.size(), static_span.size());
-
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(vector[i], static_span[i]);
-}
-
-TEST(SpanTest, ConstructFromContainer) {
- std::vector<int> vector = {1, 1, 2, 3, 5, 8};
-
- span<const int> const_span(vector);
- EXPECT_EQ(vector.data(), const_span.data());
- EXPECT_EQ(vector.size(), const_span.size());
-
- for (size_t i = 0; i < const_span.size(); ++i)
- EXPECT_EQ(vector[i], const_span[i]);
-
- span<int> dynamic_span(vector);
- EXPECT_EQ(vector.data(), dynamic_span.data());
- EXPECT_EQ(vector.size(), dynamic_span.size());
-
- for (size_t i = 0; i < dynamic_span.size(); ++i)
- EXPECT_EQ(vector[i], dynamic_span[i]);
-
- span<int, 6> static_span(vector);
- EXPECT_EQ(vector.data(), static_span.data());
- EXPECT_EQ(vector.size(), static_span.size());
-
- for (size_t i = 0; i < static_span.size(); ++i)
- EXPECT_EQ(vector[i], static_span[i]);
-}
-
-TEST(SpanTest, ConvertNonConstIntegralToConst) {
- std::vector<int> vector = {1, 1, 2, 3, 5, 8};
-
- span<int> int_span(vector.data(), vector.size());
- span<const int> const_span(int_span);
- EXPECT_THAT(const_span, Pointwise(Eq(), int_span));
-
- span<int, 6> static_int_span(vector.data(), vector.size());
- span<const int, 6> static_const_span(static_int_span);
- EXPECT_THAT(static_const_span, Pointwise(Eq(), static_int_span));
-}
-
-TEST(SpanTest, ConvertNonConstPointerToConst) {
- auto a = std::make_unique<int>(11);
- auto b = std::make_unique<int>(22);
- auto c = std::make_unique<int>(33);
- std::vector<int*> vector = {a.get(), b.get(), c.get()};
-
- span<int*> non_const_pointer_span(vector);
- EXPECT_THAT(non_const_pointer_span, Pointwise(Eq(), vector));
- span<int* const> const_pointer_span(non_const_pointer_span);
- EXPECT_THAT(const_pointer_span, Pointwise(Eq(), non_const_pointer_span));
- // Note: no test for conversion from span<int> to span<const int*>, since that
- // would imply a conversion from int** to const int**, which is unsafe.
- //
- // Note: no test for conversion from span<int*> to span<const int* const>,
- // due to CWG Defect 330:
- // http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#330
-
- span<int*, 3> static_non_const_pointer_span(vector);
- EXPECT_THAT(static_non_const_pointer_span, Pointwise(Eq(), vector));
- span<int* const, 3> static_const_pointer_span(static_non_const_pointer_span);
- EXPECT_THAT(static_const_pointer_span,
- Pointwise(Eq(), static_non_const_pointer_span));
-}
-
-TEST(SpanTest, ConvertBetweenEquivalentTypes) {
- std::vector<int32_t> vector = {2, 4, 8, 16, 32};
-
- span<int32_t> int32_t_span(vector);
- span<int> converted_span(int32_t_span);
- EXPECT_EQ(int32_t_span, converted_span);
-
- span<int32_t, 5> static_int32_t_span(vector);
- span<int, 5> static_converted_span(static_int32_t_span);
- EXPECT_EQ(static_int32_t_span, static_converted_span);
-}
-
-TEST(SpanTest, TemplatedFirst) {
- static constexpr int array[] = {1, 2, 3};
- constexpr span<const int, 3> span(array);
-
- {
- constexpr auto subspan = span.first<0>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(0u == subspan.size(), "");
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- constexpr auto subspan = span.first<1>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(1u == subspan.size(), "");
- static_assert(1u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- }
-
- {
- constexpr auto subspan = span.first<2>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(2u == subspan.size(), "");
- static_assert(2u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- static_assert(2 == subspan[1], "");
- }
-
- {
- constexpr auto subspan = span.first<3>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(3u == subspan.size(), "");
- static_assert(3u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- static_assert(2 == subspan[1], "");
- static_assert(3 == subspan[2], "");
- }
-}
-
-TEST(SpanTest, TemplatedLast) {
- static constexpr int array[] = {1, 2, 3};
- constexpr span<const int, 3> span(array);
-
- {
- constexpr auto subspan = span.last<0>();
- static_assert(span.data() + 3 == subspan.data(), "");
- static_assert(0u == subspan.size(), "");
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- constexpr auto subspan = span.last<1>();
- static_assert(span.data() + 2 == subspan.data(), "");
- static_assert(1u == subspan.size(), "");
- static_assert(1u == decltype(subspan)::extent, "");
- static_assert(3 == subspan[0], "");
- }
-
- {
- constexpr auto subspan = span.last<2>();
- static_assert(span.data() + 1 == subspan.data(), "");
- static_assert(2u == subspan.size(), "");
- static_assert(2u == decltype(subspan)::extent, "");
- static_assert(2 == subspan[0], "");
- static_assert(3 == subspan[1], "");
- }
-
- {
- constexpr auto subspan = span.last<3>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(3u == subspan.size(), "");
- static_assert(3u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- static_assert(2 == subspan[1], "");
- static_assert(3 == subspan[2], "");
- }
-}
-
-TEST(SpanTest, TemplatedSubspan) {
- static constexpr int array[] = {1, 2, 3};
- constexpr span<const int, 3> span(array);
-
- {
- constexpr auto subspan = span.subspan<0>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(3u == subspan.size(), "");
- static_assert(3u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- static_assert(2 == subspan[1], "");
- static_assert(3 == subspan[2], "");
- }
-
- {
- constexpr auto subspan = span.subspan<1>();
- static_assert(span.data() + 1 == subspan.data(), "");
- static_assert(2u == subspan.size(), "");
- static_assert(2u == decltype(subspan)::extent, "");
- static_assert(2 == subspan[0], "");
- static_assert(3 == subspan[1], "");
- }
-
- {
- constexpr auto subspan = span.subspan<2>();
- static_assert(span.data() + 2 == subspan.data(), "");
- static_assert(1u == subspan.size(), "");
- static_assert(1u == decltype(subspan)::extent, "");
- static_assert(3 == subspan[0], "");
- }
-
- {
- constexpr auto subspan = span.subspan<3>();
- static_assert(span.data() + 3 == subspan.data(), "");
- static_assert(0u == subspan.size(), "");
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- constexpr auto subspan = span.subspan<0, 0>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(0u == subspan.size(), "");
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- constexpr auto subspan = span.subspan<1, 0>();
- static_assert(span.data() + 1 == subspan.data(), "");
- static_assert(0u == subspan.size(), "");
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- constexpr auto subspan = span.subspan<2, 0>();
- static_assert(span.data() + 2 == subspan.data(), "");
- static_assert(0u == subspan.size(), "");
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- constexpr auto subspan = span.subspan<0, 1>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(1u == subspan.size(), "");
- static_assert(1u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- }
-
- {
- constexpr auto subspan = span.subspan<1, 1>();
- static_assert(span.data() + 1 == subspan.data(), "");
- static_assert(1u == subspan.size(), "");
- static_assert(1u == decltype(subspan)::extent, "");
- static_assert(2 == subspan[0], "");
- }
-
- {
- constexpr auto subspan = span.subspan<2, 1>();
- static_assert(span.data() + 2 == subspan.data(), "");
- static_assert(1u == subspan.size(), "");
- static_assert(1u == decltype(subspan)::extent, "");
- static_assert(3 == subspan[0], "");
- }
-
- {
- constexpr auto subspan = span.subspan<0, 2>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(2u == subspan.size(), "");
- static_assert(2u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- static_assert(2 == subspan[1], "");
- }
-
- {
- constexpr auto subspan = span.subspan<1, 2>();
- static_assert(span.data() + 1 == subspan.data(), "");
- static_assert(2u == subspan.size(), "");
- static_assert(2u == decltype(subspan)::extent, "");
- static_assert(2 == subspan[0], "");
- static_assert(3 == subspan[1], "");
- }
-
- {
- constexpr auto subspan = span.subspan<0, 3>();
- static_assert(span.data() == subspan.data(), "");
- static_assert(3u == subspan.size(), "");
- static_assert(3u == decltype(subspan)::extent, "");
- static_assert(1 == subspan[0], "");
- static_assert(2 == subspan[1], "");
- static_assert(3 == subspan[2], "");
- }
-}
-
-TEST(SpanTest, TemplatedFirstOnDynamicSpan) {
- int array[] = {1, 2, 3};
- span<const int> span(array);
-
- {
- auto subspan = span.first<0>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(0u, subspan.size());
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- auto subspan = span.first<1>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(1u, subspan.size());
- static_assert(1u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- }
-
- {
- auto subspan = span.first<2>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(2u, subspan.size());
- static_assert(2u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- }
-
- {
- auto subspan = span.first<3>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(3u, subspan.size());
- static_assert(3u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-}
-
-TEST(SpanTest, TemplatedLastOnDynamicSpan) {
- int array[] = {1, 2, 3};
- span<int> span(array);
-
- {
- auto subspan = span.last<0>();
- EXPECT_EQ(span.data() + 3, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- auto subspan = span.last<1>();
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- static_assert(1u == decltype(subspan)::extent, "");
- EXPECT_EQ(3, subspan[0]);
- }
-
- {
- auto subspan = span.last<2>();
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(2u, subspan.size());
- static_assert(2u == decltype(subspan)::extent, "");
- EXPECT_EQ(2, subspan[0]);
- EXPECT_EQ(3, subspan[1]);
- }
-
- {
- auto subspan = span.last<3>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(3u, subspan.size());
- static_assert(3u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-}
-
-TEST(SpanTest, TemplatedSubspanFromDynamicSpan) {
- int array[] = {1, 2, 3};
- span<int, 3> span(array);
-
- {
- auto subspan = span.subspan<0>();
- EXPECT_EQ(span.data(), subspan.data());
- static_assert(3u == decltype(subspan)::extent, "");
- EXPECT_EQ(3u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-
- {
- auto subspan = span.subspan<1>();
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(2u, subspan.size());
- static_assert(2u == decltype(subspan)::extent, "");
- EXPECT_EQ(2, subspan[0]);
- EXPECT_EQ(3, subspan[1]);
- }
-
- {
- auto subspan = span.subspan<2>();
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- static_assert(1u == decltype(subspan)::extent, "");
- EXPECT_EQ(3, subspan[0]);
- }
-
- {
- auto subspan = span.subspan<3>();
- EXPECT_EQ(span.data() + 3, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- auto subspan = span.subspan<0, 0>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(0u, subspan.size());
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- auto subspan = span.subspan<1, 0>();
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- auto subspan = span.subspan<2, 0>();
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- static_assert(0u == decltype(subspan)::extent, "");
- }
-
- {
- auto subspan = span.subspan<0, 1>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(1u, subspan.size());
- static_assert(1u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- }
-
- {
- auto subspan = span.subspan<1, 1>();
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- static_assert(1u == decltype(subspan)::extent, "");
- EXPECT_EQ(2, subspan[0]);
- }
-
- {
- auto subspan = span.subspan<2, 1>();
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- static_assert(1u == decltype(subspan)::extent, "");
- EXPECT_EQ(3, subspan[0]);
- }
-
- {
- auto subspan = span.subspan<0, 2>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(2u, subspan.size());
- static_assert(2u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- }
-
- {
- auto subspan = span.subspan<1, 2>();
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(2u, subspan.size());
- static_assert(2u == decltype(subspan)::extent, "");
- EXPECT_EQ(2, subspan[0]);
- EXPECT_EQ(3, subspan[1]);
- }
-
- {
- auto subspan = span.subspan<0, 3>();
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(3u, subspan.size());
- static_assert(3u == decltype(subspan)::extent, "");
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-}
-
-TEST(SpanTest, First) {
- int array[] = {1, 2, 3};
- span<int> span(array);
-
- {
- auto subspan = span.first(0);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(0u, subspan.size());
- }
-
- {
- auto subspan = span.first(1);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(1u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- }
-
- {
- auto subspan = span.first(2);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(2u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- }
-
- {
- auto subspan = span.first(3);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(3u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-}
-
-TEST(SpanTest, Last) {
- int array[] = {1, 2, 3};
- span<int> span(array);
-
- {
- auto subspan = span.last(0);
- EXPECT_EQ(span.data() + 3, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- }
-
- {
- auto subspan = span.last(1);
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- EXPECT_EQ(3, subspan[0]);
- }
-
- {
- auto subspan = span.last(2);
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(2u, subspan.size());
- EXPECT_EQ(2, subspan[0]);
- EXPECT_EQ(3, subspan[1]);
- }
-
- {
- auto subspan = span.last(3);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(3u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-}
-
-TEST(SpanTest, Subspan) {
- int array[] = {1, 2, 3};
- span<int> span(array);
-
- {
- auto subspan = span.subspan(0);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(3u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-
- {
- auto subspan = span.subspan(1);
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(2u, subspan.size());
- EXPECT_EQ(2, subspan[0]);
- EXPECT_EQ(3, subspan[1]);
- }
-
- {
- auto subspan = span.subspan(2);
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- EXPECT_EQ(3, subspan[0]);
- }
-
- {
- auto subspan = span.subspan(3);
- EXPECT_EQ(span.data() + 3, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- }
-
- {
- auto subspan = span.subspan(0, 0);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(0u, subspan.size());
- }
-
- {
- auto subspan = span.subspan(1, 0);
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- }
-
- {
- auto subspan = span.subspan(2, 0);
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(0u, subspan.size());
- }
-
- {
- auto subspan = span.subspan(0, 1);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(1u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- }
-
- {
- auto subspan = span.subspan(1, 1);
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- EXPECT_EQ(2, subspan[0]);
- }
-
- {
- auto subspan = span.subspan(2, 1);
- EXPECT_EQ(span.data() + 2, subspan.data());
- EXPECT_EQ(1u, subspan.size());
- EXPECT_EQ(3, subspan[0]);
- }
-
- {
- auto subspan = span.subspan(0, 2);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(2u, subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- }
-
- {
- auto subspan = span.subspan(1, 2);
- EXPECT_EQ(span.data() + 1, subspan.data());
- EXPECT_EQ(2u, subspan.size());
- EXPECT_EQ(2, subspan[0]);
- EXPECT_EQ(3, subspan[1]);
- }
-
- {
- auto subspan = span.subspan(0, 3);
- EXPECT_EQ(span.data(), subspan.data());
- EXPECT_EQ(span.size(), subspan.size());
- EXPECT_EQ(1, subspan[0]);
- EXPECT_EQ(2, subspan[1]);
- EXPECT_EQ(3, subspan[2]);
- }
-}
-
-TEST(SpanTest, Size) {
- {
- span<int> span;
- EXPECT_EQ(0u, span.size());
- }
-
- {
- int array[] = {1, 2, 3};
- span<int> span(array);
- EXPECT_EQ(3u, span.size());
- }
-}
-
-TEST(SpanTest, SizeBytes) {
- {
- span<int> span;
- EXPECT_EQ(0u, span.size_bytes());
- }
-
- {
- int array[] = {1, 2, 3};
- span<int> span(array);
- EXPECT_EQ(3u * sizeof(int), span.size_bytes());
- }
-}
-
-TEST(SpanTest, Empty) {
- {
- span<int> span;
- EXPECT_TRUE(span.empty());
- }
-
- {
- int array[] = {1, 2, 3};
- span<int> span(array);
- EXPECT_FALSE(span.empty());
- }
-}
-
-TEST(SpanTest, OperatorAt) {
- static constexpr int kArray[] = {1, 6, 1, 8, 0};
- constexpr span<const int> span(kArray);
-
- static_assert(kArray[0] == span[0], "span[0] does not equal kArray[0]");
- static_assert(kArray[1] == span[1], "span[1] does not equal kArray[1]");
- static_assert(kArray[2] == span[2], "span[2] does not equal kArray[2]");
- static_assert(kArray[3] == span[3], "span[3] does not equal kArray[3]");
- static_assert(kArray[4] == span[4], "span[4] does not equal kArray[4]");
-
- static_assert(kArray[0] == span(0), "span(0) does not equal kArray[0]");
- static_assert(kArray[1] == span(1), "span(1) does not equal kArray[1]");
- static_assert(kArray[2] == span(2), "span(2) does not equal kArray[2]");
- static_assert(kArray[3] == span(3), "span(3) does not equal kArray[3]");
- static_assert(kArray[4] == span(4), "span(4) does not equal kArray[4]");
-}
-
-TEST(SpanTest, Iterator) {
- static constexpr int kArray[] = {1, 6, 1, 8, 0};
- constexpr span<const int> span(kArray);
-
- std::vector<int> results;
- for (int i : span)
- results.emplace_back(i);
- EXPECT_THAT(results, ElementsAre(1, 6, 1, 8, 0));
-}
-
-TEST(SpanTest, ReverseIterator) {
- static constexpr int kArray[] = {1, 6, 1, 8, 0};
- constexpr span<const int> span(kArray);
-
- EXPECT_TRUE(std::equal(std::rbegin(kArray), std::rend(kArray), span.rbegin(),
- span.rend()));
- EXPECT_TRUE(std::equal(std::crbegin(kArray), std::crend(kArray),
- span.crbegin(), span.crend()));
-}
-
-TEST(SpanTest, Equality) {
- static constexpr int kArray1[] = {3, 1, 4, 1, 5};
- static constexpr int kArray2[] = {3, 1, 4, 1, 5};
- constexpr span<const int> span1(kArray1);
- constexpr span<const int, 5> span2(kArray2);
-
- EXPECT_EQ(span1, span2);
-
- static constexpr int kArray3[] = {2, 7, 1, 8, 3};
- constexpr span<const int> span3(kArray3);
-
- EXPECT_FALSE(span1 == span3);
-
- static double kArray4[] = {2.0, 7.0, 1.0, 8.0, 3.0};
- span<double, 5> span4(kArray4);
-
- EXPECT_EQ(span3, span4);
-}
-
-TEST(SpanTest, Inequality) {
- static constexpr int kArray1[] = {2, 3, 5, 7, 11};
- static constexpr int kArray2[] = {1, 4, 6, 8, 9};
- constexpr span<const int> span1(kArray1);
- constexpr span<const int, 5> span2(kArray2);
-
- EXPECT_NE(span1, span2);
-
- static constexpr int kArray3[] = {2, 3, 5, 7, 11};
- constexpr span<const int> span3(kArray3);
-
- EXPECT_FALSE(span1 != span3);
-
- static double kArray4[] = {1.0, 4.0, 6.0, 8.0, 9.0};
- span<double, 5> span4(kArray4);
-
- EXPECT_NE(span3, span4);
-}
-
-TEST(SpanTest, LessThan) {
- static constexpr int kArray1[] = {2, 3, 5, 7, 11};
- static constexpr int kArray2[] = {2, 3, 5, 7, 11, 13};
- constexpr span<const int> span1(kArray1);
- constexpr span<const int, 6> span2(kArray2);
-
- EXPECT_LT(span1, span2);
-
- static constexpr int kArray3[] = {2, 3, 5, 7, 11};
- constexpr span<const int> span3(kArray3);
-
- EXPECT_FALSE(span1 < span3);
-
- static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0, 13.0};
- span<double, 6> span4(kArray4);
-
- EXPECT_LT(span3, span4);
-}
-
-TEST(SpanTest, LessEqual) {
- static constexpr int kArray1[] = {2, 3, 5, 7, 11};
- static constexpr int kArray2[] = {2, 3, 5, 7, 11, 13};
- constexpr span<const int> span1(kArray1);
- constexpr span<const int, 6> span2(kArray2);
-
- EXPECT_LE(span1, span1);
- EXPECT_LE(span1, span2);
-
- static constexpr int kArray3[] = {2, 3, 5, 7, 10};
- constexpr span<const int> span3(kArray3);
-
- EXPECT_FALSE(span1 <= span3);
-
- static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0, 13.0};
- span<double, 6> span4(kArray4);
-
- EXPECT_LE(span3, span4);
-}
-
-TEST(SpanTest, GreaterThan) {
- static constexpr int kArray1[] = {2, 3, 5, 7, 11, 13};
- static constexpr int kArray2[] = {2, 3, 5, 7, 11};
- constexpr span<const int> span1(kArray1);
- constexpr span<const int, 5> span2(kArray2);
-
- EXPECT_GT(span1, span2);
-
- static constexpr int kArray3[] = {2, 3, 5, 7, 11, 13};
- constexpr span<const int> span3(kArray3);
-
- EXPECT_FALSE(span1 > span3);
-
- static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0};
- span<double, 5> span4(kArray4);
-
- EXPECT_GT(span3, span4);
-}
-
-TEST(SpanTest, GreaterEqual) {
- static constexpr int kArray1[] = {2, 3, 5, 7, 11, 13};
- static constexpr int kArray2[] = {2, 3, 5, 7, 11};
- constexpr span<const int> span1(kArray1);
- constexpr span<const int, 5> span2(kArray2);
-
- EXPECT_GE(span1, span1);
- EXPECT_GE(span1, span2);
-
- static constexpr int kArray3[] = {2, 3, 5, 7, 12};
- constexpr span<const int> span3(kArray3);
-
- EXPECT_FALSE(span1 >= span3);
-
- static double kArray4[] = {2.0, 3.0, 5.0, 7.0, 11.0};
- span<double, 5> span4(kArray4);
-
- EXPECT_GE(span3, span4);
-}
-
-TEST(SpanTest, AsBytes) {
- {
- constexpr int kArray[] = {2, 3, 5, 7, 11, 13};
- span<const uint8_t, sizeof(kArray)> bytes_span =
- as_bytes(make_span(kArray));
- EXPECT_EQ(reinterpret_cast<const uint8_t*>(kArray), bytes_span.data());
- EXPECT_EQ(sizeof(kArray), bytes_span.size());
- EXPECT_EQ(bytes_span.size(), bytes_span.size_bytes());
- }
-
- {
- std::vector<int> vec = {1, 1, 2, 3, 5, 8};
- span<int> mutable_span(vec);
- span<const uint8_t> bytes_span = as_bytes(mutable_span);
- EXPECT_EQ(reinterpret_cast<const uint8_t*>(vec.data()), bytes_span.data());
- EXPECT_EQ(sizeof(int) * vec.size(), bytes_span.size());
- EXPECT_EQ(bytes_span.size(), bytes_span.size_bytes());
- }
-}
-
-TEST(SpanTest, AsWritableBytes) {
- std::vector<int> vec = {1, 1, 2, 3, 5, 8};
- span<int> mutable_span(vec);
- span<uint8_t> writable_bytes_span = as_writable_bytes(mutable_span);
- EXPECT_EQ(reinterpret_cast<uint8_t*>(vec.data()), writable_bytes_span.data());
- EXPECT_EQ(sizeof(int) * vec.size(), writable_bytes_span.size());
- EXPECT_EQ(writable_bytes_span.size(), writable_bytes_span.size_bytes());
-
- // Set the first entry of vec to zero while writing through the span.
- std::fill(writable_bytes_span.data(),
- writable_bytes_span.data() + sizeof(int), 0);
- EXPECT_EQ(0, vec[0]);
-}
-
-TEST(SpanTest, MakeSpanFromDataAndSize) {
- int* nullint = nullptr;
- auto empty_span = make_span(nullint, 0);
- EXPECT_TRUE(empty_span.empty());
- EXPECT_EQ(nullptr, empty_span.data());
-
- std::vector<int> vector = {1, 1, 2, 3, 5, 8};
- span<int> span(vector.data(), vector.size());
- auto made_span = make_span(vector.data(), vector.size());
- EXPECT_EQ(span, made_span);
- static_assert(decltype(made_span)::extent == dynamic_extent, "");
-}
-
-TEST(SpanTest, MakeSpanFromPointerPair) {
- int* nullint = nullptr;
- auto empty_span = make_span(nullint, nullint);
- EXPECT_TRUE(empty_span.empty());
- EXPECT_EQ(nullptr, empty_span.data());
-
- std::vector<int> vector = {1, 1, 2, 3, 5, 8};
- span<int> span(vector.data(), vector.size());
- auto made_span = make_span(vector.data(), vector.data() + vector.size());
- EXPECT_EQ(span, made_span);
- static_assert(decltype(made_span)::extent == dynamic_extent, "");
-}
-
-TEST(SpanTest, MakeSpanFromConstexprArray) {
- static constexpr int kArray[] = {1, 2, 3, 4, 5};
- constexpr span<const int> span(kArray);
- EXPECT_EQ(span, make_span(kArray));
- static_assert(decltype(make_span(kArray))::extent == 5, "");
-}
-
-TEST(SpanTest, MakeSpanFromStdArray) {
- const std::array<int, 5> kArray = {{1, 2, 3, 4, 5}};
- span<const int> span(kArray);
- EXPECT_EQ(span, make_span(kArray));
- static_assert(decltype(make_span(kArray))::extent == 5, "");
-}
-
-TEST(SpanTest, MakeSpanFromConstContainer) {
- const std::vector<int> vector = {-1, -2, -3, -4, -5};
- span<const int> span(vector);
- EXPECT_EQ(span, make_span(vector));
- static_assert(decltype(make_span(vector))::extent == dynamic_extent, "");
-}
-
-TEST(SpanTest, MakeSpanFromContainer) {
- std::vector<int> vector = {-1, -2, -3, -4, -5};
- span<int> span(vector);
- EXPECT_EQ(span, make_span(vector));
- static_assert(decltype(make_span(vector))::extent == dynamic_extent, "");
-}
-
-TEST(SpanTest, MakeSpanFromDynamicSpan) {
- static constexpr int kArray[] = {1, 2, 3, 4, 5};
- constexpr span<const int> span(kArray);
- static_assert(std::is_same<decltype(span)::element_type,
- decltype(make_span(span))::element_type>::value,
- "make_span(span) should have the same element_type as span");
-
- static_assert(span.data() == make_span(span).data(),
- "make_span(span) should have the same data() as span");
-
- static_assert(span.size() == make_span(span).size(),
- "make_span(span) should have the same size() as span");
-
- static_assert(decltype(make_span(span))::extent == decltype(span)::extent,
- "make_span(span) should have the same extent as span");
-}
-
-TEST(SpanTest, MakeSpanFromStaticSpan) {
- static constexpr int kArray[] = {1, 2, 3, 4, 5};
- constexpr span<const int, 5> span(kArray);
- static_assert(std::is_same<decltype(span)::element_type,
- decltype(make_span(span))::element_type>::value,
- "make_span(span) should have the same element_type as span");
-
- static_assert(span.data() == make_span(span).data(),
- "make_span(span) should have the same data() as span");
-
- static_assert(span.size() == make_span(span).size(),
- "make_span(span) should have the same size() as span");
-
- static_assert(decltype(make_span(span))::extent == decltype(span)::extent,
- "make_span(span) should have the same extent as span");
-}
-
-TEST(SpanTest, EnsureConstexprGoodness) {
- static constexpr int kArray[] = {5, 4, 3, 2, 1};
- constexpr span<const int> constexpr_span(kArray);
- const size_t size = 2;
-
- const size_t start = 1;
- constexpr span<const int> subspan =
- constexpr_span.subspan(start, start + size);
- for (size_t i = 0; i < subspan.size(); ++i)
- EXPECT_EQ(kArray[start + i], subspan[i]);
-
- constexpr span<const int> firsts = constexpr_span.first(size);
- for (size_t i = 0; i < firsts.size(); ++i)
- EXPECT_EQ(kArray[i], firsts[i]);
-
- constexpr span<const int> lasts = constexpr_span.last(size);
- for (size_t i = 0; i < lasts.size(); ++i) {
- const size_t j = (arraysize(kArray) - size) + i;
- EXPECT_EQ(kArray[j], lasts[i]);
- }
-
- constexpr int item = constexpr_span[size];
- EXPECT_EQ(kArray[size], item);
-}
-
-} // namespace base
diff --git a/base/containers/span_unittest.nc b/base/containers/span_unittest.nc
deleted file mode 100644
index 0d2af89..0000000
--- a/base/containers/span_unittest.nc
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2017 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/containers/span.h"
-
-#include <array>
-#include <set>
-#include <vector>
-
-namespace base {
-
-class Base {
-};
-
-class Derived : Base {
-};
-
-#if defined(NCTEST_DEFAULT_SPAN_WITH_NON_ZERO_STATIC_EXTENT_DISALLOWED) // [r"fatal error: static_assert failed \"Invalid Extent\""]
-
-// A default constructed span must have an extent of 0 or dynamic_extent.
-void WontCompile() {
- span<int, 1> span;
-}
-
-#elif defined(NCTEST_SPAN_FROM_ARRAY_WITH_NON_MATCHING_STATIC_EXTENT_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<int, 1>'"]
-
-// A span with static extent constructed from an array must match the size of
-// the array.
-void WontCompile() {
- int array[] = {1, 2, 3};
- span<int, 1> span(array);
-}
-
-#elif defined(NCTEST_SPAN_FROM_STD_ARRAY_WITH_NON_MATCHING_STATIC_EXTENT_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<int, 2>'"]
-
-// A span with static extent constructed from std::array must match the size of
-// the array.
-void WontCompile() {
- std::array<int, 3> array = {1, 2, 3};
- span<int, 2> span(array);
-}
-
-#elif defined(NCTEST_SPAN_FROM_CONST_STD_ARRAY_WITH_NON_MATCHING_STATIC_EXTENT_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<const int, 2>'"]
-
-// A span with static extent constructed from std::array must match the size of
-// the array.
-void WontCompile() {
- const std::array<int, 3> array = {1, 2, 3};
- span<const int, 2> span(array);
-}
-
-#elif defined(NCTEST_SPAN_FROM_OTHER_SPAN_WITH_MISMATCHING_EXTENT_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<int, 4>'"]
-
-// A span with static extent constructed from another span must match the
-// extent.
-void WontCompile() {
- std::array<int, 3> array = {1, 2, 3};
- span<int, 3> span3(array);
- span<int, 4> span4(span3);
-}
-
-#elif defined(NCTEST_DYNAMIC_SPAN_TO_STATIC_SPAN_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<int, 3>'"]
-
-// Converting a dynamic span to a static span should not be allowed.
-void WontCompile() {
- span<int> dynamic_span;
- span<int, 3> static_span(dynamic_span);
-}
-
-#elif defined(NCTEST_DERIVED_TO_BASE_CONVERSION_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<base::Base \*>'"]
-
-// Internally, this is represented as a pointer to pointers to Derived. An
-// implicit conversion to a pointer to pointers to Base must not be allowed.
-// If it were allowed, then something like this would be possible.
-// Cat** cats = GetCats();
-// Animals** animals = cats;
-// animals[0] = new Dog(); // Uhoh!
-void WontCompile() {
- span<Derived*> derived_span;
- span<Base*> base_span(derived_span);
-}
-
-#elif defined(NCTEST_PTR_TO_CONSTPTR_CONVERSION_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<const int \*>'"]
-
-// Similarly, converting a span<int*> to span<const int*> requires internally
-// converting T** to const T**. This is also disallowed, as it would allow code
-// to violate the contract of const.
-void WontCompile() {
- span<int*> non_const_span;
- span<const int*> const_span(non_const_span);
-}
-
-#elif defined(NCTEST_CONST_CONTAINER_TO_MUTABLE_CONVERSION_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<int>'"]
-
-// A const container should not be convertible to a mutable span.
-void WontCompile() {
- const std::vector<int> v = {1, 2, 3};
- span<int> span(v);
-}
-
-#elif defined(NCTEST_STD_SET_CONVERSION_DISALLOWED) // [r"fatal error: no matching constructor for initialization of 'span<int>'"]
-
-// A std::set() should not satisfy the requirements for conversion to a span.
-void WontCompile() {
- std::set<int> set;
- span<int> span(set);
-}
-
-#elif defined(NCTEST_STATIC_FRONT_WITH_EXCEEDING_COUNT_DISALLOWED) // [r"fatal error: static_assert failed \"Count must not exceed Extent\""]
-
-// Static first called on a span with static extent must not exceed the size.
-void WontCompile() {
- std::array<int, 3> array = {1, 2, 3};
- span<int, 3> span(array);
- auto first = span.first<4>();
-}
-
-#elif defined(NCTEST_STATIC_LAST_WITH_EXCEEDING_COUNT_DISALLOWED) // [r"fatal error: static_assert failed \"Count must not exceed Extent\""]
-
-// Static last called on a span with static extent must not exceed the size.
-void WontCompile() {
- std::array<int, 3> array = {1, 2, 3};
- span<int, 3> span(array);
- auto last = span.last<4>();
-}
-
-#elif defined(NCTEST_STATIC_SUBSPAN_WITH_EXCEEDING_OFFSET_DISALLOWED) // [r"fatal error: static_assert failed \"Offset must not exceed Extent\""]
-
-// Static subspan called on a span with static extent must not exceed the size.
-void WontCompile() {
- std::array<int, 3> array = {1, 2, 3};
- span<int, 3> span(array);
- auto subspan = span.subspan<4>();
-}
-
-#elif defined(NCTEST_STATIC_SUBSPAN_WITH_EXCEEDING_COUNT_DISALLOWED) // [r"fatal error: static_assert failed \"Count must not exceed Extent - Offset\""]
-
-// Static subspan called on a span with static extent must not exceed the size.
-void WontCompile() {
- std::array<int, 3> array = {1, 2, 3};
- span<int, 3> span(array);
- auto subspan = span.subspan<0, 4>();
-}
-
-#elif defined(NCTEST_AS_WRITABLE_BYTES_WITH_CONST_CONTAINER_DISALLOWED) // [r"fatal error: no matching function for call to 'as_writable_bytes'"]
-
-// as_writable_bytes should not be possible for a const container.
-void WontCompile() {
- const std::vector<int> v = {1, 2, 3};
- span<uint8_t> bytes = as_writable_bytes(make_span(v));
-}
-
-#elif defined(NCTEST_MAKE_SPAN_FROM_SET_CONVERSION_DISALLOWED) // [r"fatal error: no matching function for call to 'make_span'"]
-
-// A std::set() should not satisfy the requirements for conversion to a span.
-void WontCompile() {
- std::set<int> set;
- auto span = make_span(set);
-}
-
-#endif
-
-} // namespace base
diff --git a/base/containers/stack_container_unittest.cc b/base/containers/stack_container_unittest.cc
deleted file mode 100644
index 8c039ad..0000000
--- a/base/containers/stack_container_unittest.cc
+++ /dev/null
@@ -1,145 +0,0 @@
-// 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.
-
-#include "base/containers/stack_container.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-
-#include "base/memory/ref_counted.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class Dummy : public base::RefCounted<Dummy> {
- public:
- explicit Dummy(int* alive) : alive_(alive) {
- ++*alive_;
- }
-
- private:
- friend class base::RefCounted<Dummy>;
-
- ~Dummy() {
- --*alive_;
- }
-
- int* const alive_;
-};
-
-} // namespace
-
-TEST(StackContainer, Vector) {
- const int stack_size = 3;
- StackVector<int, stack_size> vect;
- const int* stack_buffer = &vect.stack_data().stack_buffer()[0];
-
- // The initial |stack_size| elements should appear in the stack buffer.
- EXPECT_EQ(static_cast<size_t>(stack_size), vect.container().capacity());
- for (int i = 0; i < stack_size; i++) {
- vect.container().push_back(i);
- EXPECT_EQ(stack_buffer, &vect.container()[0]);
- EXPECT_TRUE(vect.stack_data().used_stack_buffer_);
- }
-
- // Adding more elements should push the array onto the heap.
- for (int i = 0; i < stack_size; i++) {
- vect.container().push_back(i + stack_size);
- EXPECT_NE(stack_buffer, &vect.container()[0]);
- EXPECT_FALSE(vect.stack_data().used_stack_buffer_);
- }
-
- // The array should still be in order.
- for (int i = 0; i < stack_size * 2; i++)
- EXPECT_EQ(i, vect.container()[i]);
-
- // Resize to smaller. Our STL implementation won't reallocate in this case,
- // otherwise it might use our stack buffer. We reserve right after the resize
- // to guarantee it isn't using the stack buffer, even though it doesn't have
- // much data.
- vect.container().resize(stack_size);
- vect.container().reserve(stack_size * 2);
- EXPECT_FALSE(vect.stack_data().used_stack_buffer_);
-
- // Copying the small vector to another should use the same allocator and use
- // the now-unused stack buffer. GENERALLY CALLERS SHOULD NOT DO THIS since
- // they have to get the template types just right and it can cause errors.
- std::vector<int, StackAllocator<int, stack_size> > other(vect.container());
- EXPECT_EQ(stack_buffer, &other.front());
- EXPECT_TRUE(vect.stack_data().used_stack_buffer_);
- for (int i = 0; i < stack_size; i++)
- EXPECT_EQ(i, other[i]);
-}
-
-TEST(StackContainer, VectorDoubleDelete) {
- // Regression testing for double-delete.
- typedef StackVector<scoped_refptr<Dummy>, 2> Vector;
- typedef Vector::ContainerType Container;
- Vector vect;
-
- int alive = 0;
- scoped_refptr<Dummy> dummy(new Dummy(&alive));
- EXPECT_EQ(alive, 1);
-
- vect->push_back(dummy);
- EXPECT_EQ(alive, 1);
-
- Dummy* dummy_unref = dummy.get();
- dummy = nullptr;
- EXPECT_EQ(alive, 1);
-
- Container::iterator itr = std::find(vect->begin(), vect->end(), dummy_unref);
- EXPECT_EQ(itr->get(), dummy_unref);
- vect->erase(itr);
- EXPECT_EQ(alive, 0);
-
- // Shouldn't crash at exit.
-}
-
-namespace {
-
-template <size_t alignment>
-class AlignedData {
- public:
- AlignedData() { memset(data_, 0, alignment); }
- ~AlignedData() = default;
- alignas(alignment) char data_[alignment];
-};
-
-} // anonymous namespace
-
-#define EXPECT_ALIGNED(ptr, align) \
- EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
-
-TEST(StackContainer, BufferAlignment) {
- StackVector<wchar_t, 16> text;
- text->push_back(L'A');
- EXPECT_ALIGNED(&text[0], alignof(wchar_t));
-
- StackVector<double, 1> doubles;
- doubles->push_back(0.0);
- EXPECT_ALIGNED(&doubles[0], alignof(double));
-
- StackVector<AlignedData<16>, 1> aligned16;
- aligned16->push_back(AlignedData<16>());
- EXPECT_ALIGNED(&aligned16[0], 16);
-
-#if !defined(__GNUC__) || defined(ARCH_CPU_X86_FAMILY)
- // It seems that non-X86 gcc doesn't respect greater than 16 byte alignment.
- // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33721 for details.
- // TODO(sbc):re-enable this if GCC starts respecting higher alignments.
- StackVector<AlignedData<256>, 1> aligned256;
- aligned256->push_back(AlignedData<256>());
- EXPECT_ALIGNED(&aligned256[0], 256);
-#endif
-}
-
-template class StackVector<int, 2>;
-template class StackVector<scoped_refptr<Dummy>, 2>;
-
-} // namespace base
diff --git a/base/containers/unique_ptr_adapters_unittest.cc b/base/containers/unique_ptr_adapters_unittest.cc
deleted file mode 100644
index 5b8f1fc..0000000
--- a/base/containers/unique_ptr_adapters_unittest.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2017 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 "base/containers/unique_ptr_adapters.h"
-
-#include <memory>
-#include <vector>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class Foo {
- public:
- Foo() { instance_count++; }
- ~Foo() { instance_count--; }
- static int instance_count;
-};
-
-int Foo::instance_count = 0;
-
-TEST(UniquePtrComparatorTest, Basic) {
- std::set<std::unique_ptr<Foo>, UniquePtrComparator> set;
- Foo* foo1 = new Foo();
- Foo* foo2 = new Foo();
- Foo* foo3 = new Foo();
- EXPECT_EQ(3, Foo::instance_count);
-
- set.emplace(foo1);
- set.emplace(foo2);
-
- auto it1 = set.find(foo1);
- EXPECT_TRUE(it1 != set.end());
- EXPECT_EQ(foo1, it1->get());
-
- {
- auto it2 = set.find(foo2);
- EXPECT_TRUE(it2 != set.end());
- EXPECT_EQ(foo2, it2->get());
- }
-
- EXPECT_TRUE(set.find(foo3) == set.end());
-
- set.erase(it1);
- EXPECT_EQ(2, Foo::instance_count);
-
- EXPECT_TRUE(set.find(foo1) == set.end());
-
- {
- auto it2 = set.find(foo2);
- EXPECT_TRUE(it2 != set.end());
- EXPECT_EQ(foo2, it2->get());
- }
-
- set.clear();
- EXPECT_EQ(1, Foo::instance_count);
-
- EXPECT_TRUE(set.find(foo1) == set.end());
- EXPECT_TRUE(set.find(foo2) == set.end());
- EXPECT_TRUE(set.find(foo3) == set.end());
-
- delete foo3;
- EXPECT_EQ(0, Foo::instance_count);
-}
-
-TEST(UniquePtrMatcherTest, Basic) {
- std::vector<std::unique_ptr<Foo>> v;
- auto foo_ptr1 = std::make_unique<Foo>();
- Foo* foo1 = foo_ptr1.get();
- v.push_back(std::move(foo_ptr1));
- auto foo_ptr2 = std::make_unique<Foo>();
- Foo* foo2 = foo_ptr2.get();
- v.push_back(std::move(foo_ptr2));
-
- {
- auto iter = std::find_if(v.begin(), v.end(), UniquePtrMatcher<Foo>(foo1));
- ASSERT_TRUE(iter != v.end());
- EXPECT_EQ(foo1, iter->get());
- }
-
- {
- auto iter = std::find_if(v.begin(), v.end(), UniquePtrMatcher<Foo>(foo2));
- ASSERT_TRUE(iter != v.end());
- EXPECT_EQ(foo2, iter->get());
- }
-
- {
- auto iter = std::find_if(v.begin(), v.end(), MatchesUniquePtr(foo2));
- ASSERT_TRUE(iter != v.end());
- EXPECT_EQ(foo2, iter->get());
- }
-}
-
-class TestDeleter {
- public:
- void operator()(Foo* foo) { delete foo; }
-};
-
-TEST(UniquePtrMatcherTest, Deleter) {
- using UniqueFoo = std::unique_ptr<Foo, TestDeleter>;
- std::vector<UniqueFoo> v;
- UniqueFoo foo_ptr1(new Foo);
- Foo* foo1 = foo_ptr1.get();
- v.push_back(std::move(foo_ptr1));
- UniqueFoo foo_ptr2(new Foo);
- Foo* foo2 = foo_ptr2.get();
- v.push_back(std::move(foo_ptr2));
-
- {
- auto iter = std::find_if(v.begin(), v.end(),
- UniquePtrMatcher<Foo, TestDeleter>(foo1));
- ASSERT_TRUE(iter != v.end());
- EXPECT_EQ(foo1, iter->get());
- }
-
- {
- auto iter = std::find_if(v.begin(), v.end(),
- UniquePtrMatcher<Foo, TestDeleter>(foo2));
- ASSERT_TRUE(iter != v.end());
- EXPECT_EQ(foo2, iter->get());
- }
-
- {
- auto iter = std::find_if(v.begin(), v.end(),
- MatchesUniquePtr<Foo, TestDeleter>(foo2));
- ASSERT_TRUE(iter != v.end());
- EXPECT_EQ(foo2, iter->get());
- }
-}
-
-} // namespace
-} // namespace base
diff --git a/base/containers/vector_buffer_unittest.cc b/base/containers/vector_buffer_unittest.cc
deleted file mode 100644
index 6d49505..0000000
--- a/base/containers/vector_buffer_unittest.cc
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2017 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 "base/containers/vector_buffer.h"
-
-#include "base/test/copy_only_int.h"
-#include "base/test/move_only_int.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-TEST(VectorBuffer, DeletePOD) {
- constexpr int size = 10;
- VectorBuffer<int> buffer(size);
- for (int i = 0; i < size; i++)
- buffer.begin()[i] = i + 1;
-
- buffer.DestructRange(buffer.begin(), buffer.end());
-
- // Delete should do nothing.
- for (int i = 0; i < size; i++)
- EXPECT_EQ(i + 1, buffer.begin()[i]);
-}
-
-TEST(VectorBuffer, DeleteMoveOnly) {
- constexpr int size = 10;
- VectorBuffer<MoveOnlyInt> buffer(size);
- for (int i = 0; i < size; i++)
- new (buffer.begin() + i) MoveOnlyInt(i + 1);
-
- buffer.DestructRange(buffer.begin(), buffer.end());
-
- // Delete should have reset all of the values to 0.
- for (int i = 0; i < size; i++)
- EXPECT_EQ(0, buffer.begin()[i].data());
-}
-
-TEST(VectorBuffer, PODMove) {
- constexpr int size = 10;
- VectorBuffer<int> dest(size);
-
- VectorBuffer<int> original(size);
- for (int i = 0; i < size; i++)
- original.begin()[i] = i + 1;
-
- original.MoveRange(original.begin(), original.end(), dest.begin());
- for (int i = 0; i < size; i++)
- EXPECT_EQ(i + 1, dest.begin()[i]);
-}
-
-TEST(VectorBuffer, MovableMove) {
- constexpr int size = 10;
- VectorBuffer<MoveOnlyInt> dest(size);
-
- VectorBuffer<MoveOnlyInt> original(size);
- for (int i = 0; i < size; i++)
- new (original.begin() + i) MoveOnlyInt(i + 1);
-
- original.MoveRange(original.begin(), original.end(), dest.begin());
-
- // Moving from a MoveOnlyInt resets to 0.
- for (int i = 0; i < size; i++) {
- EXPECT_EQ(0, original.begin()[i].data());
- EXPECT_EQ(i + 1, dest.begin()[i].data());
- }
-}
-
-TEST(VectorBuffer, CopyToMove) {
- constexpr int size = 10;
- VectorBuffer<CopyOnlyInt> dest(size);
-
- VectorBuffer<CopyOnlyInt> original(size);
- for (int i = 0; i < size; i++)
- new (original.begin() + i) CopyOnlyInt(i + 1);
-
- original.MoveRange(original.begin(), original.end(), dest.begin());
-
- // The original should have been destructed, which should reset the value to
- // 0. Technically this dereferences the destructed object.
- for (int i = 0; i < size; i++) {
- EXPECT_EQ(0, original.begin()[i].data());
- EXPECT_EQ(i + 1, dest.begin()[i].data());
- }
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/cpu_unittest.cc b/base/cpu_unittest.cc
deleted file mode 100644
index bfdb1cd..0000000
--- a/base/cpu_unittest.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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.
-
-#include "base/cpu.h"
-#include "base/stl_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if _MSC_VER >= 1700
-// C4752: found Intel(R) Advanced Vector Extensions; consider using /arch:AVX.
-#pragma warning(disable: 4752)
-#endif
-
-// Tests whether we can run extended instructions represented by the CPU
-// information. This test actually executes some extended instructions (such as
-// MMX, SSE, etc.) supported by the CPU and sees we can run them without
-// "undefined instruction" exceptions. That is, this test succeeds when this
-// test finishes without a crash.
-TEST(CPU, RunExtendedInstructions) {
-#if defined(ARCH_CPU_X86_FAMILY)
- // Retrieve the CPU information.
- base::CPU cpu;
-
- ASSERT_TRUE(cpu.has_mmx());
- ASSERT_TRUE(cpu.has_sse());
- ASSERT_TRUE(cpu.has_sse2());
-
-// GCC and clang instruction test.
-#if defined(COMPILER_GCC)
- // Execute an MMX instruction.
- __asm__ __volatile__("emms\n" : : : "mm0");
-
- // Execute an SSE instruction.
- __asm__ __volatile__("xorps %%xmm0, %%xmm0\n" : : : "xmm0");
-
- // Execute an SSE 2 instruction.
- __asm__ __volatile__("psrldq $0, %%xmm0\n" : : : "xmm0");
-
- if (cpu.has_sse3()) {
- // Execute an SSE 3 instruction.
- __asm__ __volatile__("addsubpd %%xmm0, %%xmm0\n" : : : "xmm0");
- }
-
- if (cpu.has_ssse3()) {
- // Execute a Supplimental SSE 3 instruction.
- __asm__ __volatile__("psignb %%xmm0, %%xmm0\n" : : : "xmm0");
- }
-
- if (cpu.has_sse41()) {
- // Execute an SSE 4.1 instruction.
- __asm__ __volatile__("pmuldq %%xmm0, %%xmm0\n" : : : "xmm0");
- }
-
- if (cpu.has_sse42()) {
- // Execute an SSE 4.2 instruction.
- __asm__ __volatile__("crc32 %%eax, %%eax\n" : : : "eax");
- }
-
- if (cpu.has_popcnt()) {
- // Execute a POPCNT instruction.
- __asm__ __volatile__("popcnt %%eax, %%eax\n" : : : "eax");
- }
-
- if (cpu.has_avx()) {
- // Execute an AVX instruction.
- __asm__ __volatile__("vzeroupper\n" : : : "xmm0");
- }
-
- if (cpu.has_avx2()) {
- // Execute an AVX 2 instruction.
- __asm__ __volatile__("vpunpcklbw %%ymm0, %%ymm0, %%ymm0\n" : : : "xmm0");
- }
-
-// Visual C 32 bit and ClangCL 32/64 bit test.
-#elif defined(COMPILER_MSVC) && (defined(ARCH_CPU_32_BITS) || \
- (defined(ARCH_CPU_64_BITS) && defined(__clang__)))
-
- // Execute an MMX instruction.
- __asm emms;
-
- // Execute an SSE instruction.
- __asm xorps xmm0, xmm0;
-
- // Execute an SSE 2 instruction.
- __asm psrldq xmm0, 0;
-
- if (cpu.has_sse3()) {
- // Execute an SSE 3 instruction.
- __asm addsubpd xmm0, xmm0;
- }
-
- if (cpu.has_ssse3()) {
- // Execute a Supplimental SSE 3 instruction.
- __asm psignb xmm0, xmm0;
- }
-
- if (cpu.has_sse41()) {
- // Execute an SSE 4.1 instruction.
- __asm pmuldq xmm0, xmm0;
- }
-
- if (cpu.has_sse42()) {
- // Execute an SSE 4.2 instruction.
- __asm crc32 eax, eax;
- }
-
- if (cpu.has_popcnt()) {
- // Execute a POPCNT instruction.
- __asm popcnt eax, eax;
- }
-
-// Visual C 2012 required for AVX.
-#if _MSC_VER >= 1700
- if (cpu.has_avx()) {
- // Execute an AVX instruction.
- __asm vzeroupper;
- }
-
- if (cpu.has_avx2()) {
- // Execute an AVX 2 instruction.
- __asm vpunpcklbw ymm0, ymm0, ymm0
- }
-#endif // _MSC_VER >= 1700
-#endif // defined(COMPILER_GCC)
-#endif // defined(ARCH_CPU_X86_FAMILY)
-}
-
-// For https://crbug.com/249713
-TEST(CPU, BrandAndVendorContainsNoNUL) {
- base::CPU cpu;
- EXPECT_FALSE(base::ContainsValue(cpu.cpu_brand(), '\0'));
- EXPECT_FALSE(base::ContainsValue(cpu.vendor_name(), '\0'));
-}
diff --git a/base/debug/activity_analyzer_unittest.cc b/base/debug/activity_analyzer_unittest.cc
deleted file mode 100644
index e08b43a..0000000
--- a/base/debug/activity_analyzer_unittest.cc
+++ /dev/null
@@ -1,546 +0,0 @@
-// Copyright 2016 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 "base/debug/activity_analyzer.h"
-
-#include <atomic>
-#include <memory>
-
-#include "base/auto_reset.h"
-#include "base/bind.h"
-#include "base/debug/activity_tracker.h"
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/memory/ptr_util.h"
-#include "base/pending_task.h"
-#include "base/process/process.h"
-#include "base/stl_util.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/spin_wait.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-class TestActivityTracker : public ThreadActivityTracker {
- public:
- TestActivityTracker(std::unique_ptr<char[]> memory, size_t mem_size)
- : ThreadActivityTracker(memset(memory.get(), 0, mem_size), mem_size),
- mem_segment_(std::move(memory)) {}
-
- ~TestActivityTracker() override = default;
-
- private:
- std::unique_ptr<char[]> mem_segment_;
-};
-
-} // namespace
-
-
-class ActivityAnalyzerTest : public testing::Test {
- public:
- const int kMemorySize = 1 << 20; // 1MiB
- const int kStackSize = 1 << 10; // 1KiB
-
- ActivityAnalyzerTest() = default;
-
- ~ActivityAnalyzerTest() override {
- GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
- if (global_tracker) {
- global_tracker->ReleaseTrackerForCurrentThreadForTesting();
- delete global_tracker;
- }
- }
-
- std::unique_ptr<ThreadActivityTracker> CreateActivityTracker() {
- std::unique_ptr<char[]> memory(new char[kStackSize]);
- return std::make_unique<TestActivityTracker>(std::move(memory), kStackSize);
- }
-
- template <typename Function>
- void AsOtherProcess(int64_t pid, Function function) {
- std::unique_ptr<GlobalActivityTracker> old_global =
- GlobalActivityTracker::ReleaseForTesting();
- ASSERT_TRUE(old_global);
-
- PersistentMemoryAllocator* old_allocator = old_global->allocator();
- std::unique_ptr<PersistentMemoryAllocator> new_allocator(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(old_allocator->data()), old_allocator->size(), 0,
- 0, "", false));
- GlobalActivityTracker::CreateWithAllocator(std::move(new_allocator), 3,
- pid);
-
- function();
-
- GlobalActivityTracker::ReleaseForTesting();
- GlobalActivityTracker::SetForTesting(std::move(old_global));
- }
-
- static void DoNothing() {}
-};
-
-TEST_F(ActivityAnalyzerTest, ThreadAnalyzerConstruction) {
- std::unique_ptr<ThreadActivityTracker> tracker = CreateActivityTracker();
- {
- ThreadActivityAnalyzer analyzer(*tracker);
- EXPECT_TRUE(analyzer.IsValid());
- EXPECT_EQ(PlatformThread::GetName(), analyzer.GetThreadName());
- }
-
- // TODO(bcwhite): More tests once Analyzer does more.
-}
-
-
-// GlobalActivityAnalyzer tests below.
-
-namespace {
-
-class SimpleActivityThread : public SimpleThread {
- public:
- SimpleActivityThread(const std::string& name,
- const void* source,
- Activity::Type activity,
- const ActivityData& data)
- : SimpleThread(name, Options()),
- source_(source),
- activity_(activity),
- data_(data),
- ready_(false),
- exit_(false),
- exit_condition_(&lock_) {}
-
- ~SimpleActivityThread() override = default;
-
- void Run() override {
- ThreadActivityTracker::ActivityId id =
- GlobalActivityTracker::Get()
- ->GetOrCreateTrackerForCurrentThread()
- ->PushActivity(source_, activity_, data_);
-
- {
- AutoLock auto_lock(lock_);
- ready_.store(true, std::memory_order_release);
- while (!exit_.load(std::memory_order_relaxed))
- exit_condition_.Wait();
- }
-
- GlobalActivityTracker::Get()->GetTrackerForCurrentThread()->PopActivity(id);
- }
-
- void Exit() {
- AutoLock auto_lock(lock_);
- exit_.store(true, std::memory_order_relaxed);
- exit_condition_.Signal();
- }
-
- void WaitReady() {
- SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(ready_.load(std::memory_order_acquire));
- }
-
- private:
- const void* source_;
- Activity::Type activity_;
- ActivityData data_;
-
- std::atomic<bool> ready_;
- std::atomic<bool> exit_;
- Lock lock_;
- ConditionVariable exit_condition_;
-
- DISALLOW_COPY_AND_ASSIGN(SimpleActivityThread);
-};
-
-} // namespace
-
-TEST_F(ActivityAnalyzerTest, GlobalAnalyzerConstruction) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- GlobalActivityTracker::Get()->process_data().SetString("foo", "bar");
-
- PersistentMemoryAllocator* allocator =
- GlobalActivityTracker::Get()->allocator();
- GlobalActivityAnalyzer analyzer(std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "", true));
-
- // The only thread at this point is the test thread of this process.
- const int64_t pid = analyzer.GetFirstProcess();
- ASSERT_NE(0, pid);
- ThreadActivityAnalyzer* ta1 = analyzer.GetFirstAnalyzer(pid);
- ASSERT_TRUE(ta1);
- EXPECT_FALSE(analyzer.GetNextAnalyzer());
- ThreadActivityAnalyzer::ThreadKey tk1 = ta1->GetThreadKey();
- EXPECT_EQ(ta1, analyzer.GetAnalyzerForThread(tk1));
- EXPECT_EQ(0, analyzer.GetNextProcess());
-
- // Create a second thread that will do something.
- SimpleActivityThread t2("t2", nullptr, Activity::ACT_TASK,
- ActivityData::ForTask(11));
- t2.Start();
- t2.WaitReady();
-
- // Now there should be two. Calling GetFirstProcess invalidates any
- // previously returned analyzer pointers.
- ASSERT_EQ(pid, analyzer.GetFirstProcess());
- EXPECT_TRUE(analyzer.GetFirstAnalyzer(pid));
- EXPECT_TRUE(analyzer.GetNextAnalyzer());
- EXPECT_FALSE(analyzer.GetNextAnalyzer());
- EXPECT_EQ(0, analyzer.GetNextProcess());
-
- // Let thread exit.
- t2.Exit();
- t2.Join();
-
- // Now there should be only one again.
- ASSERT_EQ(pid, analyzer.GetFirstProcess());
- ThreadActivityAnalyzer* ta2 = analyzer.GetFirstAnalyzer(pid);
- ASSERT_TRUE(ta2);
- EXPECT_FALSE(analyzer.GetNextAnalyzer());
- ThreadActivityAnalyzer::ThreadKey tk2 = ta2->GetThreadKey();
- EXPECT_EQ(ta2, analyzer.GetAnalyzerForThread(tk2));
- EXPECT_EQ(tk1, tk2);
- EXPECT_EQ(0, analyzer.GetNextProcess());
-
- // Verify that there is process data.
- const ActivityUserData::Snapshot& data_snapshot =
- analyzer.GetProcessDataSnapshot(pid);
- ASSERT_LE(1U, data_snapshot.size());
- EXPECT_EQ("bar", data_snapshot.at("foo").GetString());
-}
-
-TEST_F(ActivityAnalyzerTest, GlobalAnalyzerFromSharedMemory) {
- SharedMemoryHandle handle1;
- SharedMemoryHandle handle2;
-
- {
- std::unique_ptr<SharedMemory> shmem(new SharedMemory());
- ASSERT_TRUE(shmem->CreateAndMapAnonymous(kMemorySize));
- handle1 = shmem->handle().Duplicate();
- ASSERT_TRUE(handle1.IsValid());
- handle2 = shmem->handle().Duplicate();
- ASSERT_TRUE(handle2.IsValid());
- }
-
- GlobalActivityTracker::CreateWithSharedMemoryHandle(handle1, kMemorySize, 0,
- "", 3);
- GlobalActivityTracker::Get()->process_data().SetString("foo", "bar");
-
- std::unique_ptr<GlobalActivityAnalyzer> analyzer =
- GlobalActivityAnalyzer::CreateWithSharedMemoryHandle(handle2,
- kMemorySize);
-
- const int64_t pid = analyzer->GetFirstProcess();
- ASSERT_NE(0, pid);
- const ActivityUserData::Snapshot& data_snapshot =
- analyzer->GetProcessDataSnapshot(pid);
- ASSERT_LE(1U, data_snapshot.size());
- EXPECT_EQ("bar", data_snapshot.at("foo").GetString());
-}
-
-TEST_F(ActivityAnalyzerTest, UserDataSnapshotTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- ThreadActivityAnalyzer::Snapshot tracker_snapshot;
-
- const char string1a[] = "string1a";
- const char string1b[] = "string1b";
- const char string2a[] = "string2a";
- const char string2b[] = "string2b";
-
- PersistentMemoryAllocator* allocator =
- GlobalActivityTracker::Get()->allocator();
- GlobalActivityAnalyzer global_analyzer(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "",
- true));
-
- ThreadActivityTracker* tracker =
- GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
-
- {
- ScopedActivity activity1(1, 11, 111);
- ActivityUserData& user_data1 = activity1.user_data();
- user_data1.Set("raw1", "foo1", 4);
- user_data1.SetString("string1", "bar1");
- user_data1.SetChar("char1", '1');
- user_data1.SetInt("int1", -1111);
- user_data1.SetUint("uint1", 1111);
- user_data1.SetBool("bool1", true);
- user_data1.SetReference("ref1", string1a, sizeof(string1a));
- user_data1.SetStringReference("sref1", string1b);
-
- {
- ScopedActivity activity2(2, 22, 222);
- ActivityUserData& user_data2 = activity2.user_data();
- user_data2.Set("raw2", "foo2", 4);
- user_data2.SetString("string2", "bar2");
- user_data2.SetChar("char2", '2');
- user_data2.SetInt("int2", -2222);
- user_data2.SetUint("uint2", 2222);
- user_data2.SetBool("bool2", false);
- user_data2.SetReference("ref2", string2a, sizeof(string2a));
- user_data2.SetStringReference("sref2", string2b);
-
- ASSERT_TRUE(tracker->CreateSnapshot(&tracker_snapshot));
- ASSERT_EQ(2U, tracker_snapshot.activity_stack.size());
-
- ThreadActivityAnalyzer analyzer(*tracker);
- analyzer.AddGlobalInformation(&global_analyzer);
- const ThreadActivityAnalyzer::Snapshot& analyzer_snapshot =
- analyzer.activity_snapshot();
- ASSERT_EQ(2U, analyzer_snapshot.user_data_stack.size());
- const ActivityUserData::Snapshot& user_data =
- analyzer_snapshot.user_data_stack.at(1);
- EXPECT_EQ(8U, user_data.size());
- ASSERT_TRUE(ContainsKey(user_data, "raw2"));
- EXPECT_EQ("foo2", user_data.at("raw2").Get().as_string());
- ASSERT_TRUE(ContainsKey(user_data, "string2"));
- EXPECT_EQ("bar2", user_data.at("string2").GetString().as_string());
- ASSERT_TRUE(ContainsKey(user_data, "char2"));
- EXPECT_EQ('2', user_data.at("char2").GetChar());
- ASSERT_TRUE(ContainsKey(user_data, "int2"));
- EXPECT_EQ(-2222, user_data.at("int2").GetInt());
- ASSERT_TRUE(ContainsKey(user_data, "uint2"));
- EXPECT_EQ(2222U, user_data.at("uint2").GetUint());
- ASSERT_TRUE(ContainsKey(user_data, "bool2"));
- EXPECT_FALSE(user_data.at("bool2").GetBool());
- ASSERT_TRUE(ContainsKey(user_data, "ref2"));
- EXPECT_EQ(string2a, user_data.at("ref2").GetReference().data());
- EXPECT_EQ(sizeof(string2a), user_data.at("ref2").GetReference().size());
- ASSERT_TRUE(ContainsKey(user_data, "sref2"));
- EXPECT_EQ(string2b, user_data.at("sref2").GetStringReference().data());
- EXPECT_EQ(strlen(string2b),
- user_data.at("sref2").GetStringReference().size());
- }
-
- ASSERT_TRUE(tracker->CreateSnapshot(&tracker_snapshot));
- ASSERT_EQ(1U, tracker_snapshot.activity_stack.size());
-
- ThreadActivityAnalyzer analyzer(*tracker);
- analyzer.AddGlobalInformation(&global_analyzer);
- const ThreadActivityAnalyzer::Snapshot& analyzer_snapshot =
- analyzer.activity_snapshot();
- ASSERT_EQ(1U, analyzer_snapshot.user_data_stack.size());
- const ActivityUserData::Snapshot& user_data =
- analyzer_snapshot.user_data_stack.at(0);
- EXPECT_EQ(8U, user_data.size());
- EXPECT_EQ("foo1", user_data.at("raw1").Get().as_string());
- EXPECT_EQ("bar1", user_data.at("string1").GetString().as_string());
- EXPECT_EQ('1', user_data.at("char1").GetChar());
- EXPECT_EQ(-1111, user_data.at("int1").GetInt());
- EXPECT_EQ(1111U, user_data.at("uint1").GetUint());
- EXPECT_TRUE(user_data.at("bool1").GetBool());
- EXPECT_EQ(string1a, user_data.at("ref1").GetReference().data());
- EXPECT_EQ(sizeof(string1a), user_data.at("ref1").GetReference().size());
- EXPECT_EQ(string1b, user_data.at("sref1").GetStringReference().data());
- EXPECT_EQ(strlen(string1b),
- user_data.at("sref1").GetStringReference().size());
- }
-
- ASSERT_TRUE(tracker->CreateSnapshot(&tracker_snapshot));
- ASSERT_EQ(0U, tracker_snapshot.activity_stack.size());
-}
-
-TEST_F(ActivityAnalyzerTest, GlobalUserDataTest) {
- const int64_t pid = GetCurrentProcId();
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
-
- const char string1[] = "foo";
- const char string2[] = "bar";
-
- PersistentMemoryAllocator* allocator =
- GlobalActivityTracker::Get()->allocator();
- GlobalActivityAnalyzer global_analyzer(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "",
- true));
-
- ActivityUserData& process_data = GlobalActivityTracker::Get()->process_data();
- ASSERT_NE(0U, process_data.id());
- process_data.Set("raw", "foo", 3);
- process_data.SetString("string", "bar");
- process_data.SetChar("char", '9');
- process_data.SetInt("int", -9999);
- process_data.SetUint("uint", 9999);
- process_data.SetBool("bool", true);
- process_data.SetReference("ref", string1, sizeof(string1));
- process_data.SetStringReference("sref", string2);
-
- int64_t first_pid = global_analyzer.GetFirstProcess();
- DCHECK_EQ(pid, first_pid);
- const ActivityUserData::Snapshot& snapshot =
- global_analyzer.GetProcessDataSnapshot(pid);
- ASSERT_TRUE(ContainsKey(snapshot, "raw"));
- EXPECT_EQ("foo", snapshot.at("raw").Get().as_string());
- ASSERT_TRUE(ContainsKey(snapshot, "string"));
- EXPECT_EQ("bar", snapshot.at("string").GetString().as_string());
- ASSERT_TRUE(ContainsKey(snapshot, "char"));
- EXPECT_EQ('9', snapshot.at("char").GetChar());
- ASSERT_TRUE(ContainsKey(snapshot, "int"));
- EXPECT_EQ(-9999, snapshot.at("int").GetInt());
- ASSERT_TRUE(ContainsKey(snapshot, "uint"));
- EXPECT_EQ(9999U, snapshot.at("uint").GetUint());
- ASSERT_TRUE(ContainsKey(snapshot, "bool"));
- EXPECT_TRUE(snapshot.at("bool").GetBool());
- ASSERT_TRUE(ContainsKey(snapshot, "ref"));
- EXPECT_EQ(string1, snapshot.at("ref").GetReference().data());
- EXPECT_EQ(sizeof(string1), snapshot.at("ref").GetReference().size());
- ASSERT_TRUE(ContainsKey(snapshot, "sref"));
- EXPECT_EQ(string2, snapshot.at("sref").GetStringReference().data());
- EXPECT_EQ(strlen(string2), snapshot.at("sref").GetStringReference().size());
-}
-
-TEST_F(ActivityAnalyzerTest, GlobalModulesTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- GlobalActivityTracker* global = GlobalActivityTracker::Get();
-
- PersistentMemoryAllocator* allocator = global->allocator();
- GlobalActivityAnalyzer global_analyzer(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "",
- true));
-
- GlobalActivityTracker::ModuleInfo info1;
- info1.is_loaded = true;
- info1.address = 0x12345678;
- info1.load_time = 1111;
- info1.size = 0xABCDEF;
- info1.timestamp = 111;
- info1.age = 11;
- info1.identifier[0] = 1;
- info1.file = "anything";
- info1.debug_file = "elsewhere";
-
- global->RecordModuleInfo(info1);
- std::vector<GlobalActivityTracker::ModuleInfo> modules1;
- modules1 = global_analyzer.GetModules(global_analyzer.GetFirstProcess());
- ASSERT_EQ(1U, modules1.size());
- GlobalActivityTracker::ModuleInfo& stored1a = modules1[0];
- EXPECT_EQ(info1.is_loaded, stored1a.is_loaded);
- EXPECT_EQ(info1.address, stored1a.address);
- EXPECT_NE(info1.load_time, stored1a.load_time);
- EXPECT_EQ(info1.size, stored1a.size);
- EXPECT_EQ(info1.timestamp, stored1a.timestamp);
- EXPECT_EQ(info1.age, stored1a.age);
- EXPECT_EQ(info1.identifier[0], stored1a.identifier[0]);
- EXPECT_EQ(info1.file, stored1a.file);
- EXPECT_EQ(info1.debug_file, stored1a.debug_file);
-
- info1.is_loaded = false;
- global->RecordModuleInfo(info1);
- modules1 = global_analyzer.GetModules(global_analyzer.GetFirstProcess());
- ASSERT_EQ(1U, modules1.size());
- GlobalActivityTracker::ModuleInfo& stored1b = modules1[0];
- EXPECT_EQ(info1.is_loaded, stored1b.is_loaded);
- EXPECT_EQ(info1.address, stored1b.address);
- EXPECT_NE(info1.load_time, stored1b.load_time);
- EXPECT_EQ(info1.size, stored1b.size);
- EXPECT_EQ(info1.timestamp, stored1b.timestamp);
- EXPECT_EQ(info1.age, stored1b.age);
- EXPECT_EQ(info1.identifier[0], stored1b.identifier[0]);
- EXPECT_EQ(info1.file, stored1b.file);
- EXPECT_EQ(info1.debug_file, stored1b.debug_file);
-
- GlobalActivityTracker::ModuleInfo info2;
- info2.is_loaded = true;
- info2.address = 0x87654321;
- info2.load_time = 2222;
- info2.size = 0xFEDCBA;
- info2.timestamp = 222;
- info2.age = 22;
- info2.identifier[0] = 2;
- info2.file = "nothing";
- info2.debug_file = "farewell";
-
- global->RecordModuleInfo(info2);
- std::vector<GlobalActivityTracker::ModuleInfo> modules2;
- modules2 = global_analyzer.GetModules(global_analyzer.GetFirstProcess());
- ASSERT_EQ(2U, modules2.size());
- GlobalActivityTracker::ModuleInfo& stored2 = modules2[1];
- EXPECT_EQ(info2.is_loaded, stored2.is_loaded);
- EXPECT_EQ(info2.address, stored2.address);
- EXPECT_NE(info2.load_time, stored2.load_time);
- EXPECT_EQ(info2.size, stored2.size);
- EXPECT_EQ(info2.timestamp, stored2.timestamp);
- EXPECT_EQ(info2.age, stored2.age);
- EXPECT_EQ(info2.identifier[0], stored2.identifier[0]);
- EXPECT_EQ(info2.file, stored2.file);
- EXPECT_EQ(info2.debug_file, stored2.debug_file);
-}
-
-TEST_F(ActivityAnalyzerTest, GlobalLogMessages) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
-
- PersistentMemoryAllocator* allocator =
- GlobalActivityTracker::Get()->allocator();
- GlobalActivityAnalyzer analyzer(std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "", true));
-
- GlobalActivityTracker::Get()->RecordLogMessage("hello world");
- GlobalActivityTracker::Get()->RecordLogMessage("foo bar");
-
- std::vector<std::string> messages = analyzer.GetLogMessages();
- ASSERT_EQ(2U, messages.size());
- EXPECT_EQ("hello world", messages[0]);
- EXPECT_EQ("foo bar", messages[1]);
-}
-
-TEST_F(ActivityAnalyzerTest, GlobalMultiProcess) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 1001);
- GlobalActivityTracker* global = GlobalActivityTracker::Get();
- PersistentMemoryAllocator* allocator = global->allocator();
- EXPECT_EQ(1001, global->process_id());
-
- int64_t process_id;
- int64_t create_stamp;
- ActivityUserData::GetOwningProcessId(
- GlobalActivityTracker::Get()->process_data().GetBaseAddress(),
- &process_id, &create_stamp);
- ASSERT_EQ(1001, process_id);
-
- GlobalActivityTracker::Get()->process_data().SetInt("pid",
- global->process_id());
-
- GlobalActivityAnalyzer analyzer(std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "", true));
-
- AsOtherProcess(2002, [&global]() {
- ASSERT_NE(global, GlobalActivityTracker::Get());
- EXPECT_EQ(2002, GlobalActivityTracker::Get()->process_id());
-
- int64_t process_id;
- int64_t create_stamp;
- ActivityUserData::GetOwningProcessId(
- GlobalActivityTracker::Get()->process_data().GetBaseAddress(),
- &process_id, &create_stamp);
- ASSERT_EQ(2002, process_id);
-
- GlobalActivityTracker::Get()->process_data().SetInt(
- "pid", GlobalActivityTracker::Get()->process_id());
- });
- ASSERT_EQ(global, GlobalActivityTracker::Get());
- EXPECT_EQ(1001, GlobalActivityTracker::Get()->process_id());
-
- const int64_t pid1 = analyzer.GetFirstProcess();
- ASSERT_EQ(1001, pid1);
- const int64_t pid2 = analyzer.GetNextProcess();
- ASSERT_EQ(2002, pid2);
- EXPECT_EQ(0, analyzer.GetNextProcess());
-
- const ActivityUserData::Snapshot& pdata1 =
- analyzer.GetProcessDataSnapshot(pid1);
- const ActivityUserData::Snapshot& pdata2 =
- analyzer.GetProcessDataSnapshot(pid2);
- EXPECT_EQ(1001, pdata1.at("pid").GetInt());
- EXPECT_EQ(2002, pdata2.at("pid").GetInt());
-}
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/activity_tracker_unittest.cc b/base/debug/activity_tracker_unittest.cc
deleted file mode 100644
index e2b61a9..0000000
--- a/base/debug/activity_tracker_unittest.cc
+++ /dev/null
@@ -1,585 +0,0 @@
-// Copyright 2016 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 "base/debug/activity_tracker.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/memory/ptr_util.h"
-#include "base/pending_task.h"
-#include "base/rand_util.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/spin_wait.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-class TestActivityTracker : public ThreadActivityTracker {
- public:
- TestActivityTracker(std::unique_ptr<char[]> memory, size_t mem_size)
- : ThreadActivityTracker(memset(memory.get(), 0, mem_size), mem_size),
- mem_segment_(std::move(memory)) {}
-
- ~TestActivityTracker() override = default;
-
- private:
- std::unique_ptr<char[]> mem_segment_;
-};
-
-} // namespace
-
-
-class ActivityTrackerTest : public testing::Test {
- public:
- const int kMemorySize = 1 << 20; // 1MiB
- const int kStackSize = 1 << 10; // 1KiB
-
- using ActivityId = ThreadActivityTracker::ActivityId;
-
- ActivityTrackerTest() = default;
-
- ~ActivityTrackerTest() override {
- GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
- if (global_tracker) {
- global_tracker->ReleaseTrackerForCurrentThreadForTesting();
- delete global_tracker;
- }
- }
-
- std::unique_ptr<ThreadActivityTracker> CreateActivityTracker() {
- std::unique_ptr<char[]> memory(new char[kStackSize]);
- return std::make_unique<TestActivityTracker>(std::move(memory), kStackSize);
- }
-
- size_t GetGlobalActiveTrackerCount() {
- GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
- if (!global_tracker)
- return 0;
- return global_tracker->thread_tracker_count_.load(
- std::memory_order_relaxed);
- }
-
- size_t GetGlobalInactiveTrackerCount() {
- GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
- if (!global_tracker)
- return 0;
- AutoLock autolock(global_tracker->thread_tracker_allocator_lock_);
- return global_tracker->thread_tracker_allocator_.cache_used();
- }
-
- size_t GetGlobalUserDataMemoryCacheUsed() {
- return GlobalActivityTracker::Get()->user_data_allocator_.cache_used();
- }
-
- void HandleProcessExit(int64_t id,
- int64_t stamp,
- int code,
- GlobalActivityTracker::ProcessPhase phase,
- std::string&& command,
- ActivityUserData::Snapshot&& data) {
- exit_id_ = id;
- exit_stamp_ = stamp;
- exit_code_ = code;
- exit_phase_ = phase;
- exit_command_ = std::move(command);
- exit_data_ = std::move(data);
- }
-
- int64_t exit_id_ = 0;
- int64_t exit_stamp_;
- int exit_code_;
- GlobalActivityTracker::ProcessPhase exit_phase_;
- std::string exit_command_;
- ActivityUserData::Snapshot exit_data_;
-};
-
-TEST_F(ActivityTrackerTest, UserDataTest) {
- char buffer[256];
- memset(buffer, 0, sizeof(buffer));
- ActivityUserData data(buffer, sizeof(buffer));
- size_t space = sizeof(buffer) - sizeof(ActivityUserData::MemoryHeader);
- ASSERT_EQ(space, data.available_);
-
- data.SetInt("foo", 1);
- space -= 24;
- ASSERT_EQ(space, data.available_);
-
- data.SetUint("b", 1U); // Small names fit beside header in a word.
- space -= 16;
- ASSERT_EQ(space, data.available_);
-
- data.Set("c", buffer, 10);
- space -= 24;
- ASSERT_EQ(space, data.available_);
-
- data.SetString("dear john", "it's been fun");
- space -= 32;
- ASSERT_EQ(space, data.available_);
-
- data.Set("c", buffer, 20);
- ASSERT_EQ(space, data.available_);
-
- data.SetString("dear john", "but we're done together");
- ASSERT_EQ(space, data.available_);
-
- data.SetString("dear john", "bye");
- ASSERT_EQ(space, data.available_);
-
- data.SetChar("d", 'x');
- space -= 8;
- ASSERT_EQ(space, data.available_);
-
- data.SetBool("ee", true);
- space -= 16;
- ASSERT_EQ(space, data.available_);
-
- data.SetString("f", "");
- space -= 8;
- ASSERT_EQ(space, data.available_);
-}
-
-TEST_F(ActivityTrackerTest, PushPopTest) {
- std::unique_ptr<ThreadActivityTracker> tracker = CreateActivityTracker();
- ThreadActivityTracker::Snapshot snapshot;
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(0U, snapshot.activity_stack_depth);
- ASSERT_EQ(0U, snapshot.activity_stack.size());
-
- char origin1;
- ActivityId id1 = tracker->PushActivity(&origin1, Activity::ACT_TASK,
- ActivityData::ForTask(11));
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(1U, snapshot.activity_stack_depth);
- ASSERT_EQ(1U, snapshot.activity_stack.size());
- EXPECT_NE(0, snapshot.activity_stack[0].time_internal);
- EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
- EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin1),
- snapshot.activity_stack[0].origin_address);
- EXPECT_EQ(11U, snapshot.activity_stack[0].data.task.sequence_id);
-
- char origin2;
- char lock2;
- ActivityId id2 = tracker->PushActivity(&origin2, Activity::ACT_LOCK,
- ActivityData::ForLock(&lock2));
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(2U, snapshot.activity_stack_depth);
- ASSERT_EQ(2U, snapshot.activity_stack.size());
- EXPECT_LE(snapshot.activity_stack[0].time_internal,
- snapshot.activity_stack[1].time_internal);
- EXPECT_EQ(Activity::ACT_LOCK, snapshot.activity_stack[1].activity_type);
- EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin2),
- snapshot.activity_stack[1].origin_address);
- EXPECT_EQ(reinterpret_cast<uintptr_t>(&lock2),
- snapshot.activity_stack[1].data.lock.lock_address);
-
- tracker->PopActivity(id2);
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(1U, snapshot.activity_stack_depth);
- ASSERT_EQ(1U, snapshot.activity_stack.size());
- EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
- EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin1),
- snapshot.activity_stack[0].origin_address);
- EXPECT_EQ(11U, snapshot.activity_stack[0].data.task.sequence_id);
-
- tracker->PopActivity(id1);
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(0U, snapshot.activity_stack_depth);
- ASSERT_EQ(0U, snapshot.activity_stack.size());
-}
-
-TEST_F(ActivityTrackerTest, ScopedTaskTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
-
- ThreadActivityTracker* tracker =
- GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
- ThreadActivityTracker::Snapshot snapshot;
- ASSERT_EQ(0U, GetGlobalUserDataMemoryCacheUsed());
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(0U, snapshot.activity_stack_depth);
- ASSERT_EQ(0U, snapshot.activity_stack.size());
-
- {
- PendingTask task1(FROM_HERE, DoNothing());
- ScopedTaskRunActivity activity1(task1);
- ActivityUserData& user_data1 = activity1.user_data();
- (void)user_data1; // Tell compiler it's been used.
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(1U, snapshot.activity_stack_depth);
- ASSERT_EQ(1U, snapshot.activity_stack.size());
- EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
-
- {
- PendingTask task2(FROM_HERE, DoNothing());
- ScopedTaskRunActivity activity2(task2);
- ActivityUserData& user_data2 = activity2.user_data();
- (void)user_data2; // Tell compiler it's been used.
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(2U, snapshot.activity_stack_depth);
- ASSERT_EQ(2U, snapshot.activity_stack.size());
- EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[1].activity_type);
- }
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(1U, snapshot.activity_stack_depth);
- ASSERT_EQ(1U, snapshot.activity_stack.size());
- EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
- }
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(0U, snapshot.activity_stack_depth);
- ASSERT_EQ(0U, snapshot.activity_stack.size());
- ASSERT_EQ(2U, GetGlobalUserDataMemoryCacheUsed());
-}
-
-namespace {
-
-class SimpleLockThread : public SimpleThread {
- public:
- SimpleLockThread(const std::string& name, Lock* lock)
- : SimpleThread(name, Options()),
- lock_(lock),
- data_changed_(false),
- is_running_(false) {}
-
- ~SimpleLockThread() override = default;
-
- void Run() override {
- ThreadActivityTracker* tracker =
- GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
- uint32_t pre_version = tracker->GetDataVersionForTesting();
-
- is_running_.store(true, std::memory_order_relaxed);
- lock_->Acquire();
- data_changed_ = tracker->GetDataVersionForTesting() != pre_version;
- lock_->Release();
- is_running_.store(false, std::memory_order_relaxed);
- }
-
- bool IsRunning() { return is_running_.load(std::memory_order_relaxed); }
-
- bool WasDataChanged() { return data_changed_; };
-
- private:
- Lock* lock_;
- bool data_changed_;
- std::atomic<bool> is_running_;
-
- DISALLOW_COPY_AND_ASSIGN(SimpleLockThread);
-};
-
-} // namespace
-
-TEST_F(ActivityTrackerTest, LockTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
-
- ThreadActivityTracker* tracker =
- GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
- ThreadActivityTracker::Snapshot snapshot;
- ASSERT_EQ(0U, GetGlobalUserDataMemoryCacheUsed());
-
- Lock lock;
- uint32_t pre_version = tracker->GetDataVersionForTesting();
-
- // Check no activity when only "trying" a lock.
- EXPECT_TRUE(lock.Try());
- EXPECT_EQ(pre_version, tracker->GetDataVersionForTesting());
- lock.Release();
- EXPECT_EQ(pre_version, tracker->GetDataVersionForTesting());
-
- // Check no activity when acquiring a free lock.
- SimpleLockThread t1("locker1", &lock);
- t1.Start();
- t1.Join();
- EXPECT_FALSE(t1.WasDataChanged());
-
- // Check that activity is recorded when acquring a busy lock.
- SimpleLockThread t2("locker2", &lock);
- lock.Acquire();
- t2.Start();
- while (!t2.IsRunning())
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
- // t2 can't join until the lock is released but have to give time for t2 to
- // actually block on the lock before releasing it or the results will not
- // be correct.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(200));
- lock.Release();
- // Now the results will be valid.
- t2.Join();
- EXPECT_TRUE(t2.WasDataChanged());
-}
-
-TEST_F(ActivityTrackerTest, ExceptionTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- GlobalActivityTracker* global = GlobalActivityTracker::Get();
-
- ThreadActivityTracker* tracker =
- GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
- ThreadActivityTracker::Snapshot snapshot;
- ASSERT_EQ(0U, GetGlobalUserDataMemoryCacheUsed());
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- ASSERT_EQ(0U, snapshot.last_exception.activity_type);
-
- char origin;
- global->RecordException(&origin, 42);
-
- ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
- EXPECT_EQ(Activity::ACT_EXCEPTION, snapshot.last_exception.activity_type);
- EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin),
- snapshot.last_exception.origin_address);
- EXPECT_EQ(42U, snapshot.last_exception.data.exception.code);
-}
-
-TEST_F(ActivityTrackerTest, CreateWithFileTest) {
- const char temp_name[] = "CreateWithFileTest";
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath temp_file = temp_dir.GetPath().AppendASCII(temp_name);
- const size_t temp_size = 64 << 10; // 64 KiB
-
- // Create a global tracker on a new file.
- ASSERT_FALSE(PathExists(temp_file));
- GlobalActivityTracker::CreateWithFile(temp_file, temp_size, 0, "foo", 3);
- GlobalActivityTracker* global = GlobalActivityTracker::Get();
- EXPECT_EQ(std::string("foo"), global->allocator()->Name());
- global->ReleaseTrackerForCurrentThreadForTesting();
- delete global;
-
- // Create a global tracker over an existing file, replacing it. If the
- // replacement doesn't work, the name will remain as it was first created.
- ASSERT_TRUE(PathExists(temp_file));
- GlobalActivityTracker::CreateWithFile(temp_file, temp_size, 0, "bar", 3);
- global = GlobalActivityTracker::Get();
- EXPECT_EQ(std::string("bar"), global->allocator()->Name());
- global->ReleaseTrackerForCurrentThreadForTesting();
- delete global;
-}
-
-
-// GlobalActivityTracker tests below.
-
-TEST_F(ActivityTrackerTest, BasicTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- GlobalActivityTracker* global = GlobalActivityTracker::Get();
-
- // Ensure the data repositories have backing store, indicated by non-zero ID.
- EXPECT_NE(0U, global->process_data().id());
-}
-
-namespace {
-
-class SimpleActivityThread : public SimpleThread {
- public:
- SimpleActivityThread(const std::string& name,
- const void* origin,
- Activity::Type activity,
- const ActivityData& data)
- : SimpleThread(name, Options()),
- origin_(origin),
- activity_(activity),
- data_(data),
- ready_(false),
- exit_(false),
- exit_condition_(&lock_) {}
-
- ~SimpleActivityThread() override = default;
-
- void Run() override {
- ThreadActivityTracker::ActivityId id =
- GlobalActivityTracker::Get()
- ->GetOrCreateTrackerForCurrentThread()
- ->PushActivity(origin_, activity_, data_);
-
- {
- AutoLock auto_lock(lock_);
- ready_.store(true, std::memory_order_release);
- while (!exit_.load(std::memory_order_relaxed))
- exit_condition_.Wait();
- }
-
- GlobalActivityTracker::Get()->GetTrackerForCurrentThread()->PopActivity(id);
- }
-
- void Exit() {
- AutoLock auto_lock(lock_);
- exit_.store(true, std::memory_order_relaxed);
- exit_condition_.Signal();
- }
-
- void WaitReady() {
- SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(ready_.load(std::memory_order_acquire));
- }
-
- private:
- const void* origin_;
- Activity::Type activity_;
- ActivityData data_;
-
- std::atomic<bool> ready_;
- std::atomic<bool> exit_;
- Lock lock_;
- ConditionVariable exit_condition_;
-
- DISALLOW_COPY_AND_ASSIGN(SimpleActivityThread);
-};
-
-} // namespace
-
-TEST_F(ActivityTrackerTest, ThreadDeathTest) {
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
- const size_t starting_active = GetGlobalActiveTrackerCount();
- const size_t starting_inactive = GetGlobalInactiveTrackerCount();
-
- SimpleActivityThread t1("t1", nullptr, Activity::ACT_TASK,
- ActivityData::ForTask(11));
- t1.Start();
- t1.WaitReady();
- EXPECT_EQ(starting_active + 1, GetGlobalActiveTrackerCount());
- EXPECT_EQ(starting_inactive, GetGlobalInactiveTrackerCount());
-
- t1.Exit();
- t1.Join();
- EXPECT_EQ(starting_active, GetGlobalActiveTrackerCount());
- EXPECT_EQ(starting_inactive + 1, GetGlobalInactiveTrackerCount());
-
- // Start another thread and ensure it re-uses the existing memory.
-
- SimpleActivityThread t2("t2", nullptr, Activity::ACT_TASK,
- ActivityData::ForTask(22));
- t2.Start();
- t2.WaitReady();
- EXPECT_EQ(starting_active + 1, GetGlobalActiveTrackerCount());
- EXPECT_EQ(starting_inactive, GetGlobalInactiveTrackerCount());
-
- t2.Exit();
- t2.Join();
- EXPECT_EQ(starting_active, GetGlobalActiveTrackerCount());
- EXPECT_EQ(starting_inactive + 1, GetGlobalInactiveTrackerCount());
-}
-
-TEST_F(ActivityTrackerTest, ProcessDeathTest) {
- // This doesn't actually create and destroy a process. Instead, it uses for-
- // testing interfaces to simulate data created by other processes.
- const int64_t other_process_id = GetCurrentProcId() + 1;
-
- GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
- GlobalActivityTracker* global = GlobalActivityTracker::Get();
- ThreadActivityTracker* thread = global->GetOrCreateTrackerForCurrentThread();
-
- // Get callbacks for process exit.
- global->SetProcessExitCallback(
- Bind(&ActivityTrackerTest::HandleProcessExit, Unretained(this)));
-
- // Pretend than another process has started.
- global->RecordProcessLaunch(other_process_id, FILE_PATH_LITERAL("foo --bar"));
-
- // Do some activities.
- PendingTask task(FROM_HERE, DoNothing());
- ScopedTaskRunActivity activity(task);
- ActivityUserData& user_data = activity.user_data();
- ASSERT_NE(0U, user_data.id());
-
- // Get the memory-allocator references to that data.
- PersistentMemoryAllocator::Reference proc_data_ref =
- global->allocator()->GetAsReference(
- global->process_data().GetBaseAddress(),
- GlobalActivityTracker::kTypeIdProcessDataRecord);
- ASSERT_TRUE(proc_data_ref);
- PersistentMemoryAllocator::Reference tracker_ref =
- global->allocator()->GetAsReference(
- thread->GetBaseAddress(),
- GlobalActivityTracker::kTypeIdActivityTracker);
- ASSERT_TRUE(tracker_ref);
- PersistentMemoryAllocator::Reference user_data_ref =
- global->allocator()->GetAsReference(
- user_data.GetBaseAddress(),
- GlobalActivityTracker::kTypeIdUserDataRecord);
- ASSERT_TRUE(user_data_ref);
-
- // Make a copy of the thread-tracker state so it can be restored later.
- const size_t tracker_size = global->allocator()->GetAllocSize(tracker_ref);
- std::unique_ptr<char[]> tracker_copy(new char[tracker_size]);
- memcpy(tracker_copy.get(), thread->GetBaseAddress(), tracker_size);
-
- // Change the objects to appear to be owned by another process. Use a "past"
- // time so that exit-time is always later than create-time.
- const int64_t past_stamp = Time::Now().ToInternalValue() - 1;
- int64_t owning_id;
- int64_t stamp;
- ASSERT_TRUE(ActivityUserData::GetOwningProcessId(
- global->process_data().GetBaseAddress(), &owning_id, &stamp));
- EXPECT_NE(other_process_id, owning_id);
- ASSERT_TRUE(ThreadActivityTracker::GetOwningProcessId(
- thread->GetBaseAddress(), &owning_id, &stamp));
- EXPECT_NE(other_process_id, owning_id);
- ASSERT_TRUE(ActivityUserData::GetOwningProcessId(user_data.GetBaseAddress(),
- &owning_id, &stamp));
- EXPECT_NE(other_process_id, owning_id);
- global->process_data().SetOwningProcessIdForTesting(other_process_id,
- past_stamp);
- thread->SetOwningProcessIdForTesting(other_process_id, past_stamp);
- user_data.SetOwningProcessIdForTesting(other_process_id, past_stamp);
- ASSERT_TRUE(ActivityUserData::GetOwningProcessId(
- global->process_data().GetBaseAddress(), &owning_id, &stamp));
- EXPECT_EQ(other_process_id, owning_id);
- ASSERT_TRUE(ThreadActivityTracker::GetOwningProcessId(
- thread->GetBaseAddress(), &owning_id, &stamp));
- EXPECT_EQ(other_process_id, owning_id);
- ASSERT_TRUE(ActivityUserData::GetOwningProcessId(user_data.GetBaseAddress(),
- &owning_id, &stamp));
- EXPECT_EQ(other_process_id, owning_id);
-
- // Check that process exit will perform callback and free the allocations.
- ASSERT_EQ(0, exit_id_);
- ASSERT_EQ(GlobalActivityTracker::kTypeIdProcessDataRecord,
- global->allocator()->GetType(proc_data_ref));
- ASSERT_EQ(GlobalActivityTracker::kTypeIdActivityTracker,
- global->allocator()->GetType(tracker_ref));
- ASSERT_EQ(GlobalActivityTracker::kTypeIdUserDataRecord,
- global->allocator()->GetType(user_data_ref));
- global->RecordProcessExit(other_process_id, 0);
- EXPECT_EQ(other_process_id, exit_id_);
- EXPECT_EQ("foo --bar", exit_command_);
- EXPECT_EQ(GlobalActivityTracker::kTypeIdProcessDataRecordFree,
- global->allocator()->GetType(proc_data_ref));
- EXPECT_EQ(GlobalActivityTracker::kTypeIdActivityTrackerFree,
- global->allocator()->GetType(tracker_ref));
- EXPECT_EQ(GlobalActivityTracker::kTypeIdUserDataRecordFree,
- global->allocator()->GetType(user_data_ref));
-
- // Restore memory contents and types so things don't crash when doing real
- // process clean-up.
- memcpy(const_cast<void*>(thread->GetBaseAddress()), tracker_copy.get(),
- tracker_size);
- global->allocator()->ChangeType(
- proc_data_ref, GlobalActivityTracker::kTypeIdProcessDataRecord,
- GlobalActivityTracker::kTypeIdUserDataRecordFree, false);
- global->allocator()->ChangeType(
- tracker_ref, GlobalActivityTracker::kTypeIdActivityTracker,
- GlobalActivityTracker::kTypeIdActivityTrackerFree, false);
- global->allocator()->ChangeType(
- user_data_ref, GlobalActivityTracker::kTypeIdUserDataRecord,
- GlobalActivityTracker::kTypeIdUserDataRecordFree, false);
-}
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/alias_unittest.cc b/base/debug/alias_unittest.cc
deleted file mode 100644
index 66682f1..0000000
--- a/base/debug/alias_unittest.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 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 <memory>
-#include <string>
-
-#include "base/debug/alias.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-TEST(DebugAlias, Test) {
- std::unique_ptr<std::string> input =
- std::make_unique<std::string>("string contents");
-
- // Verify the contents get copied + the new local variable has the right type.
- DEBUG_ALIAS_FOR_CSTR(copy1, input->c_str(), 100 /* > input->size() */);
- static_assert(sizeof(copy1) == 100,
- "Verification that copy1 has expected size");
- EXPECT_STREQ("string contents", copy1);
-
- // Verify that the copy is properly null-terminated even when it is smaller
- // than the input string.
- DEBUG_ALIAS_FOR_CSTR(copy2, input->c_str(), 3 /* < input->size() */);
- static_assert(sizeof(copy2) == 3,
- "Verification that copy2 has expected size");
- EXPECT_STREQ("st", copy2);
- EXPECT_EQ('\0', copy2[2]);
-}
diff --git a/base/debug/crash_logging_unittest.cc b/base/debug/crash_logging_unittest.cc
deleted file mode 100644
index c10d36e..0000000
--- a/base/debug/crash_logging_unittest.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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 "base/debug/crash_logging.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-TEST(CrashLoggingTest, UninitializedCrashKeyStringSupport) {
- auto* crash_key = base::debug::AllocateCrashKeyString(
- "test", base::debug::CrashKeySize::Size32);
- EXPECT_FALSE(crash_key);
-
- base::debug::SetCrashKeyString(crash_key, "value");
-
- base::debug::ClearCrashKeyString(crash_key);
-}
diff --git a/base/debug/debugger_unittest.cc b/base/debug/debugger_unittest.cc
deleted file mode 100644
index 23ea83d..0000000
--- a/base/debug/debugger_unittest.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2014 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 "base/debug/debugger.h"
-
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-void CrashWithBreakDebugger() {
- base::debug::SetSuppressDebugUI(false);
- base::debug::BreakDebugger();
-
-#if defined(OS_WIN)
- // This should not be executed.
- _exit(125);
-#endif
-}
-#endif // defined(GTEST_HAS_DEATH_TEST)
-
-} // namespace
-
-// Death tests misbehave on Android.
-#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-
-TEST(Debugger, CrashAtBreakpoint) {
- EXPECT_DEATH(CrashWithBreakDebugger(), "");
-}
-
-#if defined(OS_WIN)
-TEST(Debugger, DoesntExecuteBeyondBreakpoint) {
- EXPECT_EXIT(CrashWithBreakDebugger(),
- ::testing::ExitedWithCode(0x80000003), "");
-}
-#endif // defined(OS_WIN)
-
-#else // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-TEST(Debugger, NoTest) {
-}
-#endif // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
diff --git a/base/debug/elf_reader_linux_unittest.cc b/base/debug/elf_reader_linux_unittest.cc
deleted file mode 100644
index 88ed502..0000000
--- a/base/debug/elf_reader_linux_unittest.cc
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2018 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 "base/debug/elf_reader_linux.h"
-
-#include <dlfcn.h>
-
-#include "base/files/memory_mapped_file.h"
-#include "base/strings/string_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-extern char __executable_start;
-
-namespace base {
-namespace debug {
-
-// The linker flag --build-id is passed only on official builds. Clang does not
-// enable it by default and we do not have build id section in non-official
-// builds.
-#if defined(OFFICIAL_BUILD)
-TEST(ElfReaderTest, ReadElfBuildId) {
- Optional<std::string> build_id = ReadElfBuildId(&__executable_start);
- ASSERT_TRUE(build_id);
- const size_t kGuidBytes = 20;
- EXPECT_EQ(2 * kGuidBytes, build_id.value().size());
- for (char c : *build_id) {
- EXPECT_TRUE(IsHexDigit(c));
- EXPECT_FALSE(IsAsciiLower(c));
- }
-}
-#endif
-
-TEST(ElfReaderTest, ReadElfLibraryName) {
-#if defined(OS_ANDROID)
- // On Android the library loader memory maps the full so file.
- const char kLibraryName[] = "lib_base_unittests__library";
- const void* addr = &__executable_start;
-#else
- // On Linux the executable does not contain soname and is not mapped till
- // dynamic segment. So, use malloc wrapper so file on which the test already
- // depends on.
- const char kLibraryName[] = MALLOC_WRAPPER_LIB;
- // Find any symbol in the loaded file.
- void* handle = dlopen(kLibraryName, RTLD_NOW | RTLD_LOCAL);
- const void* init_addr = dlsym(handle, "_init");
- // Use this symbol to get full path to the loaded library.
- Dl_info info;
- int res = dladdr(init_addr, &info);
- ASSERT_NE(0, res);
- std::string filename(info.dli_fname);
- EXPECT_FALSE(filename.empty());
- EXPECT_NE(std::string::npos, filename.find(kLibraryName));
-
- // Memory map the so file and use it to test reading so name.
- MemoryMappedFile file;
- file.Initialize(FilePath(filename));
- const void* addr = file.data();
-#endif
-
- auto name = ReadElfLibraryName(addr);
- ASSERT_TRUE(name);
- EXPECT_NE(std::string::npos, name->find(kLibraryName))
- << "Library name " << *name << " doesn't contain expected "
- << kLibraryName;
-}
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/leak_tracker_unittest.cc b/base/debug/leak_tracker_unittest.cc
deleted file mode 100644
index b9ecdcf..0000000
--- a/base/debug/leak_tracker_unittest.cc
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright (c) 2011 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 "base/debug/leak_tracker.h"
-
-#include <memory>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-class ClassA {
- private:
- LeakTracker<ClassA> leak_tracker_;
-};
-
-class ClassB {
- private:
- LeakTracker<ClassB> leak_tracker_;
-};
-
-#ifndef ENABLE_LEAK_TRACKER
-
-// If leak tracking is disabled, we should do nothing.
-TEST(LeakTrackerTest, NotEnabled) {
- EXPECT_EQ(-1, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(-1, LeakTracker<ClassB>::NumLiveInstances());
-
- // Use unique_ptr so compiler doesn't complain about unused variables.
- std::unique_ptr<ClassA> a1(new ClassA);
- std::unique_ptr<ClassB> b1(new ClassB);
- std::unique_ptr<ClassB> b2(new ClassB);
-
- EXPECT_EQ(-1, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(-1, LeakTracker<ClassB>::NumLiveInstances());
-}
-
-#else
-
-TEST(LeakTrackerTest, Basic) {
- {
- ClassA a1;
-
- EXPECT_EQ(1, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(0, LeakTracker<ClassB>::NumLiveInstances());
-
- ClassB b1;
- ClassB b2;
-
- EXPECT_EQ(1, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(2, LeakTracker<ClassB>::NumLiveInstances());
-
- std::unique_ptr<ClassA> a2(new ClassA);
-
- EXPECT_EQ(2, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(2, LeakTracker<ClassB>::NumLiveInstances());
-
- a2.reset();
-
- EXPECT_EQ(1, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(2, LeakTracker<ClassB>::NumLiveInstances());
- }
-
- EXPECT_EQ(0, LeakTracker<ClassA>::NumLiveInstances());
- EXPECT_EQ(0, LeakTracker<ClassB>::NumLiveInstances());
-}
-
-// Try some orderings of create/remove to hit different cases in the linked-list
-// assembly.
-TEST(LeakTrackerTest, LinkedList) {
- EXPECT_EQ(0, LeakTracker<ClassB>::NumLiveInstances());
-
- std::unique_ptr<ClassA> a1(new ClassA);
- std::unique_ptr<ClassA> a2(new ClassA);
- std::unique_ptr<ClassA> a3(new ClassA);
- std::unique_ptr<ClassA> a4(new ClassA);
-
- EXPECT_EQ(4, LeakTracker<ClassA>::NumLiveInstances());
-
- // Remove the head of the list (a1).
- a1.reset();
- EXPECT_EQ(3, LeakTracker<ClassA>::NumLiveInstances());
-
- // Remove the tail of the list (a4).
- a4.reset();
- EXPECT_EQ(2, LeakTracker<ClassA>::NumLiveInstances());
-
- // Append to the new tail of the list (a3).
- std::unique_ptr<ClassA> a5(new ClassA);
- EXPECT_EQ(3, LeakTracker<ClassA>::NumLiveInstances());
-
- a2.reset();
- a3.reset();
-
- EXPECT_EQ(1, LeakTracker<ClassA>::NumLiveInstances());
-
- a5.reset();
- EXPECT_EQ(0, LeakTracker<ClassA>::NumLiveInstances());
-}
-
-TEST(LeakTrackerTest, NoOpCheckForLeaks) {
- // There are no live instances of ClassA, so this should do nothing.
- LeakTracker<ClassA>::CheckForLeaks();
-}
-
-#endif // ENABLE_LEAK_TRACKER
-
-} // namespace
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/proc_maps_linux_unittest.cc b/base/debug/proc_maps_linux_unittest.cc
deleted file mode 100644
index d291507..0000000
--- a/base/debug/proc_maps_linux_unittest.cc
+++ /dev/null
@@ -1,328 +0,0 @@
-// 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 <stddef.h>
-#include <stdint.h>
-
-#include "base/debug/proc_maps_linux.h"
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/path_service.h"
-#include "base/strings/stringprintf.h"
-#include "base/threading/platform_thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace debug {
-
-TEST(ProcMapsTest, Empty) {
- std::vector<MappedMemoryRegion> regions;
- EXPECT_TRUE(ParseProcMaps("", ®ions));
- EXPECT_EQ(0u, regions.size());
-}
-
-TEST(ProcMapsTest, NoSpaces) {
- static const char kNoSpaces[] =
- "00400000-0040b000 r-xp 00002200 fc:00 794418 /bin/cat\n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kNoSpaces, ®ions));
- ASSERT_EQ(1u, regions.size());
-
- EXPECT_EQ(0x00400000u, regions[0].start);
- EXPECT_EQ(0x0040b000u, regions[0].end);
- EXPECT_EQ(0x00002200u, regions[0].offset);
- EXPECT_EQ("/bin/cat", regions[0].path);
-}
-
-TEST(ProcMapsTest, Spaces) {
- static const char kSpaces[] =
- "00400000-0040b000 r-xp 00002200 fc:00 794418 /bin/space cat\n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kSpaces, ®ions));
- ASSERT_EQ(1u, regions.size());
-
- EXPECT_EQ(0x00400000u, regions[0].start);
- EXPECT_EQ(0x0040b000u, regions[0].end);
- EXPECT_EQ(0x00002200u, regions[0].offset);
- EXPECT_EQ("/bin/space cat", regions[0].path);
-}
-
-TEST(ProcMapsTest, NoNewline) {
- static const char kNoSpaces[] =
- "00400000-0040b000 r-xp 00002200 fc:00 794418 /bin/cat";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_FALSE(ParseProcMaps(kNoSpaces, ®ions));
-}
-
-TEST(ProcMapsTest, NoPath) {
- static const char kNoPath[] =
- "00400000-0040b000 rw-p 00000000 00:00 0 \n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kNoPath, ®ions));
- ASSERT_EQ(1u, regions.size());
-
- EXPECT_EQ(0x00400000u, regions[0].start);
- EXPECT_EQ(0x0040b000u, regions[0].end);
- EXPECT_EQ(0x00000000u, regions[0].offset);
- EXPECT_EQ("", regions[0].path);
-}
-
-TEST(ProcMapsTest, Heap) {
- static const char kHeap[] =
- "022ac000-022cd000 rw-p 00000000 00:00 0 [heap]\n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kHeap, ®ions));
- ASSERT_EQ(1u, regions.size());
-
- EXPECT_EQ(0x022ac000u, regions[0].start);
- EXPECT_EQ(0x022cd000u, regions[0].end);
- EXPECT_EQ(0x00000000u, regions[0].offset);
- EXPECT_EQ("[heap]", regions[0].path);
-}
-
-#if defined(ARCH_CPU_32_BITS)
-TEST(ProcMapsTest, Stack32) {
- static const char kStack[] =
- "beb04000-beb25000 rw-p 00000000 00:00 0 [stack]\n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kStack, ®ions));
- ASSERT_EQ(1u, regions.size());
-
- EXPECT_EQ(0xbeb04000u, regions[0].start);
- EXPECT_EQ(0xbeb25000u, regions[0].end);
- EXPECT_EQ(0x00000000u, regions[0].offset);
- EXPECT_EQ("[stack]", regions[0].path);
-}
-#elif defined(ARCH_CPU_64_BITS)
-TEST(ProcMapsTest, Stack64) {
- static const char kStack[] =
- "7fff69c5b000-7fff69c7d000 rw-p 00000000 00:00 0 [stack]\n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kStack, ®ions));
- ASSERT_EQ(1u, regions.size());
-
- EXPECT_EQ(0x7fff69c5b000u, regions[0].start);
- EXPECT_EQ(0x7fff69c7d000u, regions[0].end);
- EXPECT_EQ(0x00000000u, regions[0].offset);
- EXPECT_EQ("[stack]", regions[0].path);
-}
-#endif
-
-TEST(ProcMapsTest, Multiple) {
- static const char kMultiple[] =
- "00400000-0040b000 r-xp 00000000 fc:00 794418 /bin/cat\n"
- "0060a000-0060b000 r--p 0000a000 fc:00 794418 /bin/cat\n"
- "0060b000-0060c000 rw-p 0000b000 fc:00 794418 /bin/cat\n";
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(kMultiple, ®ions));
- ASSERT_EQ(3u, regions.size());
-
- EXPECT_EQ(0x00400000u, regions[0].start);
- EXPECT_EQ(0x0040b000u, regions[0].end);
- EXPECT_EQ(0x00000000u, regions[0].offset);
- EXPECT_EQ("/bin/cat", regions[0].path);
-
- EXPECT_EQ(0x0060a000u, regions[1].start);
- EXPECT_EQ(0x0060b000u, regions[1].end);
- EXPECT_EQ(0x0000a000u, regions[1].offset);
- EXPECT_EQ("/bin/cat", regions[1].path);
-
- EXPECT_EQ(0x0060b000u, regions[2].start);
- EXPECT_EQ(0x0060c000u, regions[2].end);
- EXPECT_EQ(0x0000b000u, regions[2].offset);
- EXPECT_EQ("/bin/cat", regions[2].path);
-}
-
-TEST(ProcMapsTest, Permissions) {
- static struct {
- const char* input;
- uint8_t permissions;
- } kTestCases[] = {
- {"00400000-0040b000 ---s 00000000 fc:00 794418 /bin/cat\n", 0},
- {"00400000-0040b000 ---S 00000000 fc:00 794418 /bin/cat\n", 0},
- {"00400000-0040b000 r--s 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::READ},
- {"00400000-0040b000 -w-s 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::WRITE},
- {"00400000-0040b000 --xs 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::EXECUTE},
- {"00400000-0040b000 rwxs 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::READ | MappedMemoryRegion::WRITE |
- MappedMemoryRegion::EXECUTE},
- {"00400000-0040b000 ---p 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::PRIVATE},
- {"00400000-0040b000 r--p 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::READ | MappedMemoryRegion::PRIVATE},
- {"00400000-0040b000 -w-p 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::WRITE | MappedMemoryRegion::PRIVATE},
- {"00400000-0040b000 --xp 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::EXECUTE | MappedMemoryRegion::PRIVATE},
- {"00400000-0040b000 rwxp 00000000 fc:00 794418 /bin/cat\n",
- MappedMemoryRegion::READ | MappedMemoryRegion::WRITE |
- MappedMemoryRegion::EXECUTE | MappedMemoryRegion::PRIVATE},
- };
-
- for (size_t i = 0; i < arraysize(kTestCases); ++i) {
- SCOPED_TRACE(
- base::StringPrintf("kTestCases[%zu] = %s", i, kTestCases[i].input));
-
- std::vector<MappedMemoryRegion> regions;
- EXPECT_TRUE(ParseProcMaps(kTestCases[i].input, ®ions));
- EXPECT_EQ(1u, regions.size());
- if (regions.empty())
- continue;
- EXPECT_EQ(kTestCases[i].permissions, regions[0].permissions);
- }
-}
-
-#if defined(ADDRESS_SANITIZER)
-// AddressSanitizer may move local variables to a dedicated "fake stack" which
-// is outside the stack region listed in /proc/self/maps. We disable ASan
-// instrumentation for this function to force the variable to be local.
-__attribute__((no_sanitize_address))
-#endif
-void CheckProcMapsRegions(const std::vector<MappedMemoryRegion> ®ions) {
- // We should be able to find both the current executable as well as the stack
- // mapped into memory. Use the address of |exe_path| as a way of finding the
- // stack.
- FilePath exe_path;
- EXPECT_TRUE(PathService::Get(FILE_EXE, &exe_path));
- uintptr_t address = reinterpret_cast<uintptr_t>(&exe_path);
- bool found_exe = false;
- bool found_stack = false;
- bool found_address = false;
-
- for (size_t i = 0; i < regions.size(); ++i) {
- if (regions[i].path == exe_path.value()) {
- // It's OK to find the executable mapped multiple times as there'll be
- // multiple sections (e.g., text, data).
- found_exe = true;
- }
-
- if (regions[i].path == "[stack]") {
-// On Android the test is run on a background thread, since [stack] is for
-// the main thread, we cannot test this.
-#if !defined(OS_ANDROID)
- EXPECT_GE(address, regions[i].start);
- EXPECT_LT(address, regions[i].end);
-#endif
- EXPECT_TRUE(regions[i].permissions & MappedMemoryRegion::READ);
- EXPECT_TRUE(regions[i].permissions & MappedMemoryRegion::WRITE);
- EXPECT_FALSE(regions[i].permissions & MappedMemoryRegion::EXECUTE);
- EXPECT_TRUE(regions[i].permissions & MappedMemoryRegion::PRIVATE);
- EXPECT_FALSE(found_stack) << "Found duplicate stacks";
- found_stack = true;
- }
-
- if (address >= regions[i].start && address < regions[i].end) {
- EXPECT_FALSE(found_address) << "Found same address in multiple regions";
- found_address = true;
- }
- }
-
- EXPECT_TRUE(found_exe);
- EXPECT_TRUE(found_stack);
- EXPECT_TRUE(found_address);
-}
-
-TEST(ProcMapsTest, ReadProcMaps) {
- std::string proc_maps;
- ASSERT_TRUE(ReadProcMaps(&proc_maps));
-
- std::vector<MappedMemoryRegion> regions;
- ASSERT_TRUE(ParseProcMaps(proc_maps, ®ions));
- ASSERT_FALSE(regions.empty());
-
- CheckProcMapsRegions(regions);
-}
-
-TEST(ProcMapsTest, ReadProcMapsNonEmptyString) {
- std::string old_string("I forgot to clear the string");
- std::string proc_maps(old_string);
- ASSERT_TRUE(ReadProcMaps(&proc_maps));
- EXPECT_EQ(std::string::npos, proc_maps.find(old_string));
-}
-
-TEST(ProcMapsTest, MissingFields) {
- static const char* const kTestCases[] = {
- "00400000\n", // Missing end + beyond.
- "00400000-0040b000\n", // Missing perms + beyond.
- "00400000-0040b000 r-xp\n", // Missing offset + beyond.
- "00400000-0040b000 r-xp 00000000\n", // Missing device + beyond.
- "00400000-0040b000 r-xp 00000000 fc:00\n", // Missing inode + beyond.
- "00400000-0040b000 00000000 fc:00 794418 /bin/cat\n", // Missing perms.
- "00400000-0040b000 r-xp fc:00 794418 /bin/cat\n", // Missing offset.
- "00400000-0040b000 r-xp 00000000 fc:00 /bin/cat\n", // Missing inode.
- "00400000 r-xp 00000000 fc:00 794418 /bin/cat\n", // Missing end.
- "-0040b000 r-xp 00000000 fc:00 794418 /bin/cat\n", // Missing start.
- "00400000-0040b000 r-xp 00000000 794418 /bin/cat\n", // Missing device.
- };
-
- for (size_t i = 0; i < arraysize(kTestCases); ++i) {
- SCOPED_TRACE(base::StringPrintf("kTestCases[%zu] = %s", i, kTestCases[i]));
- std::vector<MappedMemoryRegion> regions;
- EXPECT_FALSE(ParseProcMaps(kTestCases[i], ®ions));
- }
-}
-
-TEST(ProcMapsTest, InvalidInput) {
- static const char* const kTestCases[] = {
- "thisisal-0040b000 rwxp 00000000 fc:00 794418 /bin/cat\n",
- "0040000d-linvalid rwxp 00000000 fc:00 794418 /bin/cat\n",
- "00400000-0040b000 inpu 00000000 fc:00 794418 /bin/cat\n",
- "00400000-0040b000 rwxp tforproc fc:00 794418 /bin/cat\n",
- "00400000-0040b000 rwxp 00000000 ma:ps 794418 /bin/cat\n",
- "00400000-0040b000 rwxp 00000000 fc:00 parse! /bin/cat\n",
- };
-
- for (size_t i = 0; i < arraysize(kTestCases); ++i) {
- SCOPED_TRACE(base::StringPrintf("kTestCases[%zu] = %s", i, kTestCases[i]));
- std::vector<MappedMemoryRegion> regions;
- EXPECT_FALSE(ParseProcMaps(kTestCases[i], ®ions));
- }
-}
-
-TEST(ProcMapsTest, ParseProcMapsEmptyString) {
- std::vector<MappedMemoryRegion> regions;
- EXPECT_TRUE(ParseProcMaps("", ®ions));
- EXPECT_EQ(0ULL, regions.size());
-}
-
-// Testing a couple of remotely possible weird things in the input:
-// - Line ending with \r\n or \n\r.
-// - File name contains quotes.
-// - File name has whitespaces.
-TEST(ProcMapsTest, ParseProcMapsWeirdCorrectInput) {
- std::vector<MappedMemoryRegion> regions;
- const std::string kContents =
- "00400000-0040b000 r-xp 00000000 fc:00 2106562 "
- " /bin/cat\r\n"
- "7f53b7dad000-7f53b7f62000 r-xp 00000000 fc:00 263011 "
- " /lib/x86_64-linux-gnu/libc-2.15.so\n\r"
- "7f53b816d000-7f53b818f000 r-xp 00000000 fc:00 264284 "
- " /lib/x86_64-linux-gnu/ld-2.15.so\n"
- "7fff9c7ff000-7fff9c800000 r-xp 00000000 00:00 0 "
- " \"vd so\"\n"
- "ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 "
- " [vsys call]\n";
- EXPECT_TRUE(ParseProcMaps(kContents, ®ions));
- EXPECT_EQ(5ULL, regions.size());
- EXPECT_EQ("/bin/cat", regions[0].path);
- EXPECT_EQ("/lib/x86_64-linux-gnu/libc-2.15.so", regions[1].path);
- EXPECT_EQ("/lib/x86_64-linux-gnu/ld-2.15.so", regions[2].path);
- EXPECT_EQ("\"vd so\"", regions[3].path);
- EXPECT_EQ("[vsys call]", regions[4].path);
-}
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/stack_trace_unittest.cc b/base/debug/stack_trace_unittest.cc
deleted file mode 100644
index 6d37c40..0000000
--- a/base/debug/stack_trace_unittest.cc
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright (c) 2011 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 <stddef.h>
-
-#include <limits>
-#include <sstream>
-#include <string>
-
-#include "base/debug/stack_trace.h"
-#include "base/logging.h"
-#include "base/process/kill.h"
-#include "base/process/process_handle.h"
-#include "base/test/test_timeouts.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_IOS)
-#include "base/test/multiprocess_test.h"
-#endif
-
-namespace base {
-namespace debug {
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_IOS)
-typedef MultiProcessTest StackTraceTest;
-#else
-typedef testing::Test StackTraceTest;
-#endif
-
-// Note: On Linux, this test currently only fully works on Debug builds.
-// See comments in the #ifdef soup if you intend to change this.
-#if defined(OS_WIN)
-// Always fails on Windows: crbug.com/32070
-#define MAYBE_OutputToStream DISABLED_OutputToStream
-#else
-#define MAYBE_OutputToStream OutputToStream
-#endif
-#if !defined(__UCLIBC__) && !defined(_AIX)
-TEST_F(StackTraceTest, MAYBE_OutputToStream) {
- StackTrace trace;
-
- // Dump the trace into a string.
- std::ostringstream os;
- trace.OutputToStream(&os);
- std::string backtrace_message = os.str();
-
- // ToString() should produce the same output.
- EXPECT_EQ(backtrace_message, trace.ToString());
-
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && NDEBUG
- // Stack traces require an extra data table that bloats our binaries,
- // so they're turned off for release builds. We stop the test here,
- // at least letting us verify that the calls don't crash.
- return;
-#endif // defined(OS_POSIX) && !defined(OS_MACOSX) && NDEBUG
-
- size_t frames_found = 0;
- trace.Addresses(&frames_found);
- ASSERT_GE(frames_found, 5u) <<
- "No stack frames found. Skipping rest of test.";
-
- // Check if the output has symbol initialization warning. If it does, fail.
- ASSERT_EQ(backtrace_message.find("Dumping unresolved backtrace"),
- std::string::npos) <<
- "Unable to resolve symbols. Skipping rest of test.";
-
-#if defined(OS_MACOSX)
-#if 0
- // Disabled due to -fvisibility=hidden in build config.
-
- // Symbol resolution via the backtrace_symbol function does not work well
- // in OS X.
- // See this thread:
- //
- // http://lists.apple.com/archives/darwin-dev/2009/Mar/msg00111.html
- //
- // Just check instead that we find our way back to the "start" symbol
- // which should be the first symbol in the trace.
- //
- // TODO(port): Find a more reliable way to resolve symbols.
-
- // Expect to at least find main.
- EXPECT_TRUE(backtrace_message.find("start") != std::string::npos)
- << "Expected to find start in backtrace:\n"
- << backtrace_message;
-
-#endif
-#elif defined(USE_SYMBOLIZE)
- // This branch is for gcc-compiled code, but not Mac due to the
- // above #if.
- // Expect a demangled symbol.
- EXPECT_TRUE(backtrace_message.find("testing::Test::Run()") !=
- std::string::npos)
- << "Expected a demangled symbol in backtrace:\n"
- << backtrace_message;
-
-#elif 0
- // This is the fall-through case; it used to cover Windows.
- // But it's disabled because of varying buildbot configs;
- // some lack symbols.
-
- // Expect to at least find main.
- EXPECT_TRUE(backtrace_message.find("main") != std::string::npos)
- << "Expected to find main in backtrace:\n"
- << backtrace_message;
-
-#if defined(OS_WIN)
-// MSVC doesn't allow the use of C99's __func__ within C++, so we fake it with
-// MSVC's __FUNCTION__ macro.
-#define __func__ __FUNCTION__
-#endif
-
- // Expect to find this function as well.
- // Note: This will fail if not linked with -rdynamic (aka -export_dynamic)
- EXPECT_TRUE(backtrace_message.find(__func__) != std::string::npos)
- << "Expected to find " << __func__ << " in backtrace:\n"
- << backtrace_message;
-
-#endif // define(OS_MACOSX)
-}
-
-#if !defined(OFFICIAL_BUILD) && !defined(NO_UNWIND_TABLES)
-// Disabled in Official builds, where Link-Time Optimization can result in two
-// or fewer stack frames being available, causing the test to fail.
-TEST_F(StackTraceTest, TruncatedTrace) {
- StackTrace trace;
-
- size_t count = 0;
- trace.Addresses(&count);
- ASSERT_LT(2u, count);
-
- StackTrace truncated(2);
- truncated.Addresses(&count);
- EXPECT_EQ(2u, count);
-}
-#endif // !defined(OFFICIAL_BUILD)
-
-// The test is used for manual testing, e.g., to see the raw output.
-TEST_F(StackTraceTest, DebugOutputToStream) {
- StackTrace trace;
- std::ostringstream os;
- trace.OutputToStream(&os);
- VLOG(1) << os.str();
-}
-
-// The test is used for manual testing, e.g., to see the raw output.
-TEST_F(StackTraceTest, DebugPrintBacktrace) {
- StackTrace().Print();
-}
-#endif // !defined(__UCLIBC__)
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-#if !defined(OS_IOS)
-static char* newArray() {
- // Clang warns about the mismatched new[]/delete if they occur in the same
- // function.
- return new char[10];
-}
-
-MULTIPROCESS_TEST_MAIN(MismatchedMallocChildProcess) {
- char* pointer = newArray();
- delete pointer;
- return 2;
-}
-
-// Regression test for StackDumpingSignalHandler async-signal unsafety.
-// Combined with tcmalloc's debugallocation, that signal handler
-// and e.g. mismatched new[]/delete would cause a hang because
-// of re-entering malloc.
-TEST_F(StackTraceTest, AsyncSignalUnsafeSignalHandlerHang) {
- Process child = SpawnChild("MismatchedMallocChildProcess");
- ASSERT_TRUE(child.IsValid());
- int exit_code;
- ASSERT_TRUE(
- child.WaitForExitWithTimeout(TestTimeouts::action_timeout(), &exit_code));
-}
-#endif // !defined(OS_IOS)
-
-namespace {
-
-std::string itoa_r_wrapper(intptr_t i, size_t sz, int base, size_t padding) {
- char buffer[1024];
- CHECK_LE(sz, sizeof(buffer));
-
- char* result = internal::itoa_r(i, buffer, sz, base, padding);
- EXPECT_TRUE(result);
- return std::string(buffer);
-}
-
-} // namespace
-
-TEST_F(StackTraceTest, itoa_r) {
- EXPECT_EQ("0", itoa_r_wrapper(0, 128, 10, 0));
- EXPECT_EQ("-1", itoa_r_wrapper(-1, 128, 10, 0));
-
- // Test edge cases.
- if (sizeof(intptr_t) == 4) {
- EXPECT_EQ("ffffffff", itoa_r_wrapper(-1, 128, 16, 0));
- EXPECT_EQ("-2147483648",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 10, 0));
- EXPECT_EQ("2147483647",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 10, 0));
-
- EXPECT_EQ("80000000",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 16, 0));
- EXPECT_EQ("7fffffff",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 16, 0));
- } else if (sizeof(intptr_t) == 8) {
- EXPECT_EQ("ffffffffffffffff", itoa_r_wrapper(-1, 128, 16, 0));
- EXPECT_EQ("-9223372036854775808",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 10, 0));
- EXPECT_EQ("9223372036854775807",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 10, 0));
-
- EXPECT_EQ("8000000000000000",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 16, 0));
- EXPECT_EQ("7fffffffffffffff",
- itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 16, 0));
- } else {
- ADD_FAILURE() << "Missing test case for your size of intptr_t ("
- << sizeof(intptr_t) << ")";
- }
-
- // Test hex output.
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0));
- EXPECT_EQ("deadbeef", itoa_r_wrapper(0xdeadbeef, 128, 16, 0));
-
- // Check that itoa_r respects passed buffer size limit.
- char buffer[1024];
- EXPECT_TRUE(internal::itoa_r(0xdeadbeef, buffer, 10, 16, 0));
- EXPECT_TRUE(internal::itoa_r(0xdeadbeef, buffer, 9, 16, 0));
- EXPECT_FALSE(internal::itoa_r(0xdeadbeef, buffer, 8, 16, 0));
- EXPECT_FALSE(internal::itoa_r(0xdeadbeef, buffer, 7, 16, 0));
- EXPECT_TRUE(internal::itoa_r(0xbeef, buffer, 5, 16, 4));
- EXPECT_FALSE(internal::itoa_r(0xbeef, buffer, 5, 16, 5));
- EXPECT_FALSE(internal::itoa_r(0xbeef, buffer, 5, 16, 6));
-
- // Test padding.
- EXPECT_EQ("1", itoa_r_wrapper(1, 128, 10, 0));
- EXPECT_EQ("1", itoa_r_wrapper(1, 128, 10, 1));
- EXPECT_EQ("01", itoa_r_wrapper(1, 128, 10, 2));
- EXPECT_EQ("001", itoa_r_wrapper(1, 128, 10, 3));
- EXPECT_EQ("0001", itoa_r_wrapper(1, 128, 10, 4));
- EXPECT_EQ("00001", itoa_r_wrapper(1, 128, 10, 5));
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0));
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 1));
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 2));
- EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 3));
- EXPECT_EQ("0688", itoa_r_wrapper(0x688, 128, 16, 4));
- EXPECT_EQ("00688", itoa_r_wrapper(0x688, 128, 16, 5));
-}
-#endif // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/task_annotator_unittest.cc b/base/debug/task_annotator_unittest.cc
deleted file mode 100644
index 51a5d32..0000000
--- a/base/debug/task_annotator_unittest.cc
+++ /dev/null
@@ -1,371 +0,0 @@
-// Copyright 2014 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 "base/debug/task_annotator.h"
-
-#include <algorithm>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/pending_task.h"
-#include "base/run_loop.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace debug {
-namespace {
-
-void TestTask(int* result) {
- *result = 123;
-}
-
-} // namespace
-
-TEST(TaskAnnotatorTest, QueueAndRunTask) {
- int result = 0;
- PendingTask pending_task(FROM_HERE, BindOnce(&TestTask, &result));
-
- TaskAnnotator annotator;
- annotator.DidQueueTask("TaskAnnotatorTest::Queue", pending_task);
- EXPECT_EQ(0, result);
- annotator.RunTask("TaskAnnotatorTest::Queue", &pending_task);
- EXPECT_EQ(123, result);
-}
-
-// Test task annotator integration in base APIs and ensuing support for
-// backtraces. Tasks posted across multiple threads in this test fixture should
-// be synchronized as BeforeRunTask() and VerifyTraceAndPost() assume tasks are
-// observed in lock steps, one at a time.
-class TaskAnnotatorBacktraceIntegrationTest
- : public ::testing::Test,
- public TaskAnnotator::ObserverForTesting {
- public:
- using ExpectedTrace = std::vector<const void*>;
-
- TaskAnnotatorBacktraceIntegrationTest() = default;
-
- ~TaskAnnotatorBacktraceIntegrationTest() override = default;
-
- // TaskAnnotator::ObserverForTesting:
- void BeforeRunTask(const PendingTask* pending_task) override {
- AutoLock auto_lock(on_before_run_task_lock_);
- last_posted_from_ = pending_task->posted_from;
- last_task_backtrace_ = pending_task->task_backtrace;
- }
-
- void SetUp() override { TaskAnnotator::RegisterObserverForTesting(this); }
-
- void TearDown() override { TaskAnnotator::ClearObserverForTesting(); }
-
- void VerifyTraceAndPost(const scoped_refptr<SequencedTaskRunner>& task_runner,
- const Location& posted_from,
- const Location& next_from_here,
- const ExpectedTrace& expected_trace,
- OnceClosure task) {
- SCOPED_TRACE(StringPrintf("Callback Depth: %zu", expected_trace.size()));
-
- EXPECT_EQ(posted_from, last_posted_from_);
- for (size_t i = 0; i < last_task_backtrace_.size(); i++) {
- SCOPED_TRACE(StringPrintf("Trace frame: %zu", i));
- if (i < expected_trace.size())
- EXPECT_EQ(expected_trace[i], last_task_backtrace_[i]);
- else
- EXPECT_EQ(nullptr, last_task_backtrace_[i]);
- }
-
- task_runner->PostTask(next_from_here, std::move(task));
- }
-
- // Same as VerifyTraceAndPost() with the exception that it also posts a task
- // that will prevent |task| from running until |wait_before_next_task| is
- // signaled.
- void VerifyTraceAndPostWithBlocker(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
- const Location& posted_from,
- const Location& next_from_here,
- const ExpectedTrace& expected_trace,
- OnceClosure task,
- WaitableEvent* wait_before_next_task) {
- DCHECK(wait_before_next_task);
-
- // Need to lock to ensure the upcoming VerifyTraceAndPost() runs before the
- // BeforeRunTask() hook for the posted WaitableEvent::Wait(). Otherwise the
- // upcoming VerifyTraceAndPost() will race to read the state saved in the
- // BeforeRunTask() hook preceding the current task.
- AutoLock auto_lock(on_before_run_task_lock_);
- task_runner->PostTask(
- FROM_HERE,
- BindOnce(&WaitableEvent::Wait, Unretained(wait_before_next_task)));
- VerifyTraceAndPost(task_runner, posted_from, next_from_here, expected_trace,
- std::move(task));
- }
-
- protected:
- static void RunTwo(OnceClosure c1, OnceClosure c2) {
- std::move(c1).Run();
- std::move(c2).Run();
- }
-
- private:
- // While calls to VerifyTraceAndPost() are strictly ordered in tests below
- // (and hence non-racy), some helper methods (e.g. Wait/Signal) do racily call
- // into BeforeRunTask(). This Lock ensures these unobserved writes are not
- // racing. Locking isn't required on read per the VerifyTraceAndPost()
- // themselves being ordered.
- Lock on_before_run_task_lock_;
-
- Location last_posted_from_ = {};
- std::array<const void*, 4> last_task_backtrace_ = {};
-
- DISALLOW_COPY_AND_ASSIGN(TaskAnnotatorBacktraceIntegrationTest);
-};
-
-// Ensure the task backtrace populates correctly.
-TEST_F(TaskAnnotatorBacktraceIntegrationTest, SingleThreadedSimple) {
- MessageLoop loop;
- const Location location0 = FROM_HERE;
- const Location location1 = FROM_HERE;
- const Location location2 = FROM_HERE;
- const Location location3 = FROM_HERE;
- const Location location4 = FROM_HERE;
- const Location location5 = FROM_HERE;
-
- RunLoop run_loop;
-
- // Task 5 has tasks 4/3/2/1 as parents (task 0 isn't visible as only the
- // last 4 parents are kept).
- OnceClosure task5 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location5, FROM_HERE,
- ExpectedTrace({location4.program_counter(), location3.program_counter(),
- location2.program_counter(), location1.program_counter()}),
- run_loop.QuitClosure());
-
- // Task i=4/3/2/1/0 have tasks [0,i) as parents.
- OnceClosure task4 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location4, location5,
- ExpectedTrace({location3.program_counter(), location2.program_counter(),
- location1.program_counter(), location0.program_counter()}),
- std::move(task5));
- OnceClosure task3 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location3, location4,
- ExpectedTrace({location2.program_counter(), location1.program_counter(),
- location0.program_counter()}),
- std::move(task4));
- OnceClosure task2 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location2, location3,
- ExpectedTrace({location1.program_counter(), location0.program_counter()}),
- std::move(task3));
- OnceClosure task1 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location1, location2,
- ExpectedTrace({location0.program_counter()}), std::move(task2));
- OnceClosure task0 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location0, location1,
- ExpectedTrace({}), std::move(task1));
-
- loop.task_runner()->PostTask(location0, std::move(task0));
-
- run_loop.Run();
-}
-
-// Ensure it works when posting tasks across multiple threads managed by //base.
-TEST_F(TaskAnnotatorBacktraceIntegrationTest, MultipleThreads) {
- test::ScopedTaskEnvironment scoped_task_environment;
-
- // Use diverse task runners (a MessageLoop on the main thread, a TaskScheduler
- // based SequencedTaskRunner, and a TaskScheduler based
- // SingleThreadTaskRunner) to verify that TaskAnnotator can capture backtraces
- // for PostTasks back-and-forth between these.
- auto main_thread_a = ThreadTaskRunnerHandle::Get();
- auto task_runner_b = CreateSingleThreadTaskRunnerWithTraits({});
- auto task_runner_c = CreateSequencedTaskRunnerWithTraits(
- {base::MayBlock(), base::WithBaseSyncPrimitives()});
-
- const Location& location_a0 = FROM_HERE;
- const Location& location_a1 = FROM_HERE;
- const Location& location_a2 = FROM_HERE;
- const Location& location_a3 = FROM_HERE;
-
- const Location& location_b0 = FROM_HERE;
- const Location& location_b1 = FROM_HERE;
-
- const Location& location_c0 = FROM_HERE;
-
- RunLoop run_loop;
-
- // All tasks below happen in lock step by nature of being posted by the
- // previous one (plus the synchronous nature of RunTwo()) with the exception
- // of the follow-up local task to |task_b0_local|. This WaitableEvent ensures
- // it completes before |task_c0| runs to avoid racy invocations of
- // BeforeRunTask()+VerifyTraceAndPost().
- WaitableEvent lock_step(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // Here is the execution order generated below:
- // A: TA0 -> TA1 \ TA2
- // B: TB0L \ + TB0F \ Signal \ /
- // ---------\--/ \ /
- // \ \ /
- // C: Wait........ TC0 /
-
- // On task runner c, post a task back to main thread that verifies its trace
- // and terminates after one more self-post.
- OnceClosure task_a2 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), main_thread_a, location_a2, location_a3,
- ExpectedTrace(
- {location_c0.program_counter(), location_b0.program_counter(),
- location_a1.program_counter(), location_a0.program_counter()}),
- run_loop.QuitClosure());
- OnceClosure task_c0 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), main_thread_a, location_c0, location_a2,
- ExpectedTrace({location_b0.program_counter(),
- location_a1.program_counter(),
- location_a0.program_counter()}),
- std::move(task_a2));
-
- // On task runner b run two tasks that conceptually come from the same
- // location (managed via RunTwo().) One will post back to task runner b and
- // another will post to task runner c to test spawning multiple tasks on
- // different message loops. The task posted to task runner c will not get
- // location b1 whereas the one posted back to task runner b will.
- OnceClosure task_b0_fork = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPostWithBlocker,
- Unretained(this), task_runner_c, location_b0, location_c0,
- ExpectedTrace(
- {location_a1.program_counter(), location_a0.program_counter()}),
- std::move(task_c0), &lock_step);
- OnceClosure task_b0_local =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), task_runner_b, location_b0, location_b1,
- ExpectedTrace({location_a1.program_counter(),
- location_a0.program_counter()}),
- BindOnce(&WaitableEvent::Signal, Unretained(&lock_step)));
-
- OnceClosure task_a1 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), task_runner_b, location_a1, location_b0,
- ExpectedTrace({location_a0.program_counter()}),
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::RunTwo,
- std::move(task_b0_local), std::move(task_b0_fork)));
- OnceClosure task_a0 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), main_thread_a, location_a0, location_a1,
- ExpectedTrace({}), std::move(task_a1));
-
- main_thread_a->PostTask(location_a0, std::move(task_a0));
-
- run_loop.Run();
-}
-
-// Ensure nesting doesn't break the chain.
-TEST_F(TaskAnnotatorBacktraceIntegrationTest, SingleThreadedNested) {
- MessageLoop loop;
- const Location location0 = FROM_HERE;
- const Location location1 = FROM_HERE;
- const Location location2 = FROM_HERE;
- const Location location3 = FROM_HERE;
- const Location location4 = FROM_HERE;
- const Location location5 = FROM_HERE;
-
- RunLoop run_loop;
-
- // Task execution below looks like this, w.r.t. to RunLoop depths:
- // 1 : T0 \ + NRL1 \ ---------> T4 -> T5
- // 2 : ---------> T1 \ -> NRL2 \ ----> T2 -> T3 / + Quit /
- // 3 : ---------> DN /
-
- // NRL1 tests that tasks that occur at a different nesting depth than their
- // parent have a sane backtrace nonetheless (both ways).
-
- // NRL2 tests that posting T2 right after exiting the RunLoop (from the same
- // task) results in NRL2 being its parent (and not the DoNothing() task that
- // just ran -- which would have been the case if the "current task" wasn't
- // restored properly when returning from a task within a task).
-
- // In other words, this is regression test for a bug in the previous
- // implementation. In the current implementation, replacing
- // tls_for_current_pending_task->Set(previous_pending_task);
- // by
- // tls_for_current_pending_task->Set(nullptr);
- // at the end of TaskAnnotator::RunTask() makes this test fail.
-
- RunLoop nested_run_loop1(RunLoop::Type::kNestableTasksAllowed);
-
- // Expectations are the same as in SingleThreadedSimple test despite the
- // nested loop starting between tasks 0 and 1 and stopping between tasks 3 and
- // 4.
- OnceClosure task5 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location5, FROM_HERE,
- ExpectedTrace({location4.program_counter(), location3.program_counter(),
- location2.program_counter(), location1.program_counter()}),
- run_loop.QuitClosure());
- OnceClosure task4 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location4, location5,
- ExpectedTrace({location3.program_counter(), location2.program_counter(),
- location1.program_counter(), location0.program_counter()}),
- std::move(task5));
- OnceClosure task3 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location3, location4,
- ExpectedTrace({location2.program_counter(), location1.program_counter(),
- location0.program_counter()}),
- std::move(task4));
-
- OnceClosure run_task_3_then_quit_nested_loop1 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::RunTwo, std::move(task3),
- nested_run_loop1.QuitClosure());
-
- OnceClosure task2 = BindOnce(
- &TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location2, location3,
- ExpectedTrace({location1.program_counter(), location0.program_counter()}),
- std::move(run_task_3_then_quit_nested_loop1));
-
- // Task 1 is custom. It enters another nested RunLoop, has it do work and exit
- // before posting the next task. This confirms that |task1| is restored as the
- // current task before posting |task2| after returning from the nested loop.
- RunLoop nested_run_loop2(RunLoop::Type::kNestableTasksAllowed);
- OnceClosure task1 = BindOnce(
- [](RunLoop* nested_run_loop, const Location& location2,
- OnceClosure task2) {
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing());
- nested_run_loop->RunUntilIdle();
- ThreadTaskRunnerHandle::Get()->PostTask(location2, std::move(task2));
- },
- Unretained(&nested_run_loop2), location2, std::move(task2));
-
- OnceClosure task0 =
- BindOnce(&TaskAnnotatorBacktraceIntegrationTest::VerifyTraceAndPost,
- Unretained(this), loop.task_runner(), location0, location1,
- ExpectedTrace({}), std::move(task1));
-
- loop.task_runner()->PostTask(location0, std::move(task0));
- loop.task_runner()->PostTask(
- FROM_HERE, BindOnce(&RunLoop::Run, Unretained(&nested_run_loop1)));
-
- run_loop.Run();
-}
-
-} // namespace debug
-} // namespace base
diff --git a/base/debug/thread_heap_usage_tracker_unittest.cc b/base/debug/thread_heap_usage_tracker_unittest.cc
deleted file mode 100644
index fc7fda4..0000000
--- a/base/debug/thread_heap_usage_tracker_unittest.cc
+++ /dev/null
@@ -1,556 +0,0 @@
-// Copyright 2016 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 "base/debug/thread_heap_usage_tracker.h"
-
-#include <map>
-
-#include "base/allocator/allocator_shim.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_MACOSX)
-#include "base/allocator/allocator_interception_mac.h"
-#endif
-
-namespace base {
-namespace debug {
-
-namespace {
-
-class TestingThreadHeapUsageTracker : public ThreadHeapUsageTracker {
- public:
- using ThreadHeapUsageTracker::DisableHeapTrackingForTesting;
- using ThreadHeapUsageTracker::EnsureTLSInitialized;
- using ThreadHeapUsageTracker::GetDispatchForTesting;
-};
-
-// A fixture class that allows testing the AllocatorDispatch associated with
-// the ThreadHeapUsageTracker class in isolation against a mocked
-// underlying
-// heap implementation.
-class ThreadHeapUsageTrackerTest : public testing::Test {
- public:
- using AllocatorDispatch = base::allocator::AllocatorDispatch;
-
- static const size_t kAllocationPadding;
- enum SizeFunctionKind {
- EXACT_SIZE_FUNCTION,
- PADDING_SIZE_FUNCTION,
- ZERO_SIZE_FUNCTION,
- };
-
- ThreadHeapUsageTrackerTest() : size_function_kind_(EXACT_SIZE_FUNCTION) {
- EXPECT_EQ(nullptr, g_self);
- g_self = this;
- }
-
- ~ThreadHeapUsageTrackerTest() override {
- EXPECT_EQ(this, g_self);
- g_self = nullptr;
- }
-
- void set_size_function_kind(SizeFunctionKind kind) {
- size_function_kind_ = kind;
- }
-
- void SetUp() override {
- TestingThreadHeapUsageTracker::EnsureTLSInitialized();
-
- dispatch_under_test_ =
- TestingThreadHeapUsageTracker::GetDispatchForTesting();
- ASSERT_EQ(nullptr, dispatch_under_test_->next);
-
- dispatch_under_test_->next = &g_mock_dispatch;
- }
-
- void TearDown() override {
- ASSERT_EQ(&g_mock_dispatch, dispatch_under_test_->next);
-
- dispatch_under_test_->next = nullptr;
- }
-
- void* MockMalloc(size_t size) {
- return dispatch_under_test_->alloc_function(dispatch_under_test_, size,
- nullptr);
- }
-
- void* MockCalloc(size_t n, size_t size) {
- return dispatch_under_test_->alloc_zero_initialized_function(
- dispatch_under_test_, n, size, nullptr);
- }
-
- void* MockAllocAligned(size_t alignment, size_t size) {
- return dispatch_under_test_->alloc_aligned_function(
- dispatch_under_test_, alignment, size, nullptr);
- }
-
- void* MockRealloc(void* address, size_t size) {
- return dispatch_under_test_->realloc_function(dispatch_under_test_, address,
- size, nullptr);
- }
-
- void MockFree(void* address) {
- dispatch_under_test_->free_function(dispatch_under_test_, address, nullptr);
- }
-
- size_t MockGetSizeEstimate(void* address) {
- return dispatch_under_test_->get_size_estimate_function(
- dispatch_under_test_, address, nullptr);
- }
-
- private:
- void RecordAlloc(void* address, size_t size) {
- if (address != nullptr)
- allocation_size_map_[address] = size;
- }
-
- void DeleteAlloc(void* address) {
- if (address != nullptr)
- EXPECT_EQ(1U, allocation_size_map_.erase(address));
- }
-
- size_t GetSizeEstimate(void* address) {
- auto it = allocation_size_map_.find(address);
- if (it == allocation_size_map_.end())
- return 0;
-
- size_t ret = it->second;
- switch (size_function_kind_) {
- case EXACT_SIZE_FUNCTION:
- break;
- case PADDING_SIZE_FUNCTION:
- ret += kAllocationPadding;
- break;
- case ZERO_SIZE_FUNCTION:
- ret = 0;
- break;
- }
-
- return ret;
- }
-
- static void* OnAllocFn(const AllocatorDispatch* self,
- size_t size,
- void* context) {
- EXPECT_EQ(&g_mock_dispatch, self);
-
- void* ret = malloc(size);
- g_self->RecordAlloc(ret, size);
- return ret;
- }
-
- static void* OnAllocZeroInitializedFn(const AllocatorDispatch* self,
- size_t n,
- size_t size,
- void* context) {
- EXPECT_EQ(&g_mock_dispatch, self);
-
- void* ret = calloc(n, size);
- g_self->RecordAlloc(ret, n * size);
- return ret;
- }
-
- static void* OnAllocAlignedFn(const AllocatorDispatch* self,
- size_t alignment,
- size_t size,
- void* context) {
- EXPECT_EQ(&g_mock_dispatch, self);
-
- // This is a cheat as it doesn't return aligned allocations. This has the
- // advantage of working for all platforms for this test.
- void* ret = malloc(size);
- g_self->RecordAlloc(ret, size);
- return ret;
- }
-
- static void* OnReallocFn(const AllocatorDispatch* self,
- void* address,
- size_t size,
- void* context) {
- EXPECT_EQ(&g_mock_dispatch, self);
-
- g_self->DeleteAlloc(address);
- void* ret = realloc(address, size);
- g_self->RecordAlloc(ret, size);
- return ret;
- }
-
- static void OnFreeFn(const AllocatorDispatch* self,
- void* address,
- void* context) {
- EXPECT_EQ(&g_mock_dispatch, self);
-
- g_self->DeleteAlloc(address);
- free(address);
- }
-
- static size_t OnGetSizeEstimateFn(const AllocatorDispatch* self,
- void* address,
- void* context) {
- EXPECT_EQ(&g_mock_dispatch, self);
-
- return g_self->GetSizeEstimate(address);
- }
-
- using AllocationSizeMap = std::map<void*, size_t>;
-
- SizeFunctionKind size_function_kind_;
- AllocationSizeMap allocation_size_map_;
- AllocatorDispatch* dispatch_under_test_;
-
- static base::allocator::AllocatorDispatch g_mock_dispatch;
- static ThreadHeapUsageTrackerTest* g_self;
-};
-
-const size_t ThreadHeapUsageTrackerTest::kAllocationPadding = 23;
-
-ThreadHeapUsageTrackerTest* ThreadHeapUsageTrackerTest::g_self = nullptr;
-
-base::allocator::AllocatorDispatch ThreadHeapUsageTrackerTest::g_mock_dispatch =
- {
- &ThreadHeapUsageTrackerTest::OnAllocFn, // alloc_function
- &ThreadHeapUsageTrackerTest::
- OnAllocZeroInitializedFn, // alloc_zero_initialized_function
- &ThreadHeapUsageTrackerTest::
- OnAllocAlignedFn, // alloc_aligned_function
- &ThreadHeapUsageTrackerTest::OnReallocFn, // realloc_function
- &ThreadHeapUsageTrackerTest::OnFreeFn, // free_function
- &ThreadHeapUsageTrackerTest::
- OnGetSizeEstimateFn, // get_size_estimate_function
- nullptr, // batch_malloc
- nullptr, // batch_free
- nullptr, // free_definite_size_function
- nullptr, // next
-};
-
-} // namespace
-
-TEST_F(ThreadHeapUsageTrackerTest, SimpleUsageWithExactSizeFunction) {
- set_size_function_kind(EXACT_SIZE_FUNCTION);
-
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- ThreadHeapUsage u1 = ThreadHeapUsageTracker::GetUsageSnapshot();
-
- EXPECT_EQ(0U, u1.alloc_ops);
- EXPECT_EQ(0U, u1.alloc_bytes);
- EXPECT_EQ(0U, u1.alloc_overhead_bytes);
- EXPECT_EQ(0U, u1.free_ops);
- EXPECT_EQ(0U, u1.free_bytes);
- EXPECT_EQ(0U, u1.max_allocated_bytes);
-
- const size_t kAllocSize = 1029U;
- void* ptr = MockMalloc(kAllocSize);
- MockFree(ptr);
-
- usage_tracker.Stop(false);
- ThreadHeapUsage u2 = usage_tracker.usage();
-
- EXPECT_EQ(1U, u2.alloc_ops);
- EXPECT_EQ(kAllocSize, u2.alloc_bytes);
- EXPECT_EQ(0U, u2.alloc_overhead_bytes);
- EXPECT_EQ(1U, u2.free_ops);
- EXPECT_EQ(kAllocSize, u2.free_bytes);
- EXPECT_EQ(kAllocSize, u2.max_allocated_bytes);
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, SimpleUsageWithPaddingSizeFunction) {
- set_size_function_kind(PADDING_SIZE_FUNCTION);
-
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- ThreadHeapUsage u1 = ThreadHeapUsageTracker::GetUsageSnapshot();
-
- EXPECT_EQ(0U, u1.alloc_ops);
- EXPECT_EQ(0U, u1.alloc_bytes);
- EXPECT_EQ(0U, u1.alloc_overhead_bytes);
- EXPECT_EQ(0U, u1.free_ops);
- EXPECT_EQ(0U, u1.free_bytes);
- EXPECT_EQ(0U, u1.max_allocated_bytes);
-
- const size_t kAllocSize = 1029U;
- void* ptr = MockMalloc(kAllocSize);
- MockFree(ptr);
-
- usage_tracker.Stop(false);
- ThreadHeapUsage u2 = usage_tracker.usage();
-
- EXPECT_EQ(1U, u2.alloc_ops);
- EXPECT_EQ(kAllocSize + kAllocationPadding, u2.alloc_bytes);
- EXPECT_EQ(kAllocationPadding, u2.alloc_overhead_bytes);
- EXPECT_EQ(1U, u2.free_ops);
- EXPECT_EQ(kAllocSize + kAllocationPadding, u2.free_bytes);
- EXPECT_EQ(kAllocSize + kAllocationPadding, u2.max_allocated_bytes);
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, SimpleUsageWithZeroSizeFunction) {
- set_size_function_kind(ZERO_SIZE_FUNCTION);
-
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- ThreadHeapUsage u1 = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(0U, u1.alloc_ops);
- EXPECT_EQ(0U, u1.alloc_bytes);
- EXPECT_EQ(0U, u1.alloc_overhead_bytes);
- EXPECT_EQ(0U, u1.free_ops);
- EXPECT_EQ(0U, u1.free_bytes);
- EXPECT_EQ(0U, u1.max_allocated_bytes);
-
- const size_t kAllocSize = 1029U;
- void* ptr = MockMalloc(kAllocSize);
- MockFree(ptr);
-
- usage_tracker.Stop(false);
- ThreadHeapUsage u2 = usage_tracker.usage();
-
- // With a get-size function that returns zero, there's no way to get the size
- // of an allocation that's being freed, hence the shim can't tally freed bytes
- // nor the high-watermark allocated bytes.
- EXPECT_EQ(1U, u2.alloc_ops);
- EXPECT_EQ(kAllocSize, u2.alloc_bytes);
- EXPECT_EQ(0U, u2.alloc_overhead_bytes);
- EXPECT_EQ(1U, u2.free_ops);
- EXPECT_EQ(0U, u2.free_bytes);
- EXPECT_EQ(0U, u2.max_allocated_bytes);
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, ReallocCorrectlyTallied) {
- const size_t kAllocSize = 237U;
-
- {
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- // Reallocating nullptr should count as a single alloc.
- void* ptr = MockRealloc(nullptr, kAllocSize);
- ThreadHeapUsage usage = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(1U, usage.alloc_ops);
- EXPECT_EQ(kAllocSize, usage.alloc_bytes);
- EXPECT_EQ(0U, usage.alloc_overhead_bytes);
- EXPECT_EQ(0U, usage.free_ops);
- EXPECT_EQ(0U, usage.free_bytes);
- EXPECT_EQ(kAllocSize, usage.max_allocated_bytes);
-
- // Reallocating a valid pointer to a zero size should count as a single
- // free.
- ptr = MockRealloc(ptr, 0U);
-
- usage_tracker.Stop(false);
- EXPECT_EQ(1U, usage_tracker.usage().alloc_ops);
- EXPECT_EQ(kAllocSize, usage_tracker.usage().alloc_bytes);
- EXPECT_EQ(0U, usage_tracker.usage().alloc_overhead_bytes);
- EXPECT_EQ(1U, usage_tracker.usage().free_ops);
- EXPECT_EQ(kAllocSize, usage_tracker.usage().free_bytes);
- EXPECT_EQ(kAllocSize, usage_tracker.usage().max_allocated_bytes);
-
- // Realloc to zero size may or may not return a nullptr - make sure to
- // free the zero-size alloc in the latter case.
- if (ptr != nullptr)
- MockFree(ptr);
- }
-
- {
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- void* ptr = MockMalloc(kAllocSize);
- ThreadHeapUsage usage = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(1U, usage.alloc_ops);
-
- // Now try reallocating a valid pointer to a larger size, this should count
- // as one free and one alloc.
- const size_t kLargerAllocSize = kAllocSize + 928U;
- ptr = MockRealloc(ptr, kLargerAllocSize);
-
- usage_tracker.Stop(false);
- EXPECT_EQ(2U, usage_tracker.usage().alloc_ops);
- EXPECT_EQ(kAllocSize + kLargerAllocSize, usage_tracker.usage().alloc_bytes);
- EXPECT_EQ(0U, usage_tracker.usage().alloc_overhead_bytes);
- EXPECT_EQ(1U, usage_tracker.usage().free_ops);
- EXPECT_EQ(kAllocSize, usage_tracker.usage().free_bytes);
- EXPECT_EQ(kLargerAllocSize, usage_tracker.usage().max_allocated_bytes);
-
- MockFree(ptr);
- }
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, NestedMaxWorks) {
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- const size_t kOuterAllocSize = 1029U;
- void* ptr = MockMalloc(kOuterAllocSize);
- MockFree(ptr);
-
- EXPECT_EQ(kOuterAllocSize,
- ThreadHeapUsageTracker::GetUsageSnapshot().max_allocated_bytes);
-
- {
- ThreadHeapUsageTracker inner_usage_tracker;
- inner_usage_tracker.Start();
-
- const size_t kInnerAllocSize = 673U;
- ptr = MockMalloc(kInnerAllocSize);
- MockFree(ptr);
-
- inner_usage_tracker.Stop(false);
-
- EXPECT_EQ(kInnerAllocSize, inner_usage_tracker.usage().max_allocated_bytes);
- }
-
- // The greater, outer allocation size should have been restored.
- EXPECT_EQ(kOuterAllocSize,
- ThreadHeapUsageTracker::GetUsageSnapshot().max_allocated_bytes);
-
- const size_t kLargerInnerAllocSize = kOuterAllocSize + 673U;
- {
- ThreadHeapUsageTracker inner_usage_tracker;
- inner_usage_tracker.Start();
-
- ptr = MockMalloc(kLargerInnerAllocSize);
- MockFree(ptr);
-
- inner_usage_tracker.Stop(false);
- EXPECT_EQ(kLargerInnerAllocSize,
- inner_usage_tracker.usage().max_allocated_bytes);
- }
-
- // The greater, inner allocation size should have been preserved.
- EXPECT_EQ(kLargerInnerAllocSize,
- ThreadHeapUsageTracker::GetUsageSnapshot().max_allocated_bytes);
-
- // Now try the case with an outstanding net alloc size when entering the
- // inner scope.
- void* outer_ptr = MockMalloc(kOuterAllocSize);
- EXPECT_EQ(kLargerInnerAllocSize,
- ThreadHeapUsageTracker::GetUsageSnapshot().max_allocated_bytes);
- {
- ThreadHeapUsageTracker inner_usage_tracker;
- inner_usage_tracker.Start();
-
- ptr = MockMalloc(kLargerInnerAllocSize);
- MockFree(ptr);
-
- inner_usage_tracker.Stop(false);
- EXPECT_EQ(kLargerInnerAllocSize,
- inner_usage_tracker.usage().max_allocated_bytes);
- }
-
- // While the inner scope saw only the inner net outstanding allocation size,
- // the outer scope saw both outstanding at the same time.
- EXPECT_EQ(kOuterAllocSize + kLargerInnerAllocSize,
- ThreadHeapUsageTracker::GetUsageSnapshot().max_allocated_bytes);
-
- MockFree(outer_ptr);
-
- // Test a net-negative scope.
- ptr = MockMalloc(kLargerInnerAllocSize);
- {
- ThreadHeapUsageTracker inner_usage_tracker;
- inner_usage_tracker.Start();
-
- MockFree(ptr);
-
- const size_t kInnerAllocSize = 1;
- ptr = MockMalloc(kInnerAllocSize);
-
- inner_usage_tracker.Stop(false);
- // Since the scope is still net-negative, the max is clamped at zero.
- EXPECT_EQ(0U, inner_usage_tracker.usage().max_allocated_bytes);
- }
-
- MockFree(ptr);
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, NoStopImpliesInclusive) {
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- const size_t kOuterAllocSize = 1029U;
- void* ptr = MockMalloc(kOuterAllocSize);
- MockFree(ptr);
-
- ThreadHeapUsage usage = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(kOuterAllocSize, usage.max_allocated_bytes);
-
- const size_t kInnerLargerAllocSize = kOuterAllocSize + 673U;
-
- {
- ThreadHeapUsageTracker inner_usage_tracker;
- inner_usage_tracker.Start();
-
- // Make a larger allocation than the outer scope.
- ptr = MockMalloc(kInnerLargerAllocSize);
- MockFree(ptr);
-
- // inner_usage_tracker goes out of scope without a Stop().
- }
-
- ThreadHeapUsage current = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(usage.alloc_ops + 1, current.alloc_ops);
- EXPECT_EQ(usage.alloc_bytes + kInnerLargerAllocSize, current.alloc_bytes);
- EXPECT_EQ(usage.free_ops + 1, current.free_ops);
- EXPECT_EQ(usage.free_bytes + kInnerLargerAllocSize, current.free_bytes);
- EXPECT_EQ(kInnerLargerAllocSize, current.max_allocated_bytes);
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, ExclusiveScopesWork) {
- ThreadHeapUsageTracker usage_tracker;
- usage_tracker.Start();
-
- const size_t kOuterAllocSize = 1029U;
- void* ptr = MockMalloc(kOuterAllocSize);
- MockFree(ptr);
-
- ThreadHeapUsage usage = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(kOuterAllocSize, usage.max_allocated_bytes);
-
- {
- ThreadHeapUsageTracker inner_usage_tracker;
- inner_usage_tracker.Start();
-
- // Make a larger allocation than the outer scope.
- ptr = MockMalloc(kOuterAllocSize + 673U);
- MockFree(ptr);
-
- // This tracker is exlusive, all activity should be private to this scope.
- inner_usage_tracker.Stop(true);
- }
-
- ThreadHeapUsage current = ThreadHeapUsageTracker::GetUsageSnapshot();
- EXPECT_EQ(usage.alloc_ops, current.alloc_ops);
- EXPECT_EQ(usage.alloc_bytes, current.alloc_bytes);
- EXPECT_EQ(usage.alloc_overhead_bytes, current.alloc_overhead_bytes);
- EXPECT_EQ(usage.free_ops, current.free_ops);
- EXPECT_EQ(usage.free_bytes, current.free_bytes);
- EXPECT_EQ(usage.max_allocated_bytes, current.max_allocated_bytes);
-}
-
-TEST_F(ThreadHeapUsageTrackerTest, AllShimFunctionsAreProvided) {
- const size_t kAllocSize = 100;
- void* alloc = MockMalloc(kAllocSize);
- size_t estimate = MockGetSizeEstimate(alloc);
- ASSERT_TRUE(estimate == 0 || estimate >= kAllocSize);
- MockFree(alloc);
-
- alloc = MockCalloc(kAllocSize, 1);
- estimate = MockGetSizeEstimate(alloc);
- ASSERT_TRUE(estimate == 0 || estimate >= kAllocSize);
- MockFree(alloc);
-
- alloc = MockAllocAligned(1, kAllocSize);
- estimate = MockGetSizeEstimate(alloc);
- ASSERT_TRUE(estimate == 0 || estimate >= kAllocSize);
-
- alloc = MockRealloc(alloc, kAllocSize);
- estimate = MockGetSizeEstimate(alloc);
- ASSERT_TRUE(estimate == 0 || estimate >= kAllocSize);
- MockFree(alloc);
-}
-
-} // namespace debug
-} // namespace base
diff --git a/base/deferred_sequenced_task_runner_unittest.cc b/base/deferred_sequenced_task_runner_unittest.cc
deleted file mode 100644
index 5cb220f..0000000
--- a/base/deferred_sequenced_task_runner_unittest.cc
+++ /dev/null
@@ -1,214 +0,0 @@
-// 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 "base/deferred_sequenced_task_runner.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback_forward.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class DeferredSequencedTaskRunnerTest : public testing::Test {
- public:
- class ExecuteTaskOnDestructor : public RefCounted<ExecuteTaskOnDestructor> {
- public:
- ExecuteTaskOnDestructor(
- DeferredSequencedTaskRunnerTest* executor,
- int task_id)
- : executor_(executor),
- task_id_(task_id) {
- }
- private:
- friend class RefCounted<ExecuteTaskOnDestructor>;
- virtual ~ExecuteTaskOnDestructor() { executor_->ExecuteTask(task_id_); }
- DeferredSequencedTaskRunnerTest* executor_;
- int task_id_;
- };
-
- void ExecuteTask(int task_id) {
- AutoLock lock(lock_);
- executed_task_ids_.push_back(task_id);
- }
-
- void PostExecuteTask(int task_id) {
- runner_->PostTask(FROM_HERE,
- BindOnce(&DeferredSequencedTaskRunnerTest::ExecuteTask,
- Unretained(this), task_id));
- }
-
- void StartRunner() {
- runner_->Start();
- }
-
- void DoNothing(ExecuteTaskOnDestructor* object) {
- }
-
- protected:
- DeferredSequencedTaskRunnerTest()
- : loop_(),
- runner_(new DeferredSequencedTaskRunner(loop_.task_runner())) {}
-
- MessageLoop loop_;
- scoped_refptr<DeferredSequencedTaskRunner> runner_;
- mutable Lock lock_;
- std::vector<int> executed_task_ids_;
-};
-
-TEST_F(DeferredSequencedTaskRunnerTest, Stopped) {
- PostExecuteTask(1);
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre());
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, Start) {
- StartRunner();
- PostExecuteTask(1);
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1));
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, StartWithMultipleElements) {
- StartRunner();
- for (int i = 1; i < 5; ++i)
- PostExecuteTask(i);
-
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1, 2, 3, 4));
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, DeferredStart) {
- PostExecuteTask(1);
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre());
-
- StartRunner();
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1));
-
- PostExecuteTask(2);
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1, 2));
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, DeferredStartWithMultipleElements) {
- for (int i = 1; i < 5; ++i)
- PostExecuteTask(i);
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre());
-
- StartRunner();
- for (int i = 5; i < 9; ++i)
- PostExecuteTask(i);
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_, testing::ElementsAre(1, 2, 3, 4, 5, 6, 7, 8));
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, DeferredStartWithMultipleThreads) {
- {
- Thread thread1("DeferredSequencedTaskRunnerTestThread1");
- Thread thread2("DeferredSequencedTaskRunnerTestThread2");
- thread1.Start();
- thread2.Start();
- for (int i = 0; i < 5; ++i) {
- thread1.task_runner()->PostTask(
- FROM_HERE, BindOnce(&DeferredSequencedTaskRunnerTest::PostExecuteTask,
- Unretained(this), 2 * i));
- thread2.task_runner()->PostTask(
- FROM_HERE, BindOnce(&DeferredSequencedTaskRunnerTest::PostExecuteTask,
- Unretained(this), 2 * i + 1));
- if (i == 2) {
- thread1.task_runner()->PostTask(
- FROM_HERE, BindOnce(&DeferredSequencedTaskRunnerTest::StartRunner,
- Unretained(this)));
- }
- }
- }
-
- RunLoop().RunUntilIdle();
- EXPECT_THAT(executed_task_ids_,
- testing::WhenSorted(testing::ElementsAre(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)));
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, ObjectDestructionOrder) {
- {
- Thread thread("DeferredSequencedTaskRunnerTestThread");
- thread.Start();
- runner_ = new DeferredSequencedTaskRunner(thread.task_runner());
- for (int i = 0; i < 5; ++i) {
- {
- // Use a block to ensure that no reference to |short_lived_object|
- // is kept on the main thread after it is posted to |runner_|.
- scoped_refptr<ExecuteTaskOnDestructor> short_lived_object =
- new ExecuteTaskOnDestructor(this, 2 * i);
- runner_->PostTask(
- FROM_HERE,
- BindOnce(&DeferredSequencedTaskRunnerTest::DoNothing,
- Unretained(this), RetainedRef(short_lived_object)));
- }
- // |short_lived_object| with id |2 * i| should be destroyed before the
- // task |2 * i + 1| is executed.
- PostExecuteTask(2 * i + 1);
- }
- StartRunner();
- }
-
- // All |short_lived_object| with id |2 * i| are destroyed before the task
- // |2 * i + 1| is executed.
- EXPECT_THAT(executed_task_ids_,
- testing::ElementsAre(0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
-}
-
-void GetRunsTasksInCurrentSequence(bool* result,
- scoped_refptr<SequencedTaskRunner> runner,
- OnceClosure quit) {
- *result = runner->RunsTasksInCurrentSequence();
- std::move(quit).Run();
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, RunsTasksInCurrentSequence) {
- scoped_refptr<DeferredSequencedTaskRunner> runner =
- MakeRefCounted<DeferredSequencedTaskRunner>();
- EXPECT_TRUE(runner->RunsTasksInCurrentSequence());
-
- Thread thread1("DeferredSequencedTaskRunnerTestThread1");
- thread1.Start();
- bool runs_task_in_current_thread = true;
- base::RunLoop run_loop;
- thread1.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&GetRunsTasksInCurrentSequence, &runs_task_in_current_thread,
- runner, run_loop.QuitClosure()));
- run_loop.Run();
- EXPECT_FALSE(runs_task_in_current_thread);
-}
-
-TEST_F(DeferredSequencedTaskRunnerTest, StartWithTaskRunner) {
- scoped_refptr<DeferredSequencedTaskRunner> runner =
- MakeRefCounted<DeferredSequencedTaskRunner>();
- bool run_called = false;
- base::RunLoop run_loop;
- runner->PostTask(FROM_HERE,
- BindOnce(
- [](bool* run_called, base::Closure quit_closure) {
- *run_called = true;
- std::move(quit_closure).Run();
- },
- &run_called, run_loop.QuitClosure()));
- runner->StartWithTaskRunner(loop_.task_runner());
- run_loop.Run();
- EXPECT_TRUE(run_called);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/environment_unittest.cc b/base/environment_unittest.cc
deleted file mode 100644
index 79800ad..0000000
--- a/base/environment_unittest.cc
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2011 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 "base/environment.h"
-
-#include <memory>
-
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-typedef PlatformTest EnvironmentTest;
-
-namespace base {
-
-namespace {
-
-constexpr char kValidEnvironmentVariable[] = "PATH";
-
-} // namespace
-
-TEST_F(EnvironmentTest, GetVar) {
- std::unique_ptr<Environment> env(Environment::Create());
- std::string env_value;
- EXPECT_TRUE(env->GetVar(kValidEnvironmentVariable, &env_value));
- EXPECT_NE(env_value, "");
-}
-
-TEST_F(EnvironmentTest, GetVarReverse) {
- std::unique_ptr<Environment> env(Environment::Create());
- const char kFooUpper[] = "FOO";
- const char kFooLower[] = "foo";
-
- // Set a variable in UPPER case.
- EXPECT_TRUE(env->SetVar(kFooUpper, kFooLower));
-
- // And then try to get this variable passing the lower case.
- std::string env_value;
- EXPECT_TRUE(env->GetVar(kFooLower, &env_value));
-
- EXPECT_STREQ(env_value.c_str(), kFooLower);
-
- EXPECT_TRUE(env->UnSetVar(kFooUpper));
-
- const char kBar[] = "bar";
- // Now do the opposite, set the variable in the lower case.
- EXPECT_TRUE(env->SetVar(kFooLower, kBar));
-
- // And then try to get this variable passing the UPPER case.
- EXPECT_TRUE(env->GetVar(kFooUpper, &env_value));
-
- EXPECT_STREQ(env_value.c_str(), kBar);
-
- EXPECT_TRUE(env->UnSetVar(kFooLower));
-}
-
-TEST_F(EnvironmentTest, HasVar) {
- std::unique_ptr<Environment> env(Environment::Create());
- EXPECT_TRUE(env->HasVar(kValidEnvironmentVariable));
-}
-
-TEST_F(EnvironmentTest, SetVar) {
- std::unique_ptr<Environment> env(Environment::Create());
-
- const char kFooUpper[] = "FOO";
- const char kFooLower[] = "foo";
- EXPECT_TRUE(env->SetVar(kFooUpper, kFooLower));
-
- // Now verify that the environment has the new variable.
- EXPECT_TRUE(env->HasVar(kFooUpper));
-
- std::string var_value;
- EXPECT_TRUE(env->GetVar(kFooUpper, &var_value));
- EXPECT_EQ(var_value, kFooLower);
-}
-
-TEST_F(EnvironmentTest, UnSetVar) {
- std::unique_ptr<Environment> env(Environment::Create());
-
- const char kFooUpper[] = "FOO";
- const char kFooLower[] = "foo";
- // First set some environment variable.
- EXPECT_TRUE(env->SetVar(kFooUpper, kFooLower));
-
- // Now verify that the environment has the new variable.
- EXPECT_TRUE(env->HasVar(kFooUpper));
-
- // Finally verify that the environment variable was erased.
- EXPECT_TRUE(env->UnSetVar(kFooUpper));
-
- // And check that the variable has been unset.
- EXPECT_FALSE(env->HasVar(kFooUpper));
-}
-
-#if defined(OS_WIN)
-
-TEST_F(EnvironmentTest, AlterEnvironment) {
- const wchar_t empty[] = L"\0";
- const wchar_t a2[] = L"A=2\0";
- EnvironmentMap changes;
- string16 e;
-
- e = AlterEnvironment(empty, changes);
- EXPECT_EQ(0, e[0]);
-
- changes[L"A"] = L"1";
- e = AlterEnvironment(empty, changes);
- EXPECT_EQ(string16(L"A=1\0\0", 5), e);
-
- changes.clear();
- changes[L"A"] = string16();
- e = AlterEnvironment(empty, changes);
- EXPECT_EQ(string16(L"\0\0", 2), e);
-
- changes.clear();
- e = AlterEnvironment(a2, changes);
- EXPECT_EQ(string16(L"A=2\0\0", 5), e);
-
- changes.clear();
- changes[L"A"] = L"1";
- e = AlterEnvironment(a2, changes);
- EXPECT_EQ(string16(L"A=1\0\0", 5), e);
-
- changes.clear();
- changes[L"A"] = string16();
- e = AlterEnvironment(a2, changes);
- EXPECT_EQ(string16(L"\0\0", 2), e);
-}
-
-#else
-
-TEST_F(EnvironmentTest, AlterEnvironment) {
- const char* const empty[] = {nullptr};
- const char* const a2[] = {"A=2", nullptr};
- EnvironmentMap changes;
- std::unique_ptr<char* []> e;
-
- e = AlterEnvironment(empty, changes);
- EXPECT_TRUE(e[0] == nullptr);
-
- changes["A"] = "1";
- e = AlterEnvironment(empty, changes);
- EXPECT_EQ(std::string("A=1"), e[0]);
- EXPECT_TRUE(e[1] == nullptr);
-
- changes.clear();
- changes["A"] = std::string();
- e = AlterEnvironment(empty, changes);
- EXPECT_TRUE(e[0] == nullptr);
-
- changes.clear();
- e = AlterEnvironment(a2, changes);
- EXPECT_EQ(std::string("A=2"), e[0]);
- EXPECT_TRUE(e[1] == nullptr);
-
- changes.clear();
- changes["A"] = "1";
- e = AlterEnvironment(a2, changes);
- EXPECT_EQ(std::string("A=1"), e[0]);
- EXPECT_TRUE(e[1] == nullptr);
-
- changes.clear();
- changes["A"] = std::string();
- e = AlterEnvironment(a2, changes);
- EXPECT_TRUE(e[0] == nullptr);
-}
-
-#endif
-
-} // namespace base
diff --git a/base/feature_list_unittest.cc b/base/feature_list_unittest.cc
deleted file mode 100644
index 164997a..0000000
--- a/base/feature_list_unittest.cc
+++ /dev/null
@@ -1,542 +0,0 @@
-// Copyright 2015 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 "base/feature_list.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <utility>
-
-#include "base/format_macros.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-constexpr char kFeatureOnByDefaultName[] = "OnByDefault";
-struct Feature kFeatureOnByDefault {
- kFeatureOnByDefaultName, FEATURE_ENABLED_BY_DEFAULT
-};
-
-constexpr char kFeatureOffByDefaultName[] = "OffByDefault";
-struct Feature kFeatureOffByDefault {
- kFeatureOffByDefaultName, FEATURE_DISABLED_BY_DEFAULT
-};
-
-std::string SortFeatureListString(const std::string& feature_list) {
- std::vector<base::StringPiece> features =
- FeatureList::SplitFeatureListString(feature_list);
- std::sort(features.begin(), features.end());
- return JoinString(features, ",");
-}
-
-} // namespace
-
-class FeatureListTest : public testing::Test {
- public:
- FeatureListTest() : feature_list_(nullptr) {
- RegisterFeatureListInstance(WrapUnique(new FeatureList));
- }
- ~FeatureListTest() override { ClearFeatureListInstance(); }
-
- void RegisterFeatureListInstance(std::unique_ptr<FeatureList> feature_list) {
- FeatureList::ClearInstanceForTesting();
- feature_list_ = feature_list.get();
- FeatureList::SetInstance(std::move(feature_list));
- }
- void ClearFeatureListInstance() {
- FeatureList::ClearInstanceForTesting();
- feature_list_ = nullptr;
- }
-
- FeatureList* feature_list() { return feature_list_; }
-
- private:
- // Weak. Owned by the FeatureList::SetInstance().
- FeatureList* feature_list_;
-
- DISALLOW_COPY_AND_ASSIGN(FeatureListTest);
-};
-
-TEST_F(FeatureListTest, DefaultStates) {
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
-}
-
-TEST_F(FeatureListTest, InitializeFromCommandLine) {
- struct {
- const char* enable_features;
- const char* disable_features;
- bool expected_feature_on_state;
- bool expected_feature_off_state;
- } test_cases[] = {
- {"", "", true, false},
- {"OffByDefault", "", true, true},
- {"OffByDefault", "OnByDefault", false, true},
- {"OnByDefault,OffByDefault", "", true, true},
- {"", "OnByDefault,OffByDefault", false, false},
- // In the case an entry is both, disable takes precedence.
- {"OnByDefault", "OnByDefault,OffByDefault", false, false},
- };
-
- for (size_t i = 0; i < arraysize(test_cases); ++i) {
- const auto& test_case = test_cases[i];
- SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i,
- test_case.enable_features,
- test_case.disable_features));
-
- ClearFeatureListInstance();
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine(test_case.enable_features,
- test_case.disable_features);
- RegisterFeatureListInstance(std::move(feature_list));
-
- EXPECT_EQ(test_case.expected_feature_on_state,
- FeatureList::IsEnabled(kFeatureOnByDefault))
- << i;
- EXPECT_EQ(test_case.expected_feature_off_state,
- FeatureList::IsEnabled(kFeatureOffByDefault))
- << i;
- }
-}
-
-TEST_F(FeatureListTest, CheckFeatureIdentity) {
- // Tests that CheckFeatureIdentity() correctly detects when two different
- // structs with the same feature name are passed to it.
-
- // Call it twice for each feature at the top of the file, since the first call
- // makes it remember the entry and the second call will verify it.
- EXPECT_TRUE(feature_list()->CheckFeatureIdentity(kFeatureOnByDefault));
- EXPECT_TRUE(feature_list()->CheckFeatureIdentity(kFeatureOnByDefault));
- EXPECT_TRUE(feature_list()->CheckFeatureIdentity(kFeatureOffByDefault));
- EXPECT_TRUE(feature_list()->CheckFeatureIdentity(kFeatureOffByDefault));
-
- // Now, call it with a distinct struct for |kFeatureOnByDefaultName|, which
- // should return false.
- struct Feature kFeatureOnByDefault2 {
- kFeatureOnByDefaultName, FEATURE_ENABLED_BY_DEFAULT
- };
- EXPECT_FALSE(feature_list()->CheckFeatureIdentity(kFeatureOnByDefault2));
-}
-
-TEST_F(FeatureListTest, FieldTrialOverrides) {
- struct {
- FeatureList::OverrideState trial1_state;
- FeatureList::OverrideState trial2_state;
- } test_cases[] = {
- {FeatureList::OVERRIDE_DISABLE_FEATURE,
- FeatureList::OVERRIDE_DISABLE_FEATURE},
- {FeatureList::OVERRIDE_DISABLE_FEATURE,
- FeatureList::OVERRIDE_ENABLE_FEATURE},
- {FeatureList::OVERRIDE_ENABLE_FEATURE,
- FeatureList::OVERRIDE_DISABLE_FEATURE},
- {FeatureList::OVERRIDE_ENABLE_FEATURE,
- FeatureList::OVERRIDE_ENABLE_FEATURE},
- };
-
- FieldTrial::ActiveGroup active_group;
- for (size_t i = 0; i < arraysize(test_cases); ++i) {
- const auto& test_case = test_cases[i];
- SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
-
- ClearFeatureListInstance();
-
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
-
- FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A");
- FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B");
- feature_list->RegisterFieldTrialOverride(kFeatureOnByDefaultName,
- test_case.trial1_state, trial1);
- feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName,
- test_case.trial2_state, trial2);
- RegisterFeatureListInstance(std::move(feature_list));
-
- // Initially, neither trial should be active.
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial1->trial_name()));
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name()));
-
- const bool expected_enabled_1 =
- (test_case.trial1_state == FeatureList::OVERRIDE_ENABLE_FEATURE);
- EXPECT_EQ(expected_enabled_1, FeatureList::IsEnabled(kFeatureOnByDefault));
- // The above should have activated |trial1|.
- EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name()));
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name()));
-
- const bool expected_enabled_2 =
- (test_case.trial2_state == FeatureList::OVERRIDE_ENABLE_FEATURE);
- EXPECT_EQ(expected_enabled_2, FeatureList::IsEnabled(kFeatureOffByDefault));
- // The above should have activated |trial2|.
- EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name()));
- EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name()));
- }
-}
-
-TEST_F(FeatureListTest, FieldTrialAssociateUseDefault) {
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
-
- FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A");
- FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B");
- feature_list->RegisterFieldTrialOverride(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial1);
- feature_list->RegisterFieldTrialOverride(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial2);
- RegisterFeatureListInstance(std::move(feature_list));
-
- // Initially, neither trial should be active.
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial1->trial_name()));
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name()));
-
- // Check the feature enabled state is its default.
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
- // The above should have activated |trial1|.
- EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name()));
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name()));
-
- // Check the feature enabled state is its default.
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
- // The above should have activated |trial2|.
- EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name()));
- EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name()));
-}
-
-TEST_F(FeatureListTest, CommandLineTakesPrecedenceOverFieldTrial) {
- ClearFeatureListInstance();
-
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
-
- // The feature is explicitly enabled on the command-line.
- feature_list->InitializeFromCommandLine(kFeatureOffByDefaultName, "");
-
- // But the FieldTrial would set the feature to disabled.
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample2", "A");
- feature_list->RegisterFieldTrialOverride(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE, trial);
- RegisterFeatureListInstance(std::move(feature_list));
-
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name()));
- // Command-line should take precedence.
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
- // Since the feature is on due to the command-line, and not as a result of the
- // field trial, the field trial should not be activated (since the Associate*
- // API wasn't used.)
- EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name()));
-}
-
-TEST_F(FeatureListTest, IsFeatureOverriddenFromCommandLine) {
- ClearFeatureListInstance();
-
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
-
- // No features are overridden from the command line yet
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
-
- // Now, enable |kFeatureOffByDefaultName| via the command-line.
- feature_list->InitializeFromCommandLine(kFeatureOffByDefaultName, "");
-
- // It should now be overridden for the enabled group.
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
- EXPECT_TRUE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
-
- // Register a field trial to associate with the feature and ensure that the
- // results are still the same.
- feature_list->AssociateReportingFieldTrial(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE,
- FieldTrialList::CreateFieldTrial("Trial1", "A"));
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
- EXPECT_TRUE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
-
- // Now, register a field trial to override |kFeatureOnByDefaultName| state
- // and check that the function still returns false for that feature.
- feature_list->RegisterFieldTrialOverride(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE,
- FieldTrialList::CreateFieldTrial("Trial2", "A"));
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
- EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
- RegisterFeatureListInstance(std::move(feature_list));
-
- // Check the expected feature states for good measure.
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault));
-}
-
-TEST_F(FeatureListTest, AssociateReportingFieldTrial) {
- struct {
- const char* enable_features;
- const char* disable_features;
- bool expected_enable_trial_created;
- bool expected_disable_trial_created;
- } test_cases[] = {
- // If no enable/disable flags are specified, no trials should be created.
- {"", "", false, false},
- // Enabling the feature should result in the enable trial created.
- {kFeatureOffByDefaultName, "", true, false},
- // Disabling the feature should result in the disable trial created.
- {"", kFeatureOffByDefaultName, false, true},
- };
-
- const char kTrialName[] = "ForcingTrial";
- const char kForcedOnGroupName[] = "ForcedOn";
- const char kForcedOffGroupName[] = "ForcedOff";
-
- for (size_t i = 0; i < arraysize(test_cases); ++i) {
- const auto& test_case = test_cases[i];
- SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i,
- test_case.enable_features,
- test_case.disable_features));
-
- ClearFeatureListInstance();
-
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine(test_case.enable_features,
- test_case.disable_features);
-
- FieldTrial* enable_trial = nullptr;
- if (feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)) {
- enable_trial = base::FieldTrialList::CreateFieldTrial(kTrialName,
- kForcedOnGroupName);
- feature_list->AssociateReportingFieldTrial(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE,
- enable_trial);
- }
- FieldTrial* disable_trial = nullptr;
- if (feature_list->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE)) {
- disable_trial = base::FieldTrialList::CreateFieldTrial(
- kTrialName, kForcedOffGroupName);
- feature_list->AssociateReportingFieldTrial(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE,
- disable_trial);
- }
- EXPECT_EQ(test_case.expected_enable_trial_created, enable_trial != nullptr);
- EXPECT_EQ(test_case.expected_disable_trial_created,
- disable_trial != nullptr);
- RegisterFeatureListInstance(std::move(feature_list));
-
- EXPECT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
- if (disable_trial) {
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
- EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
- EXPECT_EQ(kForcedOffGroupName, disable_trial->group_name());
- } else if (enable_trial) {
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
- EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
- EXPECT_EQ(kForcedOnGroupName, enable_trial->group_name());
- }
- }
-}
-
-TEST_F(FeatureListTest, GetFeatureOverrides) {
- ClearFeatureListInstance();
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine("A,X", "D");
-
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group");
- feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName,
- FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial);
-
- RegisterFeatureListInstance(std::move(feature_list));
-
- std::string enable_features;
- std::string disable_features;
- FeatureList::GetInstance()->GetFeatureOverrides(&enable_features,
- &disable_features);
- EXPECT_EQ("A,OffByDefault<Trial,X", SortFeatureListString(enable_features));
- EXPECT_EQ("D", SortFeatureListString(disable_features));
-
- FeatureList::GetInstance()->GetCommandLineFeatureOverrides(&enable_features,
- &disable_features);
- EXPECT_EQ("A,X", SortFeatureListString(enable_features));
- EXPECT_EQ("D", SortFeatureListString(disable_features));
-}
-
-TEST_F(FeatureListTest, GetFeatureOverrides_UseDefault) {
- ClearFeatureListInstance();
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine("A,X", "D");
-
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group");
- feature_list->RegisterFieldTrialOverride(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial);
-
- RegisterFeatureListInstance(std::move(feature_list));
-
- std::string enable_features;
- std::string disable_features;
- FeatureList::GetInstance()->GetFeatureOverrides(&enable_features,
- &disable_features);
- EXPECT_EQ("*OffByDefault<Trial,A,X", SortFeatureListString(enable_features));
- EXPECT_EQ("D", SortFeatureListString(disable_features));
-}
-
-TEST_F(FeatureListTest, GetFieldTrial) {
- ClearFeatureListInstance();
- FieldTrialList field_trial_list(nullptr);
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group");
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->RegisterFieldTrialOverride(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial);
- RegisterFeatureListInstance(std::move(feature_list));
-
- EXPECT_EQ(trial, FeatureList::GetFieldTrial(kFeatureOnByDefault));
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kFeatureOffByDefault));
-}
-
-TEST_F(FeatureListTest, InitializeFromCommandLine_WithFieldTrials) {
- ClearFeatureListInstance();
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial("Trial", "Group");
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine("A,OffByDefault<Trial,X", "D");
- RegisterFeatureListInstance(std::move(feature_list));
-
- EXPECT_FALSE(FieldTrialList::IsTrialActive("Trial"));
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
- EXPECT_TRUE(FieldTrialList::IsTrialActive("Trial"));
-}
-
-TEST_F(FeatureListTest, InitializeFromCommandLine_UseDefault) {
- ClearFeatureListInstance();
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial("T1", "Group");
- FieldTrialList::CreateFieldTrial("T2", "Group");
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine(
- "A,*OffByDefault<T1,*OnByDefault<T2,X", "D");
- RegisterFeatureListInstance(std::move(feature_list));
-
- EXPECT_FALSE(FieldTrialList::IsTrialActive("T1"));
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
- EXPECT_TRUE(FieldTrialList::IsTrialActive("T1"));
-
- EXPECT_FALSE(FieldTrialList::IsTrialActive("T2"));
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
- EXPECT_TRUE(FieldTrialList::IsTrialActive("T2"));
-}
-
-TEST_F(FeatureListTest, InitializeInstance) {
- ClearFeatureListInstance();
-
- std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
- FeatureList::SetInstance(std::move(feature_list));
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
-
- // Initialize from command line if we haven't yet.
- FeatureList::InitializeInstance("", kFeatureOnByDefaultName);
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault));
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
-
- // Do not initialize from commandline if we have already.
- FeatureList::InitializeInstance(kFeatureOffByDefaultName, "");
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault));
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
-}
-
-TEST_F(FeatureListTest, UninitializedInstance_IsEnabledReturnsFalse) {
- ClearFeatureListInstance();
- // This test case simulates the calling pattern found in code which does not
- // explicitly initialize the features list.
- // All IsEnabled() calls should return the default value in this scenario.
- EXPECT_EQ(nullptr, FeatureList::GetInstance());
- EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
- EXPECT_EQ(nullptr, FeatureList::GetInstance());
- EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
-}
-
-TEST_F(FeatureListTest, StoreAndRetrieveFeaturesFromSharedMemory) {
- std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-
- // Create some overrides.
- feature_list->RegisterOverride(kFeatureOffByDefaultName,
- FeatureList::OVERRIDE_ENABLE_FEATURE, nullptr);
- feature_list->RegisterOverride(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE, nullptr);
- feature_list->FinalizeInitialization();
-
- // Create an allocator and store the overrides.
- std::unique_ptr<SharedMemory> shm(new SharedMemory());
- shm->CreateAndMapAnonymous(4 << 10);
- SharedPersistentMemoryAllocator allocator(std::move(shm), 1, "", false);
- feature_list->AddFeaturesToAllocator(&allocator);
-
- std::unique_ptr<base::FeatureList> feature_list2(new base::FeatureList);
-
- // Check that the new feature list is empty.
- EXPECT_FALSE(feature_list2->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
- EXPECT_FALSE(feature_list2->IsFeatureOverriddenFromCommandLine(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
-
- feature_list2->InitializeFromSharedMemory(&allocator);
- // Check that the new feature list now has 2 overrides.
- EXPECT_TRUE(feature_list2->IsFeatureOverriddenFromCommandLine(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
- EXPECT_TRUE(feature_list2->IsFeatureOverriddenFromCommandLine(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
-}
-
-TEST_F(FeatureListTest, StoreAndRetrieveAssociatedFeaturesFromSharedMemory) {
- FieldTrialList field_trial_list(nullptr);
- std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-
- // Create some overrides.
- FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A");
- FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B");
- feature_list->RegisterFieldTrialOverride(
- kFeatureOnByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial1);
- feature_list->RegisterFieldTrialOverride(
- kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial2);
- feature_list->FinalizeInitialization();
-
- // Create an allocator and store the overrides.
- std::unique_ptr<SharedMemory> shm(new SharedMemory());
- shm->CreateAndMapAnonymous(4 << 10);
- SharedPersistentMemoryAllocator allocator(std::move(shm), 1, "", false);
- feature_list->AddFeaturesToAllocator(&allocator);
-
- std::unique_ptr<base::FeatureList> feature_list2(new base::FeatureList);
- feature_list2->InitializeFromSharedMemory(&allocator);
- feature_list2->FinalizeInitialization();
-
- // Check that the field trials are still associated.
- FieldTrial* associated_trial1 =
- feature_list2->GetAssociatedFieldTrial(kFeatureOnByDefault);
- FieldTrial* associated_trial2 =
- feature_list2->GetAssociatedFieldTrial(kFeatureOffByDefault);
- EXPECT_EQ(associated_trial1, trial1);
- EXPECT_EQ(associated_trial2, trial2);
-}
-
-} // namespace base
diff --git a/base/file_version_info_win_unittest.cc b/base/file_version_info_win_unittest.cc
deleted file mode 100644
index a4acc4c..0000000
--- a/base/file_version_info_win_unittest.cc
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright (c) 2011 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 "base/file_version_info_win.h"
-
-#include <windows.h>
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/file_version_info.h"
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/path_service.h"
-#include "base/scoped_native_library.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::FilePath;
-
-namespace {
-
-FilePath GetTestDataPath() {
- FilePath path;
- base::PathService::Get(base::DIR_SOURCE_ROOT, &path);
- path = path.AppendASCII("base");
- path = path.AppendASCII("test");
- path = path.AppendASCII("data");
- path = path.AppendASCII("file_version_info_unittest");
- return path;
-}
-
-class FileVersionInfoFactory {
- public:
- explicit FileVersionInfoFactory(const FilePath& path) : path_(path) {}
-
- std::unique_ptr<FileVersionInfo> Create() const {
- return base::WrapUnique(FileVersionInfo::CreateFileVersionInfo(path_));
- }
-
- private:
- const FilePath path_;
-
- DISALLOW_COPY_AND_ASSIGN(FileVersionInfoFactory);
-};
-
-class FileVersionInfoForModuleFactory {
- public:
- explicit FileVersionInfoForModuleFactory(const FilePath& path)
- // Load the library with LOAD_LIBRARY_AS_IMAGE_RESOURCE since it shouldn't
- // be executed.
- : library_(::LoadLibraryEx(path.value().c_str(),
- nullptr,
- LOAD_LIBRARY_AS_IMAGE_RESOURCE)) {
- EXPECT_TRUE(library_.is_valid());
- }
-
- std::unique_ptr<FileVersionInfo> Create() const {
- return base::WrapUnique(
- FileVersionInfo::CreateFileVersionInfoForModule(library_.get()));
- }
-
- private:
- const base::ScopedNativeLibrary library_;
-
- DISALLOW_COPY_AND_ASSIGN(FileVersionInfoForModuleFactory);
-};
-
-template <typename T>
-class FileVersionInfoTest : public testing::Test {};
-
-using FileVersionInfoFactories =
- ::testing::Types<FileVersionInfoFactory, FileVersionInfoForModuleFactory>;
-
-} // namespace
-
-TYPED_TEST_CASE(FileVersionInfoTest, FileVersionInfoFactories);
-
-TYPED_TEST(FileVersionInfoTest, HardCodedProperties) {
- const wchar_t kDLLName[] = {L"FileVersionInfoTest1.dll"};
-
- const wchar_t* const kExpectedValues[15] = {
- // FileVersionInfoTest.dll
- L"Goooooogle", // company_name
- L"Google", // company_short_name
- L"This is the product name", // product_name
- L"This is the product short name", // product_short_name
- L"The Internal Name", // internal_name
- L"4.3.2.1", // product_version
- L"Private build property", // private_build
- L"Special build property", // special_build
- L"This is a particularly interesting comment", // comments
- L"This is the original filename", // original_filename
- L"This is my file description", // file_description
- L"1.2.3.4", // file_version
- L"This is the legal copyright", // legal_copyright
- L"This is the legal trademarks", // legal_trademarks
- L"This is the last change", // last_change
- };
-
- FilePath dll_path = GetTestDataPath();
- dll_path = dll_path.Append(kDLLName);
-
- TypeParam factory(dll_path);
- std::unique_ptr<FileVersionInfo> version_info(factory.Create());
- ASSERT_TRUE(version_info);
-
- int j = 0;
- EXPECT_EQ(kExpectedValues[j++], version_info->company_name());
- EXPECT_EQ(kExpectedValues[j++], version_info->company_short_name());
- EXPECT_EQ(kExpectedValues[j++], version_info->product_name());
- EXPECT_EQ(kExpectedValues[j++], version_info->product_short_name());
- EXPECT_EQ(kExpectedValues[j++], version_info->internal_name());
- EXPECT_EQ(kExpectedValues[j++], version_info->product_version());
- EXPECT_EQ(kExpectedValues[j++], version_info->private_build());
- EXPECT_EQ(kExpectedValues[j++], version_info->special_build());
- EXPECT_EQ(kExpectedValues[j++], version_info->comments());
- EXPECT_EQ(kExpectedValues[j++], version_info->original_filename());
- EXPECT_EQ(kExpectedValues[j++], version_info->file_description());
- EXPECT_EQ(kExpectedValues[j++], version_info->file_version());
- EXPECT_EQ(kExpectedValues[j++], version_info->legal_copyright());
- EXPECT_EQ(kExpectedValues[j++], version_info->legal_trademarks());
- EXPECT_EQ(kExpectedValues[j++], version_info->last_change());
-}
-
-TYPED_TEST(FileVersionInfoTest, IsOfficialBuild) {
- constexpr struct {
- const wchar_t* const dll_name;
- const bool is_official_build;
- } kTestItems[]{
- {L"FileVersionInfoTest1.dll", true}, {L"FileVersionInfoTest2.dll", false},
- };
-
- for (const auto& test_item : kTestItems) {
- const FilePath dll_path = GetTestDataPath().Append(test_item.dll_name);
-
- TypeParam factory(dll_path);
- std::unique_ptr<FileVersionInfo> version_info(factory.Create());
- ASSERT_TRUE(version_info);
-
- EXPECT_EQ(test_item.is_official_build, version_info->is_official_build());
- }
-}
-
-TYPED_TEST(FileVersionInfoTest, CustomProperties) {
- FilePath dll_path = GetTestDataPath();
- dll_path = dll_path.AppendASCII("FileVersionInfoTest1.dll");
-
- TypeParam factory(dll_path);
- std::unique_ptr<FileVersionInfo> version_info(factory.Create());
- ASSERT_TRUE(version_info);
-
- // Test few existing properties.
- std::wstring str;
- FileVersionInfoWin* version_info_win =
- static_cast<FileVersionInfoWin*>(version_info.get());
- EXPECT_TRUE(version_info_win->GetValue(L"Custom prop 1", &str));
- EXPECT_EQ(L"Un", str);
- EXPECT_EQ(L"Un", version_info_win->GetStringValue(L"Custom prop 1"));
-
- EXPECT_TRUE(version_info_win->GetValue(L"Custom prop 2", &str));
- EXPECT_EQ(L"Deux", str);
- EXPECT_EQ(L"Deux", version_info_win->GetStringValue(L"Custom prop 2"));
-
- EXPECT_TRUE(version_info_win->GetValue(L"Custom prop 3", &str));
- EXPECT_EQ(L"1600 Amphitheatre Parkway Mountain View, CA 94043", str);
- EXPECT_EQ(L"1600 Amphitheatre Parkway Mountain View, CA 94043",
- version_info_win->GetStringValue(L"Custom prop 3"));
-
- // Test an non-existing property.
- EXPECT_FALSE(version_info_win->GetValue(L"Unknown property", &str));
- EXPECT_EQ(L"", version_info_win->GetStringValue(L"Unknown property"));
-}
diff --git a/base/files/dir_reader_posix_unittest.cc b/base/files/dir_reader_posix_unittest.cc
deleted file mode 100644
index f82619b..0000000
--- a/base/files/dir_reader_posix_unittest.cc
+++ /dev/null
@@ -1,95 +0,0 @@
-// 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.
-
-#include "base/files/dir_reader_posix.h"
-
-#include <fcntl.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_ANDROID)
-#include "base/os_compat_android.h"
-#endif
-
-namespace base {
-
-TEST(DirReaderPosixUnittest, Read) {
- static const unsigned kNumFiles = 100;
-
- if (DirReaderPosix::IsFallback())
- return;
-
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- const char* dir = temp_dir.GetPath().value().c_str();
- ASSERT_TRUE(dir);
-
- char wdbuf[PATH_MAX];
- PCHECK(getcwd(wdbuf, PATH_MAX));
-
- PCHECK(chdir(dir) == 0);
-
- for (unsigned i = 0; i < kNumFiles; i++) {
- char buf[16];
- snprintf(buf, sizeof(buf), "%d", i);
- const int fd = open(buf, O_CREAT | O_RDONLY | O_EXCL, 0600);
- PCHECK(fd >= 0);
- PCHECK(close(fd) == 0);
- }
-
- std::set<unsigned> seen;
-
- DirReaderPosix reader(dir);
- EXPECT_TRUE(reader.IsValid());
-
- if (!reader.IsValid())
- return;
-
- bool seen_dot = false, seen_dotdot = false;
-
- for (; reader.Next(); ) {
- if (strcmp(reader.name(), ".") == 0) {
- seen_dot = true;
- continue;
- }
- if (strcmp(reader.name(), "..") == 0) {
- seen_dotdot = true;
- continue;
- }
-
- SCOPED_TRACE(testing::Message() << "reader.name(): " << reader.name());
-
- char *endptr;
- const unsigned long value = strtoul(reader.name(), &endptr, 10);
-
- EXPECT_FALSE(*endptr);
- EXPECT_LT(value, kNumFiles);
- EXPECT_EQ(0u, seen.count(value));
- seen.insert(value);
- }
-
- for (unsigned i = 0; i < kNumFiles; i++) {
- char buf[16];
- snprintf(buf, sizeof(buf), "%d", i);
- PCHECK(unlink(buf) == 0);
- }
-
- PCHECK(rmdir(dir) == 0);
-
- PCHECK(chdir(wdbuf) == 0);
-
- EXPECT_TRUE(seen_dot);
- EXPECT_TRUE(seen_dotdot);
- EXPECT_EQ(kNumFiles, seen.size());
-}
-
-} // namespace base
diff --git a/base/files/file_descriptor_watcher_posix_unittest.cc b/base/files/file_descriptor_watcher_posix_unittest.cc
deleted file mode 100644
index 8fc57ce..0000000
--- a/base/files/file_descriptor_watcher_posix_unittest.cc
+++ /dev/null
@@ -1,318 +0,0 @@
-// Copyright 2016 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 "base/files/file_descriptor_watcher_posix.h"
-
-#include <unistd.h>
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/files/file_util.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/run_loop.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_checker_impl.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class Mock {
- public:
- Mock() = default;
-
- MOCK_METHOD0(ReadableCallback, void());
- MOCK_METHOD0(WritableCallback, void());
-
- private:
- DISALLOW_COPY_AND_ASSIGN(Mock);
-};
-
-enum class FileDescriptorWatcherTestType {
- MESSAGE_LOOP_FOR_IO_ON_MAIN_THREAD,
- MESSAGE_LOOP_FOR_IO_ON_OTHER_THREAD,
-};
-
-class FileDescriptorWatcherTest
- : public testing::TestWithParam<FileDescriptorWatcherTestType> {
- public:
- FileDescriptorWatcherTest()
- : message_loop_(GetParam() == FileDescriptorWatcherTestType::
- MESSAGE_LOOP_FOR_IO_ON_MAIN_THREAD
- ? new MessageLoopForIO
- : new MessageLoop),
- other_thread_("FileDescriptorWatcherTest_OtherThread") {}
- ~FileDescriptorWatcherTest() override = default;
-
- void SetUp() override {
- ASSERT_EQ(0, pipe(pipe_fds_));
-
- MessageLoop* message_loop_for_io;
- if (GetParam() ==
- FileDescriptorWatcherTestType::MESSAGE_LOOP_FOR_IO_ON_OTHER_THREAD) {
- Thread::Options options;
- options.message_loop_type = MessageLoop::TYPE_IO;
- ASSERT_TRUE(other_thread_.StartWithOptions(options));
- message_loop_for_io = other_thread_.message_loop();
- } else {
- message_loop_for_io = message_loop_.get();
- }
-
- ASSERT_TRUE(message_loop_for_io->IsType(MessageLoop::TYPE_IO));
- file_descriptor_watcher_ = std::make_unique<FileDescriptorWatcher>(
- static_cast<MessageLoopForIO*>(message_loop_for_io));
- }
-
- void TearDown() override {
- if (GetParam() ==
- FileDescriptorWatcherTestType::MESSAGE_LOOP_FOR_IO_ON_MAIN_THREAD &&
- message_loop_) {
- // Allow the delete task posted by the Controller's destructor to run.
- base::RunLoop().RunUntilIdle();
- }
-
- // Ensure that OtherThread is done processing before closing fds.
- other_thread_.Stop();
-
- EXPECT_EQ(0, IGNORE_EINTR(close(pipe_fds_[0])));
- EXPECT_EQ(0, IGNORE_EINTR(close(pipe_fds_[1])));
- }
-
- protected:
- int read_file_descriptor() const { return pipe_fds_[0]; }
- int write_file_descriptor() const { return pipe_fds_[1]; }
-
- // Waits for a short delay and run pending tasks.
- void WaitAndRunPendingTasks() {
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- RunLoop().RunUntilIdle();
- }
-
- // Registers ReadableCallback() to be called on |mock_| when
- // read_file_descriptor() is readable without blocking.
- std::unique_ptr<FileDescriptorWatcher::Controller> WatchReadable() {
- std::unique_ptr<FileDescriptorWatcher::Controller> controller =
- FileDescriptorWatcher::WatchReadable(
- read_file_descriptor(),
- Bind(&Mock::ReadableCallback, Unretained(&mock_)));
- EXPECT_TRUE(controller);
-
- // Unless read_file_descriptor() was readable before the callback was
- // registered, this shouldn't do anything.
- WaitAndRunPendingTasks();
-
- return controller;
- }
-
- // Registers WritableCallback() to be called on |mock_| when
- // write_file_descriptor() is writable without blocking.
- std::unique_ptr<FileDescriptorWatcher::Controller> WatchWritable() {
- std::unique_ptr<FileDescriptorWatcher::Controller> controller =
- FileDescriptorWatcher::WatchWritable(
- write_file_descriptor(),
- Bind(&Mock::WritableCallback, Unretained(&mock_)));
- EXPECT_TRUE(controller);
- return controller;
- }
-
- void WriteByte() {
- constexpr char kByte = '!';
- ASSERT_TRUE(
- WriteFileDescriptor(write_file_descriptor(), &kByte, sizeof(kByte)));
- }
-
- void ReadByte() {
- // This is always called as part of the WatchReadable() callback, which
- // should run on the main thread.
- EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-
- char buffer;
- ASSERT_TRUE(ReadFromFD(read_file_descriptor(), &buffer, sizeof(buffer)));
- }
-
- // Mock on wich callbacks are invoked.
- testing::StrictMock<Mock> mock_;
-
- // MessageLoop bound to the main thread.
- std::unique_ptr<MessageLoop> message_loop_;
-
- // Thread running a MessageLoopForIO. Used when the test type is
- // MESSAGE_LOOP_FOR_IO_ON_OTHER_THREAD.
- Thread other_thread_;
-
- private:
- // Determines which MessageLoopForIO is used to watch file descriptors for
- // which callbacks are registered on the main thread.
- std::unique_ptr<FileDescriptorWatcher> file_descriptor_watcher_;
-
- // Watched file descriptors.
- int pipe_fds_[2];
-
- // Used to verify that callbacks run on the thread on which they are
- // registered.
- ThreadCheckerImpl thread_checker_;
-
- DISALLOW_COPY_AND_ASSIGN(FileDescriptorWatcherTest);
-};
-
-} // namespace
-
-TEST_P(FileDescriptorWatcherTest, WatchWritable) {
- auto controller = WatchWritable();
-
- // The write end of a newly created pipe is immediately writable.
- RunLoop run_loop;
- EXPECT_CALL(mock_, WritableCallback())
- .WillOnce(testing::Invoke(&run_loop, &RunLoop::Quit));
- run_loop.Run();
-}
-
-TEST_P(FileDescriptorWatcherTest, WatchReadableOneByte) {
- auto controller = WatchReadable();
-
- // Write 1 byte to the pipe, making it readable without blocking. Expect one
- // call to ReadableCallback() which will read 1 byte from the pipe.
- WriteByte();
- RunLoop run_loop;
- EXPECT_CALL(mock_, ReadableCallback())
- .WillOnce(testing::Invoke([this, &run_loop]() {
- ReadByte();
- run_loop.Quit();
- }));
- run_loop.Run();
- testing::Mock::VerifyAndClear(&mock_);
-
- // No more call to ReadableCallback() is expected.
- WaitAndRunPendingTasks();
-}
-
-TEST_P(FileDescriptorWatcherTest, WatchReadableTwoBytes) {
- auto controller = WatchReadable();
-
- // Write 2 bytes to the pipe. Expect two calls to ReadableCallback() which
- // will each read 1 byte from the pipe.
- WriteByte();
- WriteByte();
- RunLoop run_loop;
- EXPECT_CALL(mock_, ReadableCallback())
- .WillOnce(testing::Invoke([this]() { ReadByte(); }))
- .WillOnce(testing::Invoke([this, &run_loop]() {
- ReadByte();
- run_loop.Quit();
- }));
- run_loop.Run();
- testing::Mock::VerifyAndClear(&mock_);
-
- // No more call to ReadableCallback() is expected.
- WaitAndRunPendingTasks();
-}
-
-TEST_P(FileDescriptorWatcherTest, WatchReadableByteWrittenFromCallback) {
- auto controller = WatchReadable();
-
- // Write 1 byte to the pipe. Expect one call to ReadableCallback() from which
- // 1 byte is read and 1 byte is written to the pipe. Then, expect another call
- // to ReadableCallback() from which the remaining byte is read from the pipe.
- WriteByte();
- RunLoop run_loop;
- EXPECT_CALL(mock_, ReadableCallback())
- .WillOnce(testing::Invoke([this]() {
- ReadByte();
- WriteByte();
- }))
- .WillOnce(testing::Invoke([this, &run_loop]() {
- ReadByte();
- run_loop.Quit();
- }));
- run_loop.Run();
- testing::Mock::VerifyAndClear(&mock_);
-
- // No more call to ReadableCallback() is expected.
- WaitAndRunPendingTasks();
-}
-
-TEST_P(FileDescriptorWatcherTest, DeleteControllerFromCallback) {
- auto controller = WatchReadable();
-
- // Write 1 byte to the pipe. Expect one call to ReadableCallback() from which
- // |controller| is deleted.
- WriteByte();
- RunLoop run_loop;
- EXPECT_CALL(mock_, ReadableCallback())
- .WillOnce(testing::Invoke([&run_loop, &controller]() {
- controller = nullptr;
- run_loop.Quit();
- }));
- run_loop.Run();
- testing::Mock::VerifyAndClear(&mock_);
-
- // Since |controller| has been deleted, no call to ReadableCallback() is
- // expected even though the pipe is still readable without blocking.
- WaitAndRunPendingTasks();
-}
-
-TEST_P(FileDescriptorWatcherTest,
- DeleteControllerBeforeFileDescriptorReadable) {
- auto controller = WatchReadable();
-
- // Cancel the watch.
- controller = nullptr;
-
- // Write 1 byte to the pipe to make it readable without blocking.
- WriteByte();
-
- // No call to ReadableCallback() is expected.
- WaitAndRunPendingTasks();
-}
-
-TEST_P(FileDescriptorWatcherTest, DeleteControllerAfterFileDescriptorReadable) {
- auto controller = WatchReadable();
-
- // Write 1 byte to the pipe to make it readable without blocking.
- WriteByte();
-
- // Cancel the watch.
- controller = nullptr;
-
- // No call to ReadableCallback() is expected.
- WaitAndRunPendingTasks();
-}
-
-TEST_P(FileDescriptorWatcherTest, DeleteControllerAfterDeleteMessageLoopForIO) {
- auto controller = WatchReadable();
-
- // Delete the MessageLoopForIO.
- if (GetParam() ==
- FileDescriptorWatcherTestType::MESSAGE_LOOP_FOR_IO_ON_MAIN_THREAD) {
- message_loop_ = nullptr;
- } else {
- other_thread_.Stop();
- }
-
- // Deleting |controller| shouldn't crash even though that causes a task to be
- // posted to the MessageLoopForIO thread.
- controller = nullptr;
-}
-
-INSTANTIATE_TEST_CASE_P(
- MessageLoopForIOOnMainThread,
- FileDescriptorWatcherTest,
- ::testing::Values(
- FileDescriptorWatcherTestType::MESSAGE_LOOP_FOR_IO_ON_MAIN_THREAD));
-INSTANTIATE_TEST_CASE_P(
- MessageLoopForIOOnOtherThread,
- FileDescriptorWatcherTest,
- ::testing::Values(
- FileDescriptorWatcherTestType::MESSAGE_LOOP_FOR_IO_ON_OTHER_THREAD));
-
-} // namespace base
diff --git a/base/files/file_enumerator_unittest.cc b/base/files/file_enumerator_unittest.cc
deleted file mode 100644
index 11df075..0000000
--- a/base/files/file_enumerator_unittest.cc
+++ /dev/null
@@ -1,312 +0,0 @@
-// Copyright 2017 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 "base/files/file_enumerator.h"
-
-#include <utility>
-#include <vector>
-
-#include "base/containers/circular_deque.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::ElementsAre;
-using testing::IsEmpty;
-using testing::UnorderedElementsAre;
-
-namespace base {
-namespace {
-
-const FilePath::StringType kEmptyPattern;
-
-const std::vector<FileEnumerator::FolderSearchPolicy> kFolderSearchPolicies{
- FileEnumerator::FolderSearchPolicy::MATCH_ONLY,
- FileEnumerator::FolderSearchPolicy::ALL};
-
-circular_deque<FilePath> RunEnumerator(
- const FilePath& root_path,
- bool recursive,
- int file_type,
- const FilePath::StringType& pattern,
- FileEnumerator::FolderSearchPolicy folder_search_policy) {
- circular_deque<FilePath> rv;
- FileEnumerator enumerator(root_path, recursive, file_type, pattern,
- folder_search_policy);
- for (auto file = enumerator.Next(); !file.empty(); file = enumerator.Next())
- rv.emplace_back(std::move(file));
- return rv;
-}
-
-bool CreateDummyFile(const FilePath& path) {
- return WriteFile(path, "42", sizeof("42")) == sizeof("42");
-}
-
-} // namespace
-
-TEST(FileEnumerator, NotExistingPath) {
- const FilePath path = FilePath::FromUTF8Unsafe("some_not_existing_path");
- ASSERT_FALSE(PathExists(path));
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files = RunEnumerator(
- path, true, FileEnumerator::FILES & FileEnumerator::DIRECTORIES,
- FILE_PATH_LITERAL(""), policy);
- EXPECT_THAT(files, IsEmpty());
- }
-}
-
-TEST(FileEnumerator, EmptyFolder) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files =
- RunEnumerator(temp_dir.GetPath(), true,
- FileEnumerator::FILES & FileEnumerator::DIRECTORIES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, IsEmpty());
- }
-}
-
-TEST(FileEnumerator, SingleFileInFolderForFileSearch) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
- const FilePath file = path.AppendASCII("test.txt");
- ASSERT_TRUE(CreateDummyFile(file));
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files = RunEnumerator(
- temp_dir.GetPath(), true, FileEnumerator::FILES, kEmptyPattern, policy);
- EXPECT_THAT(files, ElementsAre(file));
- }
-}
-
-TEST(FileEnumerator, SingleFileInFolderForDirSearch) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
- ASSERT_TRUE(CreateDummyFile(path.AppendASCII("test.txt")));
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, IsEmpty());
- }
-}
-
-TEST(FileEnumerator, SingleFileInFolderWithFiltering) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
- const FilePath file = path.AppendASCII("test.txt");
- ASSERT_TRUE(CreateDummyFile(file));
-
- for (auto policy : kFolderSearchPolicies) {
- auto files = RunEnumerator(path, true, FileEnumerator::FILES,
- FILE_PATH_LITERAL("*.txt"), policy);
- EXPECT_THAT(files, ElementsAre(file));
-
- files = RunEnumerator(path, true, FileEnumerator::FILES,
- FILE_PATH_LITERAL("*.pdf"), policy);
- EXPECT_THAT(files, IsEmpty());
- }
-}
-
-TEST(FileEnumerator, TwoFilesInFolder) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
- const FilePath foo_txt = path.AppendASCII("foo.txt");
- const FilePath bar_txt = path.AppendASCII("bar.txt");
- ASSERT_TRUE(CreateDummyFile(foo_txt));
- ASSERT_TRUE(CreateDummyFile(bar_txt));
-
- for (auto policy : kFolderSearchPolicies) {
- auto files = RunEnumerator(path, true, FileEnumerator::FILES,
- FILE_PATH_LITERAL("*.txt"), policy);
- EXPECT_THAT(files, UnorderedElementsAre(foo_txt, bar_txt));
-
- files = RunEnumerator(path, true, FileEnumerator::FILES,
- FILE_PATH_LITERAL("foo*"), policy);
- EXPECT_THAT(files, ElementsAre(foo_txt));
-
- files = RunEnumerator(path, true, FileEnumerator::FILES,
- FILE_PATH_LITERAL("*.pdf"), policy);
- EXPECT_THAT(files, IsEmpty());
-
- files =
- RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
- EXPECT_THAT(files, UnorderedElementsAre(foo_txt, bar_txt));
- }
-}
-
-TEST(FileEnumerator, SingleFolderInFolderForFileSearch) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
-
- ScopedTempDir temp_subdir;
- ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files =
- RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
- EXPECT_THAT(files, IsEmpty());
- }
-}
-
-TEST(FileEnumerator, SingleFolderInFolderForDirSearch) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
-
- ScopedTempDir temp_subdir;
- ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, ElementsAre(temp_subdir.GetPath()));
- }
-}
-
-TEST(FileEnumerator, TwoFoldersInFolder) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
-
- const FilePath subdir_foo = path.AppendASCII("foo");
- const FilePath subdir_bar = path.AppendASCII("bar");
- ASSERT_TRUE(CreateDirectory(subdir_foo));
- ASSERT_TRUE(CreateDirectory(subdir_bar));
-
- for (auto policy : kFolderSearchPolicies) {
- auto files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, UnorderedElementsAre(subdir_foo, subdir_bar));
-
- files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
- FILE_PATH_LITERAL("foo"), policy);
- EXPECT_THAT(files, ElementsAre(subdir_foo));
- }
-}
-
-TEST(FileEnumerator, FolderAndFileInFolder) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
-
- ScopedTempDir temp_subdir;
- ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
- const FilePath file = path.AppendASCII("test.txt");
- ASSERT_TRUE(CreateDummyFile(file));
-
- for (auto policy : kFolderSearchPolicies) {
- auto files =
- RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
- EXPECT_THAT(files, ElementsAre(file));
-
- files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, ElementsAre(temp_subdir.GetPath()));
-
- files = RunEnumerator(path, true,
- FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, UnorderedElementsAre(file, temp_subdir.GetPath()));
- }
-}
-
-TEST(FileEnumerator, FilesInParentFolderAlwaysFirst) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath& path = temp_dir.GetPath();
-
- ScopedTempDir temp_subdir;
- ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
- const FilePath foo_txt = path.AppendASCII("foo.txt");
- const FilePath bar_txt = temp_subdir.GetPath().AppendASCII("bar.txt");
- ASSERT_TRUE(CreateDummyFile(foo_txt));
- ASSERT_TRUE(CreateDummyFile(bar_txt));
-
- for (auto policy : kFolderSearchPolicies) {
- const auto files =
- RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
- EXPECT_THAT(files, ElementsAre(foo_txt, bar_txt));
- }
-}
-
-TEST(FileEnumerator, FileInSubfolder) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath subdir = temp_dir.GetPath().AppendASCII("subdir");
- ASSERT_TRUE(CreateDirectory(subdir));
-
- const FilePath file = subdir.AppendASCII("test.txt");
- ASSERT_TRUE(CreateDummyFile(file));
-
- for (auto policy : kFolderSearchPolicies) {
- auto files = RunEnumerator(temp_dir.GetPath(), true, FileEnumerator::FILES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, ElementsAre(file));
-
- files = RunEnumerator(temp_dir.GetPath(), false, FileEnumerator::FILES,
- kEmptyPattern, policy);
- EXPECT_THAT(files, IsEmpty());
- }
-}
-
-TEST(FileEnumerator, FilesInSubfoldersWithFiltering) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- const FilePath test_txt = temp_dir.GetPath().AppendASCII("test.txt");
- const FilePath subdir_foo = temp_dir.GetPath().AppendASCII("foo_subdir");
- const FilePath subdir_bar = temp_dir.GetPath().AppendASCII("bar_subdir");
- const FilePath foo_test = subdir_foo.AppendASCII("test.txt");
- const FilePath foo_foo = subdir_foo.AppendASCII("foo.txt");
- const FilePath foo_bar = subdir_foo.AppendASCII("bar.txt");
- const FilePath bar_test = subdir_bar.AppendASCII("test.txt");
- const FilePath bar_foo = subdir_bar.AppendASCII("foo.txt");
- const FilePath bar_bar = subdir_bar.AppendASCII("bar.txt");
- ASSERT_TRUE(CreateDummyFile(test_txt));
- ASSERT_TRUE(CreateDirectory(subdir_foo));
- ASSERT_TRUE(CreateDirectory(subdir_bar));
- ASSERT_TRUE(CreateDummyFile(foo_test));
- ASSERT_TRUE(CreateDummyFile(foo_foo));
- ASSERT_TRUE(CreateDummyFile(foo_bar));
- ASSERT_TRUE(CreateDummyFile(bar_test));
- ASSERT_TRUE(CreateDummyFile(bar_foo));
- ASSERT_TRUE(CreateDummyFile(bar_bar));
-
- auto files =
- RunEnumerator(temp_dir.GetPath(), true,
- FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
- FILE_PATH_LITERAL("foo*"),
- FileEnumerator::FolderSearchPolicy::MATCH_ONLY);
- EXPECT_THAT(files,
- UnorderedElementsAre(subdir_foo, foo_test, foo_foo, foo_bar));
-
- files = RunEnumerator(temp_dir.GetPath(), true,
- FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
- FILE_PATH_LITERAL("foo*"),
- FileEnumerator::FolderSearchPolicy::ALL);
- EXPECT_THAT(files, UnorderedElementsAre(subdir_foo, foo_foo, bar_foo));
-}
-
-} // namespace base
diff --git a/base/files/file_locking_unittest.cc b/base/files/file_locking_unittest.cc
deleted file mode 100644
index bfe62ce..0000000
--- a/base/files/file_locking_unittest.cc
+++ /dev/null
@@ -1,232 +0,0 @@
-// Copyright 2015 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 "base/command_line.h"
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/macros.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-using base::File;
-using base::FilePath;
-
-namespace {
-
-// Flag for the parent to share a temp dir to the child.
-const char kTempDirFlag[] = "temp-dir";
-
-// Flags to control how the subprocess unlocks the file.
-const char kFileUnlock[] = "file-unlock";
-const char kCloseUnlock[] = "close-unlock";
-const char kExitUnlock[] = "exit-unlock";
-
-// File to lock in temp dir.
-const char kLockFile[] = "lockfile";
-
-// Constants for various requests and responses, used as |signal_file| parameter
-// to signal/wait helpers.
-const char kSignalLockFileLocked[] = "locked.signal";
-const char kSignalLockFileClose[] = "close.signal";
-const char kSignalLockFileClosed[] = "closed.signal";
-const char kSignalLockFileUnlock[] = "unlock.signal";
-const char kSignalLockFileUnlocked[] = "unlocked.signal";
-const char kSignalExit[] = "exit.signal";
-
-// Signal an event by creating a file which didn't previously exist.
-bool SignalEvent(const FilePath& signal_dir, const char* signal_file) {
- File file(signal_dir.AppendASCII(signal_file),
- File::FLAG_CREATE | File::FLAG_WRITE);
- return file.IsValid();
-}
-
-// Check whether an event was signaled.
-bool CheckEvent(const FilePath& signal_dir, const char* signal_file) {
- File file(signal_dir.AppendASCII(signal_file),
- File::FLAG_OPEN | File::FLAG_READ);
- return file.IsValid();
-}
-
-// Busy-wait for an event to be signaled, returning false for timeout.
-bool WaitForEventWithTimeout(const FilePath& signal_dir,
- const char* signal_file,
- const base::TimeDelta& timeout) {
- const base::Time finish_by = base::Time::Now() + timeout;
- while (!CheckEvent(signal_dir, signal_file)) {
- if (base::Time::Now() > finish_by)
- return false;
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
- }
- return true;
-}
-
-// Wait forever for the event to be signaled (should never return false).
-bool WaitForEvent(const FilePath& signal_dir, const char* signal_file) {
- return WaitForEventWithTimeout(signal_dir, signal_file,
- base::TimeDelta::Max());
-}
-
-// Keep these in sync so StartChild*() can refer to correct test main.
-#define ChildMain ChildLockUnlock
-#define ChildMainString "ChildLockUnlock"
-
-// Subprocess to test getting a file lock then releasing it. |kTempDirFlag|
-// must pass in an existing temporary directory for the lockfile and signal
-// files. One of the following flags must be passed to determine how to unlock
-// the lock file:
-// - |kFileUnlock| calls Unlock() to unlock.
-// - |kCloseUnlock| calls Close() while the lock is held.
-// - |kExitUnlock| exits while the lock is held.
-MULTIPROCESS_TEST_MAIN(ChildMain) {
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- const FilePath temp_path = command_line->GetSwitchValuePath(kTempDirFlag);
- CHECK(base::DirectoryExists(temp_path));
-
- // Immediately lock the file.
- File file(temp_path.AppendASCII(kLockFile),
- File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE);
- CHECK(file.IsValid());
- CHECK_EQ(File::FILE_OK, file.Lock());
- CHECK(SignalEvent(temp_path, kSignalLockFileLocked));
-
- if (command_line->HasSwitch(kFileUnlock)) {
- // Wait for signal to unlock, then unlock the file.
- CHECK(WaitForEvent(temp_path, kSignalLockFileUnlock));
- CHECK_EQ(File::FILE_OK, file.Unlock());
- CHECK(SignalEvent(temp_path, kSignalLockFileUnlocked));
- } else if (command_line->HasSwitch(kCloseUnlock)) {
- // Wait for the signal to close, then close the file.
- CHECK(WaitForEvent(temp_path, kSignalLockFileClose));
- file.Close();
- CHECK(!file.IsValid());
- CHECK(SignalEvent(temp_path, kSignalLockFileClosed));
- } else {
- CHECK(command_line->HasSwitch(kExitUnlock));
- }
-
- // Wait for signal to exit, so that unlock or close can be distinguished from
- // exit.
- CHECK(WaitForEvent(temp_path, kSignalExit));
- return 0;
-}
-
-} // namespace
-
-class FileLockingTest : public testing::Test {
- public:
- FileLockingTest() = default;
-
- protected:
- void SetUp() override {
- testing::Test::SetUp();
-
- // Setup the temp dir and the lock file.
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- lock_file_.Initialize(
- temp_dir_.GetPath().AppendASCII(kLockFile),
- File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE);
- ASSERT_TRUE(lock_file_.IsValid());
- }
-
- bool SignalEvent(const char* signal_file) {
- return ::SignalEvent(temp_dir_.GetPath(), signal_file);
- }
-
- bool WaitForEventOrTimeout(const char* signal_file) {
- return ::WaitForEventWithTimeout(temp_dir_.GetPath(), signal_file,
- TestTimeouts::action_timeout());
- }
-
- // Start a child process set to use the specified unlock action, and wait for
- // it to lock the file.
- void StartChildAndSignalLock(const char* unlock_action) {
- // Create a temporary dir and spin up a ChildLockExit subprocess against it.
- const FilePath temp_path = temp_dir_.GetPath();
- base::CommandLine child_command_line(
- base::GetMultiProcessTestChildBaseCommandLine());
- child_command_line.AppendSwitchPath(kTempDirFlag, temp_path);
- child_command_line.AppendSwitch(unlock_action);
- lock_child_ = base::SpawnMultiProcessTestChild(
- ChildMainString, child_command_line, base::LaunchOptions());
- ASSERT_TRUE(lock_child_.IsValid());
-
- // Wait for the child to lock the file.
- ASSERT_TRUE(WaitForEventOrTimeout(kSignalLockFileLocked));
- }
-
- // Signal the child to exit cleanly.
- void ExitChildCleanly() {
- ASSERT_TRUE(SignalEvent(kSignalExit));
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- lock_child_, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
-
- base::ScopedTempDir temp_dir_;
- base::File lock_file_;
- base::Process lock_child_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(FileLockingTest);
-};
-
-// Test that locks are released by Unlock().
-TEST_F(FileLockingTest, LockAndUnlock) {
- StartChildAndSignalLock(kFileUnlock);
-
- ASSERT_NE(File::FILE_OK, lock_file_.Lock());
- ASSERT_TRUE(SignalEvent(kSignalLockFileUnlock));
- ASSERT_TRUE(WaitForEventOrTimeout(kSignalLockFileUnlocked));
- ASSERT_EQ(File::FILE_OK, lock_file_.Lock());
- ASSERT_EQ(File::FILE_OK, lock_file_.Unlock());
-
- ExitChildCleanly();
-}
-
-// Test that locks are released on Close().
-TEST_F(FileLockingTest, UnlockOnClose) {
- StartChildAndSignalLock(kCloseUnlock);
-
- ASSERT_NE(File::FILE_OK, lock_file_.Lock());
- ASSERT_TRUE(SignalEvent(kSignalLockFileClose));
- ASSERT_TRUE(WaitForEventOrTimeout(kSignalLockFileClosed));
- ASSERT_EQ(File::FILE_OK, lock_file_.Lock());
- ASSERT_EQ(File::FILE_OK, lock_file_.Unlock());
-
- ExitChildCleanly();
-}
-
-// Test that locks are released on exit.
-TEST_F(FileLockingTest, UnlockOnExit) {
- StartChildAndSignalLock(kExitUnlock);
-
- ASSERT_NE(File::FILE_OK, lock_file_.Lock());
- ExitChildCleanly();
- ASSERT_EQ(File::FILE_OK, lock_file_.Lock());
- ASSERT_EQ(File::FILE_OK, lock_file_.Unlock());
-}
-
-// Test that killing the process releases the lock. This should cover crashing.
-// Flaky on Android (http://crbug.com/747518)
-#if defined(OS_ANDROID)
-#define MAYBE_UnlockOnTerminate DISABLED_UnlockOnTerminate
-#else
-#define MAYBE_UnlockOnTerminate UnlockOnTerminate
-#endif
-TEST_F(FileLockingTest, MAYBE_UnlockOnTerminate) {
- // The child will wait for an exit which never arrives.
- StartChildAndSignalLock(kExitUnlock);
-
- ASSERT_NE(File::FILE_OK, lock_file_.Lock());
- ASSERT_TRUE(TerminateMultiProcessTestChild(lock_child_, 0, true));
- ASSERT_EQ(File::FILE_OK, lock_file_.Lock());
- ASSERT_EQ(File::FILE_OK, lock_file_.Unlock());
-}
diff --git a/base/files/file_path_unittest.cc b/base/files/file_path_unittest.cc
deleted file mode 100644
index d0fd00e..0000000
--- a/base/files/file_path_unittest.cc
+++ /dev/null
@@ -1,1319 +0,0 @@
-// 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.
-
-#include <stddef.h>
-
-#include <sstream>
-
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include "base/test/scoped_locale.h"
-#endif
-
-// This macro helps avoid wrapped lines in the test structs.
-#define FPL(x) FILE_PATH_LITERAL(x)
-
-// This macro constructs strings which can contain NULs.
-#define FPS(x) FilePath::StringType(FPL(x), arraysize(FPL(x)) - 1)
-
-namespace base {
-
-struct UnaryTestData {
- const FilePath::CharType* input;
- const FilePath::CharType* expected;
-};
-
-struct UnaryBooleanTestData {
- const FilePath::CharType* input;
- bool expected;
-};
-
-struct BinaryTestData {
- const FilePath::CharType* inputs[2];
- const FilePath::CharType* expected;
-};
-
-struct BinaryBooleanTestData {
- const FilePath::CharType* inputs[2];
- bool expected;
-};
-
-struct BinaryIntTestData {
- const FilePath::CharType* inputs[2];
- int expected;
-};
-
-struct UTF8TestData {
- const FilePath::CharType* native;
- const char* utf8;
-};
-
-// file_util winds up using autoreleased objects on the Mac, so this needs
-// to be a PlatformTest
-typedef PlatformTest FilePathTest;
-
-TEST_F(FilePathTest, DirName) {
- const struct UnaryTestData cases[] = {
- { FPL(""), FPL(".") },
- { FPL("aa"), FPL(".") },
- { FPL("/aa/bb"), FPL("/aa") },
- { FPL("/aa/bb/"), FPL("/aa") },
- { FPL("/aa/bb//"), FPL("/aa") },
- { FPL("/aa/bb/ccc"), FPL("/aa/bb") },
- { FPL("/aa"), FPL("/") },
- { FPL("/aa/"), FPL("/") },
- { FPL("/"), FPL("/") },
- { FPL("//"), FPL("//") },
- { FPL("///"), FPL("/") },
- { FPL("aa/"), FPL(".") },
- { FPL("aa/bb"), FPL("aa") },
- { FPL("aa/bb/"), FPL("aa") },
- { FPL("aa/bb//"), FPL("aa") },
- { FPL("aa//bb//"), FPL("aa") },
- { FPL("aa//bb/"), FPL("aa") },
- { FPL("aa//bb"), FPL("aa") },
- { FPL("//aa/bb"), FPL("//aa") },
- { FPL("//aa/"), FPL("//") },
- { FPL("//aa"), FPL("//") },
- { FPL("0:"), FPL(".") },
- { FPL("@:"), FPL(".") },
- { FPL("[:"), FPL(".") },
- { FPL("`:"), FPL(".") },
- { FPL("{:"), FPL(".") },
- { FPL("\xB3:"), FPL(".") },
- { FPL("\xC5:"), FPL(".") },
- { FPL("/aa/../bb/cc"), FPL("/aa/../bb")},
-#if defined(OS_WIN)
- { FPL("\x0143:"), FPL(".") },
-#endif // OS_WIN
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("c:"), FPL("c:") },
- { FPL("C:"), FPL("C:") },
- { FPL("A:"), FPL("A:") },
- { FPL("Z:"), FPL("Z:") },
- { FPL("a:"), FPL("a:") },
- { FPL("z:"), FPL("z:") },
- { FPL("c:aa"), FPL("c:") },
- { FPL("c:/"), FPL("c:/") },
- { FPL("c://"), FPL("c://") },
- { FPL("c:///"), FPL("c:/") },
- { FPL("c:/aa"), FPL("c:/") },
- { FPL("c:/aa/"), FPL("c:/") },
- { FPL("c:/aa/bb"), FPL("c:/aa") },
- { FPL("c:aa/bb"), FPL("c:aa") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("\\aa\\bb"), FPL("\\aa") },
- { FPL("\\aa\\bb\\"), FPL("\\aa") },
- { FPL("\\aa\\bb\\\\"), FPL("\\aa") },
- { FPL("\\aa\\bb\\ccc"), FPL("\\aa\\bb") },
- { FPL("\\aa"), FPL("\\") },
- { FPL("\\aa\\"), FPL("\\") },
- { FPL("\\"), FPL("\\") },
- { FPL("\\\\"), FPL("\\\\") },
- { FPL("\\\\\\"), FPL("\\") },
- { FPL("aa\\"), FPL(".") },
- { FPL("aa\\bb"), FPL("aa") },
- { FPL("aa\\bb\\"), FPL("aa") },
- { FPL("aa\\bb\\\\"), FPL("aa") },
- { FPL("aa\\\\bb\\\\"), FPL("aa") },
- { FPL("aa\\\\bb\\"), FPL("aa") },
- { FPL("aa\\\\bb"), FPL("aa") },
- { FPL("\\\\aa\\bb"), FPL("\\\\aa") },
- { FPL("\\\\aa\\"), FPL("\\\\") },
- { FPL("\\\\aa"), FPL("\\\\") },
- { FPL("aa\\..\\bb\\c"), FPL("aa\\..\\bb")},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("c:\\"), FPL("c:\\") },
- { FPL("c:\\\\"), FPL("c:\\\\") },
- { FPL("c:\\\\\\"), FPL("c:\\") },
- { FPL("c:\\aa"), FPL("c:\\") },
- { FPL("c:\\aa\\"), FPL("c:\\") },
- { FPL("c:\\aa\\bb"), FPL("c:\\aa") },
- { FPL("c:aa\\bb"), FPL("c:aa") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- FilePath observed = input.DirName();
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-
-TEST_F(FilePathTest, BaseName) {
- const struct UnaryTestData cases[] = {
- { FPL(""), FPL("") },
- { FPL("aa"), FPL("aa") },
- { FPL("/aa/bb"), FPL("bb") },
- { FPL("/aa/bb/"), FPL("bb") },
- { FPL("/aa/bb//"), FPL("bb") },
- { FPL("/aa/bb/ccc"), FPL("ccc") },
- { FPL("/aa"), FPL("aa") },
- { FPL("/"), FPL("/") },
- { FPL("//"), FPL("//") },
- { FPL("///"), FPL("/") },
- { FPL("aa/"), FPL("aa") },
- { FPL("aa/bb"), FPL("bb") },
- { FPL("aa/bb/"), FPL("bb") },
- { FPL("aa/bb//"), FPL("bb") },
- { FPL("aa//bb//"), FPL("bb") },
- { FPL("aa//bb/"), FPL("bb") },
- { FPL("aa//bb"), FPL("bb") },
- { FPL("//aa/bb"), FPL("bb") },
- { FPL("//aa/"), FPL("aa") },
- { FPL("//aa"), FPL("aa") },
- { FPL("0:"), FPL("0:") },
- { FPL("@:"), FPL("@:") },
- { FPL("[:"), FPL("[:") },
- { FPL("`:"), FPL("`:") },
- { FPL("{:"), FPL("{:") },
- { FPL("\xB3:"), FPL("\xB3:") },
- { FPL("\xC5:"), FPL("\xC5:") },
-#if defined(OS_WIN)
- { FPL("\x0143:"), FPL("\x0143:") },
-#endif // OS_WIN
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("c:"), FPL("") },
- { FPL("C:"), FPL("") },
- { FPL("A:"), FPL("") },
- { FPL("Z:"), FPL("") },
- { FPL("a:"), FPL("") },
- { FPL("z:"), FPL("") },
- { FPL("c:aa"), FPL("aa") },
- { FPL("c:/"), FPL("/") },
- { FPL("c://"), FPL("//") },
- { FPL("c:///"), FPL("/") },
- { FPL("c:/aa"), FPL("aa") },
- { FPL("c:/aa/"), FPL("aa") },
- { FPL("c:/aa/bb"), FPL("bb") },
- { FPL("c:aa/bb"), FPL("bb") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("\\aa\\bb"), FPL("bb") },
- { FPL("\\aa\\bb\\"), FPL("bb") },
- { FPL("\\aa\\bb\\\\"), FPL("bb") },
- { FPL("\\aa\\bb\\ccc"), FPL("ccc") },
- { FPL("\\aa"), FPL("aa") },
- { FPL("\\"), FPL("\\") },
- { FPL("\\\\"), FPL("\\\\") },
- { FPL("\\\\\\"), FPL("\\") },
- { FPL("aa\\"), FPL("aa") },
- { FPL("aa\\bb"), FPL("bb") },
- { FPL("aa\\bb\\"), FPL("bb") },
- { FPL("aa\\bb\\\\"), FPL("bb") },
- { FPL("aa\\\\bb\\\\"), FPL("bb") },
- { FPL("aa\\\\bb\\"), FPL("bb") },
- { FPL("aa\\\\bb"), FPL("bb") },
- { FPL("\\\\aa\\bb"), FPL("bb") },
- { FPL("\\\\aa\\"), FPL("aa") },
- { FPL("\\\\aa"), FPL("aa") },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("c:\\"), FPL("\\") },
- { FPL("c:\\\\"), FPL("\\\\") },
- { FPL("c:\\\\\\"), FPL("\\") },
- { FPL("c:\\aa"), FPL("aa") },
- { FPL("c:\\aa\\"), FPL("aa") },
- { FPL("c:\\aa\\bb"), FPL("bb") },
- { FPL("c:aa\\bb"), FPL("bb") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- FilePath observed = input.BaseName();
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-
-TEST_F(FilePathTest, Append) {
- const struct BinaryTestData cases[] = {
- { { FPL(""), FPL("cc") }, FPL("cc") },
- { { FPL("."), FPL("ff") }, FPL("ff") },
- { { FPL("."), FPL("") }, FPL(".") },
- { { FPL("/"), FPL("cc") }, FPL("/cc") },
- { { FPL("/aa"), FPL("") }, FPL("/aa") },
- { { FPL("/aa/"), FPL("") }, FPL("/aa") },
- { { FPL("//aa"), FPL("") }, FPL("//aa") },
- { { FPL("//aa/"), FPL("") }, FPL("//aa") },
- { { FPL("//"), FPL("aa") }, FPL("//aa") },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:"), FPL("a") }, FPL("c:a") },
- { { FPL("c:"), FPL("") }, FPL("c:") },
- { { FPL("c:/"), FPL("a") }, FPL("c:/a") },
- { { FPL("c://"), FPL("a") }, FPL("c://a") },
- { { FPL("c:///"), FPL("a") }, FPL("c:/a") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- // Append introduces the default separator character, so these test cases
- // need to be defined with different expected results on platforms that use
- // different default separator characters.
- { { FPL("\\"), FPL("cc") }, FPL("\\cc") },
- { { FPL("\\aa"), FPL("") }, FPL("\\aa") },
- { { FPL("\\aa\\"), FPL("") }, FPL("\\aa") },
- { { FPL("\\\\aa"), FPL("") }, FPL("\\\\aa") },
- { { FPL("\\\\aa\\"), FPL("") }, FPL("\\\\aa") },
- { { FPL("\\\\"), FPL("aa") }, FPL("\\\\aa") },
- { { FPL("/aa/bb"), FPL("cc") }, FPL("/aa/bb\\cc") },
- { { FPL("/aa/bb/"), FPL("cc") }, FPL("/aa/bb\\cc") },
- { { FPL("aa/bb/"), FPL("cc") }, FPL("aa/bb\\cc") },
- { { FPL("aa/bb"), FPL("cc") }, FPL("aa/bb\\cc") },
- { { FPL("a/b"), FPL("c") }, FPL("a/b\\c") },
- { { FPL("a/b/"), FPL("c") }, FPL("a/b\\c") },
- { { FPL("//aa"), FPL("bb") }, FPL("//aa\\bb") },
- { { FPL("//aa/"), FPL("bb") }, FPL("//aa\\bb") },
- { { FPL("\\aa\\bb"), FPL("cc") }, FPL("\\aa\\bb\\cc") },
- { { FPL("\\aa\\bb\\"), FPL("cc") }, FPL("\\aa\\bb\\cc") },
- { { FPL("aa\\bb\\"), FPL("cc") }, FPL("aa\\bb\\cc") },
- { { FPL("aa\\bb"), FPL("cc") }, FPL("aa\\bb\\cc") },
- { { FPL("a\\b"), FPL("c") }, FPL("a\\b\\c") },
- { { FPL("a\\b\\"), FPL("c") }, FPL("a\\b\\c") },
- { { FPL("\\\\aa"), FPL("bb") }, FPL("\\\\aa\\bb") },
- { { FPL("\\\\aa\\"), FPL("bb") }, FPL("\\\\aa\\bb") },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:\\"), FPL("a") }, FPL("c:\\a") },
- { { FPL("c:\\\\"), FPL("a") }, FPL("c:\\\\a") },
- { { FPL("c:\\\\\\"), FPL("a") }, FPL("c:\\a") },
- { { FPL("c:\\"), FPL("") }, FPL("c:\\") },
- { { FPL("c:\\a"), FPL("b") }, FPL("c:\\a\\b") },
- { { FPL("c:\\a\\"), FPL("b") }, FPL("c:\\a\\b") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#else // FILE_PATH_USES_WIN_SEPARATORS
- { { FPL("/aa/bb"), FPL("cc") }, FPL("/aa/bb/cc") },
- { { FPL("/aa/bb/"), FPL("cc") }, FPL("/aa/bb/cc") },
- { { FPL("aa/bb/"), FPL("cc") }, FPL("aa/bb/cc") },
- { { FPL("aa/bb"), FPL("cc") }, FPL("aa/bb/cc") },
- { { FPL("a/b"), FPL("c") }, FPL("a/b/c") },
- { { FPL("a/b/"), FPL("c") }, FPL("a/b/c") },
- { { FPL("//aa"), FPL("bb") }, FPL("//aa/bb") },
- { { FPL("//aa/"), FPL("bb") }, FPL("//aa/bb") },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:/"), FPL("a") }, FPL("c:/a") },
- { { FPL("c:/"), FPL("") }, FPL("c:/") },
- { { FPL("c:/a"), FPL("b") }, FPL("c:/a/b") },
- { { FPL("c:/a/"), FPL("b") }, FPL("c:/a/b") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath root(cases[i].inputs[0]);
- FilePath::StringType leaf(cases[i].inputs[1]);
- FilePath observed_str = root.Append(leaf);
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_str.value()) <<
- "i: " << i << ", root: " << root.value() << ", leaf: " << leaf;
- FilePath observed_path = root.Append(FilePath(leaf));
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_path.value()) <<
- "i: " << i << ", root: " << root.value() << ", leaf: " << leaf;
-
- // TODO(erikkay): It would be nice to have a unicode test append value to
- // handle the case when AppendASCII is passed UTF8
-#if defined(OS_WIN)
- std::string ascii = WideToUTF8(leaf);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- std::string ascii = leaf;
-#endif
- observed_str = root.AppendASCII(ascii);
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed_str.value()) <<
- "i: " << i << ", root: " << root.value() << ", leaf: " << leaf;
- }
-}
-
-TEST_F(FilePathTest, StripTrailingSeparators) {
- const struct UnaryTestData cases[] = {
- { FPL(""), FPL("") },
- { FPL("/"), FPL("/") },
- { FPL("//"), FPL("//") },
- { FPL("///"), FPL("/") },
- { FPL("////"), FPL("/") },
- { FPL("a/"), FPL("a") },
- { FPL("a//"), FPL("a") },
- { FPL("a///"), FPL("a") },
- { FPL("a////"), FPL("a") },
- { FPL("/a"), FPL("/a") },
- { FPL("/a/"), FPL("/a") },
- { FPL("/a//"), FPL("/a") },
- { FPL("/a///"), FPL("/a") },
- { FPL("/a////"), FPL("/a") },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("c:"), FPL("c:") },
- { FPL("c:/"), FPL("c:/") },
- { FPL("c://"), FPL("c://") },
- { FPL("c:///"), FPL("c:/") },
- { FPL("c:////"), FPL("c:/") },
- { FPL("c:/a"), FPL("c:/a") },
- { FPL("c:/a/"), FPL("c:/a") },
- { FPL("c:/a//"), FPL("c:/a") },
- { FPL("c:/a///"), FPL("c:/a") },
- { FPL("c:/a////"), FPL("c:/a") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("\\"), FPL("\\") },
- { FPL("\\\\"), FPL("\\\\") },
- { FPL("\\\\\\"), FPL("\\") },
- { FPL("\\\\\\\\"), FPL("\\") },
- { FPL("a\\"), FPL("a") },
- { FPL("a\\\\"), FPL("a") },
- { FPL("a\\\\\\"), FPL("a") },
- { FPL("a\\\\\\\\"), FPL("a") },
- { FPL("\\a"), FPL("\\a") },
- { FPL("\\a\\"), FPL("\\a") },
- { FPL("\\a\\\\"), FPL("\\a") },
- { FPL("\\a\\\\\\"), FPL("\\a") },
- { FPL("\\a\\\\\\\\"), FPL("\\a") },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("c:\\"), FPL("c:\\") },
- { FPL("c:\\\\"), FPL("c:\\\\") },
- { FPL("c:\\\\\\"), FPL("c:\\") },
- { FPL("c:\\\\\\\\"), FPL("c:\\") },
- { FPL("c:\\a"), FPL("c:\\a") },
- { FPL("c:\\a\\"), FPL("c:\\a") },
- { FPL("c:\\a\\\\"), FPL("c:\\a") },
- { FPL("c:\\a\\\\\\"), FPL("c:\\a") },
- { FPL("c:\\a\\\\\\\\"), FPL("c:\\a") },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- FilePath observed = input.StripTrailingSeparators();
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-
-TEST_F(FilePathTest, IsAbsolute) {
- const struct UnaryBooleanTestData cases[] = {
- { FPL(""), false },
- { FPL("a"), false },
- { FPL("c:"), false },
- { FPL("c:a"), false },
- { FPL("a/b"), false },
- { FPL("//"), true },
- { FPL("//a"), true },
- { FPL("c:a/b"), false },
- { FPL("?:/a"), false },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("/"), false },
- { FPL("/a"), false },
- { FPL("/."), false },
- { FPL("/.."), false },
- { FPL("c:/"), true },
- { FPL("c:/a"), true },
- { FPL("c:/."), true },
- { FPL("c:/.."), true },
- { FPL("C:/a"), true },
- { FPL("d:/a"), true },
-#else // FILE_PATH_USES_DRIVE_LETTERS
- { FPL("/"), true },
- { FPL("/a"), true },
- { FPL("/."), true },
- { FPL("/.."), true },
- { FPL("c:/"), false },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("a\\b"), false },
- { FPL("\\\\"), true },
- { FPL("\\\\a"), true },
- { FPL("a\\b"), false },
- { FPL("\\\\"), true },
- { FPL("//a"), true },
- { FPL("c:a\\b"), false },
- { FPL("?:\\a"), false },
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("\\"), false },
- { FPL("\\a"), false },
- { FPL("\\."), false },
- { FPL("\\.."), false },
- { FPL("c:\\"), true },
- { FPL("c:\\"), true },
- { FPL("c:\\a"), true },
- { FPL("c:\\."), true },
- { FPL("c:\\.."), true },
- { FPL("C:\\a"), true },
- { FPL("d:\\a"), true },
-#else // FILE_PATH_USES_DRIVE_LETTERS
- { FPL("\\"), true },
- { FPL("\\a"), true },
- { FPL("\\."), true },
- { FPL("\\.."), true },
- { FPL("c:\\"), false },
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- bool observed = input.IsAbsolute();
- EXPECT_EQ(cases[i].expected, observed) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-
-TEST_F(FilePathTest, PathComponentsTest) {
- const struct UnaryTestData cases[] = {
- { FPL("//foo/bar/baz/"), FPL("|//|foo|bar|baz")},
- { FPL("///"), FPL("|/")},
- { FPL("/foo//bar//baz/"), FPL("|/|foo|bar|baz")},
- { FPL("/foo/bar/baz/"), FPL("|/|foo|bar|baz")},
- { FPL("/foo/bar/baz//"), FPL("|/|foo|bar|baz")},
- { FPL("/foo/bar/baz///"), FPL("|/|foo|bar|baz")},
- { FPL("/foo/bar/baz"), FPL("|/|foo|bar|baz")},
- { FPL("/foo/bar.bot/baz.txt"), FPL("|/|foo|bar.bot|baz.txt")},
- { FPL("//foo//bar/baz"), FPL("|//|foo|bar|baz")},
- { FPL("/"), FPL("|/")},
- { FPL("foo"), FPL("|foo")},
- { FPL(""), FPL("")},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { FPL("e:/foo"), FPL("|e:|/|foo")},
- { FPL("e:/"), FPL("|e:|/")},
- { FPL("e:"), FPL("|e:")},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("../foo"), FPL("|..|foo")},
- { FPL("./foo"), FPL("|foo")},
- { FPL("../foo/bar/"), FPL("|..|foo|bar") },
- { FPL("\\\\foo\\bar\\baz\\"), FPL("|\\\\|foo|bar|baz")},
- { FPL("\\\\\\"), FPL("|\\")},
- { FPL("\\foo\\\\bar\\\\baz\\"), FPL("|\\|foo|bar|baz")},
- { FPL("\\foo\\bar\\baz\\"), FPL("|\\|foo|bar|baz")},
- { FPL("\\foo\\bar\\baz\\\\"), FPL("|\\|foo|bar|baz")},
- { FPL("\\foo\\bar\\baz\\\\\\"), FPL("|\\|foo|bar|baz")},
- { FPL("\\foo\\bar\\baz"), FPL("|\\|foo|bar|baz")},
- { FPL("\\foo\\bar/baz\\\\\\"), FPL("|\\|foo|bar|baz")},
- { FPL("/foo\\bar\\baz"), FPL("|/|foo|bar|baz")},
- { FPL("\\foo\\bar.bot\\baz.txt"), FPL("|\\|foo|bar.bot|baz.txt")},
- { FPL("\\\\foo\\\\bar\\baz"), FPL("|\\\\|foo|bar|baz")},
- { FPL("\\"), FPL("|\\")},
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- std::vector<FilePath::StringType> comps;
- input.GetComponents(&comps);
-
- FilePath::StringType observed;
- for (size_t j = 0; j < comps.size(); ++j) {
- observed.append(FILE_PATH_LITERAL("|"), 1);
- observed.append(comps[j]);
- }
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-
-TEST_F(FilePathTest, IsParentTest) {
- const struct BinaryBooleanTestData cases[] = {
- { { FPL("/"), FPL("/foo/bar/baz") }, true},
- { { FPL("/foo/bar"), FPL("/foo/bar/baz") }, true},
- { { FPL("/foo/bar/"), FPL("/foo/bar/baz") }, true},
- { { FPL("//foo/bar/"), FPL("//foo/bar/baz") }, true},
- { { FPL("/foo/bar"), FPL("/foo2/bar/baz") }, false},
- { { FPL("/foo/bar.txt"), FPL("/foo/bar/baz") }, false},
- { { FPL("/foo/bar"), FPL("/foo/bar2/baz") }, false},
- { { FPL("/foo/bar"), FPL("/foo/bar") }, false},
- { { FPL("/foo/bar/baz"), FPL("/foo/bar") }, false},
- { { FPL("foo/bar"), FPL("foo/bar/baz") }, true},
- { { FPL("foo/bar"), FPL("foo2/bar/baz") }, false},
- { { FPL("foo/bar"), FPL("foo/bar2/baz") }, false},
- { { FPL(""), FPL("foo") }, false},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:/foo/bar"), FPL("c:/foo/bar/baz") }, true},
- { { FPL("E:/foo/bar"), FPL("e:/foo/bar/baz") }, true},
- { { FPL("f:/foo/bar"), FPL("F:/foo/bar/baz") }, true},
- { { FPL("E:/Foo/bar"), FPL("e:/foo/bar/baz") }, false},
- { { FPL("f:/foo/bar"), FPL("F:/foo/Bar/baz") }, false},
- { { FPL("c:/"), FPL("c:/foo/bar/baz") }, true},
- { { FPL("c:"), FPL("c:/foo/bar/baz") }, true},
- { { FPL("c:/foo/bar"), FPL("d:/foo/bar/baz") }, false},
- { { FPL("c:/foo/bar"), FPL("D:/foo/bar/baz") }, false},
- { { FPL("C:/foo/bar"), FPL("d:/foo/bar/baz") }, false},
- { { FPL("c:/foo/bar"), FPL("c:/foo2/bar/baz") }, false},
- { { FPL("e:/foo/bar"), FPL("E:/foo2/bar/baz") }, false},
- { { FPL("F:/foo/bar"), FPL("f:/foo2/bar/baz") }, false},
- { { FPL("c:/foo/bar"), FPL("c:/foo/bar2/baz") }, false},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("\\foo\\bar"), FPL("\\foo\\bar\\baz") }, true},
- { { FPL("\\foo/bar"), FPL("\\foo\\bar\\baz") }, true},
- { { FPL("\\foo/bar"), FPL("\\foo/bar/baz") }, true},
- { { FPL("\\"), FPL("\\foo\\bar\\baz") }, true},
- { { FPL(""), FPL("\\foo\\bar\\baz") }, false},
- { { FPL("\\foo\\bar"), FPL("\\foo2\\bar\\baz") }, false},
- { { FPL("\\foo\\bar"), FPL("\\foo\\bar2\\baz") }, false},
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath parent(cases[i].inputs[0]);
- FilePath child(cases[i].inputs[1]);
-
- EXPECT_EQ(parent.IsParent(child), cases[i].expected) <<
- "i: " << i << ", parent: " << parent.value() << ", child: " <<
- child.value();
- }
-}
-
-TEST_F(FilePathTest, AppendRelativePathTest) {
- const struct BinaryTestData cases[] = {
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("/"), FPL("/foo/bar/baz") }, FPL("foo\\bar\\baz")},
-#else // FILE_PATH_USES_WIN_SEPARATORS
- { { FPL("/"), FPL("/foo/bar/baz") }, FPL("foo/bar/baz")},
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- { { FPL("/foo/bar"), FPL("/foo/bar/baz") }, FPL("baz")},
- { { FPL("/foo/bar/"), FPL("/foo/bar/baz") }, FPL("baz")},
- { { FPL("//foo/bar/"), FPL("//foo/bar/baz") }, FPL("baz")},
- { { FPL("/foo/bar"), FPL("/foo2/bar/baz") }, FPL("")},
- { { FPL("/foo/bar.txt"), FPL("/foo/bar/baz") }, FPL("")},
- { { FPL("/foo/bar"), FPL("/foo/bar2/baz") }, FPL("")},
- { { FPL("/foo/bar"), FPL("/foo/bar") }, FPL("")},
- { { FPL("/foo/bar/baz"), FPL("/foo/bar") }, FPL("")},
- { { FPL("foo/bar"), FPL("foo/bar/baz") }, FPL("baz")},
- { { FPL("foo/bar"), FPL("foo2/bar/baz") }, FPL("")},
- { { FPL("foo/bar"), FPL("foo/bar2/baz") }, FPL("")},
- { { FPL(""), FPL("foo") }, FPL("")},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:/foo/bar"), FPL("c:/foo/bar/baz") }, FPL("baz")},
- { { FPL("E:/foo/bar"), FPL("e:/foo/bar/baz") }, FPL("baz")},
- { { FPL("f:/foo/bar"), FPL("F:/foo/bar/baz") }, FPL("baz")},
- { { FPL("E:/Foo/bar"), FPL("e:/foo/bar/baz") }, FPL("")},
- { { FPL("f:/foo/bar"), FPL("F:/foo/Bar/baz") }, FPL("")},
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("c:/"), FPL("c:/foo/bar/baz") }, FPL("foo\\bar\\baz")},
- // TODO(akalin): Figure out how to handle the corner case in the
- // commented-out test case below. Appending to an empty path gives
- // /foo\bar\baz but appending to a nonempty path "blah" gives
- // blah\foo\bar\baz.
- // { { FPL("c:"), FPL("c:/foo/bar/baz") }, FPL("foo\\bar\\baz")},
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- { { FPL("c:/foo/bar"), FPL("d:/foo/bar/baz") }, FPL("")},
- { { FPL("c:/foo/bar"), FPL("D:/foo/bar/baz") }, FPL("")},
- { { FPL("C:/foo/bar"), FPL("d:/foo/bar/baz") }, FPL("")},
- { { FPL("c:/foo/bar"), FPL("c:/foo2/bar/baz") }, FPL("")},
- { { FPL("e:/foo/bar"), FPL("E:/foo2/bar/baz") }, FPL("")},
- { { FPL("F:/foo/bar"), FPL("f:/foo2/bar/baz") }, FPL("")},
- { { FPL("c:/foo/bar"), FPL("c:/foo/bar2/baz") }, FPL("")},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("\\foo\\bar"), FPL("\\foo\\bar\\baz") }, FPL("baz")},
- { { FPL("\\foo/bar"), FPL("\\foo\\bar\\baz") }, FPL("baz")},
- { { FPL("\\foo/bar"), FPL("\\foo/bar/baz") }, FPL("baz")},
- { { FPL("\\"), FPL("\\foo\\bar\\baz") }, FPL("foo\\bar\\baz")},
- { { FPL(""), FPL("\\foo\\bar\\baz") }, FPL("")},
- { { FPL("\\foo\\bar"), FPL("\\foo2\\bar\\baz") }, FPL("")},
- { { FPL("\\foo\\bar"), FPL("\\foo\\bar2\\baz") }, FPL("")},
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- const FilePath base(FPL("blah"));
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath parent(cases[i].inputs[0]);
- FilePath child(cases[i].inputs[1]);
- {
- FilePath result;
- bool success = parent.AppendRelativePath(child, &result);
- EXPECT_EQ(cases[i].expected[0] != '\0', success) <<
- "i: " << i << ", parent: " << parent.value() << ", child: " <<
- child.value();
- EXPECT_STREQ(cases[i].expected, result.value().c_str()) <<
- "i: " << i << ", parent: " << parent.value() << ", child: " <<
- child.value();
- }
- {
- FilePath result(base);
- bool success = parent.AppendRelativePath(child, &result);
- EXPECT_EQ(cases[i].expected[0] != '\0', success) <<
- "i: " << i << ", parent: " << parent.value() << ", child: " <<
- child.value();
- EXPECT_EQ(base.Append(cases[i].expected).value(), result.value()) <<
- "i: " << i << ", parent: " << parent.value() << ", child: " <<
- child.value();
- }
- }
-}
-
-TEST_F(FilePathTest, EqualityTest) {
- const struct BinaryBooleanTestData cases[] = {
- { { FPL("/foo/bar/baz"), FPL("/foo/bar/baz") }, true},
- { { FPL("/foo/bar"), FPL("/foo/bar/baz") }, false},
- { { FPL("/foo/bar/baz"), FPL("/foo/bar") }, false},
- { { FPL("//foo/bar/"), FPL("//foo/bar/") }, true},
- { { FPL("/foo/bar"), FPL("/foo2/bar") }, false},
- { { FPL("/foo/bar.txt"), FPL("/foo/bar") }, false},
- { { FPL("foo/bar"), FPL("foo/bar") }, true},
- { { FPL("foo/bar"), FPL("foo/bar/baz") }, false},
- { { FPL(""), FPL("foo") }, false},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:/foo/bar"), FPL("c:/foo/bar") }, true},
- { { FPL("E:/foo/bar"), FPL("e:/foo/bar") }, true},
- { { FPL("f:/foo/bar"), FPL("F:/foo/bar") }, true},
- { { FPL("E:/Foo/bar"), FPL("e:/foo/bar") }, false},
- { { FPL("f:/foo/bar"), FPL("F:/foo/Bar") }, false},
- { { FPL("c:/"), FPL("c:/") }, true},
- { { FPL("c:"), FPL("c:") }, true},
- { { FPL("c:/foo/bar"), FPL("d:/foo/bar") }, false},
- { { FPL("c:/foo/bar"), FPL("D:/foo/bar") }, false},
- { { FPL("C:/foo/bar"), FPL("d:/foo/bar") }, false},
- { { FPL("c:/foo/bar"), FPL("c:/foo2/bar") }, false},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("\\foo\\bar"), FPL("\\foo\\bar") }, true},
- { { FPL("\\foo/bar"), FPL("\\foo/bar") }, true},
- { { FPL("\\foo/bar"), FPL("\\foo\\bar") }, false},
- { { FPL("\\"), FPL("\\") }, true},
- { { FPL("\\"), FPL("/") }, false},
- { { FPL(""), FPL("\\") }, false},
- { { FPL("\\foo\\bar"), FPL("\\foo2\\bar") }, false},
- { { FPL("\\foo\\bar"), FPL("\\foo\\bar2") }, false},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:\\foo\\bar"), FPL("c:\\foo\\bar") }, true},
- { { FPL("E:\\foo\\bar"), FPL("e:\\foo\\bar") }, true},
- { { FPL("f:\\foo\\bar"), FPL("F:\\foo/bar") }, false},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#endif // FILE_PATH_USES_WIN_SEPARATORS
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath a(cases[i].inputs[0]);
- FilePath b(cases[i].inputs[1]);
-
- EXPECT_EQ(a == b, cases[i].expected) <<
- "equality i: " << i << ", a: " << a.value() << ", b: " <<
- b.value();
- }
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath a(cases[i].inputs[0]);
- FilePath b(cases[i].inputs[1]);
-
- EXPECT_EQ(a != b, !cases[i].expected) <<
- "inequality i: " << i << ", a: " << a.value() << ", b: " <<
- b.value();
- }
-}
-
-TEST_F(FilePathTest, Extension) {
- FilePath base_dir(FILE_PATH_LITERAL("base_dir"));
-
- FilePath jpg = base_dir.Append(FILE_PATH_LITERAL("foo.jpg"));
- EXPECT_EQ(FILE_PATH_LITERAL(".jpg"), jpg.Extension());
- EXPECT_EQ(FILE_PATH_LITERAL(".jpg"), jpg.FinalExtension());
-
- FilePath base = jpg.BaseName().RemoveExtension();
- EXPECT_EQ(FILE_PATH_LITERAL("foo"), base.value());
-
- FilePath path_no_ext = base_dir.Append(base);
- EXPECT_EQ(path_no_ext.value(), jpg.RemoveExtension().value());
-
- EXPECT_EQ(path_no_ext.value(), path_no_ext.RemoveExtension().value());
- EXPECT_EQ(FILE_PATH_LITERAL(""), path_no_ext.Extension());
- EXPECT_EQ(FILE_PATH_LITERAL(""), path_no_ext.FinalExtension());
-}
-
-TEST_F(FilePathTest, Extension2) {
- const struct UnaryTestData cases[] = {
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("C:\\a\\b\\c.ext"), FPL(".ext") },
- { FPL("C:\\a\\b\\c."), FPL(".") },
- { FPL("C:\\a\\b\\c"), FPL("") },
- { FPL("C:\\a\\b\\"), FPL("") },
- { FPL("C:\\a\\b.\\"), FPL(".") },
- { FPL("C:\\a\\b\\c.ext1.ext2"), FPL(".ext2") },
- { FPL("C:\\foo.bar\\\\\\"), FPL(".bar") },
- { FPL("C:\\foo.bar\\.."), FPL("") },
- { FPL("C:\\foo.bar\\..\\\\"), FPL("") },
-#endif
- { FPL("/foo/bar/baz.ext"), FPL(".ext") },
- { FPL("/foo/bar/baz."), FPL(".") },
- { FPL("/foo/bar/baz.."), FPL(".") },
- { FPL("/foo/bar/baz"), FPL("") },
- { FPL("/foo/bar/"), FPL("") },
- { FPL("/foo/bar./"), FPL(".") },
- { FPL("/foo/bar/baz.ext1.ext2"), FPL(".ext2") },
- { FPL("/subversion-1.6.12.zip"), FPL(".zip") },
- { FPL("/foo.12345.gz"), FPL(".gz") },
- { FPL("/foo..gz"), FPL(".gz") },
- { FPL("."), FPL("") },
- { FPL(".."), FPL("") },
- { FPL("./foo"), FPL("") },
- { FPL("./foo.ext"), FPL(".ext") },
- { FPL("/foo.ext1/bar.ext2"), FPL(".ext2") },
- { FPL("/foo.bar////"), FPL(".bar") },
- { FPL("/foo.bar/.."), FPL("") },
- { FPL("/foo.bar/..////"), FPL("") },
- { FPL("/foo.1234.luser.js"), FPL(".js") },
- { FPL("/user.js"), FPL(".js") },
- };
- const struct UnaryTestData double_extension_cases[] = {
- { FPL("/foo.tar.gz"), FPL(".tar.gz") },
- { FPL("/foo.tar.Z"), FPL(".tar.Z") },
- { FPL("/foo.tar.bz2"), FPL(".tar.bz2") },
- { FPL("/foo.1234.gz"), FPL(".1234.gz") },
- { FPL("/foo.1234.tar.gz"), FPL(".tar.gz") },
- { FPL("/foo.tar.tar.gz"), FPL(".tar.gz") },
- { FPL("/foo.tar.gz.gz"), FPL(".gz.gz") },
- { FPL("/foo.1234.user.js"), FPL(".user.js") },
- { FPL("foo.user.js"), FPL(".user.js") },
- { FPL("/foo.tar.bz"), FPL(".tar.bz") },
- };
- for (unsigned int i = 0; i < arraysize(cases); ++i) {
- FilePath path(cases[i].input);
- FilePath::StringType extension = path.Extension();
- FilePath::StringType final_extension = path.FinalExtension();
- EXPECT_STREQ(cases[i].expected, extension.c_str())
- << "i: " << i << ", path: " << path.value();
- EXPECT_STREQ(cases[i].expected, final_extension.c_str())
- << "i: " << i << ", path: " << path.value();
- }
- for (unsigned int i = 0; i < arraysize(double_extension_cases); ++i) {
- FilePath path(double_extension_cases[i].input);
- FilePath::StringType extension = path.Extension();
- EXPECT_STREQ(double_extension_cases[i].expected, extension.c_str())
- << "i: " << i << ", path: " << path.value();
- }
-}
-
-TEST_F(FilePathTest, InsertBeforeExtension) {
- const struct BinaryTestData cases[] = {
- { { FPL(""), FPL("") }, FPL("") },
- { { FPL(""), FPL("txt") }, FPL("") },
- { { FPL("."), FPL("txt") }, FPL("") },
- { { FPL(".."), FPL("txt") }, FPL("") },
- { { FPL("foo.dll"), FPL("txt") }, FPL("footxt.dll") },
- { { FPL("."), FPL("") }, FPL(".") },
- { { FPL("foo.dll"), FPL(".txt") }, FPL("foo.txt.dll") },
- { { FPL("foo"), FPL("txt") }, FPL("footxt") },
- { { FPL("foo"), FPL(".txt") }, FPL("foo.txt") },
- { { FPL("foo.baz.dll"), FPL("txt") }, FPL("foo.baztxt.dll") },
- { { FPL("foo.baz.dll"), FPL(".txt") }, FPL("foo.baz.txt.dll") },
- { { FPL("foo.dll"), FPL("") }, FPL("foo.dll") },
- { { FPL("foo.dll"), FPL(".") }, FPL("foo..dll") },
- { { FPL("foo"), FPL("") }, FPL("foo") },
- { { FPL("foo"), FPL(".") }, FPL("foo.") },
- { { FPL("foo.baz.dll"), FPL("") }, FPL("foo.baz.dll") },
- { { FPL("foo.baz.dll"), FPL(".") }, FPL("foo.baz..dll") },
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("\\"), FPL("") }, FPL("\\") },
- { { FPL("\\"), FPL("txt") }, FPL("\\txt") },
- { { FPL("\\."), FPL("txt") }, FPL("") },
- { { FPL("\\.."), FPL("txt") }, FPL("") },
- { { FPL("\\."), FPL("") }, FPL("\\.") },
- { { FPL("C:\\bar\\foo.dll"), FPL("txt") },
- FPL("C:\\bar\\footxt.dll") },
- { { FPL("C:\\bar.baz\\foodll"), FPL("txt") },
- FPL("C:\\bar.baz\\foodlltxt") },
- { { FPL("C:\\bar.baz\\foo.dll"), FPL("txt") },
- FPL("C:\\bar.baz\\footxt.dll") },
- { { FPL("C:\\bar.baz\\foo.dll.exe"), FPL("txt") },
- FPL("C:\\bar.baz\\foo.dlltxt.exe") },
- { { FPL("C:\\bar.baz\\foo"), FPL("") },
- FPL("C:\\bar.baz\\foo") },
- { { FPL("C:\\bar.baz\\foo.exe"), FPL("") },
- FPL("C:\\bar.baz\\foo.exe") },
- { { FPL("C:\\bar.baz\\foo.dll.exe"), FPL("") },
- FPL("C:\\bar.baz\\foo.dll.exe") },
- { { FPL("C:\\bar\\baz\\foo.exe"), FPL(" (1)") },
- FPL("C:\\bar\\baz\\foo (1).exe") },
- { { FPL("C:\\foo.baz\\\\"), FPL(" (1)") }, FPL("C:\\foo (1).baz") },
- { { FPL("C:\\foo.baz\\..\\"), FPL(" (1)") }, FPL("") },
-#endif
- { { FPL("/"), FPL("") }, FPL("/") },
- { { FPL("/"), FPL("txt") }, FPL("/txt") },
- { { FPL("/."), FPL("txt") }, FPL("") },
- { { FPL("/.."), FPL("txt") }, FPL("") },
- { { FPL("/."), FPL("") }, FPL("/.") },
- { { FPL("/bar/foo.dll"), FPL("txt") }, FPL("/bar/footxt.dll") },
- { { FPL("/bar.baz/foodll"), FPL("txt") }, FPL("/bar.baz/foodlltxt") },
- { { FPL("/bar.baz/foo.dll"), FPL("txt") }, FPL("/bar.baz/footxt.dll") },
- { { FPL("/bar.baz/foo.dll.exe"), FPL("txt") },
- FPL("/bar.baz/foo.dlltxt.exe") },
- { { FPL("/bar.baz/foo"), FPL("") }, FPL("/bar.baz/foo") },
- { { FPL("/bar.baz/foo.exe"), FPL("") }, FPL("/bar.baz/foo.exe") },
- { { FPL("/bar.baz/foo.dll.exe"), FPL("") }, FPL("/bar.baz/foo.dll.exe") },
- { { FPL("/bar/baz/foo.exe"), FPL(" (1)") }, FPL("/bar/baz/foo (1).exe") },
- { { FPL("/bar/baz/..////"), FPL(" (1)") }, FPL("") },
- };
- for (unsigned int i = 0; i < arraysize(cases); ++i) {
- FilePath path(cases[i].inputs[0]);
- FilePath result = path.InsertBeforeExtension(cases[i].inputs[1]);
- EXPECT_EQ(cases[i].expected, result.value()) << "i: " << i <<
- ", path: " << path.value() << ", insert: " << cases[i].inputs[1];
- }
-}
-
-TEST_F(FilePathTest, RemoveExtension) {
- const struct UnaryTestData cases[] = {
- { FPL(""), FPL("") },
- { FPL("."), FPL(".") },
- { FPL(".."), FPL("..") },
- { FPL("foo.dll"), FPL("foo") },
- { FPL("./foo.dll"), FPL("./foo") },
- { FPL("foo..dll"), FPL("foo.") },
- { FPL("foo"), FPL("foo") },
- { FPL("foo."), FPL("foo") },
- { FPL("foo.."), FPL("foo.") },
- { FPL("foo.baz.dll"), FPL("foo.baz") },
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { FPL("C:\\foo.bar\\foo"), FPL("C:\\foo.bar\\foo") },
- { FPL("C:\\foo.bar\\..\\\\"), FPL("C:\\foo.bar\\..\\\\") },
-#endif
- { FPL("/foo.bar/foo"), FPL("/foo.bar/foo") },
- { FPL("/foo.bar/..////"), FPL("/foo.bar/..////") },
- };
- for (unsigned int i = 0; i < arraysize(cases); ++i) {
- FilePath path(cases[i].input);
- FilePath removed = path.RemoveExtension();
- FilePath removed_final = path.RemoveFinalExtension();
- EXPECT_EQ(cases[i].expected, removed.value()) << "i: " << i <<
- ", path: " << path.value();
- EXPECT_EQ(cases[i].expected, removed_final.value()) << "i: " << i <<
- ", path: " << path.value();
- }
- {
- FilePath path(FPL("foo.tar.gz"));
- FilePath removed = path.RemoveExtension();
- FilePath removed_final = path.RemoveFinalExtension();
- EXPECT_EQ(FPL("foo"), removed.value()) << ", path: " << path.value();
- EXPECT_EQ(FPL("foo.tar"), removed_final.value()) << ", path: "
- << path.value();
- }
-}
-
-TEST_F(FilePathTest, ReplaceExtension) {
- const struct BinaryTestData cases[] = {
- { { FPL(""), FPL("") }, FPL("") },
- { { FPL(""), FPL("txt") }, FPL("") },
- { { FPL("."), FPL("txt") }, FPL("") },
- { { FPL(".."), FPL("txt") }, FPL("") },
- { { FPL("."), FPL("") }, FPL("") },
- { { FPL("foo.dll"), FPL("txt") }, FPL("foo.txt") },
- { { FPL("./foo.dll"), FPL("txt") }, FPL("./foo.txt") },
- { { FPL("foo..dll"), FPL("txt") }, FPL("foo..txt") },
- { { FPL("foo.dll"), FPL(".txt") }, FPL("foo.txt") },
- { { FPL("foo"), FPL("txt") }, FPL("foo.txt") },
- { { FPL("foo."), FPL("txt") }, FPL("foo.txt") },
- { { FPL("foo.."), FPL("txt") }, FPL("foo..txt") },
- { { FPL("foo"), FPL(".txt") }, FPL("foo.txt") },
- { { FPL("foo.baz.dll"), FPL("txt") }, FPL("foo.baz.txt") },
- { { FPL("foo.baz.dll"), FPL(".txt") }, FPL("foo.baz.txt") },
- { { FPL("foo.dll"), FPL("") }, FPL("foo") },
- { { FPL("foo.dll"), FPL(".") }, FPL("foo") },
- { { FPL("foo"), FPL("") }, FPL("foo") },
- { { FPL("foo"), FPL(".") }, FPL("foo") },
- { { FPL("foo.baz.dll"), FPL("") }, FPL("foo.baz") },
- { { FPL("foo.baz.dll"), FPL(".") }, FPL("foo.baz") },
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("C:\\foo.bar\\foo"), FPL("baz") }, FPL("C:\\foo.bar\\foo.baz") },
- { { FPL("C:\\foo.bar\\..\\\\"), FPL("baz") }, FPL("") },
-#endif
- { { FPL("/foo.bar/foo"), FPL("baz") }, FPL("/foo.bar/foo.baz") },
- { { FPL("/foo.bar/..////"), FPL("baz") }, FPL("") },
- };
- for (unsigned int i = 0; i < arraysize(cases); ++i) {
- FilePath path(cases[i].inputs[0]);
- FilePath replaced = path.ReplaceExtension(cases[i].inputs[1]);
- EXPECT_EQ(cases[i].expected, replaced.value()) << "i: " << i <<
- ", path: " << path.value() << ", replace: " << cases[i].inputs[1];
- }
-}
-
-TEST_F(FilePathTest, AddExtension) {
- const struct BinaryTestData cases[] = {
- { { FPL(""), FPL("") }, FPL("") },
- { { FPL(""), FPL("txt") }, FPL("") },
- { { FPL("."), FPL("txt") }, FPL("") },
- { { FPL(".."), FPL("txt") }, FPL("") },
- { { FPL("."), FPL("") }, FPL("") },
- { { FPL("foo.dll"), FPL("txt") }, FPL("foo.dll.txt") },
- { { FPL("./foo.dll"), FPL("txt") }, FPL("./foo.dll.txt") },
- { { FPL("foo..dll"), FPL("txt") }, FPL("foo..dll.txt") },
- { { FPL("foo.dll"), FPL(".txt") }, FPL("foo.dll.txt") },
- { { FPL("foo"), FPL("txt") }, FPL("foo.txt") },
- { { FPL("foo."), FPL("txt") }, FPL("foo.txt") },
- { { FPL("foo.."), FPL("txt") }, FPL("foo..txt") },
- { { FPL("foo"), FPL(".txt") }, FPL("foo.txt") },
- { { FPL("foo.baz.dll"), FPL("txt") }, FPL("foo.baz.dll.txt") },
- { { FPL("foo.baz.dll"), FPL(".txt") }, FPL("foo.baz.dll.txt") },
- { { FPL("foo.dll"), FPL("") }, FPL("foo.dll") },
- { { FPL("foo.dll"), FPL(".") }, FPL("foo.dll") },
- { { FPL("foo"), FPL("") }, FPL("foo") },
- { { FPL("foo"), FPL(".") }, FPL("foo") },
- { { FPL("foo.baz.dll"), FPL("") }, FPL("foo.baz.dll") },
- { { FPL("foo.baz.dll"), FPL(".") }, FPL("foo.baz.dll") },
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("C:\\foo.bar\\foo"), FPL("baz") }, FPL("C:\\foo.bar\\foo.baz") },
- { { FPL("C:\\foo.bar\\..\\\\"), FPL("baz") }, FPL("") },
-#endif
- { { FPL("/foo.bar/foo"), FPL("baz") }, FPL("/foo.bar/foo.baz") },
- { { FPL("/foo.bar/..////"), FPL("baz") }, FPL("") },
- };
- for (unsigned int i = 0; i < arraysize(cases); ++i) {
- FilePath path(cases[i].inputs[0]);
- FilePath added = path.AddExtension(cases[i].inputs[1]);
- EXPECT_EQ(cases[i].expected, added.value()) << "i: " << i <<
- ", path: " << path.value() << ", add: " << cases[i].inputs[1];
- }
-}
-
-TEST_F(FilePathTest, MatchesExtension) {
- const struct BinaryBooleanTestData cases[] = {
- { { FPL("foo"), FPL("") }, true},
- { { FPL("foo"), FPL(".") }, false},
- { { FPL("foo."), FPL("") }, false},
- { { FPL("foo."), FPL(".") }, true},
- { { FPL("foo.txt"), FPL(".dll") }, false},
- { { FPL("foo.txt"), FPL(".txt") }, true},
- { { FPL("foo.txt.dll"), FPL(".txt") }, false},
- { { FPL("foo.txt.dll"), FPL(".dll") }, true},
- { { FPL("foo.TXT"), FPL(".txt") }, true},
- { { FPL("foo.txt"), FPL(".TXT") }, true},
- { { FPL("foo.tXt"), FPL(".txt") }, true},
- { { FPL("foo.txt"), FPL(".tXt") }, true},
- { { FPL("foo.tXt"), FPL(".TXT") }, true},
- { { FPL("foo.tXt"), FPL(".tXt") }, true},
-#if defined(FILE_PATH_USES_DRIVE_LETTERS)
- { { FPL("c:/foo.txt.dll"), FPL(".txt") }, false},
- { { FPL("c:/foo.txt"), FPL(".txt") }, true},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- { { FPL("c:\\bar\\foo.txt.dll"), FPL(".txt") }, false},
- { { FPL("c:\\bar\\foo.txt"), FPL(".txt") }, true},
-#endif // FILE_PATH_USES_DRIVE_LETTERS
- { { FPL("/bar/foo.txt.dll"), FPL(".txt") }, false},
- { { FPL("/bar/foo.txt"), FPL(".txt") }, true},
-#if defined(OS_WIN) || defined(OS_MACOSX)
- // Umlauts A, O, U: direct comparison, and upper case vs. lower case
- { { FPL("foo.\u00E4\u00F6\u00FC"), FPL(".\u00E4\u00F6\u00FC") }, true},
- { { FPL("foo.\u00C4\u00D6\u00DC"), FPL(".\u00E4\u00F6\u00FC") }, true},
- // C with circumflex: direct comparison, and upper case vs. lower case
- { { FPL("foo.\u0109"), FPL(".\u0109") }, true},
- { { FPL("foo.\u0108"), FPL(".\u0109") }, true},
-#endif
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath path(cases[i].inputs[0]);
- FilePath::StringType ext(cases[i].inputs[1]);
-
- EXPECT_EQ(cases[i].expected, path.MatchesExtension(ext)) <<
- "i: " << i << ", path: " << path.value() << ", ext: " << ext;
- }
-}
-
-TEST_F(FilePathTest, CompareIgnoreCase) {
- const struct BinaryIntTestData cases[] = {
- { { FPL("foo"), FPL("foo") }, 0},
- { { FPL("FOO"), FPL("foo") }, 0},
- { { FPL("foo.ext"), FPL("foo.ext") }, 0},
- { { FPL("FOO.EXT"), FPL("foo.ext") }, 0},
- { { FPL("Foo.Ext"), FPL("foo.ext") }, 0},
- { { FPL("foO"), FPL("foo") }, 0},
- { { FPL("foo"), FPL("foO") }, 0},
- { { FPL("fOo"), FPL("foo") }, 0},
- { { FPL("foo"), FPL("fOo") }, 0},
- { { FPL("bar"), FPL("foo") }, -1},
- { { FPL("foo"), FPL("bar") }, 1},
- { { FPL("BAR"), FPL("foo") }, -1},
- { { FPL("FOO"), FPL("bar") }, 1},
- { { FPL("bar"), FPL("FOO") }, -1},
- { { FPL("foo"), FPL("BAR") }, 1},
- { { FPL("BAR"), FPL("FOO") }, -1},
- { { FPL("FOO"), FPL("BAR") }, 1},
- // German "Eszett" (lower case and the new-fangled upper case)
- // Note that uc(<lowercase eszett>) => "SS", NOT <uppercase eszett>!
- // However, neither Windows nor Mac OSX converts these.
- // (or even have glyphs for <uppercase eszett>)
- { { FPL("\u00DF"), FPL("\u00DF") }, 0},
- { { FPL("\u1E9E"), FPL("\u1E9E") }, 0},
- { { FPL("\u00DF"), FPL("\u1E9E") }, -1},
- { { FPL("SS"), FPL("\u00DF") }, -1},
- { { FPL("SS"), FPL("\u1E9E") }, -1},
-#if defined(OS_WIN) || defined(OS_MACOSX)
- // Umlauts A, O, U: direct comparison, and upper case vs. lower case
- { { FPL("\u00E4\u00F6\u00FC"), FPL("\u00E4\u00F6\u00FC") }, 0},
- { { FPL("\u00C4\u00D6\u00DC"), FPL("\u00E4\u00F6\u00FC") }, 0},
- // C with circumflex: direct comparison, and upper case vs. lower case
- { { FPL("\u0109"), FPL("\u0109") }, 0},
- { { FPL("\u0108"), FPL("\u0109") }, 0},
- // Cyrillic letter SHA: direct comparison, and upper case vs. lower case
- { { FPL("\u0428"), FPL("\u0428") }, 0},
- { { FPL("\u0428"), FPL("\u0448") }, 0},
- // Greek letter DELTA: direct comparison, and upper case vs. lower case
- { { FPL("\u0394"), FPL("\u0394") }, 0},
- { { FPL("\u0394"), FPL("\u03B4") }, 0},
- // Japanese full-width A: direct comparison, and upper case vs. lower case
- // Note that full-width and standard characters are considered different.
- { { FPL("\uFF21"), FPL("\uFF21") }, 0},
- { { FPL("\uFF21"), FPL("\uFF41") }, 0},
- { { FPL("A"), FPL("\uFF21") }, -1},
- { { FPL("A"), FPL("\uFF41") }, -1},
- { { FPL("a"), FPL("\uFF21") }, -1},
- { { FPL("a"), FPL("\uFF41") }, -1},
-#endif
-#if defined(OS_MACOSX)
- // Codepoints > 0x1000
- // Georgian letter DON: direct comparison, and upper case vs. lower case
- { { FPL("\u10A3"), FPL("\u10A3") }, 0},
- { { FPL("\u10A3"), FPL("\u10D3") }, 0},
- // Combining characters vs. pre-composed characters, upper and lower case
- { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("\u1E31\u1E77\u1E53n") }, 0},
- { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("kuon") }, 1},
- { { FPL("kuon"), FPL("k\u0301u\u032Do\u0304\u0301n") }, -1},
- { { FPL("K\u0301U\u032DO\u0304\u0301N"), FPL("KUON") }, 1},
- { { FPL("KUON"), FPL("K\u0301U\u032DO\u0304\u0301N") }, -1},
- { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("KUON") }, 1},
- { { FPL("K\u0301U\u032DO\u0304\u0301N"), FPL("\u1E31\u1E77\u1E53n") }, 0},
- { { FPL("k\u0301u\u032Do\u0304\u0301n"), FPL("\u1E30\u1E76\u1E52n") }, 0},
- { { FPL("k\u0301u\u032Do\u0304\u0302n"), FPL("\u1E30\u1E76\u1E52n") }, 1},
-#endif
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath::StringType s1(cases[i].inputs[0]);
- FilePath::StringType s2(cases[i].inputs[1]);
- int result = FilePath::CompareIgnoreCase(s1, s2);
- EXPECT_EQ(cases[i].expected, result) <<
- "i: " << i << ", s1: " << s1 << ", s2: " << s2;
- }
-}
-
-TEST_F(FilePathTest, ReferencesParent) {
- const struct UnaryBooleanTestData cases[] = {
- { FPL("."), false },
- { FPL(".."), true },
- { FPL(".. "), true },
- { FPL(" .."), true },
- { FPL("..."), true },
- { FPL("a.."), false },
- { FPL("..a"), false },
- { FPL("../"), true },
- { FPL("/.."), true },
- { FPL("/../"), true },
- { FPL("/a../"), false },
- { FPL("/..a/"), false },
- { FPL("//.."), true },
- { FPL("..//"), true },
- { FPL("//..//"), true },
- { FPL("a//..//c"), true },
- { FPL("../b/c"), true },
- { FPL("/../b/c"), true },
- { FPL("a/b/.."), true },
- { FPL("a/b/../"), true },
- { FPL("a/../c"), true },
- { FPL("a/b/c"), false },
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- bool observed = input.ReferencesParent();
- EXPECT_EQ(cases[i].expected, observed) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-
-TEST_F(FilePathTest, FromUTF8Unsafe_And_AsUTF8Unsafe) {
- const struct UTF8TestData cases[] = {
- { FPL("foo.txt"), "foo.txt" },
- // "aeo" with accents. Use http://0xcc.net/jsescape/ to decode them.
- { FPL("\u00E0\u00E8\u00F2.txt"), "\xC3\xA0\xC3\xA8\xC3\xB2.txt" },
- // Full-width "ABC".
- { FPL("\uFF21\uFF22\uFF23.txt"),
- "\xEF\xBC\xA1\xEF\xBC\xA2\xEF\xBC\xA3.txt" },
- };
-
-#if !defined(SYSTEM_NATIVE_UTF8) && defined(OS_LINUX)
- ScopedLocale locale("en_US.UTF-8");
-#endif
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- // Test FromUTF8Unsafe() works.
- FilePath from_utf8 = FilePath::FromUTF8Unsafe(cases[i].utf8);
- EXPECT_EQ(cases[i].native, from_utf8.value())
- << "i: " << i << ", input: " << cases[i].native;
- // Test AsUTF8Unsafe() works.
- FilePath from_native = FilePath(cases[i].native);
- EXPECT_EQ(cases[i].utf8, from_native.AsUTF8Unsafe())
- << "i: " << i << ", input: " << cases[i].native;
- // Test the two file paths are identical.
- EXPECT_EQ(from_utf8.value(), from_native.value());
- }
-}
-
-TEST_F(FilePathTest, ConstructWithNUL) {
- // Assert FPS() works.
- ASSERT_EQ(3U, FPS("a\0b").length());
-
- // Test constructor strips '\0'
- FilePath path(FPS("a\0b"));
- EXPECT_EQ(1U, path.value().length());
- EXPECT_EQ(FPL("a"), path.value());
-}
-
-TEST_F(FilePathTest, AppendWithNUL) {
- // Assert FPS() works.
- ASSERT_EQ(3U, FPS("b\0b").length());
-
- // Test Append() strips '\0'
- FilePath path(FPL("a"));
- path = path.Append(FPS("b\0b"));
- EXPECT_EQ(3U, path.value().length());
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
- EXPECT_EQ(FPL("a\\b"), path.value());
-#else
- EXPECT_EQ(FPL("a/b"), path.value());
-#endif
-}
-
-TEST_F(FilePathTest, ReferencesParentWithNUL) {
- // Assert FPS() works.
- ASSERT_EQ(3U, FPS("..\0").length());
-
- // Test ReferencesParent() doesn't break with "..\0"
- FilePath path(FPS("..\0"));
- EXPECT_TRUE(path.ReferencesParent());
-}
-
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
-TEST_F(FilePathTest, NormalizePathSeparators) {
- const struct UnaryTestData cases[] = {
- { FPL("foo/bar"), FPL("foo\\bar") },
- { FPL("foo/bar\\betz"), FPL("foo\\bar\\betz") },
- { FPL("foo\\bar"), FPL("foo\\bar") },
- { FPL("foo\\bar/betz"), FPL("foo\\bar\\betz") },
- { FPL("foo"), FPL("foo") },
- // Trailing slashes don't automatically get stripped. That's what
- // StripTrailingSeparators() is for.
- { FPL("foo\\"), FPL("foo\\") },
- { FPL("foo/"), FPL("foo\\") },
- { FPL("foo/bar\\"), FPL("foo\\bar\\") },
- { FPL("foo\\bar/"), FPL("foo\\bar\\") },
- { FPL("foo/bar/"), FPL("foo\\bar\\") },
- { FPL("foo\\bar\\"), FPL("foo\\bar\\") },
- { FPL("\\foo/bar"), FPL("\\foo\\bar") },
- { FPL("/foo\\bar"), FPL("\\foo\\bar") },
- { FPL("c:/foo/bar/"), FPL("c:\\foo\\bar\\") },
- { FPL("/foo/bar/"), FPL("\\foo\\bar\\") },
- { FPL("\\foo\\bar\\"), FPL("\\foo\\bar\\") },
- { FPL("c:\\foo/bar"), FPL("c:\\foo\\bar") },
- { FPL("//foo\\bar\\"), FPL("\\\\foo\\bar\\") },
- { FPL("\\\\foo\\bar\\"), FPL("\\\\foo\\bar\\") },
- { FPL("//foo\\bar\\"), FPL("\\\\foo\\bar\\") },
- // This method does not normalize the number of path separators.
- { FPL("foo\\\\bar"), FPL("foo\\\\bar") },
- { FPL("foo//bar"), FPL("foo\\\\bar") },
- { FPL("foo/\\bar"), FPL("foo\\\\bar") },
- { FPL("foo\\/bar"), FPL("foo\\\\bar") },
- { FPL("///foo\\\\bar"), FPL("\\\\\\foo\\\\bar") },
- { FPL("foo//bar///"), FPL("foo\\\\bar\\\\\\") },
- { FPL("foo/\\bar/\\"), FPL("foo\\\\bar\\\\") },
- { FPL("/\\foo\\/bar"), FPL("\\\\foo\\\\bar") },
- };
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- FilePath observed = input.NormalizePathSeparators();
- EXPECT_EQ(FilePath::StringType(cases[i].expected), observed.value()) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-#endif
-
-TEST_F(FilePathTest, EndsWithSeparator) {
- const UnaryBooleanTestData cases[] = {
- { FPL(""), false },
- { FPL("/"), true },
- { FPL("foo/"), true },
- { FPL("bar"), false },
- { FPL("/foo/bar"), false },
- };
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input = FilePath(cases[i].input).NormalizePathSeparators();
- EXPECT_EQ(cases[i].expected, input.EndsWithSeparator());
- }
-}
-
-TEST_F(FilePathTest, AsEndingWithSeparator) {
- const UnaryTestData cases[] = {
- { FPL(""), FPL("") },
- { FPL("/"), FPL("/") },
- { FPL("foo"), FPL("foo/") },
- { FPL("foo/"), FPL("foo/") }
- };
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input = FilePath(cases[i].input).NormalizePathSeparators();
- FilePath expected = FilePath(cases[i].expected).NormalizePathSeparators();
- EXPECT_EQ(expected.value(), input.AsEndingWithSeparator().value());
- }
-}
-
-#if defined(OS_ANDROID)
-TEST_F(FilePathTest, ContentUriTest) {
- const struct UnaryBooleanTestData cases[] = {
- { FPL("content://foo.bar"), true },
- { FPL("content://foo.bar/"), true },
- { FPL("content://foo/bar"), true },
- { FPL("CoNTenT://foo.bar"), true },
- { FPL("content://"), true },
- { FPL("content:///foo.bar"), true },
- { FPL("content://3foo/bar"), true },
- { FPL("content://_foo/bar"), true },
- { FPL(".. "), false },
- { FPL("foo.bar"), false },
- { FPL("content:foo.bar"), false },
- { FPL("content:/foo.ba"), false },
- { FPL("content:/dir/foo.bar"), false },
- { FPL("content: //foo.bar"), false },
- { FPL("content%2a%2f%2f"), false },
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath input(cases[i].input);
- bool observed = input.IsContentUri();
- EXPECT_EQ(cases[i].expected, observed) <<
- "i: " << i << ", input: " << input.value();
- }
-}
-#endif
-
-// Test the operator<<(ostream, FilePath).
-TEST_F(FilePathTest, PrintToOstream) {
- std::stringstream ss;
- FilePath fp(FPL("foo"));
- ss << fp;
- EXPECT_EQ("foo", ss.str());
-}
-
-// Test GetHFSDecomposedForm should return empty result for invalid UTF-8
-// strings.
-#if defined(OS_MACOSX)
-TEST_F(FilePathTest, GetHFSDecomposedFormWithInvalidInput) {
- const FilePath::CharType* cases[] = {
- FPL("\xc3\x28"),
- FPL("\xe2\x82\x28"),
- FPL("\xe2\x28\xa1"),
- FPL("\xf0\x28\x8c\xbc"),
- FPL("\xf0\x28\x8c\x28"),
- };
- for (auto* invalid_input : cases) {
- FilePath::StringType observed = FilePath::GetHFSDecomposedForm(
- invalid_input);
- EXPECT_TRUE(observed.empty());
- }
-}
-#endif
-
-} // namespace base
diff --git a/base/files/file_path_watcher_unittest.cc b/base/files/file_path_watcher_unittest.cc
deleted file mode 100644
index 9e3d94d..0000000
--- a/base/files/file_path_watcher_unittest.cc
+++ /dev/null
@@ -1,873 +0,0 @@
-// 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.
-
-#include "base/files/file_path_watcher.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include <aclapi.h>
-#elif defined(OS_POSIX)
-#include <sys/stat.h>
-#endif
-
-#include <set>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/compiler_specific.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/test_file_util.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_ANDROID)
-#include "base/android/path_utils.h"
-#endif // defined(OS_ANDROID)
-
-#if defined(OS_POSIX)
-#include "base/files/file_descriptor_watcher_posix.h"
-#endif // defined(OS_POSIX)
-
-namespace base {
-
-namespace {
-
-class TestDelegate;
-
-// Aggregates notifications from the test delegates and breaks the message loop
-// the test thread is waiting on once they all came in.
-class NotificationCollector
- : public base::RefCountedThreadSafe<NotificationCollector> {
- public:
- NotificationCollector() : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
-
- // Called from the file thread by the delegates.
- void OnChange(TestDelegate* delegate) {
- task_runner_->PostTask(
- FROM_HERE, base::BindOnce(&NotificationCollector::RecordChange, this,
- base::Unretained(delegate)));
- }
-
- void Register(TestDelegate* delegate) {
- delegates_.insert(delegate);
- }
-
- void Reset() {
- signaled_.clear();
- }
-
- bool Success() {
- return signaled_ == delegates_;
- }
-
- private:
- friend class base::RefCountedThreadSafe<NotificationCollector>;
- ~NotificationCollector() = default;
-
- void RecordChange(TestDelegate* delegate) {
- // Warning: |delegate| is Unretained. Do not dereference.
- ASSERT_TRUE(task_runner_->BelongsToCurrentThread());
- ASSERT_TRUE(delegates_.count(delegate));
- signaled_.insert(delegate);
-
- // Check whether all delegates have been signaled.
- if (signaled_ == delegates_)
- task_runner_->PostTask(FROM_HERE,
- RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- }
-
- // Set of registered delegates.
- std::set<TestDelegate*> delegates_;
-
- // Set of signaled delegates.
- std::set<TestDelegate*> signaled_;
-
- // The loop we should break after all delegates signaled.
- scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-};
-
-class TestDelegateBase : public SupportsWeakPtr<TestDelegateBase> {
- public:
- TestDelegateBase() = default;
- virtual ~TestDelegateBase() = default;
-
- virtual void OnFileChanged(const FilePath& path, bool error) = 0;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
-};
-
-// A mock class for testing. Gmock is not appropriate because it is not
-// thread-safe for setting expectations. Thus the test code cannot safely
-// reset expectations while the file watcher is running.
-// Instead, TestDelegate gets the notifications from FilePathWatcher and uses
-// NotificationCollector to aggregate the results.
-class TestDelegate : public TestDelegateBase {
- public:
- explicit TestDelegate(NotificationCollector* collector)
- : collector_(collector) {
- collector_->Register(this);
- }
- ~TestDelegate() override = default;
-
- void OnFileChanged(const FilePath& path, bool error) override {
- if (error)
- ADD_FAILURE() << "Error " << path.value();
- else
- collector_->OnChange(this);
- }
-
- private:
- scoped_refptr<NotificationCollector> collector_;
-
- DISALLOW_COPY_AND_ASSIGN(TestDelegate);
-};
-
-class FilePathWatcherTest : public testing::Test {
- public:
- FilePathWatcherTest()
-#if defined(OS_POSIX)
- : file_descriptor_watcher_(&loop_)
-#endif
- {
- }
-
- ~FilePathWatcherTest() override = default;
-
- protected:
- void SetUp() override {
-#if defined(OS_ANDROID)
- // Watching files is only permitted when all parent directories are
- // accessible, which is not the case for the default temp directory
- // on Android which is under /data/data. Use /sdcard instead.
- // TODO(pauljensen): Remove this when crbug.com/475568 is fixed.
- FilePath parent_dir;
- ASSERT_TRUE(android::GetExternalStorageDirectory(&parent_dir));
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(parent_dir));
-#else // defined(OS_ANDROID)
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-#endif // defined(OS_ANDROID)
- collector_ = new NotificationCollector();
- }
-
- void TearDown() override { RunLoop().RunUntilIdle(); }
-
- FilePath test_file() {
- return temp_dir_.GetPath().AppendASCII("FilePathWatcherTest");
- }
-
- FilePath test_link() {
- return temp_dir_.GetPath().AppendASCII("FilePathWatcherTest.lnk");
- }
-
- // Write |content| to |file|. Returns true on success.
- bool WriteFile(const FilePath& file, const std::string& content) {
- int write_size = ::base::WriteFile(file, content.c_str(), content.length());
- return write_size == static_cast<int>(content.length());
- }
-
- bool SetupWatch(const FilePath& target,
- FilePathWatcher* watcher,
- TestDelegateBase* delegate,
- bool recursive_watch) WARN_UNUSED_RESULT;
-
- bool WaitForEvents() WARN_UNUSED_RESULT {
- collector_->Reset();
-
- RunLoop run_loop;
- // Make sure we timeout if we don't get notified.
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, run_loop.QuitWhenIdleClosure(),
- TestTimeouts::action_timeout());
- run_loop.Run();
- return collector_->Success();
- }
-
- NotificationCollector* collector() { return collector_.get(); }
-
- MessageLoopForIO loop_;
-#if defined(OS_POSIX)
- FileDescriptorWatcher file_descriptor_watcher_;
-#endif
-
- ScopedTempDir temp_dir_;
- scoped_refptr<NotificationCollector> collector_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(FilePathWatcherTest);
-};
-
-bool FilePathWatcherTest::SetupWatch(const FilePath& target,
- FilePathWatcher* watcher,
- TestDelegateBase* delegate,
- bool recursive_watch) {
- return watcher->Watch(
- target, recursive_watch,
- base::Bind(&TestDelegateBase::OnFileChanged, delegate->AsWeakPtr()));
-}
-
-// Basic test: Create the file and verify that we notice.
-TEST_F(FilePathWatcherTest, NewFile) {
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
-
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that modifying the file is caught.
-TEST_F(FilePathWatcherTest, ModifiedFile) {
- ASSERT_TRUE(WriteFile(test_file(), "content"));
-
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the file is modified.
- ASSERT_TRUE(WriteFile(test_file(), "new content"));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that moving the file into place is caught.
-TEST_F(FilePathWatcherTest, MovedFile) {
- FilePath source_file(temp_dir_.GetPath().AppendASCII("source"));
- ASSERT_TRUE(WriteFile(source_file, "content"));
-
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the file is modified.
- ASSERT_TRUE(base::Move(source_file, test_file()));
- ASSERT_TRUE(WaitForEvents());
-}
-
-TEST_F(FilePathWatcherTest, DeletedFile) {
- ASSERT_TRUE(WriteFile(test_file(), "content"));
-
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the file is deleted.
- base::DeleteFile(test_file(), false);
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Used by the DeleteDuringNotify test below.
-// Deletes the FilePathWatcher when it's notified.
-class Deleter : public TestDelegateBase {
- public:
- Deleter(FilePathWatcher* watcher, MessageLoop* loop)
- : watcher_(watcher),
- loop_(loop) {
- }
- ~Deleter() override = default;
-
- void OnFileChanged(const FilePath&, bool) override {
- watcher_.reset();
- loop_->task_runner()->PostTask(
- FROM_HERE, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- }
-
- FilePathWatcher* watcher() const { return watcher_.get(); }
-
- private:
- std::unique_ptr<FilePathWatcher> watcher_;
- MessageLoop* loop_;
-
- DISALLOW_COPY_AND_ASSIGN(Deleter);
-};
-
-// Verify that deleting a watcher during the callback doesn't crash.
-TEST_F(FilePathWatcherTest, DeleteDuringNotify) {
- FilePathWatcher* watcher = new FilePathWatcher;
- // Takes ownership of watcher.
- std::unique_ptr<Deleter> deleter(new Deleter(watcher, &loop_));
- ASSERT_TRUE(SetupWatch(test_file(), watcher, deleter.get(), false));
-
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(WaitForEvents());
-
- // We win if we haven't crashed yet.
- // Might as well double-check it got deleted, too.
- ASSERT_TRUE(deleter->watcher() == nullptr);
-}
-
-// Verify that deleting the watcher works even if there is a pending
-// notification.
-// Flaky on MacOS (and ARM linux): http://crbug.com/85930
-TEST_F(FilePathWatcherTest, DISABLED_DestroyWithPendingNotification) {
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- FilePathWatcher watcher;
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
- ASSERT_TRUE(WriteFile(test_file(), "content"));
-}
-
-TEST_F(FilePathWatcherTest, MultipleWatchersSingleFile) {
- FilePathWatcher watcher1, watcher2;
- std::unique_ptr<TestDelegate> delegate1(new TestDelegate(collector()));
- std::unique_ptr<TestDelegate> delegate2(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher1, delegate1.get(), false));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher2, delegate2.get(), false));
-
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that watching a file whose parent directory doesn't exist yet works if
-// the directory and file are created eventually.
-TEST_F(FilePathWatcherTest, NonExistentDirectory) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath file(dir.AppendASCII("file"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get(), false));
-
- ASSERT_TRUE(base::CreateDirectory(dir));
-
- ASSERT_TRUE(WriteFile(file, "content"));
-
- VLOG(1) << "Waiting for file creation";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file, "content v2"));
- VLOG(1) << "Waiting for file change";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(base::DeleteFile(file, false));
- VLOG(1) << "Waiting for file deletion";
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Exercises watch reconfiguration for the case that directories on the path
-// are rapidly created.
-TEST_F(FilePathWatcherTest, DirectoryChain) {
- FilePath path(temp_dir_.GetPath());
- std::vector<std::string> dir_names;
- for (int i = 0; i < 20; i++) {
- std::string dir(base::StringPrintf("d%d", i));
- dir_names.push_back(dir);
- path = path.AppendASCII(dir);
- }
-
- FilePathWatcher watcher;
- FilePath file(path.AppendASCII("file"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get(), false));
-
- FilePath sub_path(temp_dir_.GetPath());
- for (std::vector<std::string>::const_iterator d(dir_names.begin());
- d != dir_names.end(); ++d) {
- sub_path = sub_path.AppendASCII(*d);
- ASSERT_TRUE(base::CreateDirectory(sub_path));
- }
- VLOG(1) << "Create File";
- ASSERT_TRUE(WriteFile(file, "content"));
- VLOG(1) << "Waiting for file creation";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file, "content v2"));
- VLOG(1) << "Waiting for file modification";
- ASSERT_TRUE(WaitForEvents());
-}
-
-#if defined(OS_MACOSX)
-// http://crbug.com/85930
-#define DisappearingDirectory DISABLED_DisappearingDirectory
-#endif
-TEST_F(FilePathWatcherTest, DisappearingDirectory) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath file(dir.AppendASCII("file"));
- ASSERT_TRUE(base::CreateDirectory(dir));
- ASSERT_TRUE(WriteFile(file, "content"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get(), false));
-
- ASSERT_TRUE(base::DeleteFile(dir, true));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Tests that a file that is deleted and reappears is tracked correctly.
-TEST_F(FilePathWatcherTest, DeleteAndRecreate) {
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
-
- ASSERT_TRUE(base::DeleteFile(test_file(), false));
- VLOG(1) << "Waiting for file deletion";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- VLOG(1) << "Waiting for file creation";
- ASSERT_TRUE(WaitForEvents());
-}
-
-TEST_F(FilePathWatcherTest, WatchDirectory) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath file1(dir.AppendASCII("file1"));
- FilePath file2(dir.AppendASCII("file2"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(dir, &watcher, delegate.get(), false));
-
- ASSERT_TRUE(base::CreateDirectory(dir));
- VLOG(1) << "Waiting for directory creation";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file1, "content"));
- VLOG(1) << "Waiting for file1 creation";
- ASSERT_TRUE(WaitForEvents());
-
-#if !defined(OS_MACOSX)
- // Mac implementation does not detect files modified in a directory.
- ASSERT_TRUE(WriteFile(file1, "content v2"));
- VLOG(1) << "Waiting for file1 modification";
- ASSERT_TRUE(WaitForEvents());
-#endif // !OS_MACOSX
-
- ASSERT_TRUE(base::DeleteFile(file1, false));
- VLOG(1) << "Waiting for file1 deletion";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file2, "content"));
- VLOG(1) << "Waiting for file2 creation";
- ASSERT_TRUE(WaitForEvents());
-}
-
-TEST_F(FilePathWatcherTest, MoveParent) {
- FilePathWatcher file_watcher;
- FilePathWatcher subdir_watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath dest(temp_dir_.GetPath().AppendASCII("dest"));
- FilePath subdir(dir.AppendASCII("subdir"));
- FilePath file(subdir.AppendASCII("file"));
- std::unique_ptr<TestDelegate> file_delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(file, &file_watcher, file_delegate.get(), false));
- std::unique_ptr<TestDelegate> subdir_delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(subdir, &subdir_watcher, subdir_delegate.get(),
- false));
-
- // Setup a directory hierarchy.
- ASSERT_TRUE(base::CreateDirectory(subdir));
- ASSERT_TRUE(WriteFile(file, "content"));
- VLOG(1) << "Waiting for file creation";
- ASSERT_TRUE(WaitForEvents());
-
- // Move the parent directory.
- base::Move(dir, dest);
- VLOG(1) << "Waiting for directory move";
- ASSERT_TRUE(WaitForEvents());
-}
-
-TEST_F(FilePathWatcherTest, RecursiveWatch) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- bool setup_result = SetupWatch(dir, &watcher, delegate.get(), true);
- if (!FilePathWatcher::RecursiveWatchAvailable()) {
- ASSERT_FALSE(setup_result);
- return;
- }
- ASSERT_TRUE(setup_result);
-
- // Main directory("dir") creation.
- ASSERT_TRUE(base::CreateDirectory(dir));
- ASSERT_TRUE(WaitForEvents());
-
- // Create "$dir/file1".
- FilePath file1(dir.AppendASCII("file1"));
- ASSERT_TRUE(WriteFile(file1, "content"));
- ASSERT_TRUE(WaitForEvents());
-
- // Create "$dir/subdir".
- FilePath subdir(dir.AppendASCII("subdir"));
- ASSERT_TRUE(base::CreateDirectory(subdir));
- ASSERT_TRUE(WaitForEvents());
-
- // Create "$dir/subdir/subdir_file1".
- FilePath subdir_file1(subdir.AppendASCII("subdir_file1"));
- ASSERT_TRUE(WriteFile(subdir_file1, "content"));
- ASSERT_TRUE(WaitForEvents());
-
- // Create "$dir/subdir/subdir_child_dir".
- FilePath subdir_child_dir(subdir.AppendASCII("subdir_child_dir"));
- ASSERT_TRUE(base::CreateDirectory(subdir_child_dir));
- ASSERT_TRUE(WaitForEvents());
-
- // Create "$dir/subdir/subdir_child_dir/child_dir_file1".
- FilePath child_dir_file1(subdir_child_dir.AppendASCII("child_dir_file1"));
- ASSERT_TRUE(WriteFile(child_dir_file1, "content v2"));
- ASSERT_TRUE(WaitForEvents());
-
- // Write into "$dir/subdir/subdir_child_dir/child_dir_file1".
- ASSERT_TRUE(WriteFile(child_dir_file1, "content"));
- ASSERT_TRUE(WaitForEvents());
-
-// Apps cannot change file attributes on Android in /sdcard as /sdcard uses the
-// "fuse" file system, while /data uses "ext4". Running these tests in /data
-// would be preferable and allow testing file attributes and symlinks.
-// TODO(pauljensen): Re-enable when crbug.com/475568 is fixed and SetUp() places
-// the |temp_dir_| in /data.
-#if !defined(OS_ANDROID)
- // Modify "$dir/subdir/subdir_child_dir/child_dir_file1" attributes.
- ASSERT_TRUE(base::MakeFileUnreadable(child_dir_file1));
- ASSERT_TRUE(WaitForEvents());
-#endif
-
- // Delete "$dir/subdir/subdir_file1".
- ASSERT_TRUE(base::DeleteFile(subdir_file1, false));
- ASSERT_TRUE(WaitForEvents());
-
- // Delete "$dir/subdir/subdir_child_dir/child_dir_file1".
- ASSERT_TRUE(base::DeleteFile(child_dir_file1, false));
- ASSERT_TRUE(WaitForEvents());
-}
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-// Apps cannot create symlinks on Android in /sdcard as /sdcard uses the
-// "fuse" file system, while /data uses "ext4". Running these tests in /data
-// would be preferable and allow testing file attributes and symlinks.
-// TODO(pauljensen): Re-enable when crbug.com/475568 is fixed and SetUp() places
-// the |temp_dir_| in /data.
-//
-// This test is disabled on Fuchsia since it doesn't support symlinking.
-TEST_F(FilePathWatcherTest, RecursiveWithSymLink) {
- if (!FilePathWatcher::RecursiveWatchAvailable())
- return;
-
- FilePathWatcher watcher;
- FilePath test_dir(temp_dir_.GetPath().AppendASCII("test_dir"));
- ASSERT_TRUE(base::CreateDirectory(test_dir));
- FilePath symlink(test_dir.AppendASCII("symlink"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(symlink, &watcher, delegate.get(), true));
-
- // Link creation.
- FilePath target1(temp_dir_.GetPath().AppendASCII("target1"));
- ASSERT_TRUE(base::CreateSymbolicLink(target1, symlink));
- ASSERT_TRUE(WaitForEvents());
-
- // Target1 creation.
- ASSERT_TRUE(base::CreateDirectory(target1));
- ASSERT_TRUE(WaitForEvents());
-
- // Create a file in target1.
- FilePath target1_file(target1.AppendASCII("file"));
- ASSERT_TRUE(WriteFile(target1_file, "content"));
- ASSERT_TRUE(WaitForEvents());
-
- // Link change.
- FilePath target2(temp_dir_.GetPath().AppendASCII("target2"));
- ASSERT_TRUE(base::CreateDirectory(target2));
- ASSERT_TRUE(base::DeleteFile(symlink, false));
- ASSERT_TRUE(base::CreateSymbolicLink(target2, symlink));
- ASSERT_TRUE(WaitForEvents());
-
- // Create a file in target2.
- FilePath target2_file(target2.AppendASCII("file"));
- ASSERT_TRUE(WriteFile(target2_file, "content"));
- ASSERT_TRUE(WaitForEvents());
-}
-#endif // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-
-TEST_F(FilePathWatcherTest, MoveChild) {
- FilePathWatcher file_watcher;
- FilePathWatcher subdir_watcher;
- FilePath source_dir(temp_dir_.GetPath().AppendASCII("source"));
- FilePath source_subdir(source_dir.AppendASCII("subdir"));
- FilePath source_file(source_subdir.AppendASCII("file"));
- FilePath dest_dir(temp_dir_.GetPath().AppendASCII("dest"));
- FilePath dest_subdir(dest_dir.AppendASCII("subdir"));
- FilePath dest_file(dest_subdir.AppendASCII("file"));
-
- // Setup a directory hierarchy.
- ASSERT_TRUE(base::CreateDirectory(source_subdir));
- ASSERT_TRUE(WriteFile(source_file, "content"));
-
- std::unique_ptr<TestDelegate> file_delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(dest_file, &file_watcher, file_delegate.get(), false));
- std::unique_ptr<TestDelegate> subdir_delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(dest_subdir, &subdir_watcher, subdir_delegate.get(),
- false));
-
- // Move the directory into place, s.t. the watched file appears.
- ASSERT_TRUE(base::Move(source_dir, dest_dir));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that changing attributes on a file is caught
-#if defined(OS_ANDROID)
-// Apps cannot change file attributes on Android in /sdcard as /sdcard uses the
-// "fuse" file system, while /data uses "ext4". Running these tests in /data
-// would be preferable and allow testing file attributes and symlinks.
-// TODO(pauljensen): Re-enable when crbug.com/475568 is fixed and SetUp() places
-// the |temp_dir_| in /data.
-#define FileAttributesChanged DISABLED_FileAttributesChanged
-#endif // defined(OS_ANDROID
-TEST_F(FilePathWatcherTest, FileAttributesChanged) {
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the file is modified.
- ASSERT_TRUE(base::MakeFileUnreadable(test_file()));
- ASSERT_TRUE(WaitForEvents());
-}
-
-#if defined(OS_LINUX)
-
-// Verify that creating a symlink is caught.
-TEST_F(FilePathWatcherTest, CreateLink) {
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- // Note that we are watching the symlink
- ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the link is created.
- // Note that test_file() doesn't have to exist.
- ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that deleting a symlink is caught.
-TEST_F(FilePathWatcherTest, DeleteLink) {
- // Unfortunately this test case only works if the link target exists.
- // TODO(craig) fix this as part of crbug.com/91561.
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the link is deleted.
- ASSERT_TRUE(base::DeleteFile(test_link(), false));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that modifying a target file that a link is pointing to
-// when we are watching the link is caught.
-TEST_F(FilePathWatcherTest, ModifiedLinkedFile) {
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- // Note that we are watching the symlink.
- ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the file is modified.
- ASSERT_TRUE(WriteFile(test_file(), "new content"));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that creating a target file that a link is pointing to
-// when we are watching the link is caught.
-TEST_F(FilePathWatcherTest, CreateTargetLinkedFile) {
- ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- // Note that we are watching the symlink.
- ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the target file is created.
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that deleting a target file that a link is pointing to
-// when we are watching the link is caught.
-TEST_F(FilePathWatcherTest, DeleteTargetLinkedFile) {
- ASSERT_TRUE(WriteFile(test_file(), "content"));
- ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- // Note that we are watching the symlink.
- ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
-
- // Now make sure we get notified if the target file is deleted.
- ASSERT_TRUE(base::DeleteFile(test_file(), false));
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that watching a file whose parent directory is a link that
-// doesn't exist yet works if the symlink is created eventually.
-TEST_F(FilePathWatcherTest, LinkedDirectoryPart1) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath link_dir(temp_dir_.GetPath().AppendASCII("dir.lnk"));
- FilePath file(dir.AppendASCII("file"));
- FilePath linkfile(link_dir.AppendASCII("file"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- // dir/file should exist.
- ASSERT_TRUE(base::CreateDirectory(dir));
- ASSERT_TRUE(WriteFile(file, "content"));
- // Note that we are watching dir.lnk/file which doesn't exist yet.
- ASSERT_TRUE(SetupWatch(linkfile, &watcher, delegate.get(), false));
-
- ASSERT_TRUE(CreateSymbolicLink(dir, link_dir));
- VLOG(1) << "Waiting for link creation";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file, "content v2"));
- VLOG(1) << "Waiting for file change";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(base::DeleteFile(file, false));
- VLOG(1) << "Waiting for file deletion";
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that watching a file whose parent directory is a
-// dangling symlink works if the directory is created eventually.
-TEST_F(FilePathWatcherTest, LinkedDirectoryPart2) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath link_dir(temp_dir_.GetPath().AppendASCII("dir.lnk"));
- FilePath file(dir.AppendASCII("file"));
- FilePath linkfile(link_dir.AppendASCII("file"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- // Now create the link from dir.lnk pointing to dir but
- // neither dir nor dir/file exist yet.
- ASSERT_TRUE(CreateSymbolicLink(dir, link_dir));
- // Note that we are watching dir.lnk/file.
- ASSERT_TRUE(SetupWatch(linkfile, &watcher, delegate.get(), false));
-
- ASSERT_TRUE(base::CreateDirectory(dir));
- ASSERT_TRUE(WriteFile(file, "content"));
- VLOG(1) << "Waiting for dir/file creation";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file, "content v2"));
- VLOG(1) << "Waiting for file change";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(base::DeleteFile(file, false));
- VLOG(1) << "Waiting for file deletion";
- ASSERT_TRUE(WaitForEvents());
-}
-
-// Verify that watching a file with a symlink on the path
-// to the file works.
-TEST_F(FilePathWatcherTest, LinkedDirectoryPart3) {
- FilePathWatcher watcher;
- FilePath dir(temp_dir_.GetPath().AppendASCII("dir"));
- FilePath link_dir(temp_dir_.GetPath().AppendASCII("dir.lnk"));
- FilePath file(dir.AppendASCII("file"));
- FilePath linkfile(link_dir.AppendASCII("file"));
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(base::CreateDirectory(dir));
- ASSERT_TRUE(CreateSymbolicLink(dir, link_dir));
- // Note that we are watching dir.lnk/file but the file doesn't exist yet.
- ASSERT_TRUE(SetupWatch(linkfile, &watcher, delegate.get(), false));
-
- ASSERT_TRUE(WriteFile(file, "content"));
- VLOG(1) << "Waiting for file creation";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(WriteFile(file, "content v2"));
- VLOG(1) << "Waiting for file change";
- ASSERT_TRUE(WaitForEvents());
-
- ASSERT_TRUE(base::DeleteFile(file, false));
- VLOG(1) << "Waiting for file deletion";
- ASSERT_TRUE(WaitForEvents());
-}
-
-#endif // OS_LINUX
-
-enum Permission {
- Read,
- Write,
- Execute
-};
-
-#if defined(OS_MACOSX)
-bool ChangeFilePermissions(const FilePath& path, Permission perm, bool allow) {
- struct stat stat_buf;
-
- if (stat(path.value().c_str(), &stat_buf) != 0)
- return false;
-
- mode_t mode = 0;
- switch (perm) {
- case Read:
- mode = S_IRUSR | S_IRGRP | S_IROTH;
- break;
- case Write:
- mode = S_IWUSR | S_IWGRP | S_IWOTH;
- break;
- case Execute:
- mode = S_IXUSR | S_IXGRP | S_IXOTH;
- break;
- default:
- ADD_FAILURE() << "unknown perm " << perm;
- return false;
- }
- if (allow) {
- stat_buf.st_mode |= mode;
- } else {
- stat_buf.st_mode &= ~mode;
- }
- return chmod(path.value().c_str(), stat_buf.st_mode) == 0;
-}
-#endif // defined(OS_MACOSX)
-
-#if defined(OS_MACOSX)
-// Linux implementation of FilePathWatcher doesn't catch attribute changes.
-// http://crbug.com/78043
-// Windows implementation of FilePathWatcher catches attribute changes that
-// don't affect the path being watched.
-// http://crbug.com/78045
-
-// Verify that changing attributes on a directory works.
-TEST_F(FilePathWatcherTest, DirAttributesChanged) {
- FilePath test_dir1(
- temp_dir_.GetPath().AppendASCII("DirAttributesChangedDir1"));
- FilePath test_dir2(test_dir1.AppendASCII("DirAttributesChangedDir2"));
- FilePath test_file(test_dir2.AppendASCII("DirAttributesChangedFile"));
- // Setup a directory hierarchy.
- ASSERT_TRUE(base::CreateDirectory(test_dir1));
- ASSERT_TRUE(base::CreateDirectory(test_dir2));
- ASSERT_TRUE(WriteFile(test_file, "content"));
-
- FilePathWatcher watcher;
- std::unique_ptr<TestDelegate> delegate(new TestDelegate(collector()));
- ASSERT_TRUE(SetupWatch(test_file, &watcher, delegate.get(), false));
-
- // We should not get notified in this case as it hasn't affected our ability
- // to access the file.
- ASSERT_TRUE(ChangeFilePermissions(test_dir1, Read, false));
- loop_.task_runner()->PostDelayedTask(
- FROM_HERE, RunLoop::QuitCurrentWhenIdleClosureDeprecated(),
- TestTimeouts::tiny_timeout());
- ASSERT_FALSE(WaitForEvents());
- ASSERT_TRUE(ChangeFilePermissions(test_dir1, Read, true));
-
- // We should get notified in this case because filepathwatcher can no
- // longer access the file
- ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, false));
- ASSERT_TRUE(WaitForEvents());
- ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, true));
-}
-
-#endif // OS_MACOSX
-} // namespace
-
-} // namespace base
diff --git a/base/files/file_proxy_unittest.cc b/base/files/file_proxy_unittest.cc
deleted file mode 100644
index 73a0497..0000000
--- a/base/files/file_proxy_unittest.cc
+++ /dev/null
@@ -1,399 +0,0 @@
-// Copyright 2014 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 "base/files/file_proxy.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class FileProxyTest : public testing::Test {
- public:
- FileProxyTest()
- : file_thread_("FileProxyTestFileThread"),
- error_(File::FILE_OK),
- bytes_written_(-1),
- weak_factory_(this) {}
-
- void SetUp() override {
- ASSERT_TRUE(dir_.CreateUniqueTempDir());
- ASSERT_TRUE(file_thread_.Start());
- }
-
- void DidFinish(File::Error error) {
- error_ = error;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- void DidCreateOrOpen(File::Error error) {
- error_ = error;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- void DidCreateTemporary(File::Error error,
- const FilePath& path) {
- error_ = error;
- path_ = path;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- void DidGetFileInfo(File::Error error,
- const File::Info& file_info) {
- error_ = error;
- file_info_ = file_info;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- void DidRead(File::Error error,
- const char* data,
- int bytes_read) {
- error_ = error;
- buffer_.resize(bytes_read);
- memcpy(&buffer_[0], data, bytes_read);
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- void DidWrite(File::Error error,
- int bytes_written) {
- error_ = error;
- bytes_written_ = bytes_written;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- protected:
- void CreateProxy(uint32_t flags, FileProxy* proxy) {
- proxy->CreateOrOpen(
- TestPath(), flags,
- BindOnce(&FileProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_TRUE(proxy->IsValid());
- }
-
- TaskRunner* file_task_runner() const {
- return file_thread_.task_runner().get();
- }
- const FilePath& TestDirPath() const { return dir_.GetPath(); }
- const FilePath TestPath() const { return dir_.GetPath().AppendASCII("test"); }
-
- ScopedTempDir dir_;
- MessageLoopForIO message_loop_;
- Thread file_thread_;
-
- File::Error error_;
- FilePath path_;
- File::Info file_info_;
- std::vector<char> buffer_;
- int bytes_written_;
- WeakPtrFactory<FileProxyTest> weak_factory_;
-};
-
-TEST_F(FileProxyTest, CreateOrOpen_Create) {
- FileProxy proxy(file_task_runner());
- proxy.CreateOrOpen(
- TestPath(), File::FLAG_CREATE | File::FLAG_READ,
- BindOnce(&FileProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_TRUE(proxy.IsValid());
- EXPECT_TRUE(proxy.created());
- EXPECT_TRUE(PathExists(TestPath()));
-}
-
-TEST_F(FileProxyTest, CreateOrOpen_Open) {
- // Creates a file.
- base::WriteFile(TestPath(), nullptr, 0);
- ASSERT_TRUE(PathExists(TestPath()));
-
- // Opens the created file.
- FileProxy proxy(file_task_runner());
- proxy.CreateOrOpen(
- TestPath(), File::FLAG_OPEN | File::FLAG_READ,
- BindOnce(&FileProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_TRUE(proxy.IsValid());
- EXPECT_FALSE(proxy.created());
-}
-
-TEST_F(FileProxyTest, CreateOrOpen_OpenNonExistent) {
- FileProxy proxy(file_task_runner());
- proxy.CreateOrOpen(
- TestPath(), File::FLAG_OPEN | File::FLAG_READ,
- BindOnce(&FileProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_EQ(File::FILE_ERROR_NOT_FOUND, error_);
- EXPECT_FALSE(proxy.IsValid());
- EXPECT_FALSE(proxy.created());
- EXPECT_FALSE(PathExists(TestPath()));
-}
-
-TEST_F(FileProxyTest, CreateOrOpen_AbandonedCreate) {
- bool prev = ThreadRestrictions::SetIOAllowed(false);
- {
- FileProxy proxy(file_task_runner());
- proxy.CreateOrOpen(
- TestPath(), File::FLAG_CREATE | File::FLAG_READ,
- BindOnce(&FileProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr()));
- }
- RunLoop().Run();
- ThreadRestrictions::SetIOAllowed(prev);
-
- EXPECT_TRUE(PathExists(TestPath()));
-}
-
-TEST_F(FileProxyTest, Close) {
- // Creates a file.
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_CREATE | File::FLAG_WRITE, &proxy);
-
-#if defined(OS_WIN)
- // This fails on Windows if the file is not closed.
- EXPECT_FALSE(base::Move(TestPath(), TestDirPath().AppendASCII("new")));
-#endif
-
- proxy.Close(BindOnce(&FileProxyTest::DidFinish, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_FALSE(proxy.IsValid());
-
- // Now it should pass on all platforms.
- EXPECT_TRUE(base::Move(TestPath(), TestDirPath().AppendASCII("new")));
-}
-
-TEST_F(FileProxyTest, CreateTemporary) {
- {
- FileProxy proxy(file_task_runner());
- proxy.CreateTemporary(0 /* additional_file_flags */,
- BindOnce(&FileProxyTest::DidCreateTemporary,
- weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- EXPECT_TRUE(proxy.IsValid());
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_TRUE(PathExists(path_));
-
- // The file should be writable.
- proxy.Write(0, "test", 4,
- BindOnce(&FileProxyTest::DidWrite, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_EQ(4, bytes_written_);
- }
-
- // Make sure the written data can be read from the returned path.
- std::string data;
- EXPECT_TRUE(ReadFileToString(path_, &data));
- EXPECT_EQ("test", data);
-
- // Make sure we can & do delete the created file to prevent leaks on the bots.
- EXPECT_TRUE(base::DeleteFile(path_, false));
-}
-
-TEST_F(FileProxyTest, SetAndTake) {
- File file(TestPath(), File::FLAG_CREATE | File::FLAG_READ);
- ASSERT_TRUE(file.IsValid());
- FileProxy proxy(file_task_runner());
- EXPECT_FALSE(proxy.IsValid());
- proxy.SetFile(std::move(file));
- EXPECT_TRUE(proxy.IsValid());
- EXPECT_FALSE(file.IsValid());
-
- file = proxy.TakeFile();
- EXPECT_FALSE(proxy.IsValid());
- EXPECT_TRUE(file.IsValid());
-}
-
-TEST_F(FileProxyTest, DuplicateFile) {
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_CREATE | File::FLAG_WRITE, &proxy);
- ASSERT_TRUE(proxy.IsValid());
-
- base::File duplicate = proxy.DuplicateFile();
- EXPECT_TRUE(proxy.IsValid());
- EXPECT_TRUE(duplicate.IsValid());
-
- FileProxy invalid_proxy(file_task_runner());
- ASSERT_FALSE(invalid_proxy.IsValid());
-
- base::File invalid_duplicate = invalid_proxy.DuplicateFile();
- EXPECT_FALSE(invalid_proxy.IsValid());
- EXPECT_FALSE(invalid_duplicate.IsValid());
-}
-
-TEST_F(FileProxyTest, GetInfo) {
- // Setup.
- ASSERT_EQ(4, base::WriteFile(TestPath(), "test", 4));
- File::Info expected_info;
- GetFileInfo(TestPath(), &expected_info);
-
- // Run.
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_OPEN | File::FLAG_READ, &proxy);
- proxy.GetInfo(
- BindOnce(&FileProxyTest::DidGetFileInfo, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- // Verify.
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_EQ(expected_info.size, file_info_.size);
- EXPECT_EQ(expected_info.is_directory, file_info_.is_directory);
- EXPECT_EQ(expected_info.is_symbolic_link, file_info_.is_symbolic_link);
- EXPECT_EQ(expected_info.last_modified, file_info_.last_modified);
- EXPECT_EQ(expected_info.creation_time, file_info_.creation_time);
-}
-
-TEST_F(FileProxyTest, Read) {
- // Setup.
- const char expected_data[] = "bleh";
- int expected_bytes = arraysize(expected_data);
- ASSERT_EQ(expected_bytes,
- base::WriteFile(TestPath(), expected_data, expected_bytes));
-
- // Run.
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_OPEN | File::FLAG_READ, &proxy);
-
- proxy.Read(0, 128,
- BindOnce(&FileProxyTest::DidRead, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- // Verify.
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_EQ(expected_bytes, static_cast<int>(buffer_.size()));
- for (size_t i = 0; i < buffer_.size(); ++i) {
- EXPECT_EQ(expected_data[i], buffer_[i]);
- }
-}
-
-TEST_F(FileProxyTest, WriteAndFlush) {
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_CREATE | File::FLAG_WRITE, &proxy);
-
- const char data[] = "foo!";
- int data_bytes = arraysize(data);
- proxy.Write(0, data, data_bytes,
- BindOnce(&FileProxyTest::DidWrite, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_EQ(File::FILE_OK, error_);
- EXPECT_EQ(data_bytes, bytes_written_);
-
- // Flush the written data. (So that the following read should always
- // succeed. On some platforms it may work with or without this flush.)
- proxy.Flush(BindOnce(&FileProxyTest::DidFinish, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_EQ(File::FILE_OK, error_);
-
- // Verify the written data.
- char buffer[10];
- EXPECT_EQ(data_bytes, base::ReadFile(TestPath(), buffer, data_bytes));
- for (int i = 0; i < data_bytes; ++i) {
- EXPECT_EQ(data[i], buffer[i]);
- }
-}
-
-#if defined(OS_ANDROID)
-// Flaky on Android, see http://crbug.com/489602
-#define MAYBE_SetTimes DISABLED_SetTimes
-#else
-#define MAYBE_SetTimes SetTimes
-#endif
-TEST_F(FileProxyTest, MAYBE_SetTimes) {
- FileProxy proxy(file_task_runner());
- CreateProxy(
- File::FLAG_CREATE | File::FLAG_WRITE | File::FLAG_WRITE_ATTRIBUTES,
- &proxy);
-
- Time last_accessed_time = Time::Now() - TimeDelta::FromDays(12345);
- Time last_modified_time = Time::Now() - TimeDelta::FromHours(98765);
-
- proxy.SetTimes(
- last_accessed_time, last_modified_time,
- BindOnce(&FileProxyTest::DidFinish, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
- EXPECT_EQ(File::FILE_OK, error_);
-
- File::Info info;
- GetFileInfo(TestPath(), &info);
-
- // The returned values may only have the seconds precision, so we cast
- // the double values to int here.
- EXPECT_EQ(static_cast<int>(last_modified_time.ToDoubleT()),
- static_cast<int>(info.last_modified.ToDoubleT()));
- EXPECT_EQ(static_cast<int>(last_accessed_time.ToDoubleT()),
- static_cast<int>(info.last_accessed.ToDoubleT()));
-}
-
-TEST_F(FileProxyTest, SetLength_Shrink) {
- // Setup.
- const char kTestData[] = "0123456789";
- ASSERT_EQ(10, base::WriteFile(TestPath(), kTestData, 10));
- File::Info info;
- GetFileInfo(TestPath(), &info);
- ASSERT_EQ(10, info.size);
-
- // Run.
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_OPEN | File::FLAG_WRITE, &proxy);
- proxy.SetLength(
- 7, BindOnce(&FileProxyTest::DidFinish, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- // Verify.
- GetFileInfo(TestPath(), &info);
- ASSERT_EQ(7, info.size);
-
- char buffer[7];
- EXPECT_EQ(7, base::ReadFile(TestPath(), buffer, 7));
- int i = 0;
- for (; i < 7; ++i)
- EXPECT_EQ(kTestData[i], buffer[i]);
-}
-
-TEST_F(FileProxyTest, SetLength_Expand) {
- // Setup.
- const char kTestData[] = "9876543210";
- ASSERT_EQ(10, base::WriteFile(TestPath(), kTestData, 10));
- File::Info info;
- GetFileInfo(TestPath(), &info);
- ASSERT_EQ(10, info.size);
-
- // Run.
- FileProxy proxy(file_task_runner());
- CreateProxy(File::FLAG_OPEN | File::FLAG_WRITE, &proxy);
- proxy.SetLength(
- 53, BindOnce(&FileProxyTest::DidFinish, weak_factory_.GetWeakPtr()));
- RunLoop().Run();
-
- // Verify.
- GetFileInfo(TestPath(), &info);
- ASSERT_EQ(53, info.size);
-
- char buffer[53];
- EXPECT_EQ(53, base::ReadFile(TestPath(), buffer, 53));
- int i = 0;
- for (; i < 10; ++i)
- EXPECT_EQ(kTestData[i], buffer[i]);
- for (; i < 53; ++i)
- EXPECT_EQ(0, buffer[i]);
-}
-
-} // namespace base
diff --git a/base/files/file_unittest.cc b/base/files/file_unittest.cc
deleted file mode 100644
index b9992ad..0000000
--- a/base/files/file_unittest.cc
+++ /dev/null
@@ -1,721 +0,0 @@
-// 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.
-
-#include "base/files/file.h"
-
-#include <stdint.h>
-
-#include <utility>
-
-#include "base/files/file_util.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::File;
-using base::FilePath;
-
-TEST(FileTest, Create) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
-
- {
- // Don't create a File at all.
- File file;
- EXPECT_FALSE(file.IsValid());
- EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details());
-
- File file2(base::File::FILE_ERROR_TOO_MANY_OPENED);
- EXPECT_FALSE(file2.IsValid());
- EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details());
- }
-
- {
- // Open a file that doesn't exist.
- File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
- EXPECT_FALSE(file.IsValid());
- EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file.error_details());
- EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, base::File::GetLastFileError());
- }
-
- {
- // Open or create a file.
- File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
- EXPECT_TRUE(file.IsValid());
- EXPECT_TRUE(file.created());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
- }
-
- {
- // Open an existing file.
- File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
- EXPECT_TRUE(file.IsValid());
- EXPECT_FALSE(file.created());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
-
- // This time verify closing the file.
- file.Close();
- EXPECT_FALSE(file.IsValid());
- }
-
- {
- // Open an existing file through Initialize
- File file;
- file.Initialize(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
- EXPECT_TRUE(file.IsValid());
- EXPECT_FALSE(file.created());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
-
- // This time verify closing the file.
- file.Close();
- EXPECT_FALSE(file.IsValid());
- }
-
- {
- // Create a file that exists.
- File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_READ);
- EXPECT_FALSE(file.IsValid());
- EXPECT_FALSE(file.created());
- EXPECT_EQ(base::File::FILE_ERROR_EXISTS, file.error_details());
- EXPECT_EQ(base::File::FILE_ERROR_EXISTS, base::File::GetLastFileError());
- }
-
- {
- // Create or overwrite a file.
- File file(file_path,
- base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
- EXPECT_TRUE(file.IsValid());
- EXPECT_TRUE(file.created());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
- }
-
- {
- // Create a delete-on-close file.
- file_path = temp_dir.GetPath().AppendASCII("create_file_2");
- File file(file_path,
- base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
- base::File::FLAG_DELETE_ON_CLOSE);
- EXPECT_TRUE(file.IsValid());
- EXPECT_TRUE(file.created());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
- }
-
- EXPECT_FALSE(base::PathExists(file_path));
-}
-
-TEST(FileTest, SelfSwap) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
- File file(file_path,
- base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_DELETE_ON_CLOSE);
- std::swap(file, file);
- EXPECT_TRUE(file.IsValid());
-}
-
-TEST(FileTest, Async) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("create_file");
-
- {
- File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC);
- EXPECT_TRUE(file.IsValid());
- EXPECT_TRUE(file.async());
- }
-
- {
- File file(file_path, base::File::FLAG_OPEN_ALWAYS);
- EXPECT_TRUE(file.IsValid());
- EXPECT_FALSE(file.async());
- }
-}
-
-TEST(FileTest, DeleteOpenFile) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
-
- // Create a file.
- File file(file_path,
- base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
- base::File::FLAG_SHARE_DELETE);
- EXPECT_TRUE(file.IsValid());
- EXPECT_TRUE(file.created());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
-
- // Open an existing file and mark it as delete on close.
- File same_file(file_path,
- base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE |
- base::File::FLAG_READ);
- EXPECT_TRUE(file.IsValid());
- EXPECT_FALSE(same_file.created());
- EXPECT_EQ(base::File::FILE_OK, same_file.error_details());
-
- // Close both handles and check that the file is gone.
- file.Close();
- same_file.Close();
- EXPECT_FALSE(base::PathExists(file_path));
-}
-
-TEST(FileTest, ReadWrite) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("read_write_file");
- File file(file_path,
- base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE);
- ASSERT_TRUE(file.IsValid());
-
- char data_to_write[] = "test";
- const int kTestDataSize = 4;
-
- // Write 0 bytes to the file.
- int bytes_written = file.Write(0, data_to_write, 0);
- EXPECT_EQ(0, bytes_written);
-
- // Write 0 bytes, with buf=nullptr.
- bytes_written = file.Write(0, nullptr, 0);
- EXPECT_EQ(0, bytes_written);
-
- // Write "test" to the file.
- bytes_written = file.Write(0, data_to_write, kTestDataSize);
- EXPECT_EQ(kTestDataSize, bytes_written);
-
- // Read from EOF.
- char data_read_1[32];
- int bytes_read = file.Read(kTestDataSize, data_read_1, kTestDataSize);
- EXPECT_EQ(0, bytes_read);
-
- // Read from somewhere in the middle of the file.
- const int kPartialReadOffset = 1;
- bytes_read = file.Read(kPartialReadOffset, data_read_1, kTestDataSize);
- EXPECT_EQ(kTestDataSize - kPartialReadOffset, bytes_read);
- for (int i = 0; i < bytes_read; i++)
- EXPECT_EQ(data_to_write[i + kPartialReadOffset], data_read_1[i]);
-
- // Read 0 bytes.
- bytes_read = file.Read(0, data_read_1, 0);
- EXPECT_EQ(0, bytes_read);
-
- // Read the entire file.
- bytes_read = file.Read(0, data_read_1, kTestDataSize);
- EXPECT_EQ(kTestDataSize, bytes_read);
- for (int i = 0; i < bytes_read; i++)
- EXPECT_EQ(data_to_write[i], data_read_1[i]);
-
- // Read again, but using the trivial native wrapper.
- bytes_read = file.ReadNoBestEffort(0, data_read_1, kTestDataSize);
- EXPECT_LE(bytes_read, kTestDataSize);
- for (int i = 0; i < bytes_read; i++)
- EXPECT_EQ(data_to_write[i], data_read_1[i]);
-
- // Write past the end of the file.
- const int kOffsetBeyondEndOfFile = 10;
- const int kPartialWriteLength = 2;
- bytes_written = file.Write(kOffsetBeyondEndOfFile,
- data_to_write, kPartialWriteLength);
- EXPECT_EQ(kPartialWriteLength, bytes_written);
-
- // Make sure the file was extended.
- int64_t file_size = 0;
- EXPECT_TRUE(GetFileSize(file_path, &file_size));
- EXPECT_EQ(kOffsetBeyondEndOfFile + kPartialWriteLength, file_size);
-
- // Make sure the file was zero-padded.
- char data_read_2[32];
- bytes_read = file.Read(0, data_read_2, static_cast<int>(file_size));
- EXPECT_EQ(file_size, bytes_read);
- for (int i = 0; i < kTestDataSize; i++)
- EXPECT_EQ(data_to_write[i], data_read_2[i]);
- for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++)
- EXPECT_EQ(0, data_read_2[i]);
- for (int i = kOffsetBeyondEndOfFile; i < file_size; i++)
- EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]);
-}
-
-TEST(FileTest, GetLastFileError) {
-#if defined(OS_WIN)
- ::SetLastError(ERROR_ACCESS_DENIED);
-#else
- errno = EACCES;
-#endif
- EXPECT_EQ(File::FILE_ERROR_ACCESS_DENIED, File::GetLastFileError());
-
- base::ScopedTempDir temp_dir;
- EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
-
- FilePath nonexistent_path(temp_dir.GetPath().AppendASCII("nonexistent"));
- File file(nonexistent_path, File::FLAG_OPEN | File::FLAG_READ);
- File::Error last_error = File::GetLastFileError();
- EXPECT_FALSE(file.IsValid());
- EXPECT_EQ(File::FILE_ERROR_NOT_FOUND, file.error_details());
- EXPECT_EQ(File::FILE_ERROR_NOT_FOUND, last_error);
-}
-
-TEST(FileTest, Append) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("append_file");
- File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND);
- ASSERT_TRUE(file.IsValid());
-
- char data_to_write[] = "test";
- const int kTestDataSize = 4;
-
- // Write 0 bytes to the file.
- int bytes_written = file.Write(0, data_to_write, 0);
- EXPECT_EQ(0, bytes_written);
-
- // Write 0 bytes, with buf=nullptr.
- bytes_written = file.Write(0, nullptr, 0);
- EXPECT_EQ(0, bytes_written);
-
- // Write "test" to the file.
- bytes_written = file.Write(0, data_to_write, kTestDataSize);
- EXPECT_EQ(kTestDataSize, bytes_written);
-
- file.Close();
- File file2(file_path,
- base::File::FLAG_OPEN | base::File::FLAG_READ |
- base::File::FLAG_APPEND);
- ASSERT_TRUE(file2.IsValid());
-
- // Test passing the file around.
- file = std::move(file2);
- EXPECT_FALSE(file2.IsValid());
- ASSERT_TRUE(file.IsValid());
-
- char append_data_to_write[] = "78";
- const int kAppendDataSize = 2;
-
- // Append "78" to the file.
- bytes_written = file.Write(0, append_data_to_write, kAppendDataSize);
- EXPECT_EQ(kAppendDataSize, bytes_written);
-
- // Read the entire file.
- char data_read_1[32];
- int bytes_read = file.Read(0, data_read_1,
- kTestDataSize + kAppendDataSize);
- EXPECT_EQ(kTestDataSize + kAppendDataSize, bytes_read);
- for (int i = 0; i < kTestDataSize; i++)
- EXPECT_EQ(data_to_write[i], data_read_1[i]);
- for (int i = 0; i < kAppendDataSize; i++)
- EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]);
-}
-
-
-TEST(FileTest, Length) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("truncate_file");
- File file(file_path,
- base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE);
- ASSERT_TRUE(file.IsValid());
- EXPECT_EQ(0, file.GetLength());
-
- // Write "test" to the file.
- char data_to_write[] = "test";
- int kTestDataSize = 4;
- int bytes_written = file.Write(0, data_to_write, kTestDataSize);
- EXPECT_EQ(kTestDataSize, bytes_written);
-
- // Extend the file.
- const int kExtendedFileLength = 10;
- int64_t file_size = 0;
- EXPECT_TRUE(file.SetLength(kExtendedFileLength));
- EXPECT_EQ(kExtendedFileLength, file.GetLength());
- EXPECT_TRUE(GetFileSize(file_path, &file_size));
- EXPECT_EQ(kExtendedFileLength, file_size);
-
- // Make sure the file was zero-padded.
- char data_read[32];
- int bytes_read = file.Read(0, data_read, static_cast<int>(file_size));
- EXPECT_EQ(file_size, bytes_read);
- for (int i = 0; i < kTestDataSize; i++)
- EXPECT_EQ(data_to_write[i], data_read[i]);
- for (int i = kTestDataSize; i < file_size; i++)
- EXPECT_EQ(0, data_read[i]);
-
- // Truncate the file.
- const int kTruncatedFileLength = 2;
- EXPECT_TRUE(file.SetLength(kTruncatedFileLength));
- EXPECT_EQ(kTruncatedFileLength, file.GetLength());
- EXPECT_TRUE(GetFileSize(file_path, &file_size));
- EXPECT_EQ(kTruncatedFileLength, file_size);
-
- // Make sure the file was truncated.
- bytes_read = file.Read(0, data_read, kTestDataSize);
- EXPECT_EQ(file_size, bytes_read);
- for (int i = 0; i < file_size; i++)
- EXPECT_EQ(data_to_write[i], data_read[i]);
-
- // Close the file and reopen with base::File::FLAG_CREATE_ALWAYS, and make
- // sure the file is empty (old file was overridden).
- file.Close();
- file.Initialize(file_path,
- base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
- EXPECT_EQ(0, file.GetLength());
-}
-
-// Flakily fails: http://crbug.com/86494
-#if defined(OS_ANDROID)
-TEST(FileTest, TouchGetInfo) {
-#else
-TEST(FileTest, DISABLED_TouchGetInfo) {
-#endif
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- File file(temp_dir.GetPath().AppendASCII("touch_get_info_file"),
- base::File::FLAG_CREATE | base::File::FLAG_WRITE |
- base::File::FLAG_WRITE_ATTRIBUTES);
- ASSERT_TRUE(file.IsValid());
-
- // Get info for a newly created file.
- base::File::Info info;
- EXPECT_TRUE(file.GetInfo(&info));
-
- // Add 2 seconds to account for possible rounding errors on
- // filesystems that use a 1s or 2s timestamp granularity.
- base::Time now = base::Time::Now() + base::TimeDelta::FromSeconds(2);
- EXPECT_EQ(0, info.size);
- EXPECT_FALSE(info.is_directory);
- EXPECT_FALSE(info.is_symbolic_link);
- EXPECT_LE(info.last_accessed.ToInternalValue(), now.ToInternalValue());
- EXPECT_LE(info.last_modified.ToInternalValue(), now.ToInternalValue());
- EXPECT_LE(info.creation_time.ToInternalValue(), now.ToInternalValue());
- base::Time creation_time = info.creation_time;
-
- // Write "test" to the file.
- char data[] = "test";
- const int kTestDataSize = 4;
- int bytes_written = file.Write(0, data, kTestDataSize);
- EXPECT_EQ(kTestDataSize, bytes_written);
-
- // Change the last_accessed and last_modified dates.
- // It's best to add values that are multiples of 2 (in seconds)
- // to the current last_accessed and last_modified times, because
- // FATxx uses a 2s timestamp granularity.
- base::Time new_last_accessed =
- info.last_accessed + base::TimeDelta::FromSeconds(234);
- base::Time new_last_modified =
- info.last_modified + base::TimeDelta::FromMinutes(567);
-
- EXPECT_TRUE(file.SetTimes(new_last_accessed, new_last_modified));
-
- // Make sure the file info was updated accordingly.
- EXPECT_TRUE(file.GetInfo(&info));
- EXPECT_EQ(info.size, kTestDataSize);
- EXPECT_FALSE(info.is_directory);
- EXPECT_FALSE(info.is_symbolic_link);
-
- // ext2/ext3 and HPS/HPS+ seem to have a timestamp granularity of 1s.
-#if defined(OS_POSIX)
- EXPECT_EQ(info.last_accessed.ToTimeVal().tv_sec,
- new_last_accessed.ToTimeVal().tv_sec);
- EXPECT_EQ(info.last_modified.ToTimeVal().tv_sec,
- new_last_modified.ToTimeVal().tv_sec);
-#else
- EXPECT_EQ(info.last_accessed.ToInternalValue(),
- new_last_accessed.ToInternalValue());
- EXPECT_EQ(info.last_modified.ToInternalValue(),
- new_last_modified.ToInternalValue());
-#endif
-
- EXPECT_EQ(info.creation_time.ToInternalValue(),
- creation_time.ToInternalValue());
-}
-
-TEST(FileTest, ReadAtCurrentPosition) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path =
- temp_dir.GetPath().AppendASCII("read_at_current_position");
- File file(file_path,
- base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE);
- EXPECT_TRUE(file.IsValid());
-
- const char kData[] = "test";
- const int kDataSize = sizeof(kData) - 1;
- EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize));
-
- EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0));
-
- char buffer[kDataSize];
- int first_chunk_size = kDataSize / 2;
- EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size));
- EXPECT_EQ(kDataSize - first_chunk_size,
- file.ReadAtCurrentPos(buffer + first_chunk_size,
- kDataSize - first_chunk_size));
- EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
-}
-
-TEST(FileTest, WriteAtCurrentPosition) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path =
- temp_dir.GetPath().AppendASCII("write_at_current_position");
- File file(file_path,
- base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE);
- EXPECT_TRUE(file.IsValid());
-
- const char kData[] = "test";
- const int kDataSize = sizeof(kData) - 1;
-
- int first_chunk_size = kDataSize / 2;
- EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size));
- EXPECT_EQ(kDataSize - first_chunk_size,
- file.WriteAtCurrentPos(kData + first_chunk_size,
- kDataSize - first_chunk_size));
-
- char buffer[kDataSize];
- EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize));
- EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
-}
-
-TEST(FileTest, Seek) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("seek_file");
- File file(file_path,
- base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE);
- ASSERT_TRUE(file.IsValid());
-
- const int64_t kOffset = 10;
- EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset));
- EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset));
- EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset));
- EXPECT_TRUE(file.SetLength(kOffset * 2));
- EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset));
-}
-
-TEST(FileTest, Duplicate) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
- File file(file_path,(base::File::FLAG_CREATE |
- base::File::FLAG_READ |
- base::File::FLAG_WRITE));
- ASSERT_TRUE(file.IsValid());
-
- File file2(file.Duplicate());
- ASSERT_TRUE(file2.IsValid());
-
- // Write through one handle, close it, read through the other.
- static const char kData[] = "now is a good time.";
- static const int kDataLen = sizeof(kData) - 1;
-
- ASSERT_EQ(0, file.Seek(base::File::FROM_CURRENT, 0));
- ASSERT_EQ(0, file2.Seek(base::File::FROM_CURRENT, 0));
- ASSERT_EQ(kDataLen, file.WriteAtCurrentPos(kData, kDataLen));
- ASSERT_EQ(kDataLen, file.Seek(base::File::FROM_CURRENT, 0));
- ASSERT_EQ(kDataLen, file2.Seek(base::File::FROM_CURRENT, 0));
- file.Close();
- char buf[kDataLen];
- ASSERT_EQ(kDataLen, file2.Read(0, &buf[0], kDataLen));
- ASSERT_EQ(std::string(kData, kDataLen), std::string(&buf[0], kDataLen));
-}
-
-TEST(FileTest, DuplicateDeleteOnClose) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
- File file(file_path,(base::File::FLAG_CREATE |
- base::File::FLAG_READ |
- base::File::FLAG_WRITE |
- base::File::FLAG_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
- File file2(file.Duplicate());
- ASSERT_TRUE(file2.IsValid());
- file.Close();
- file2.Close();
- ASSERT_FALSE(base::PathExists(file_path));
-}
-
-#if defined(OS_WIN)
-TEST(FileTest, GetInfoForDirectory) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath empty_dir =
- temp_dir.GetPath().Append(FILE_PATH_LITERAL("gpfi_test"));
- ASSERT_TRUE(CreateDirectory(empty_dir));
-
- base::File dir(
- ::CreateFile(empty_dir.value().c_str(),
- GENERIC_READ | GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- NULL,
- OPEN_EXISTING,
- FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
- NULL));
- ASSERT_TRUE(dir.IsValid());
-
- base::File::Info info;
- EXPECT_TRUE(dir.GetInfo(&info));
- EXPECT_TRUE(info.is_directory);
- EXPECT_FALSE(info.is_symbolic_link);
- EXPECT_EQ(0, info.size);
-}
-
-TEST(FileTest, DeleteNoop) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // Creating and closing a file with DELETE perms should do nothing special.
- File file(file_path,
- (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
- file.Close();
- ASSERT_TRUE(base::PathExists(file_path));
-}
-
-TEST(FileTest, Delete) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // Creating a file with DELETE and then marking for delete on close should
- // delete it.
- File file(file_path,
- (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
- ASSERT_TRUE(file.DeleteOnClose(true));
- file.Close();
- ASSERT_FALSE(base::PathExists(file_path));
-}
-
-TEST(FileTest, DeleteThenRevoke) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // Creating a file with DELETE, marking it for delete, then clearing delete on
- // close should not delete it.
- File file(file_path,
- (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
- ASSERT_TRUE(file.DeleteOnClose(true));
- ASSERT_TRUE(file.DeleteOnClose(false));
- file.Close();
- ASSERT_TRUE(base::PathExists(file_path));
-}
-
-TEST(FileTest, IrrevokableDeleteOnClose) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // DELETE_ON_CLOSE cannot be revoked by this opener.
- File file(
- file_path,
- (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE | base::File::FLAG_DELETE_ON_CLOSE |
- base::File::FLAG_SHARE_DELETE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
- // https://msdn.microsoft.com/library/windows/desktop/aa364221.aspx says that
- // setting the dispositon has no effect if the handle was opened with
- // FLAG_DELETE_ON_CLOSE. Do not make the test's success dependent on whether
- // or not SetFileInformationByHandle indicates success or failure. (It happens
- // to indicate success on Windows 10.)
- file.DeleteOnClose(false);
- file.Close();
- ASSERT_FALSE(base::PathExists(file_path));
-}
-
-TEST(FileTest, IrrevokableDeleteOnCloseOther) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // DELETE_ON_CLOSE cannot be revoked by another opener.
- File file(
- file_path,
- (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE | base::File::FLAG_DELETE_ON_CLOSE |
- base::File::FLAG_SHARE_DELETE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
-
- File file2(
- file_path,
- (base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE |
- base::File::FLAG_SHARE_DELETE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file2.IsValid());
-
- file2.DeleteOnClose(false);
- file2.Close();
- ASSERT_TRUE(base::PathExists(file_path));
- file.Close();
- ASSERT_FALSE(base::PathExists(file_path));
-}
-
-TEST(FileTest, DeleteWithoutPermission) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // It should not be possible to mark a file for deletion when it was not
- // created/opened with DELETE.
- File file(file_path, (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE));
- ASSERT_TRUE(file.IsValid());
- ASSERT_FALSE(file.DeleteOnClose(true));
- file.Close();
- ASSERT_TRUE(base::PathExists(file_path));
-}
-
-TEST(FileTest, UnsharedDeleteOnClose) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // Opening with DELETE_ON_CLOSE when a previous opener hasn't enabled sharing
- // will fail.
- File file(file_path, (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE));
- ASSERT_TRUE(file.IsValid());
- File file2(
- file_path,
- (base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE |
- base::File::FLAG_DELETE_ON_CLOSE | base::File::FLAG_SHARE_DELETE));
- ASSERT_FALSE(file2.IsValid());
-
- file.Close();
- ASSERT_TRUE(base::PathExists(file_path));
-}
-
-TEST(FileTest, NoDeleteOnCloseWithMappedFile) {
- base::ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("file");
-
- // Mapping a file into memory blocks DeleteOnClose.
- File file(file_path,
- (base::File::FLAG_CREATE | base::File::FLAG_READ |
- base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
- ASSERT_TRUE(file.IsValid());
- ASSERT_EQ(5, file.WriteAtCurrentPos("12345", 5));
-
- {
- base::MemoryMappedFile mapping;
- ASSERT_TRUE(mapping.Initialize(file.Duplicate()));
- ASSERT_EQ(5U, mapping.length());
-
- EXPECT_FALSE(file.DeleteOnClose(true));
- }
-
- file.Close();
- ASSERT_TRUE(base::PathExists(file_path));
-}
-#endif // defined(OS_WIN)
diff --git a/base/files/file_util_unittest.cc b/base/files/file_util_unittest.cc
deleted file mode 100644
index b4de085..0000000
--- a/base/files/file_util_unittest.cc
+++ /dev/null
@@ -1,3683 +0,0 @@
-// 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.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <fstream>
-#include <initializer_list>
-#include <memory>
-#include <set>
-#include <utility>
-#include <vector>
-
-#include "base/base_paths.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback_helpers.h"
-#include "base/command_line.h"
-#include "base/environment.h"
-#include "base/files/file.h"
-#include "base/files/file_enumerator.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/macros.h"
-#include "base/path_service.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/scoped_environment_variable_override.h"
-#include "base/test/test_file_util.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-#include "testing/platform_test.h"
-
-#if defined(OS_WIN)
-#include <shellapi.h>
-#include <shlobj.h>
-#include <tchar.h>
-#include <windows.h>
-#include <winioctl.h>
-#include "base/strings/string_number_conversions.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/win_util.h"
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-
-#if defined(OS_LINUX)
-#include <linux/fs.h>
-#endif
-
-#if defined(OS_ANDROID)
-#include "base/android/content_uri_utils.h"
-#endif
-
-// This macro helps avoid wrapped lines in the test structs.
-#define FPL(x) FILE_PATH_LITERAL(x)
-
-namespace base {
-
-namespace {
-
-const size_t kLargeFileSize = (1 << 16) + 3;
-
-// To test that NormalizeFilePath() deals with NTFS reparse points correctly,
-// we need functions to create and delete reparse points.
-#if defined(OS_WIN)
-typedef struct _REPARSE_DATA_BUFFER {
- ULONG ReparseTag;
- USHORT ReparseDataLength;
- USHORT Reserved;
- union {
- struct {
- USHORT SubstituteNameOffset;
- USHORT SubstituteNameLength;
- USHORT PrintNameOffset;
- USHORT PrintNameLength;
- ULONG Flags;
- WCHAR PathBuffer[1];
- } SymbolicLinkReparseBuffer;
- struct {
- USHORT SubstituteNameOffset;
- USHORT SubstituteNameLength;
- USHORT PrintNameOffset;
- USHORT PrintNameLength;
- WCHAR PathBuffer[1];
- } MountPointReparseBuffer;
- struct {
- UCHAR DataBuffer[1];
- } GenericReparseBuffer;
- };
-} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
-
-// Sets a reparse point. |source| will now point to |target|. Returns true if
-// the call succeeds, false otherwise.
-bool SetReparsePoint(HANDLE source, const FilePath& target_path) {
- std::wstring kPathPrefix = L"\\??\\";
- std::wstring target_str;
- // The juction will not work if the target path does not start with \??\ .
- if (kPathPrefix != target_path.value().substr(0, kPathPrefix.size()))
- target_str += kPathPrefix;
- target_str += target_path.value();
- const wchar_t* target = target_str.c_str();
- USHORT size_target = static_cast<USHORT>(wcslen(target)) * sizeof(target[0]);
- char buffer[2000] = {0};
- DWORD returned;
-
- REPARSE_DATA_BUFFER* data = reinterpret_cast<REPARSE_DATA_BUFFER*>(buffer);
-
- data->ReparseTag = 0xa0000003;
- memcpy(data->MountPointReparseBuffer.PathBuffer, target, size_target + 2);
-
- data->MountPointReparseBuffer.SubstituteNameLength = size_target;
- data->MountPointReparseBuffer.PrintNameOffset = size_target + 2;
- data->ReparseDataLength = size_target + 4 + 8;
-
- int data_size = data->ReparseDataLength + 8;
-
- if (!DeviceIoControl(source, FSCTL_SET_REPARSE_POINT, &buffer, data_size,
- NULL, 0, &returned, NULL)) {
- return false;
- }
- return true;
-}
-
-// Delete the reparse point referenced by |source|. Returns true if the call
-// succeeds, false otherwise.
-bool DeleteReparsePoint(HANDLE source) {
- DWORD returned;
- REPARSE_DATA_BUFFER data = {0};
- data.ReparseTag = 0xa0000003;
- if (!DeviceIoControl(source, FSCTL_DELETE_REPARSE_POINT, &data, 8, NULL, 0,
- &returned, NULL)) {
- return false;
- }
- return true;
-}
-
-// Manages a reparse point for a test.
-class ReparsePoint {
- public:
- // Creates a reparse point from |source| (an empty directory) to |target|.
- ReparsePoint(const FilePath& source, const FilePath& target) {
- dir_.Set(
- ::CreateFile(source.value().c_str(),
- GENERIC_READ | GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- NULL,
- OPEN_EXISTING,
- FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
- NULL));
- created_ = dir_.IsValid() && SetReparsePoint(dir_.Get(), target);
- }
-
- ~ReparsePoint() {
- if (created_)
- DeleteReparsePoint(dir_.Get());
- }
-
- bool IsValid() { return created_; }
-
- private:
- win::ScopedHandle dir_;
- bool created_;
- DISALLOW_COPY_AND_ASSIGN(ReparsePoint);
-};
-
-#endif
-
-// Fuchsia doesn't support file permissions.
-#if !defined(OS_FUCHSIA)
-#if defined(OS_POSIX)
-// Provide a simple way to change the permissions bits on |path| in tests.
-// ASSERT failures will return, but not stop the test. Caller should wrap
-// calls to this function in ASSERT_NO_FATAL_FAILURE().
-void ChangePosixFilePermissions(const FilePath& path,
- int mode_bits_to_set,
- int mode_bits_to_clear) {
- ASSERT_FALSE(mode_bits_to_set & mode_bits_to_clear)
- << "Can't set and clear the same bits.";
-
- int mode = 0;
- ASSERT_TRUE(GetPosixFilePermissions(path, &mode));
- mode |= mode_bits_to_set;
- mode &= ~mode_bits_to_clear;
- ASSERT_TRUE(SetPosixFilePermissions(path, mode));
-}
-#endif // defined(OS_POSIX)
-
-// Sets the source file to read-only.
-void SetReadOnly(const FilePath& path, bool read_only) {
-#if defined(OS_WIN)
- // On Windows, it involves setting/removing the 'readonly' bit.
- DWORD attrs = GetFileAttributes(path.value().c_str());
- ASSERT_NE(INVALID_FILE_ATTRIBUTES, attrs);
- ASSERT_TRUE(SetFileAttributes(
- path.value().c_str(), read_only ? (attrs | FILE_ATTRIBUTE_READONLY)
- : (attrs & ~FILE_ATTRIBUTE_READONLY)));
-
- DWORD expected =
- read_only
- ? ((attrs & (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DIRECTORY)) |
- FILE_ATTRIBUTE_READONLY)
- : (attrs & (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DIRECTORY));
-
- // Ignore FILE_ATTRIBUTE_NOT_CONTENT_INDEXED if present.
- attrs = GetFileAttributes(path.value().c_str()) &
- ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
- ASSERT_EQ(expected, attrs);
-#else
- // On all other platforms, it involves removing/setting the write bit.
- mode_t mode = read_only ? S_IRUSR : (S_IRUSR | S_IWUSR);
- EXPECT_TRUE(SetPosixFilePermissions(
- path, DirectoryExists(path) ? (mode | S_IXUSR) : mode));
-#endif // defined(OS_WIN)
-}
-
-bool IsReadOnly(const FilePath& path) {
-#if defined(OS_WIN)
- DWORD attrs = GetFileAttributes(path.value().c_str());
- EXPECT_NE(INVALID_FILE_ATTRIBUTES, attrs);
- return attrs & FILE_ATTRIBUTE_READONLY;
-#else
- int mode = 0;
- EXPECT_TRUE(GetPosixFilePermissions(path, &mode));
- return !(mode & S_IWUSR);
-#endif // defined(OS_WIN)
-}
-
-#endif // defined(OS_FUCHSIA)
-
-const wchar_t bogus_content[] = L"I'm cannon fodder.";
-
-const int FILES_AND_DIRECTORIES =
- FileEnumerator::FILES | FileEnumerator::DIRECTORIES;
-
-// file_util winds up using autoreleased objects on the Mac, so this needs
-// to be a PlatformTest
-class FileUtilTest : public PlatformTest {
- protected:
- void SetUp() override {
- PlatformTest::SetUp();
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- }
-
- ScopedTempDir temp_dir_;
-};
-
-// Collects all the results from the given file enumerator, and provides an
-// interface to query whether a given file is present.
-class FindResultCollector {
- public:
- explicit FindResultCollector(FileEnumerator* enumerator) {
- FilePath cur_file;
- while (!(cur_file = enumerator->Next()).value().empty()) {
- FilePath::StringType path = cur_file.value();
- // The file should not be returned twice.
- EXPECT_TRUE(files_.end() == files_.find(path))
- << "Same file returned twice";
-
- // Save for later.
- files_.insert(path);
- }
- }
-
- // Returns true if the enumerator found the file.
- bool HasFile(const FilePath& file) const {
- return files_.find(file.value()) != files_.end();
- }
-
- int size() {
- return static_cast<int>(files_.size());
- }
-
- private:
- std::set<FilePath::StringType> files_;
-};
-
-// Simple function to dump some text into a new file.
-void CreateTextFile(const FilePath& filename,
- const std::wstring& contents) {
- std::wofstream file;
- file.open(filename.value().c_str());
- ASSERT_TRUE(file.is_open());
- file << contents;
- file.close();
-}
-
-// Simple function to take out some text from a file.
-std::wstring ReadTextFile(const FilePath& filename) {
- wchar_t contents[64];
- std::wifstream file;
- file.open(filename.value().c_str());
- EXPECT_TRUE(file.is_open());
- file.getline(contents, arraysize(contents));
- file.close();
- return std::wstring(contents);
-}
-
-// Sets |is_inheritable| to indicate whether or not |stream| is set up to be
-// inerhited into child processes (i.e., HANDLE_FLAG_INHERIT is set on the
-// underlying handle on Windows, or FD_CLOEXEC is not set on the underlying file
-// descriptor on POSIX). Calls to this function must be wrapped with
-// ASSERT_NO_FATAL_FAILURE to properly abort tests in case of fatal failure.
-void GetIsInheritable(FILE* stream, bool* is_inheritable) {
-#if defined(OS_WIN)
- HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(stream)));
- ASSERT_NE(INVALID_HANDLE_VALUE, handle);
-
- DWORD info = 0;
- ASSERT_EQ(TRUE, ::GetHandleInformation(handle, &info));
- *is_inheritable = ((info & HANDLE_FLAG_INHERIT) != 0);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- int fd = fileno(stream);
- ASSERT_NE(-1, fd);
- int flags = fcntl(fd, F_GETFD, 0);
- ASSERT_NE(-1, flags);
- *is_inheritable = ((flags & FD_CLOEXEC) == 0);
-#else
-#error Not implemented
-#endif
-}
-
-TEST_F(FileUtilTest, FileAndDirectorySize) {
- // Create three files of 20, 30 and 3 chars (utf8). ComputeDirectorySize
- // should return 53 bytes.
- FilePath file_01 = temp_dir_.GetPath().Append(FPL("The file 01.txt"));
- CreateTextFile(file_01, L"12345678901234567890");
- int64_t size_f1 = 0;
- ASSERT_TRUE(GetFileSize(file_01, &size_f1));
- EXPECT_EQ(20ll, size_f1);
-
- FilePath subdir_path = temp_dir_.GetPath().Append(FPL("Level2"));
- CreateDirectory(subdir_path);
-
- FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
- CreateTextFile(file_02, L"123456789012345678901234567890");
- int64_t size_f2 = 0;
- ASSERT_TRUE(GetFileSize(file_02, &size_f2));
- EXPECT_EQ(30ll, size_f2);
-
- FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
- CreateDirectory(subsubdir_path);
-
- FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
- CreateTextFile(file_03, L"123");
-
- int64_t computed_size = ComputeDirectorySize(temp_dir_.GetPath());
- EXPECT_EQ(size_f1 + size_f2 + 3, computed_size);
-}
-
-TEST_F(FileUtilTest, NormalizeFilePathBasic) {
- // Create a directory under the test dir. Because we create it,
- // we know it is not a link.
- FilePath file_a_path = temp_dir_.GetPath().Append(FPL("file_a"));
- FilePath dir_path = temp_dir_.GetPath().Append(FPL("dir"));
- FilePath file_b_path = dir_path.Append(FPL("file_b"));
- CreateDirectory(dir_path);
-
- FilePath normalized_file_a_path, normalized_file_b_path;
- ASSERT_FALSE(PathExists(file_a_path));
- ASSERT_FALSE(NormalizeFilePath(file_a_path, &normalized_file_a_path))
- << "NormalizeFilePath() should fail on nonexistent paths.";
-
- CreateTextFile(file_a_path, bogus_content);
- ASSERT_TRUE(PathExists(file_a_path));
- ASSERT_TRUE(NormalizeFilePath(file_a_path, &normalized_file_a_path));
-
- CreateTextFile(file_b_path, bogus_content);
- ASSERT_TRUE(PathExists(file_b_path));
- ASSERT_TRUE(NormalizeFilePath(file_b_path, &normalized_file_b_path));
-
- // Beacuse this test created |dir_path|, we know it is not a link
- // or junction. So, the real path of the directory holding file a
- // must be the parent of the path holding file b.
- ASSERT_TRUE(normalized_file_a_path.DirName()
- .IsParent(normalized_file_b_path.DirName()));
-}
-
-#if defined(OS_WIN)
-
-TEST_F(FileUtilTest, NormalizeFilePathReparsePoints) {
- // Build the following directory structure:
- //
- // temp_dir
- // |-> base_a
- // | |-> sub_a
- // | |-> file.txt
- // | |-> long_name___... (Very long name.)
- // | |-> sub_long
- // | |-> deep.txt
- // |-> base_b
- // |-> to_sub_a (reparse point to temp_dir\base_a\sub_a)
- // |-> to_base_b (reparse point to temp_dir\base_b)
- // |-> to_sub_long (reparse point to temp_dir\sub_a\long_name_\sub_long)
-
- FilePath base_a = temp_dir_.GetPath().Append(FPL("base_a"));
-#if defined(OS_WIN)
- // TEMP can have a lower case drive letter.
- string16 temp_base_a = base_a.value();
- ASSERT_FALSE(temp_base_a.empty());
- *temp_base_a.begin() = ToUpperASCII(*temp_base_a.begin());
- base_a = FilePath(temp_base_a);
-#endif
- ASSERT_TRUE(CreateDirectory(base_a));
-
- FilePath sub_a = base_a.Append(FPL("sub_a"));
- ASSERT_TRUE(CreateDirectory(sub_a));
-
- FilePath file_txt = sub_a.Append(FPL("file.txt"));
- CreateTextFile(file_txt, bogus_content);
-
- // Want a directory whose name is long enough to make the path to the file
- // inside just under MAX_PATH chars. This will be used to test that when
- // a junction expands to a path over MAX_PATH chars in length,
- // NormalizeFilePath() fails without crashing.
- FilePath sub_long_rel(FPL("sub_long"));
- FilePath deep_txt(FPL("deep.txt"));
-
- int target_length = MAX_PATH;
- target_length -= (sub_a.value().length() + 1); // +1 for the sepperator '\'.
- target_length -= (sub_long_rel.Append(deep_txt).value().length() + 1);
- // Without making the path a bit shorter, CreateDirectory() fails.
- // the resulting path is still long enough to hit the failing case in
- // NormalizePath().
- const int kCreateDirLimit = 4;
- target_length -= kCreateDirLimit;
- FilePath::StringType long_name_str = FPL("long_name_");
- long_name_str.resize(target_length, '_');
-
- FilePath long_name = sub_a.Append(FilePath(long_name_str));
- FilePath deep_file = long_name.Append(sub_long_rel).Append(deep_txt);
- ASSERT_EQ(static_cast<size_t>(MAX_PATH - kCreateDirLimit),
- deep_file.value().length());
-
- FilePath sub_long = deep_file.DirName();
- ASSERT_TRUE(CreateDirectory(sub_long));
- CreateTextFile(deep_file, bogus_content);
-
- FilePath base_b = temp_dir_.GetPath().Append(FPL("base_b"));
- ASSERT_TRUE(CreateDirectory(base_b));
-
- FilePath to_sub_a = base_b.Append(FPL("to_sub_a"));
- ASSERT_TRUE(CreateDirectory(to_sub_a));
- FilePath normalized_path;
- {
- ReparsePoint reparse_to_sub_a(to_sub_a, sub_a);
- ASSERT_TRUE(reparse_to_sub_a.IsValid());
-
- FilePath to_base_b = base_b.Append(FPL("to_base_b"));
- ASSERT_TRUE(CreateDirectory(to_base_b));
- ReparsePoint reparse_to_base_b(to_base_b, base_b);
- ASSERT_TRUE(reparse_to_base_b.IsValid());
-
- FilePath to_sub_long = base_b.Append(FPL("to_sub_long"));
- ASSERT_TRUE(CreateDirectory(to_sub_long));
- ReparsePoint reparse_to_sub_long(to_sub_long, sub_long);
- ASSERT_TRUE(reparse_to_sub_long.IsValid());
-
- // Normalize a junction free path: base_a\sub_a\file.txt .
- ASSERT_TRUE(NormalizeFilePath(file_txt, &normalized_path));
- ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
-
- // Check that the path base_b\to_sub_a\file.txt can be normalized to exclude
- // the junction to_sub_a.
- ASSERT_TRUE(NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
- &normalized_path));
- ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
-
- // Check that the path base_b\to_base_b\to_base_b\to_sub_a\file.txt can be
- // normalized to exclude junctions to_base_b and to_sub_a .
- ASSERT_TRUE(NormalizeFilePath(base_b.Append(FPL("to_base_b"))
- .Append(FPL("to_base_b"))
- .Append(FPL("to_sub_a"))
- .Append(FPL("file.txt")),
- &normalized_path));
- ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
-
- // A long enough path will cause NormalizeFilePath() to fail. Make a long
- // path using to_base_b many times, and check that paths long enough to fail
- // do not cause a crash.
- FilePath long_path = base_b;
- const int kLengthLimit = MAX_PATH + 200;
- while (long_path.value().length() <= kLengthLimit) {
- long_path = long_path.Append(FPL("to_base_b"));
- }
- long_path = long_path.Append(FPL("to_sub_a"))
- .Append(FPL("file.txt"));
-
- ASSERT_FALSE(NormalizeFilePath(long_path, &normalized_path));
-
- // Normalizing the junction to deep.txt should fail, because the expanded
- // path to deep.txt is longer than MAX_PATH.
- ASSERT_FALSE(NormalizeFilePath(to_sub_long.Append(deep_txt),
- &normalized_path));
-
- // Delete the reparse points, and see that NormalizeFilePath() fails
- // to traverse them.
- }
-
- ASSERT_FALSE(NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
- &normalized_path));
-}
-
-TEST_F(FileUtilTest, DevicePathToDriveLetter) {
- // Get a drive letter.
- string16 real_drive_letter =
- ToUpperASCII(temp_dir_.GetPath().value().substr(0, 2));
- if (!isalpha(real_drive_letter[0]) || ':' != real_drive_letter[1]) {
- LOG(ERROR) << "Can't get a drive letter to test with.";
- return;
- }
-
- // Get the NT style path to that drive.
- wchar_t device_path[MAX_PATH] = {'\0'};
- ASSERT_TRUE(
- ::QueryDosDevice(real_drive_letter.c_str(), device_path, MAX_PATH));
- FilePath actual_device_path(device_path);
- FilePath win32_path;
-
- // Run DevicePathToDriveLetterPath() on the NT style path we got from
- // QueryDosDevice(). Expect the drive letter we started with.
- ASSERT_TRUE(DevicePathToDriveLetterPath(actual_device_path, &win32_path));
- ASSERT_EQ(real_drive_letter, win32_path.value());
-
- // Add some directories to the path. Expect those extra path componenets
- // to be preserved.
- FilePath kRelativePath(FPL("dir1\\dir2\\file.txt"));
- ASSERT_TRUE(DevicePathToDriveLetterPath(
- actual_device_path.Append(kRelativePath),
- &win32_path));
- EXPECT_EQ(FilePath(real_drive_letter + L"\\").Append(kRelativePath).value(),
- win32_path.value());
-
- // Deform the real path so that it is invalid by removing the last four
- // characters. The way windows names devices that are hard disks
- // (\Device\HardDiskVolume${NUMBER}) guarantees that the string is longer
- // than three characters. The only way the truncated string could be a
- // real drive is if more than 10^3 disks are mounted:
- // \Device\HardDiskVolume10000 would be truncated to \Device\HardDiskVolume1
- // Check that DevicePathToDriveLetterPath fails.
- int path_length = actual_device_path.value().length();
- int new_length = path_length - 4;
- ASSERT_LT(0, new_length);
- FilePath prefix_of_real_device_path(
- actual_device_path.value().substr(0, new_length));
- ASSERT_FALSE(DevicePathToDriveLetterPath(prefix_of_real_device_path,
- &win32_path));
-
- ASSERT_FALSE(DevicePathToDriveLetterPath(
- prefix_of_real_device_path.Append(kRelativePath),
- &win32_path));
-
- // Deform the real path so that it is invalid by adding some characters. For
- // example, if C: maps to \Device\HardDiskVolume8, then we simulate a
- // request for the drive letter whose native path is
- // \Device\HardDiskVolume812345 . We assume such a device does not exist,
- // because drives are numbered in order and mounting 112345 hard disks will
- // never happen.
- const FilePath::StringType kExtraChars = FPL("12345");
-
- FilePath real_device_path_plus_numbers(
- actual_device_path.value() + kExtraChars);
-
- ASSERT_FALSE(DevicePathToDriveLetterPath(
- real_device_path_plus_numbers,
- &win32_path));
-
- ASSERT_FALSE(DevicePathToDriveLetterPath(
- real_device_path_plus_numbers.Append(kRelativePath),
- &win32_path));
-}
-
-TEST_F(FileUtilTest, CreateTemporaryFileInDirLongPathTest) {
- // Test that CreateTemporaryFileInDir() creates a path and returns a long path
- // if it is available. This test requires that:
- // - the filesystem at |temp_dir_| supports long filenames.
- // - the account has FILE_LIST_DIRECTORY permission for all ancestor
- // directories of |temp_dir_|.
- const FilePath::CharType kLongDirName[] = FPL("A long path");
- const FilePath::CharType kTestSubDirName[] = FPL("test");
- FilePath long_test_dir = temp_dir_.GetPath().Append(kLongDirName);
- ASSERT_TRUE(CreateDirectory(long_test_dir));
-
- // kLongDirName is not a 8.3 component. So GetShortName() should give us a
- // different short name.
- WCHAR path_buffer[MAX_PATH];
- DWORD path_buffer_length = GetShortPathName(long_test_dir.value().c_str(),
- path_buffer, MAX_PATH);
- ASSERT_LT(path_buffer_length, DWORD(MAX_PATH));
- ASSERT_NE(DWORD(0), path_buffer_length);
- FilePath short_test_dir(path_buffer);
- ASSERT_STRNE(kLongDirName, short_test_dir.BaseName().value().c_str());
-
- FilePath temp_file;
- ASSERT_TRUE(CreateTemporaryFileInDir(short_test_dir, &temp_file));
- EXPECT_STREQ(kLongDirName, temp_file.DirName().BaseName().value().c_str());
- EXPECT_TRUE(PathExists(temp_file));
-
- // Create a subdirectory of |long_test_dir| and make |long_test_dir|
- // unreadable. We should still be able to create a temp file in the
- // subdirectory, but we won't be able to determine the long path for it. This
- // mimics the environment that some users run where their user profiles reside
- // in a location where the don't have full access to the higher level
- // directories. (Note that this assumption is true for NTFS, but not for some
- // network file systems. E.g. AFS).
- FilePath access_test_dir = long_test_dir.Append(kTestSubDirName);
- ASSERT_TRUE(CreateDirectory(access_test_dir));
- FilePermissionRestorer long_test_dir_restorer(long_test_dir);
- ASSERT_TRUE(MakeFileUnreadable(long_test_dir));
-
- // Use the short form of the directory to create a temporary filename.
- ASSERT_TRUE(CreateTemporaryFileInDir(
- short_test_dir.Append(kTestSubDirName), &temp_file));
- EXPECT_TRUE(PathExists(temp_file));
- EXPECT_TRUE(short_test_dir.IsParent(temp_file.DirName()));
-
- // Check that the long path can't be determined for |temp_file|.
- path_buffer_length = GetLongPathName(temp_file.value().c_str(),
- path_buffer, MAX_PATH);
- EXPECT_EQ(DWORD(0), path_buffer_length);
-}
-
-#endif // defined(OS_WIN)
-
-#if defined(OS_POSIX)
-
-TEST_F(FileUtilTest, CreateAndReadSymlinks) {
- FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
- FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
- CreateTextFile(link_to, bogus_content);
-
- ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
- << "Failed to create file symlink.";
-
- // If we created the link properly, we should be able to read the contents
- // through it.
- EXPECT_EQ(bogus_content, ReadTextFile(link_from));
-
- FilePath result;
- ASSERT_TRUE(ReadSymbolicLink(link_from, &result));
- EXPECT_EQ(link_to.value(), result.value());
-
- // Link to a directory.
- link_from = temp_dir_.GetPath().Append(FPL("from_dir"));
- link_to = temp_dir_.GetPath().Append(FPL("to_dir"));
- ASSERT_TRUE(CreateDirectory(link_to));
- ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
- << "Failed to create directory symlink.";
-
- // Test failures.
- EXPECT_FALSE(CreateSymbolicLink(link_to, link_to));
- EXPECT_FALSE(ReadSymbolicLink(link_to, &result));
- FilePath missing = temp_dir_.GetPath().Append(FPL("missing"));
- EXPECT_FALSE(ReadSymbolicLink(missing, &result));
-}
-
-// The following test of NormalizeFilePath() require that we create a symlink.
-// This can not be done on Windows before Vista. On Vista, creating a symlink
-// requires privilege "SeCreateSymbolicLinkPrivilege".
-// TODO(skerner): Investigate the possibility of giving base_unittests the
-// privileges required to create a symlink.
-TEST_F(FileUtilTest, NormalizeFilePathSymlinks) {
- // Link one file to another.
- FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
- FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
- CreateTextFile(link_to, bogus_content);
-
- ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
- << "Failed to create file symlink.";
-
- // Check that NormalizeFilePath sees the link.
- FilePath normalized_path;
- ASSERT_TRUE(NormalizeFilePath(link_from, &normalized_path));
- EXPECT_NE(link_from, link_to);
- EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
- EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
-
- // Link to a directory.
- link_from = temp_dir_.GetPath().Append(FPL("from_dir"));
- link_to = temp_dir_.GetPath().Append(FPL("to_dir"));
- ASSERT_TRUE(CreateDirectory(link_to));
- ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
- << "Failed to create directory symlink.";
-
- EXPECT_FALSE(NormalizeFilePath(link_from, &normalized_path))
- << "Links to directories should return false.";
-
- // Test that a loop in the links causes NormalizeFilePath() to return false.
- link_from = temp_dir_.GetPath().Append(FPL("link_a"));
- link_to = temp_dir_.GetPath().Append(FPL("link_b"));
- ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
- << "Failed to create loop symlink a.";
- ASSERT_TRUE(CreateSymbolicLink(link_from, link_to))
- << "Failed to create loop symlink b.";
-
- // Infinite loop!
- EXPECT_FALSE(NormalizeFilePath(link_from, &normalized_path));
-}
-
-TEST_F(FileUtilTest, DeleteSymlinkToExistentFile) {
- // Create a file.
- FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
- CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(PathExists(file_name));
-
- // Create a symlink to the file.
- FilePath file_link = temp_dir_.GetPath().Append("file_link_2");
- ASSERT_TRUE(CreateSymbolicLink(file_name, file_link))
- << "Failed to create symlink.";
-
- // Delete the symbolic link.
- EXPECT_TRUE(DeleteFile(file_link, false));
-
- // Make sure original file is not deleted.
- EXPECT_FALSE(PathExists(file_link));
- EXPECT_TRUE(PathExists(file_name));
-}
-
-TEST_F(FileUtilTest, DeleteSymlinkToNonExistentFile) {
- // Create a non-existent file path.
- FilePath non_existent =
- temp_dir_.GetPath().Append(FPL("Test DeleteFile 3.txt"));
- EXPECT_FALSE(PathExists(non_existent));
-
- // Create a symlink to the non-existent file.
- FilePath file_link = temp_dir_.GetPath().Append("file_link_3");
- ASSERT_TRUE(CreateSymbolicLink(non_existent, file_link))
- << "Failed to create symlink.";
-
- // Make sure the symbolic link is exist.
- EXPECT_TRUE(IsLink(file_link));
- EXPECT_FALSE(PathExists(file_link));
-
- // Delete the symbolic link.
- EXPECT_TRUE(DeleteFile(file_link, false));
-
- // Make sure the symbolic link is deleted.
- EXPECT_FALSE(IsLink(file_link));
-}
-
-TEST_F(FileUtilTest, CopyFileFollowsSymlinks) {
- FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
- FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
- CreateTextFile(link_to, bogus_content);
-
- ASSERT_TRUE(CreateSymbolicLink(link_to, link_from));
-
- // If we created the link properly, we should be able to read the contents
- // through it.
- EXPECT_EQ(bogus_content, ReadTextFile(link_from));
-
- FilePath result;
- ASSERT_TRUE(ReadSymbolicLink(link_from, &result));
- EXPECT_EQ(link_to.value(), result.value());
-
- // Create another file and copy it to |link_from|.
- FilePath src_file = temp_dir_.GetPath().Append(FPL("src.txt"));
- const std::wstring file_contents(L"Gooooooooooooooooooooogle");
- CreateTextFile(src_file, file_contents);
- ASSERT_TRUE(CopyFile(src_file, link_from));
-
- // Make sure |link_from| is still a symlink, and |link_to| has been written to
- // by CopyFile().
- EXPECT_TRUE(IsLink(link_from));
- EXPECT_EQ(file_contents, ReadTextFile(link_from));
- EXPECT_EQ(file_contents, ReadTextFile(link_to));
-}
-
-TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
- // Create a file path.
- FilePath file_name =
- temp_dir_.GetPath().Append(FPL("Test Readable File.txt"));
- EXPECT_FALSE(PathExists(file_name));
-
- static constexpr char kData[] = "hello";
- static constexpr int kDataSize = sizeof(kData) - 1;
- char buffer[kDataSize];
-
- // Write file.
- EXPECT_EQ(kDataSize, WriteFile(file_name, kData, kDataSize));
- EXPECT_TRUE(PathExists(file_name));
-
- // Make sure the file is readable.
- int32_t mode = 0;
- EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
- EXPECT_TRUE(mode & FILE_PERMISSION_READ_BY_USER);
-
- // Get rid of the read permission.
- EXPECT_TRUE(SetPosixFilePermissions(file_name, 0u));
- EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
- EXPECT_FALSE(mode & FILE_PERMISSION_READ_BY_USER);
- // Make sure the file can't be read.
- EXPECT_EQ(-1, ReadFile(file_name, buffer, kDataSize));
-
- // Give the read permission.
- EXPECT_TRUE(SetPosixFilePermissions(file_name, FILE_PERMISSION_READ_BY_USER));
- EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
- EXPECT_TRUE(mode & FILE_PERMISSION_READ_BY_USER);
- // Make sure the file can be read.
- EXPECT_EQ(kDataSize, ReadFile(file_name, buffer, kDataSize));
-
- // Delete the file.
- EXPECT_TRUE(DeleteFile(file_name, false));
- EXPECT_FALSE(PathExists(file_name));
-}
-
-TEST_F(FileUtilTest, ChangeFilePermissionsAndWrite) {
- // Create a file path.
- FilePath file_name =
- temp_dir_.GetPath().Append(FPL("Test Readable File.txt"));
- EXPECT_FALSE(PathExists(file_name));
-
- const std::string kData("hello");
-
- // Write file.
- EXPECT_EQ(static_cast<int>(kData.length()),
- WriteFile(file_name, kData.data(), kData.length()));
- EXPECT_TRUE(PathExists(file_name));
-
- // Make sure the file is writable.
- int mode = 0;
- EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
- EXPECT_TRUE(mode & FILE_PERMISSION_WRITE_BY_USER);
- EXPECT_TRUE(PathIsWritable(file_name));
-
- // Get rid of the write permission.
- EXPECT_TRUE(SetPosixFilePermissions(file_name, 0u));
- EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
- EXPECT_FALSE(mode & FILE_PERMISSION_WRITE_BY_USER);
- // Make sure the file can't be write.
- EXPECT_EQ(-1, WriteFile(file_name, kData.data(), kData.length()));
- EXPECT_FALSE(PathIsWritable(file_name));
-
- // Give read permission.
- EXPECT_TRUE(SetPosixFilePermissions(file_name,
- FILE_PERMISSION_WRITE_BY_USER));
- EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
- EXPECT_TRUE(mode & FILE_PERMISSION_WRITE_BY_USER);
- // Make sure the file can be write.
- EXPECT_EQ(static_cast<int>(kData.length()),
- WriteFile(file_name, kData.data(), kData.length()));
- EXPECT_TRUE(PathIsWritable(file_name));
-
- // Delete the file.
- EXPECT_TRUE(DeleteFile(file_name, false));
- EXPECT_FALSE(PathExists(file_name));
-}
-
-TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
- // Create a directory path.
- FilePath subdir_path = temp_dir_.GetPath().Append(FPL("PermissionTest1"));
- CreateDirectory(subdir_path);
- ASSERT_TRUE(PathExists(subdir_path));
-
- // Create a dummy file to enumerate.
- FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
- EXPECT_FALSE(PathExists(file_name));
- const std::string kData("hello");
- EXPECT_EQ(static_cast<int>(kData.length()),
- WriteFile(file_name, kData.data(), kData.length()));
- EXPECT_TRUE(PathExists(file_name));
-
- // Make sure the directory has the all permissions.
- int mode = 0;
- EXPECT_TRUE(GetPosixFilePermissions(subdir_path, &mode));
- EXPECT_EQ(FILE_PERMISSION_USER_MASK, mode & FILE_PERMISSION_USER_MASK);
-
- // Get rid of the permissions from the directory.
- EXPECT_TRUE(SetPosixFilePermissions(subdir_path, 0u));
- EXPECT_TRUE(GetPosixFilePermissions(subdir_path, &mode));
- EXPECT_FALSE(mode & FILE_PERMISSION_USER_MASK);
-
- // Make sure the file in the directory can't be enumerated.
- FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
- EXPECT_TRUE(PathExists(subdir_path));
- FindResultCollector c1(&f1);
- EXPECT_EQ(0, c1.size());
- EXPECT_FALSE(GetPosixFilePermissions(file_name, &mode));
-
- // Give the permissions to the directory.
- EXPECT_TRUE(SetPosixFilePermissions(subdir_path, FILE_PERMISSION_USER_MASK));
- EXPECT_TRUE(GetPosixFilePermissions(subdir_path, &mode));
- EXPECT_EQ(FILE_PERMISSION_USER_MASK, mode & FILE_PERMISSION_USER_MASK);
-
- // Make sure the file in the directory can be enumerated.
- FileEnumerator f2(subdir_path, true, FileEnumerator::FILES);
- FindResultCollector c2(&f2);
- EXPECT_TRUE(c2.HasFile(file_name));
- EXPECT_EQ(1, c2.size());
-
- // Delete the file.
- EXPECT_TRUE(DeleteFile(subdir_path, true));
- EXPECT_FALSE(PathExists(subdir_path));
-}
-
-TEST_F(FileUtilTest, ExecutableExistsInPath) {
- // Create two directories that we will put in our PATH
- const FilePath::CharType kDir1[] = FPL("dir1");
- const FilePath::CharType kDir2[] = FPL("dir2");
-
- FilePath dir1 = temp_dir_.GetPath().Append(kDir1);
- FilePath dir2 = temp_dir_.GetPath().Append(kDir2);
- ASSERT_TRUE(CreateDirectory(dir1));
- ASSERT_TRUE(CreateDirectory(dir2));
-
- test::ScopedEnvironmentVariableOverride scoped_env(
- "PATH", dir1.value() + ":" + dir2.value());
- ASSERT_TRUE(scoped_env.IsOverridden());
-
- const FilePath::CharType kRegularFileName[] = FPL("regular_file");
- const FilePath::CharType kExeFileName[] = FPL("exe");
- const FilePath::CharType kDneFileName[] = FPL("does_not_exist");
-
- const FilePath kExePath = dir1.Append(kExeFileName);
- const FilePath kRegularFilePath = dir2.Append(kRegularFileName);
-
- // Write file.
- const std::string kData("hello");
- ASSERT_EQ(static_cast<int>(kData.length()),
- WriteFile(kExePath, kData.data(), kData.length()));
- ASSERT_TRUE(PathExists(kExePath));
- ASSERT_EQ(static_cast<int>(kData.length()),
- WriteFile(kRegularFilePath, kData.data(), kData.length()));
- ASSERT_TRUE(PathExists(kRegularFilePath));
-
- ASSERT_TRUE(SetPosixFilePermissions(dir1.Append(kExeFileName),
- FILE_PERMISSION_EXECUTE_BY_USER));
-
- EXPECT_TRUE(ExecutableExistsInPath(scoped_env.GetEnv(), kExeFileName));
- EXPECT_FALSE(ExecutableExistsInPath(scoped_env.GetEnv(), kRegularFileName));
- EXPECT_FALSE(ExecutableExistsInPath(scoped_env.GetEnv(), kDneFileName));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryPermissions) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create some regular files under the directory with various permissions.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Reggy-1.txt"));
- CreateTextFile(file_name_from, L"Mordecai");
- ASSERT_TRUE(PathExists(file_name_from));
- ASSERT_TRUE(SetPosixFilePermissions(file_name_from, 0755));
-
- FilePath file2_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Reggy-2.txt"));
- CreateTextFile(file2_name_from, L"Rigby");
- ASSERT_TRUE(PathExists(file2_name_from));
- ASSERT_TRUE(SetPosixFilePermissions(file2_name_from, 0777));
-
- FilePath file3_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Reggy-3.txt"));
- CreateTextFile(file3_name_from, L"Benson");
- ASSERT_TRUE(PathExists(file3_name_from));
- ASSERT_TRUE(SetPosixFilePermissions(file3_name_from, 0400));
-
- // Copy the directory recursively.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Reggy-1.txt"));
- FilePath file2_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Reggy-2.txt"));
- FilePath file3_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Reggy-3.txt"));
-
- ASSERT_FALSE(PathExists(dir_name_to));
-
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, true));
- ASSERT_TRUE(PathExists(file_name_to));
- ASSERT_TRUE(PathExists(file2_name_to));
- ASSERT_TRUE(PathExists(file3_name_to));
-
- int mode = 0;
- int expected_mode;
- ASSERT_TRUE(GetPosixFilePermissions(file_name_to, &mode));
-#if defined(OS_MACOSX)
- expected_mode = 0755;
-#elif defined(OS_CHROMEOS)
- expected_mode = 0644;
-#else
- expected_mode = 0600;
-#endif
- EXPECT_EQ(expected_mode, mode);
-
- ASSERT_TRUE(GetPosixFilePermissions(file2_name_to, &mode));
-#if defined(OS_MACOSX)
- expected_mode = 0755;
-#elif defined(OS_CHROMEOS)
- expected_mode = 0644;
-#else
- expected_mode = 0600;
-#endif
- EXPECT_EQ(expected_mode, mode);
-
- ASSERT_TRUE(GetPosixFilePermissions(file3_name_to, &mode));
-#if defined(OS_MACOSX)
- expected_mode = 0600;
-#elif defined(OS_CHROMEOS)
- expected_mode = 0644;
-#else
- expected_mode = 0600;
-#endif
- EXPECT_EQ(expected_mode, mode);
-}
-
-TEST_F(FileUtilTest, CopyDirectoryPermissionsOverExistingFile) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Reggy-1.txt"));
- CreateTextFile(file_name_from, L"Mordecai");
- ASSERT_TRUE(PathExists(file_name_from));
- ASSERT_TRUE(SetPosixFilePermissions(file_name_from, 0644));
-
- // Create a directory.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
-
- // Create a file under the directory with wider permissions.
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Reggy-1.txt"));
- CreateTextFile(file_name_to, L"Rigby");
- ASSERT_TRUE(PathExists(file_name_to));
- ASSERT_TRUE(SetPosixFilePermissions(file_name_to, 0777));
-
- // Ensure that when we copy the directory, the file contents are copied
- // but the permissions on the destination are left alone.
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
- ASSERT_TRUE(PathExists(file_name_to));
- ASSERT_EQ(L"Mordecai", ReadTextFile(file_name_to));
-
- int mode = 0;
- ASSERT_TRUE(GetPosixFilePermissions(file_name_to, &mode));
- EXPECT_EQ(0777, mode);
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclDoesNotOverwrite) {
- // Create source directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Reggy-1.txt"));
- CreateTextFile(file_name_from, L"Mordecai");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create destination directory.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
-
- // Create a file under the directory with the same name.
- FilePath file_name_to = dir_name_to.Append(FILE_PATH_LITERAL("Reggy-1.txt"));
- CreateTextFile(file_name_to, L"Rigby");
- ASSERT_TRUE(PathExists(file_name_to));
-
- // Ensure that copying failed and the file was not overwritten.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
- ASSERT_TRUE(PathExists(file_name_to));
- ASSERT_EQ(L"Rigby", ReadTextFile(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclDirectoryOverExistingFile) {
- // Create source directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from = dir_name_from.Append(FILE_PATH_LITERAL("Subsub"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create destination directory.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
-
- // Create a regular file under the directory with the same name.
- FilePath file_name_to = dir_name_to.Append(FILE_PATH_LITERAL("Subsub"));
- CreateTextFile(file_name_to, L"Rigby");
- ASSERT_TRUE(PathExists(file_name_to));
-
- // Ensure that copying failed and the file was not overwritten.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
- ASSERT_TRUE(PathExists(file_name_to));
- ASSERT_EQ(L"Rigby", ReadTextFile(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclDirectoryOverExistingDirectory) {
- // Create source directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from = dir_name_from.Append(FILE_PATH_LITERAL("Subsub"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create destination directory.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
-
- // Create a subdirectory under the directory with the same name.
- FilePath subdir_name_to = dir_name_to.Append(FILE_PATH_LITERAL("Subsub"));
- CreateDirectory(subdir_name_to);
- ASSERT_TRUE(PathExists(subdir_name_to));
-
- // Ensure that copying failed and the file was not overwritten.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
-}
-
-TEST_F(FileUtilTest, CopyFileExecutablePermission) {
- FilePath src = temp_dir_.GetPath().Append(FPL("src.txt"));
- const std::wstring file_contents(L"Gooooooooooooooooooooogle");
- CreateTextFile(src, file_contents);
-
- ASSERT_TRUE(SetPosixFilePermissions(src, 0755));
- int mode = 0;
- ASSERT_TRUE(GetPosixFilePermissions(src, &mode));
- EXPECT_EQ(0755, mode);
-
- FilePath dst = temp_dir_.GetPath().Append(FPL("dst.txt"));
- ASSERT_TRUE(CopyFile(src, dst));
- EXPECT_EQ(file_contents, ReadTextFile(dst));
-
- ASSERT_TRUE(GetPosixFilePermissions(dst, &mode));
- int expected_mode;
-#if defined(OS_MACOSX)
- expected_mode = 0755;
-#elif defined(OS_CHROMEOS)
- expected_mode = 0644;
-#else
- expected_mode = 0600;
-#endif
- EXPECT_EQ(expected_mode, mode);
- ASSERT_TRUE(DeleteFile(dst, false));
-
- ASSERT_TRUE(SetPosixFilePermissions(src, 0777));
- ASSERT_TRUE(GetPosixFilePermissions(src, &mode));
- EXPECT_EQ(0777, mode);
-
- ASSERT_TRUE(CopyFile(src, dst));
- EXPECT_EQ(file_contents, ReadTextFile(dst));
-
- ASSERT_TRUE(GetPosixFilePermissions(dst, &mode));
-#if defined(OS_MACOSX)
- expected_mode = 0755;
-#elif defined(OS_CHROMEOS)
- expected_mode = 0644;
-#else
- expected_mode = 0600;
-#endif
- EXPECT_EQ(expected_mode, mode);
- ASSERT_TRUE(DeleteFile(dst, false));
-
- ASSERT_TRUE(SetPosixFilePermissions(src, 0400));
- ASSERT_TRUE(GetPosixFilePermissions(src, &mode));
- EXPECT_EQ(0400, mode);
-
- ASSERT_TRUE(CopyFile(src, dst));
- EXPECT_EQ(file_contents, ReadTextFile(dst));
-
- ASSERT_TRUE(GetPosixFilePermissions(dst, &mode));
-#if defined(OS_MACOSX)
- expected_mode = 0600;
-#elif defined(OS_CHROMEOS)
- expected_mode = 0644;
-#else
- expected_mode = 0600;
-#endif
- EXPECT_EQ(expected_mode, mode);
-
- // This time, do not delete |dst|. Instead set its permissions to 0777.
- ASSERT_TRUE(SetPosixFilePermissions(dst, 0777));
- ASSERT_TRUE(GetPosixFilePermissions(dst, &mode));
- EXPECT_EQ(0777, mode);
-
- // Overwrite it and check the permissions again.
- ASSERT_TRUE(CopyFile(src, dst));
- EXPECT_EQ(file_contents, ReadTextFile(dst));
- ASSERT_TRUE(GetPosixFilePermissions(dst, &mode));
- EXPECT_EQ(0777, mode);
-}
-
-#endif // defined(OS_POSIX)
-
-#if !defined(OS_FUCHSIA)
-
-TEST_F(FileUtilTest, CopyFileACL) {
- // While FileUtilTest.CopyFile asserts the content is correctly copied over,
- // this test case asserts the access control bits are meeting expectations in
- // CopyFile().
- FilePath src = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("src.txt"));
- const std::wstring file_contents(L"Gooooooooooooooooooooogle");
- CreateTextFile(src, file_contents);
-
- // Set the source file to read-only.
- ASSERT_FALSE(IsReadOnly(src));
- SetReadOnly(src, true);
- ASSERT_TRUE(IsReadOnly(src));
-
- // Copy the file.
- FilePath dst = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("dst.txt"));
- ASSERT_TRUE(CopyFile(src, dst));
- EXPECT_EQ(file_contents, ReadTextFile(dst));
-
- ASSERT_FALSE(IsReadOnly(dst));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryACL) {
- // Create source directories.
- FilePath src = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("src"));
- FilePath src_subdir = src.Append(FILE_PATH_LITERAL("subdir"));
- CreateDirectory(src_subdir);
- ASSERT_TRUE(PathExists(src_subdir));
-
- // Create a file under the directory.
- FilePath src_file = src.Append(FILE_PATH_LITERAL("src.txt"));
- CreateTextFile(src_file, L"Gooooooooooooooooooooogle");
- SetReadOnly(src_file, true);
- ASSERT_TRUE(IsReadOnly(src_file));
-
- // Make directory read-only.
- SetReadOnly(src_subdir, true);
- ASSERT_TRUE(IsReadOnly(src_subdir));
-
- // Copy the directory recursively.
- FilePath dst = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("dst"));
- FilePath dst_file = dst.Append(FILE_PATH_LITERAL("src.txt"));
- EXPECT_TRUE(CopyDirectory(src, dst, true));
-
- FilePath dst_subdir = dst.Append(FILE_PATH_LITERAL("subdir"));
- ASSERT_FALSE(IsReadOnly(dst_subdir));
- ASSERT_FALSE(IsReadOnly(dst_file));
-
- // Give write permissions to allow deletion.
- SetReadOnly(src_subdir, false);
- ASSERT_FALSE(IsReadOnly(src_subdir));
-}
-
-#endif // !defined(OS_FUCHSIA)
-
-TEST_F(FileUtilTest, DeleteNonExistent) {
- FilePath non_existent =
- temp_dir_.GetPath().AppendASCII("bogus_file_dne.foobar");
- ASSERT_FALSE(PathExists(non_existent));
-
- EXPECT_TRUE(DeleteFile(non_existent, false));
- ASSERT_FALSE(PathExists(non_existent));
- EXPECT_TRUE(DeleteFile(non_existent, true));
- ASSERT_FALSE(PathExists(non_existent));
-}
-
-TEST_F(FileUtilTest, DeleteNonExistentWithNonExistentParent) {
- FilePath non_existent = temp_dir_.GetPath().AppendASCII("bogus_topdir");
- non_existent = non_existent.AppendASCII("bogus_subdir");
- ASSERT_FALSE(PathExists(non_existent));
-
- EXPECT_TRUE(DeleteFile(non_existent, false));
- ASSERT_FALSE(PathExists(non_existent));
- EXPECT_TRUE(DeleteFile(non_existent, true));
- ASSERT_FALSE(PathExists(non_existent));
-}
-
-TEST_F(FileUtilTest, DeleteFile) {
- // Create a file
- FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 1.txt"));
- CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(PathExists(file_name));
-
- // Make sure it's deleted
- EXPECT_TRUE(DeleteFile(file_name, false));
- EXPECT_FALSE(PathExists(file_name));
-
- // Test recursive case, create a new file
- file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
- CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(PathExists(file_name));
-
- // Make sure it's deleted
- EXPECT_TRUE(DeleteFile(file_name, true));
- EXPECT_FALSE(PathExists(file_name));
-}
-
-#if defined(OS_WIN)
-// Tests that the Delete function works for wild cards, especially
-// with the recursion flag. Also coincidentally tests PathExists.
-// TODO(erikkay): see if anyone's actually using this feature of the API
-TEST_F(FileUtilTest, DeleteWildCard) {
- // Create a file and a directory
- FilePath file_name =
- temp_dir_.GetPath().Append(FPL("Test DeleteWildCard.txt"));
- CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(PathExists(file_name));
-
- FilePath subdir_path = temp_dir_.GetPath().Append(FPL("DeleteWildCardDir"));
- CreateDirectory(subdir_path);
- ASSERT_TRUE(PathExists(subdir_path));
-
- // Create the wildcard path
- FilePath directory_contents = temp_dir_.GetPath();
- directory_contents = directory_contents.Append(FPL("*"));
-
- // Delete non-recursively and check that only the file is deleted
- EXPECT_TRUE(DeleteFile(directory_contents, false));
- EXPECT_FALSE(PathExists(file_name));
- EXPECT_TRUE(PathExists(subdir_path));
-
- // Delete recursively and make sure all contents are deleted
- EXPECT_TRUE(DeleteFile(directory_contents, true));
- EXPECT_FALSE(PathExists(file_name));
- EXPECT_FALSE(PathExists(subdir_path));
-}
-
-// TODO(erikkay): see if anyone's actually using this feature of the API
-TEST_F(FileUtilTest, DeleteNonExistantWildCard) {
- // Create a file and a directory
- FilePath subdir_path =
- temp_dir_.GetPath().Append(FPL("DeleteNonExistantWildCard"));
- CreateDirectory(subdir_path);
- ASSERT_TRUE(PathExists(subdir_path));
-
- // Create the wildcard path
- FilePath directory_contents = subdir_path;
- directory_contents = directory_contents.Append(FPL("*"));
-
- // Delete non-recursively and check nothing got deleted
- EXPECT_TRUE(DeleteFile(directory_contents, false));
- EXPECT_TRUE(PathExists(subdir_path));
-
- // Delete recursively and check nothing got deleted
- EXPECT_TRUE(DeleteFile(directory_contents, true));
- EXPECT_TRUE(PathExists(subdir_path));
-}
-#endif
-
-// Tests non-recursive Delete() for a directory.
-TEST_F(FileUtilTest, DeleteDirNonRecursive) {
- // Create a subdirectory and put a file and two directories inside.
- FilePath test_subdir =
- temp_dir_.GetPath().Append(FPL("DeleteDirNonRecursive"));
- CreateDirectory(test_subdir);
- ASSERT_TRUE(PathExists(test_subdir));
-
- FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
- CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(PathExists(file_name));
-
- FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
- CreateDirectory(subdir_path1);
- ASSERT_TRUE(PathExists(subdir_path1));
-
- FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
- CreateDirectory(subdir_path2);
- ASSERT_TRUE(PathExists(subdir_path2));
-
- // Delete non-recursively and check that the empty dir got deleted
- EXPECT_TRUE(DeleteFile(subdir_path2, false));
- EXPECT_FALSE(PathExists(subdir_path2));
-
- // Delete non-recursively and check that nothing got deleted
- EXPECT_FALSE(DeleteFile(test_subdir, false));
- EXPECT_TRUE(PathExists(test_subdir));
- EXPECT_TRUE(PathExists(file_name));
- EXPECT_TRUE(PathExists(subdir_path1));
-}
-
-// Tests recursive Delete() for a directory.
-TEST_F(FileUtilTest, DeleteDirRecursive) {
- // Create a subdirectory and put a file and two directories inside.
- FilePath test_subdir = temp_dir_.GetPath().Append(FPL("DeleteDirRecursive"));
- CreateDirectory(test_subdir);
- ASSERT_TRUE(PathExists(test_subdir));
-
- FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
- CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(PathExists(file_name));
-
- FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
- CreateDirectory(subdir_path1);
- ASSERT_TRUE(PathExists(subdir_path1));
-
- FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
- CreateDirectory(subdir_path2);
- ASSERT_TRUE(PathExists(subdir_path2));
-
- // Delete recursively and check that the empty dir got deleted
- EXPECT_TRUE(DeleteFile(subdir_path2, true));
- EXPECT_FALSE(PathExists(subdir_path2));
-
- // Delete recursively and check that everything got deleted
- EXPECT_TRUE(DeleteFile(test_subdir, true));
- EXPECT_FALSE(PathExists(file_name));
- EXPECT_FALSE(PathExists(subdir_path1));
- EXPECT_FALSE(PathExists(test_subdir));
-}
-
-// Tests recursive Delete() for a directory.
-TEST_F(FileUtilTest, DeleteDirRecursiveWithOpenFile) {
- // Create a subdirectory and put a file and two directories inside.
- FilePath test_subdir = temp_dir_.GetPath().Append(FPL("DeleteWithOpenFile"));
- CreateDirectory(test_subdir);
- ASSERT_TRUE(PathExists(test_subdir));
-
- FilePath file_name1 = test_subdir.Append(FPL("Undeletebable File1.txt"));
- File file1(file_name1,
- File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE);
- ASSERT_TRUE(PathExists(file_name1));
-
- FilePath file_name2 = test_subdir.Append(FPL("Deleteable File2.txt"));
- CreateTextFile(file_name2, bogus_content);
- ASSERT_TRUE(PathExists(file_name2));
-
- FilePath file_name3 = test_subdir.Append(FPL("Undeletebable File3.txt"));
- File file3(file_name3,
- File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE);
- ASSERT_TRUE(PathExists(file_name3));
-
-#if defined(OS_LINUX)
- // On Windows, holding the file open in sufficient to make it un-deletable.
- // The POSIX code is verifiable on Linux by creating an "immutable" file but
- // this is best-effort because it's not supported by all file systems. Both
- // files will have the same flags so no need to get them individually.
- int flags;
- bool file_attrs_supported =
- ioctl(file1.GetPlatformFile(), FS_IOC_GETFLAGS, &flags) == 0;
- // Some filesystems (e.g. tmpfs) don't support file attributes.
- if (file_attrs_supported) {
- flags |= FS_IMMUTABLE_FL;
- ioctl(file1.GetPlatformFile(), FS_IOC_SETFLAGS, &flags);
- ioctl(file3.GetPlatformFile(), FS_IOC_SETFLAGS, &flags);
- }
-#endif
-
- // Delete recursively and check that at least the second file got deleted.
- // This ensures that un-deletable files don't impact those that can be.
- DeleteFile(test_subdir, true);
- EXPECT_FALSE(PathExists(file_name2));
-
-#if defined(OS_LINUX)
- // Make sure that the test can clean up after itself.
- if (file_attrs_supported) {
- flags &= ~FS_IMMUTABLE_FL;
- ioctl(file1.GetPlatformFile(), FS_IOC_SETFLAGS, &flags);
- ioctl(file3.GetPlatformFile(), FS_IOC_SETFLAGS, &flags);
- }
-#endif
-}
-
-TEST_F(FileUtilTest, MoveFileNew) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // The destination.
- FilePath file_name_to = temp_dir_.GetPath().Append(
- FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
- ASSERT_FALSE(PathExists(file_name_to));
-
- EXPECT_TRUE(Move(file_name_from, file_name_to));
-
- // Check everything has been moved.
- EXPECT_FALSE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-TEST_F(FileUtilTest, MoveFileExists) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // The destination name.
- FilePath file_name_to = temp_dir_.GetPath().Append(
- FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
- CreateTextFile(file_name_to, L"Old file content");
- ASSERT_TRUE(PathExists(file_name_to));
-
- EXPECT_TRUE(Move(file_name_from, file_name_to));
-
- // Check everything has been moved.
- EXPECT_FALSE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
-}
-
-TEST_F(FileUtilTest, MoveFileDirExists) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // The destination directory
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
-
- EXPECT_FALSE(Move(file_name_from, dir_name_to));
-}
-
-
-TEST_F(FileUtilTest, MoveNew) {
- // Create a directory
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory
- FilePath txt_file_name(FILE_PATH_LITERAL("Move_Test_File.txt"));
- FilePath file_name_from = dir_name_from.Append(txt_file_name);
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Move the directory.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
-
- ASSERT_FALSE(PathExists(dir_name_to));
-
- EXPECT_TRUE(Move(dir_name_from, dir_name_to));
-
- // Check everything has been moved.
- EXPECT_FALSE(PathExists(dir_name_from));
- EXPECT_FALSE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
-
- // Test path traversal.
- file_name_from = dir_name_to.Append(txt_file_name);
- file_name_to = dir_name_to.Append(FILE_PATH_LITERAL(".."));
- file_name_to = file_name_to.Append(txt_file_name);
- EXPECT_FALSE(Move(file_name_from, file_name_to));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_FALSE(PathExists(file_name_to));
- EXPECT_TRUE(internal::MoveUnsafe(file_name_from, file_name_to));
- EXPECT_FALSE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-TEST_F(FileUtilTest, MoveExist) {
- // Create a directory
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Move the directory
- FilePath dir_name_exists =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
-
- FilePath dir_name_to =
- dir_name_exists.Append(FILE_PATH_LITERAL("Move_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
-
- // Create the destination directory.
- CreateDirectory(dir_name_exists);
- ASSERT_TRUE(PathExists(dir_name_exists));
-
- EXPECT_TRUE(Move(dir_name_from, dir_name_to));
-
- // Check everything has been moved.
- EXPECT_FALSE(PathExists(dir_name_from));
- EXPECT_FALSE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create a file under the subdirectory.
- FilePath file_name2_from =
- subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name2_from));
-
- // Copy the directory recursively.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- FilePath subdir_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
- FilePath file_name2_to =
- subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-
- ASSERT_FALSE(PathExists(dir_name_to));
-
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, true));
-
- // Check everything has been copied.
- EXPECT_TRUE(PathExists(dir_name_from));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(subdir_name_from));
- EXPECT_TRUE(PathExists(file_name2_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_TRUE(PathExists(subdir_name_to));
- EXPECT_TRUE(PathExists(file_name2_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryRecursivelyExists) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create a file under the subdirectory.
- FilePath file_name2_from =
- subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name2_from));
-
- // Copy the directory recursively.
- FilePath dir_name_exists =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
-
- FilePath dir_name_to =
- dir_name_exists.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- FilePath subdir_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
- FilePath file_name2_to =
- subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-
- // Create the destination directory.
- CreateDirectory(dir_name_exists);
- ASSERT_TRUE(PathExists(dir_name_exists));
-
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_exists, true));
-
- // Check everything has been copied.
- EXPECT_TRUE(PathExists(dir_name_from));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(subdir_name_from));
- EXPECT_TRUE(PathExists(file_name2_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_TRUE(PathExists(subdir_name_to));
- EXPECT_TRUE(PathExists(file_name2_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryNew) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create a file under the subdirectory.
- FilePath file_name2_from =
- subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name2_from));
-
- // Copy the directory not recursively.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- FilePath subdir_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
-
- ASSERT_FALSE(PathExists(dir_name_to));
-
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
-
- // Check everything has been copied.
- EXPECT_TRUE(PathExists(dir_name_from));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(subdir_name_from));
- EXPECT_TRUE(PathExists(file_name2_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_FALSE(PathExists(subdir_name_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExists) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create a file under the subdirectory.
- FilePath file_name2_from =
- subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name2_from));
-
- // Copy the directory not recursively.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- FilePath subdir_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
-
- // Create the destination directory.
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
-
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
-
- // Check everything has been copied.
- EXPECT_TRUE(PathExists(dir_name_from));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(subdir_name_from));
- EXPECT_TRUE(PathExists(file_name2_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_FALSE(PathExists(subdir_name_to));
-}
-
-TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToNew) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // The destination name
- FilePath file_name_to = temp_dir_.GetPath().Append(
- FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
- ASSERT_FALSE(PathExists(file_name_to));
-
- EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
-
- // Check the has been copied
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExisting) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // The destination name
- FilePath file_name_to = temp_dir_.GetPath().Append(
- FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
- CreateTextFile(file_name_to, L"Old file content");
- ASSERT_TRUE(PathExists(file_name_to));
-
- EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
-
- // Check the has been copied
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExistingDirectory) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // The destination
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
- CreateDirectory(dir_name_to);
- ASSERT_TRUE(PathExists(dir_name_to));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-
- EXPECT_TRUE(CopyDirectory(file_name_from, dir_name_to, true));
-
- // Check the has been copied
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyFileFailureWithCopyDirectoryExcl) {
- // Create a file
- FilePath file_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Make a destination file.
- FilePath file_name_to = temp_dir_.GetPath().Append(
- FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
- CreateTextFile(file_name_to, L"Old file content");
- ASSERT_TRUE(PathExists(file_name_to));
-
- // Overwriting the destination should fail.
- EXPECT_FALSE(CopyDirectoryExcl(file_name_from, file_name_to, true));
- EXPECT_EQ(L"Old file content", ReadTextFile(file_name_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryWithTrailingSeparators) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Copy the directory recursively.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-
- // Create from path with trailing separators.
-#if defined(OS_WIN)
- FilePath from_path =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir\\\\\\"));
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- FilePath from_path =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir///"));
-#endif
-
- EXPECT_TRUE(CopyDirectory(from_path, dir_name_to, true));
-
- // Check everything has been copied.
- EXPECT_TRUE(PathExists(dir_name_from));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-#if defined(OS_POSIX)
-TEST_F(FileUtilTest, CopyDirectoryWithNonRegularFiles) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a symbolic link under the directory pointing to that file.
- FilePath symlink_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Symlink"));
- ASSERT_TRUE(CreateSymbolicLink(file_name_from, symlink_name_from));
- ASSERT_TRUE(PathExists(symlink_name_from));
-
- // Create a fifo under the directory.
- FilePath fifo_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Fifo"));
- ASSERT_EQ(0, mkfifo(fifo_name_from.value().c_str(), 0644));
- ASSERT_TRUE(PathExists(fifo_name_from));
-
- // Copy the directory.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- FilePath symlink_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Symlink"));
- FilePath fifo_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Fifo"));
-
- ASSERT_FALSE(PathExists(dir_name_to));
-
- EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
-
- // Check that only directories and regular files are copied.
- EXPECT_TRUE(PathExists(dir_name_from));
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(symlink_name_from));
- EXPECT_TRUE(PathExists(fifo_name_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
- EXPECT_FALSE(PathExists(symlink_name_to));
- EXPECT_FALSE(PathExists(fifo_name_to));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclFileOverSymlink) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a destination directory with a symlink of the same name.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_to));
- ASSERT_TRUE(PathExists(dir_name_to));
-
- FilePath symlink_target =
- dir_name_to.Append(FILE_PATH_LITERAL("Symlink_Target.txt"));
- CreateTextFile(symlink_target, L"asdf");
- ASSERT_TRUE(PathExists(symlink_target));
-
- FilePath symlink_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- ASSERT_TRUE(CreateSymbolicLink(symlink_target, symlink_name_to));
- ASSERT_TRUE(PathExists(symlink_name_to));
-
- // Check that copying fails.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclDirectoryOverSymlink) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from = dir_name_from.Append(FILE_PATH_LITERAL("Subsub"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create a destination directory with a symlink of the same name.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_to));
- ASSERT_TRUE(PathExists(dir_name_to));
-
- FilePath symlink_target = dir_name_to.Append(FILE_PATH_LITERAL("Subsub"));
- CreateTextFile(symlink_target, L"asdf");
- ASSERT_TRUE(PathExists(symlink_target));
-
- FilePath symlink_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- ASSERT_TRUE(CreateSymbolicLink(symlink_target, symlink_name_to));
- ASSERT_TRUE(PathExists(symlink_name_to));
-
- // Check that copying fails.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclFileOverDanglingSymlink) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a destination directory with a dangling symlink of the same name.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_to));
- ASSERT_TRUE(PathExists(dir_name_to));
-
- FilePath symlink_target =
- dir_name_to.Append(FILE_PATH_LITERAL("Symlink_Target.txt"));
- CreateTextFile(symlink_target, L"asdf");
- ASSERT_TRUE(PathExists(symlink_target));
-
- FilePath symlink_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- ASSERT_TRUE(CreateSymbolicLink(symlink_target, symlink_name_to));
- ASSERT_TRUE(PathExists(symlink_name_to));
- ASSERT_TRUE(DeleteFile(symlink_target, false));
-
- // Check that copying fails and that no file was created for the symlink's
- // referent.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
- EXPECT_FALSE(PathExists(symlink_target));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclDirectoryOverDanglingSymlink) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a subdirectory.
- FilePath subdir_name_from = dir_name_from.Append(FILE_PATH_LITERAL("Subsub"));
- CreateDirectory(subdir_name_from);
- ASSERT_TRUE(PathExists(subdir_name_from));
-
- // Create a destination directory with a dangling symlink of the same name.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_to));
- ASSERT_TRUE(PathExists(dir_name_to));
-
- FilePath symlink_target =
- dir_name_to.Append(FILE_PATH_LITERAL("Symlink_Target.txt"));
- CreateTextFile(symlink_target, L"asdf");
- ASSERT_TRUE(PathExists(symlink_target));
-
- FilePath symlink_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- ASSERT_TRUE(CreateSymbolicLink(symlink_target, symlink_name_to));
- ASSERT_TRUE(PathExists(symlink_name_to));
- ASSERT_TRUE(DeleteFile(symlink_target, false));
-
- // Check that copying fails and that no directory was created for the
- // symlink's referent.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
- EXPECT_FALSE(PathExists(symlink_target));
-}
-
-TEST_F(FileUtilTest, CopyDirectoryExclFileOverFifo) {
- // Create a directory.
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory.
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Create a destination directory with a fifo of the same name.
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_to));
- ASSERT_TRUE(PathExists(dir_name_to));
-
- FilePath fifo_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- ASSERT_EQ(0, mkfifo(fifo_name_to.value().c_str(), 0644));
- ASSERT_TRUE(PathExists(fifo_name_to));
-
- // Check that copying fails.
- EXPECT_FALSE(CopyDirectoryExcl(dir_name_from, dir_name_to, false));
-}
-#endif // defined(OS_POSIX)
-
-TEST_F(FileUtilTest, CopyFile) {
- // Create a directory
- FilePath dir_name_from =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
- ASSERT_TRUE(CreateDirectory(dir_name_from));
- ASSERT_TRUE(DirectoryExists(dir_name_from));
-
- // Create a file under the directory
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- const std::wstring file_contents(L"Gooooooooooooooooooooogle");
- CreateTextFile(file_name_from, file_contents);
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Copy the file.
- FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
- ASSERT_TRUE(CopyFile(file_name_from, dest_file));
-
- // Try to copy the file to another location using '..' in the path.
- FilePath dest_file2(dir_name_from);
- dest_file2 = dest_file2.AppendASCII("..");
- dest_file2 = dest_file2.AppendASCII("DestFile.txt");
- ASSERT_FALSE(CopyFile(file_name_from, dest_file2));
-
- FilePath dest_file2_test(dir_name_from);
- dest_file2_test = dest_file2_test.DirName();
- dest_file2_test = dest_file2_test.AppendASCII("DestFile.txt");
-
- // Check expected copy results.
- EXPECT_TRUE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(dest_file));
- EXPECT_EQ(file_contents, ReadTextFile(dest_file));
- EXPECT_FALSE(PathExists(dest_file2_test));
- EXPECT_FALSE(PathExists(dest_file2));
-
- // Change |file_name_from| contents.
- const std::wstring new_file_contents(L"Moogle");
- CreateTextFile(file_name_from, new_file_contents);
- ASSERT_TRUE(PathExists(file_name_from));
- EXPECT_EQ(new_file_contents, ReadTextFile(file_name_from));
-
- // Overwrite |dest_file|.
- ASSERT_TRUE(CopyFile(file_name_from, dest_file));
- EXPECT_TRUE(PathExists(dest_file));
- EXPECT_EQ(new_file_contents, ReadTextFile(dest_file));
-
- // Create another directory.
- FilePath dest_dir = temp_dir_.GetPath().Append(FPL("dest_dir"));
- ASSERT_TRUE(CreateDirectory(dest_dir));
- EXPECT_TRUE(DirectoryExists(dest_dir));
- EXPECT_TRUE(IsDirectoryEmpty(dest_dir));
-
- // Make sure CopyFile() cannot overwrite a directory.
- ASSERT_FALSE(CopyFile(file_name_from, dest_dir));
- EXPECT_TRUE(DirectoryExists(dest_dir));
- EXPECT_TRUE(IsDirectoryEmpty(dest_dir));
-}
-
-// file_util winds up using autoreleased objects on the Mac, so this needs
-// to be a PlatformTest.
-typedef PlatformTest ReadOnlyFileUtilTest;
-
-TEST_F(ReadOnlyFileUtilTest, ContentsEqual) {
- FilePath data_dir;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
- data_dir = data_dir.AppendASCII("file_util");
- ASSERT_TRUE(PathExists(data_dir));
-
- FilePath original_file =
- data_dir.Append(FILE_PATH_LITERAL("original.txt"));
- FilePath same_file =
- data_dir.Append(FILE_PATH_LITERAL("same.txt"));
- FilePath same_length_file =
- data_dir.Append(FILE_PATH_LITERAL("same_length.txt"));
- FilePath different_file =
- data_dir.Append(FILE_PATH_LITERAL("different.txt"));
- FilePath different_first_file =
- data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
- FilePath different_last_file =
- data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
- FilePath empty1_file =
- data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
- FilePath empty2_file =
- data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
- FilePath shortened_file =
- data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
- FilePath binary_file =
- data_dir.Append(FILE_PATH_LITERAL("binary_file.bin"));
- FilePath binary_file_same =
- data_dir.Append(FILE_PATH_LITERAL("binary_file_same.bin"));
- FilePath binary_file_diff =
- data_dir.Append(FILE_PATH_LITERAL("binary_file_diff.bin"));
-
- EXPECT_TRUE(ContentsEqual(original_file, original_file));
- EXPECT_TRUE(ContentsEqual(original_file, same_file));
- EXPECT_FALSE(ContentsEqual(original_file, same_length_file));
- EXPECT_FALSE(ContentsEqual(original_file, different_file));
- EXPECT_FALSE(ContentsEqual(FilePath(FILE_PATH_LITERAL("bogusname")),
- FilePath(FILE_PATH_LITERAL("bogusname"))));
- EXPECT_FALSE(ContentsEqual(original_file, different_first_file));
- EXPECT_FALSE(ContentsEqual(original_file, different_last_file));
- EXPECT_TRUE(ContentsEqual(empty1_file, empty2_file));
- EXPECT_FALSE(ContentsEqual(original_file, shortened_file));
- EXPECT_FALSE(ContentsEqual(shortened_file, original_file));
- EXPECT_TRUE(ContentsEqual(binary_file, binary_file_same));
- EXPECT_FALSE(ContentsEqual(binary_file, binary_file_diff));
-}
-
-TEST_F(ReadOnlyFileUtilTest, TextContentsEqual) {
- FilePath data_dir;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
- data_dir = data_dir.AppendASCII("file_util");
- ASSERT_TRUE(PathExists(data_dir));
-
- FilePath original_file =
- data_dir.Append(FILE_PATH_LITERAL("original.txt"));
- FilePath same_file =
- data_dir.Append(FILE_PATH_LITERAL("same.txt"));
- FilePath crlf_file =
- data_dir.Append(FILE_PATH_LITERAL("crlf.txt"));
- FilePath shortened_file =
- data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
- FilePath different_file =
- data_dir.Append(FILE_PATH_LITERAL("different.txt"));
- FilePath different_first_file =
- data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
- FilePath different_last_file =
- data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
- FilePath first1_file =
- data_dir.Append(FILE_PATH_LITERAL("first1.txt"));
- FilePath first2_file =
- data_dir.Append(FILE_PATH_LITERAL("first2.txt"));
- FilePath empty1_file =
- data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
- FilePath empty2_file =
- data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
- FilePath blank_line_file =
- data_dir.Append(FILE_PATH_LITERAL("blank_line.txt"));
- FilePath blank_line_crlf_file =
- data_dir.Append(FILE_PATH_LITERAL("blank_line_crlf.txt"));
-
- EXPECT_TRUE(TextContentsEqual(original_file, same_file));
- EXPECT_TRUE(TextContentsEqual(original_file, crlf_file));
- EXPECT_FALSE(TextContentsEqual(original_file, shortened_file));
- EXPECT_FALSE(TextContentsEqual(original_file, different_file));
- EXPECT_FALSE(TextContentsEqual(original_file, different_first_file));
- EXPECT_FALSE(TextContentsEqual(original_file, different_last_file));
- EXPECT_FALSE(TextContentsEqual(first1_file, first2_file));
- EXPECT_TRUE(TextContentsEqual(empty1_file, empty2_file));
- EXPECT_FALSE(TextContentsEqual(original_file, empty1_file));
- EXPECT_TRUE(TextContentsEqual(blank_line_file, blank_line_crlf_file));
-}
-
-// We don't need equivalent functionality outside of Windows.
-#if defined(OS_WIN)
-TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
- // Create a directory
- FilePath dir_name_from = temp_dir_.GetPath().Append(
- FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
- CreateDirectory(dir_name_from);
- ASSERT_TRUE(PathExists(dir_name_from));
-
- // Create a file under the directory
- FilePath file_name_from =
- dir_name_from.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
- CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(PathExists(file_name_from));
-
- // Move the directory by using CopyAndDeleteDirectory
- FilePath dir_name_to =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("CopyAndDelete_To_Subdir"));
- FilePath file_name_to =
- dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
-
- ASSERT_FALSE(PathExists(dir_name_to));
-
- EXPECT_TRUE(internal::CopyAndDeleteDirectory(dir_name_from,
- dir_name_to));
-
- // Check everything has been moved.
- EXPECT_FALSE(PathExists(dir_name_from));
- EXPECT_FALSE(PathExists(file_name_from));
- EXPECT_TRUE(PathExists(dir_name_to));
- EXPECT_TRUE(PathExists(file_name_to));
-}
-
-TEST_F(FileUtilTest, GetTempDirTest) {
- static const TCHAR* kTmpKey = _T("TMP");
- static const TCHAR* kTmpValues[] = {
- _T(""), _T("C:"), _T("C:\\"), _T("C:\\tmp"), _T("C:\\tmp\\")
- };
- // Save the original $TMP.
- size_t original_tmp_size;
- TCHAR* original_tmp;
- ASSERT_EQ(0, ::_tdupenv_s(&original_tmp, &original_tmp_size, kTmpKey));
- // original_tmp may be NULL.
-
- for (unsigned int i = 0; i < arraysize(kTmpValues); ++i) {
- FilePath path;
- ::_tputenv_s(kTmpKey, kTmpValues[i]);
- GetTempDir(&path);
- EXPECT_TRUE(path.IsAbsolute()) << "$TMP=" << kTmpValues[i] <<
- " result=" << path.value();
- }
-
- // Restore the original $TMP.
- if (original_tmp) {
- ::_tputenv_s(kTmpKey, original_tmp);
- free(original_tmp);
- } else {
- ::_tputenv_s(kTmpKey, _T(""));
- }
-}
-#endif // OS_WIN
-
-// Test that files opened by OpenFile are not set up for inheritance into child
-// procs.
-TEST_F(FileUtilTest, OpenFileNoInheritance) {
- FilePath file_path(temp_dir_.GetPath().Append(FPL("a_file")));
-
- for (const char* mode : {"wb", "r,ccs=UTF-8"}) {
- SCOPED_TRACE(mode);
- ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_path, L"Geepers"));
- FILE* file = OpenFile(file_path, mode);
- ASSERT_NE(nullptr, file);
- {
- ScopedClosureRunner file_closer(Bind(IgnoreResult(&CloseFile), file));
- bool is_inheritable = true;
- ASSERT_NO_FATAL_FAILURE(GetIsInheritable(file, &is_inheritable));
- EXPECT_FALSE(is_inheritable);
- }
- ASSERT_TRUE(DeleteFile(file_path, false));
- }
-}
-
-TEST_F(FileUtilTest, CreateTemporaryFileTest) {
- FilePath temp_files[3];
- for (int i = 0; i < 3; i++) {
- ASSERT_TRUE(CreateTemporaryFile(&(temp_files[i])));
- EXPECT_TRUE(PathExists(temp_files[i]));
- EXPECT_FALSE(DirectoryExists(temp_files[i]));
- }
- for (int i = 0; i < 3; i++)
- EXPECT_FALSE(temp_files[i] == temp_files[(i+1)%3]);
- for (int i = 0; i < 3; i++)
- EXPECT_TRUE(DeleteFile(temp_files[i], false));
-}
-
-TEST_F(FileUtilTest, CreateAndOpenTemporaryFileTest) {
- FilePath names[3];
- FILE* fps[3];
- int i;
-
- // Create; make sure they are open and exist.
- for (i = 0; i < 3; ++i) {
- fps[i] = CreateAndOpenTemporaryFile(&(names[i]));
- ASSERT_TRUE(fps[i]);
- EXPECT_TRUE(PathExists(names[i]));
- }
-
- // Make sure all names are unique.
- for (i = 0; i < 3; ++i) {
- EXPECT_FALSE(names[i] == names[(i+1)%3]);
- }
-
- // Close and delete.
- for (i = 0; i < 3; ++i) {
- EXPECT_TRUE(CloseFile(fps[i]));
- EXPECT_TRUE(DeleteFile(names[i], false));
- }
-}
-
-TEST_F(FileUtilTest, FileToFILE) {
- File file;
- FILE* stream = FileToFILE(std::move(file), "w");
- EXPECT_FALSE(stream);
-
- FilePath file_name = temp_dir_.GetPath().Append(FPL("The file.txt"));
- file = File(file_name, File::FLAG_CREATE | File::FLAG_WRITE);
- EXPECT_TRUE(file.IsValid());
-
- stream = FileToFILE(std::move(file), "w");
- EXPECT_TRUE(stream);
- EXPECT_FALSE(file.IsValid());
- EXPECT_TRUE(CloseFile(stream));
-}
-
-TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
- FilePath temp_dir;
- ASSERT_TRUE(CreateNewTempDirectory(FilePath::StringType(), &temp_dir));
- EXPECT_TRUE(PathExists(temp_dir));
- EXPECT_TRUE(DeleteFile(temp_dir, false));
-}
-
-TEST_F(FileUtilTest, CreateNewTemporaryDirInDirTest) {
- FilePath new_dir;
- ASSERT_TRUE(CreateTemporaryDirInDir(
- temp_dir_.GetPath(), FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
- &new_dir));
- EXPECT_TRUE(PathExists(new_dir));
- EXPECT_TRUE(temp_dir_.GetPath().IsParent(new_dir));
- EXPECT_TRUE(DeleteFile(new_dir, false));
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-TEST_F(FileUtilTest, GetShmemTempDirTest) {
- FilePath dir;
- EXPECT_TRUE(GetShmemTempDir(false, &dir));
- EXPECT_TRUE(DirectoryExists(dir));
-}
-#endif
-
-TEST_F(FileUtilTest, GetHomeDirTest) {
-#if !defined(OS_ANDROID) // Not implemented on Android.
- // We don't actually know what the home directory is supposed to be without
- // calling some OS functions which would just duplicate the implementation.
- // So here we just test that it returns something "reasonable".
- FilePath home = GetHomeDir();
- ASSERT_FALSE(home.empty());
- ASSERT_TRUE(home.IsAbsolute());
-#endif
-}
-
-TEST_F(FileUtilTest, CreateDirectoryTest) {
- FilePath test_root =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("create_directory_test"));
-#if defined(OS_WIN)
- FilePath test_path =
- test_root.Append(FILE_PATH_LITERAL("dir\\tree\\likely\\doesnt\\exist\\"));
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- FilePath test_path =
- test_root.Append(FILE_PATH_LITERAL("dir/tree/likely/doesnt/exist/"));
-#endif
-
- EXPECT_FALSE(PathExists(test_path));
- EXPECT_TRUE(CreateDirectory(test_path));
- EXPECT_TRUE(PathExists(test_path));
- // CreateDirectory returns true if the DirectoryExists returns true.
- EXPECT_TRUE(CreateDirectory(test_path));
-
- // Doesn't work to create it on top of a non-dir
- test_path = test_path.Append(FILE_PATH_LITERAL("foobar.txt"));
- EXPECT_FALSE(PathExists(test_path));
- CreateTextFile(test_path, L"test file");
- EXPECT_TRUE(PathExists(test_path));
- EXPECT_FALSE(CreateDirectory(test_path));
-
- EXPECT_TRUE(DeleteFile(test_root, true));
- EXPECT_FALSE(PathExists(test_root));
- EXPECT_FALSE(PathExists(test_path));
-
- // Verify assumptions made by the Windows implementation:
- // 1. The current directory always exists.
- // 2. The root directory always exists.
- ASSERT_TRUE(DirectoryExists(FilePath(FilePath::kCurrentDirectory)));
- FilePath top_level = test_root;
- while (top_level != top_level.DirName()) {
- top_level = top_level.DirName();
- }
- ASSERT_TRUE(DirectoryExists(top_level));
-
- // Given these assumptions hold, it should be safe to
- // test that "creating" these directories succeeds.
- EXPECT_TRUE(CreateDirectory(
- FilePath(FilePath::kCurrentDirectory)));
- EXPECT_TRUE(CreateDirectory(top_level));
-
-#if defined(OS_WIN)
- FilePath invalid_drive(FILE_PATH_LITERAL("o:\\"));
- FilePath invalid_path =
- invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
- if (!PathExists(invalid_drive)) {
- EXPECT_FALSE(CreateDirectory(invalid_path));
- }
-#endif
-}
-
-TEST_F(FileUtilTest, DetectDirectoryTest) {
- // Check a directory
- FilePath test_root =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("detect_directory_test"));
- EXPECT_FALSE(PathExists(test_root));
- EXPECT_TRUE(CreateDirectory(test_root));
- EXPECT_TRUE(PathExists(test_root));
- EXPECT_TRUE(DirectoryExists(test_root));
- // Check a file
- FilePath test_path =
- test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
- EXPECT_FALSE(PathExists(test_path));
- CreateTextFile(test_path, L"test file");
- EXPECT_TRUE(PathExists(test_path));
- EXPECT_FALSE(DirectoryExists(test_path));
- EXPECT_TRUE(DeleteFile(test_path, false));
-
- EXPECT_TRUE(DeleteFile(test_root, true));
-}
-
-TEST_F(FileUtilTest, FileEnumeratorTest) {
- // Test an empty directory.
- FileEnumerator f0(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
- EXPECT_EQ(FPL(""), f0.Next().value());
- EXPECT_EQ(FPL(""), f0.Next().value());
-
- // Test an empty directory, non-recursively, including "..".
- FileEnumerator f0_dotdot(
- temp_dir_.GetPath(), false,
- FILES_AND_DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
- EXPECT_EQ(temp_dir_.GetPath().Append(FPL("..")).value(),
- f0_dotdot.Next().value());
- EXPECT_EQ(FPL(""), f0_dotdot.Next().value());
-
- // create the directories
- FilePath dir1 = temp_dir_.GetPath().Append(FPL("dir1"));
- EXPECT_TRUE(CreateDirectory(dir1));
- FilePath dir2 = temp_dir_.GetPath().Append(FPL("dir2"));
- EXPECT_TRUE(CreateDirectory(dir2));
- FilePath dir2inner = dir2.Append(FPL("inner"));
- EXPECT_TRUE(CreateDirectory(dir2inner));
-
- // create the files
- FilePath dir2file = dir2.Append(FPL("dir2file.txt"));
- CreateTextFile(dir2file, std::wstring());
- FilePath dir2innerfile = dir2inner.Append(FPL("innerfile.txt"));
- CreateTextFile(dir2innerfile, std::wstring());
- FilePath file1 = temp_dir_.GetPath().Append(FPL("file1.txt"));
- CreateTextFile(file1, std::wstring());
- FilePath file2_rel = dir2.Append(FilePath::kParentDirectory)
- .Append(FPL("file2.txt"));
- CreateTextFile(file2_rel, std::wstring());
- FilePath file2_abs = temp_dir_.GetPath().Append(FPL("file2.txt"));
-
- // Only enumerate files.
- FileEnumerator f1(temp_dir_.GetPath(), true, FileEnumerator::FILES);
- FindResultCollector c1(&f1);
- EXPECT_TRUE(c1.HasFile(file1));
- EXPECT_TRUE(c1.HasFile(file2_abs));
- EXPECT_TRUE(c1.HasFile(dir2file));
- EXPECT_TRUE(c1.HasFile(dir2innerfile));
- EXPECT_EQ(4, c1.size());
-
- // Only enumerate directories.
- FileEnumerator f2(temp_dir_.GetPath(), true, FileEnumerator::DIRECTORIES);
- FindResultCollector c2(&f2);
- EXPECT_TRUE(c2.HasFile(dir1));
- EXPECT_TRUE(c2.HasFile(dir2));
- EXPECT_TRUE(c2.HasFile(dir2inner));
- EXPECT_EQ(3, c2.size());
-
- // Only enumerate directories non-recursively.
- FileEnumerator f2_non_recursive(temp_dir_.GetPath(), false,
- FileEnumerator::DIRECTORIES);
- FindResultCollector c2_non_recursive(&f2_non_recursive);
- EXPECT_TRUE(c2_non_recursive.HasFile(dir1));
- EXPECT_TRUE(c2_non_recursive.HasFile(dir2));
- EXPECT_EQ(2, c2_non_recursive.size());
-
- // Only enumerate directories, non-recursively, including "..".
- FileEnumerator f2_dotdot(
- temp_dir_.GetPath(), false,
- FileEnumerator::DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
- FindResultCollector c2_dotdot(&f2_dotdot);
- EXPECT_TRUE(c2_dotdot.HasFile(dir1));
- EXPECT_TRUE(c2_dotdot.HasFile(dir2));
- EXPECT_TRUE(c2_dotdot.HasFile(temp_dir_.GetPath().Append(FPL(".."))));
- EXPECT_EQ(3, c2_dotdot.size());
-
- // Enumerate files and directories.
- FileEnumerator f3(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
- FindResultCollector c3(&f3);
- EXPECT_TRUE(c3.HasFile(dir1));
- EXPECT_TRUE(c3.HasFile(dir2));
- EXPECT_TRUE(c3.HasFile(file1));
- EXPECT_TRUE(c3.HasFile(file2_abs));
- EXPECT_TRUE(c3.HasFile(dir2file));
- EXPECT_TRUE(c3.HasFile(dir2inner));
- EXPECT_TRUE(c3.HasFile(dir2innerfile));
- EXPECT_EQ(7, c3.size());
-
- // Non-recursive operation.
- FileEnumerator f4(temp_dir_.GetPath(), false, FILES_AND_DIRECTORIES);
- FindResultCollector c4(&f4);
- EXPECT_TRUE(c4.HasFile(dir2));
- EXPECT_TRUE(c4.HasFile(dir2));
- EXPECT_TRUE(c4.HasFile(file1));
- EXPECT_TRUE(c4.HasFile(file2_abs));
- EXPECT_EQ(4, c4.size());
-
- // Enumerate with a pattern.
- FileEnumerator f5(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES,
- FPL("dir*"));
- FindResultCollector c5(&f5);
- EXPECT_TRUE(c5.HasFile(dir1));
- EXPECT_TRUE(c5.HasFile(dir2));
- EXPECT_TRUE(c5.HasFile(dir2file));
- EXPECT_TRUE(c5.HasFile(dir2inner));
- EXPECT_TRUE(c5.HasFile(dir2innerfile));
- EXPECT_EQ(5, c5.size());
-
-#if defined(OS_WIN)
- {
- // Make dir1 point to dir2.
- ReparsePoint reparse_point(dir1, dir2);
- EXPECT_TRUE(reparse_point.IsValid());
-
- // There can be a delay for the enumeration code to see the change on
- // the file system so skip this test for XP.
- // Enumerate the reparse point.
- FileEnumerator f6(dir1, true, FILES_AND_DIRECTORIES);
- FindResultCollector c6(&f6);
- FilePath inner2 = dir1.Append(FPL("inner"));
- EXPECT_TRUE(c6.HasFile(inner2));
- EXPECT_TRUE(c6.HasFile(inner2.Append(FPL("innerfile.txt"))));
- EXPECT_TRUE(c6.HasFile(dir1.Append(FPL("dir2file.txt"))));
- EXPECT_EQ(3, c6.size());
-
- // No changes for non recursive operation.
- FileEnumerator f7(temp_dir_.GetPath(), false, FILES_AND_DIRECTORIES);
- FindResultCollector c7(&f7);
- EXPECT_TRUE(c7.HasFile(dir2));
- EXPECT_TRUE(c7.HasFile(dir2));
- EXPECT_TRUE(c7.HasFile(file1));
- EXPECT_TRUE(c7.HasFile(file2_abs));
- EXPECT_EQ(4, c7.size());
-
- // Should not enumerate inside dir1 when using recursion.
- FileEnumerator f8(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
- FindResultCollector c8(&f8);
- EXPECT_TRUE(c8.HasFile(dir1));
- EXPECT_TRUE(c8.HasFile(dir2));
- EXPECT_TRUE(c8.HasFile(file1));
- EXPECT_TRUE(c8.HasFile(file2_abs));
- EXPECT_TRUE(c8.HasFile(dir2file));
- EXPECT_TRUE(c8.HasFile(dir2inner));
- EXPECT_TRUE(c8.HasFile(dir2innerfile));
- EXPECT_EQ(7, c8.size());
- }
-#endif
-
- // Make sure the destructor closes the find handle while in the middle of a
- // query to allow TearDown to delete the directory.
- FileEnumerator f9(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
- EXPECT_FALSE(f9.Next().value().empty()); // Should have found something
- // (we don't care what).
-}
-
-TEST_F(FileUtilTest, AppendToFile) {
- FilePath data_dir =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("FilePathTest"));
-
- // Create a fresh, empty copy of this directory.
- if (PathExists(data_dir)) {
- ASSERT_TRUE(DeleteFile(data_dir, true));
- }
- ASSERT_TRUE(CreateDirectory(data_dir));
-
- // Create a fresh, empty copy of this directory.
- if (PathExists(data_dir)) {
- ASSERT_TRUE(DeleteFile(data_dir, true));
- }
- ASSERT_TRUE(CreateDirectory(data_dir));
- FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
-
- std::string data("hello");
- EXPECT_FALSE(AppendToFile(foobar, data.c_str(), data.size()));
- EXPECT_EQ(static_cast<int>(data.length()),
- WriteFile(foobar, data.c_str(), data.length()));
- EXPECT_TRUE(AppendToFile(foobar, data.c_str(), data.size()));
-
- const std::wstring read_content = ReadTextFile(foobar);
- EXPECT_EQ(L"hellohello", read_content);
-}
-
-TEST_F(FileUtilTest, ReadFile) {
- // Create a test file to be read.
- const std::string kTestData("The quick brown fox jumps over the lazy dog.");
- FilePath file_path =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileTest"));
-
- ASSERT_EQ(static_cast<int>(kTestData.size()),
- WriteFile(file_path, kTestData.data(), kTestData.size()));
-
- // Make buffers with various size.
- std::vector<char> small_buffer(kTestData.size() / 2);
- std::vector<char> exact_buffer(kTestData.size());
- std::vector<char> large_buffer(kTestData.size() * 2);
-
- // Read the file with smaller buffer.
- int bytes_read_small = ReadFile(
- file_path, &small_buffer[0], static_cast<int>(small_buffer.size()));
- EXPECT_EQ(static_cast<int>(small_buffer.size()), bytes_read_small);
- EXPECT_EQ(
- std::string(kTestData.begin(), kTestData.begin() + small_buffer.size()),
- std::string(small_buffer.begin(), small_buffer.end()));
-
- // Read the file with buffer which have exactly same size.
- int bytes_read_exact = ReadFile(
- file_path, &exact_buffer[0], static_cast<int>(exact_buffer.size()));
- EXPECT_EQ(static_cast<int>(kTestData.size()), bytes_read_exact);
- EXPECT_EQ(kTestData, std::string(exact_buffer.begin(), exact_buffer.end()));
-
- // Read the file with larger buffer.
- int bytes_read_large = ReadFile(
- file_path, &large_buffer[0], static_cast<int>(large_buffer.size()));
- EXPECT_EQ(static_cast<int>(kTestData.size()), bytes_read_large);
- EXPECT_EQ(kTestData, std::string(large_buffer.begin(),
- large_buffer.begin() + kTestData.size()));
-
- // Make sure the return value is -1 if the file doesn't exist.
- FilePath file_path_not_exist =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileNotExistTest"));
- EXPECT_EQ(-1,
- ReadFile(file_path_not_exist,
- &exact_buffer[0],
- static_cast<int>(exact_buffer.size())));
-}
-
-TEST_F(FileUtilTest, ReadFileToString) {
- const char kTestData[] = "0123";
- std::string data;
-
- FilePath file_path =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
- FilePath file_path_dangerous =
- temp_dir_.GetPath()
- .Append(FILE_PATH_LITERAL(".."))
- .Append(temp_dir_.GetPath().BaseName())
- .Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
-
- // Create test file.
- ASSERT_EQ(static_cast<int>(strlen(kTestData)),
- WriteFile(file_path, kTestData, strlen(kTestData)));
-
- EXPECT_TRUE(ReadFileToString(file_path, &data));
- EXPECT_EQ(kTestData, data);
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 0));
- EXPECT_EQ(0u, data.length());
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 2));
- EXPECT_EQ("01", data);
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 3));
- EXPECT_EQ("012", data);
-
- data = "temp";
- EXPECT_TRUE(ReadFileToStringWithMaxSize(file_path, &data, 4));
- EXPECT_EQ("0123", data);
-
- data = "temp";
- EXPECT_TRUE(ReadFileToStringWithMaxSize(file_path, &data, 6));
- EXPECT_EQ("0123", data);
-
- EXPECT_TRUE(ReadFileToStringWithMaxSize(file_path, nullptr, 6));
-
- EXPECT_TRUE(ReadFileToString(file_path, nullptr));
-
- data = "temp";
- EXPECT_FALSE(ReadFileToString(file_path_dangerous, &data));
- EXPECT_EQ(0u, data.length());
-
- // Delete test file.
- EXPECT_TRUE(DeleteFile(file_path, false));
-
- data = "temp";
- EXPECT_FALSE(ReadFileToString(file_path, &data));
- EXPECT_EQ(0u, data.length());
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 6));
- EXPECT_EQ(0u, data.length());
-}
-
-#if !defined(OS_WIN)
-TEST_F(FileUtilTest, ReadFileToStringWithUnknownFileSize) {
- FilePath file_path("/dev/zero");
- std::string data = "temp";
-
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 0));
- EXPECT_EQ(0u, data.length());
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 2));
- EXPECT_EQ(std::string(2, '\0'), data);
-
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, nullptr, 6));
-
- // Read more than buffer size.
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, kLargeFileSize));
- EXPECT_EQ(kLargeFileSize, data.length());
- EXPECT_EQ(std::string(kLargeFileSize, '\0'), data);
-
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, nullptr, kLargeFileSize));
-}
-#endif // !defined(OS_WIN)
-
-#if !defined(OS_WIN) && !defined(OS_NACL) && !defined(OS_FUCHSIA) && \
- !defined(OS_IOS)
-#define ChildMain WriteToPipeChildMain
-#define ChildMainString "WriteToPipeChildMain"
-
-MULTIPROCESS_TEST_MAIN(ChildMain) {
- const char kTestData[] = "0123";
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- const FilePath pipe_path = command_line->GetSwitchValuePath("pipe-path");
-
- int fd = open(pipe_path.value().c_str(), O_WRONLY);
- CHECK_NE(-1, fd);
- size_t written = 0;
- while (written < strlen(kTestData)) {
- ssize_t res = write(fd, kTestData + written, strlen(kTestData) - written);
- if (res == -1)
- break;
- written += res;
- }
- CHECK_EQ(strlen(kTestData), written);
- CHECK_EQ(0, close(fd));
- return 0;
-}
-
-#define MoreThanBufferSizeChildMain WriteToPipeMoreThanBufferSizeChildMain
-#define MoreThanBufferSizeChildMainString \
- "WriteToPipeMoreThanBufferSizeChildMain"
-
-MULTIPROCESS_TEST_MAIN(MoreThanBufferSizeChildMain) {
- std::string data(kLargeFileSize, 'c');
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- const FilePath pipe_path = command_line->GetSwitchValuePath("pipe-path");
-
- int fd = open(pipe_path.value().c_str(), O_WRONLY);
- CHECK_NE(-1, fd);
-
- size_t written = 0;
- while (written < data.size()) {
- ssize_t res = write(fd, data.c_str() + written, data.size() - written);
- if (res == -1) {
- // We are unable to write because reading process has already read
- // requested number of bytes and closed pipe.
- break;
- }
- written += res;
- }
- CHECK_EQ(0, close(fd));
- return 0;
-}
-
-TEST_F(FileUtilTest, ReadFileToStringWithNamedPipe) {
- FilePath pipe_path =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("test_pipe"));
- ASSERT_EQ(0, mkfifo(pipe_path.value().c_str(), 0600));
-
- base::CommandLine child_command_line(
- base::GetMultiProcessTestChildBaseCommandLine());
- child_command_line.AppendSwitchPath("pipe-path", pipe_path);
-
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- ChildMainString, child_command_line, base::LaunchOptions());
- ASSERT_TRUE(child_process.IsValid());
-
- std::string data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(pipe_path, &data, 2));
- EXPECT_EQ("01", data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- ChildMainString, child_command_line, base::LaunchOptions());
- ASSERT_TRUE(child_process.IsValid());
-
- std::string data = "temp";
- EXPECT_TRUE(ReadFileToStringWithMaxSize(pipe_path, &data, 6));
- EXPECT_EQ("0123", data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line,
- base::LaunchOptions());
- ASSERT_TRUE(child_process.IsValid());
-
- std::string data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(pipe_path, &data, 6));
- EXPECT_EQ("cccccc", data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line,
- base::LaunchOptions());
- ASSERT_TRUE(child_process.IsValid());
-
- std::string data = "temp";
- EXPECT_FALSE(
- ReadFileToStringWithMaxSize(pipe_path, &data, kLargeFileSize - 1));
- EXPECT_EQ(std::string(kLargeFileSize - 1, 'c'), data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line,
- base::LaunchOptions());
- ASSERT_TRUE(child_process.IsValid());
-
- std::string data = "temp";
- EXPECT_TRUE(ReadFileToStringWithMaxSize(pipe_path, &data, kLargeFileSize));
- EXPECT_EQ(std::string(kLargeFileSize, 'c'), data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line,
- base::LaunchOptions());
- ASSERT_TRUE(child_process.IsValid());
-
- std::string data = "temp";
- EXPECT_TRUE(
- ReadFileToStringWithMaxSize(pipe_path, &data, kLargeFileSize * 5));
- EXPECT_EQ(std::string(kLargeFileSize, 'c'), data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
-
- ASSERT_EQ(0, unlink(pipe_path.value().c_str()));
-}
-#endif // !defined(OS_WIN) && !defined(OS_NACL) && !defined(OS_FUCHSIA) &&
- // !defined(OS_IOS)
-
-#if defined(OS_WIN)
-#define ChildMain WriteToPipeChildMain
-#define ChildMainString "WriteToPipeChildMain"
-
-MULTIPROCESS_TEST_MAIN(ChildMain) {
- const char kTestData[] = "0123";
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- const FilePath pipe_path = command_line->GetSwitchValuePath("pipe-path");
- std::string switch_string = command_line->GetSwitchValueASCII("sync_event");
- EXPECT_FALSE(switch_string.empty());
- unsigned int switch_uint = 0;
- EXPECT_TRUE(StringToUint(switch_string, &switch_uint));
- win::ScopedHandle sync_event(win::Uint32ToHandle(switch_uint));
-
- HANDLE ph = CreateNamedPipe(pipe_path.value().c_str(), PIPE_ACCESS_OUTBOUND,
- PIPE_WAIT, 1, 0, 0, 0, NULL);
- EXPECT_NE(ph, INVALID_HANDLE_VALUE);
- EXPECT_TRUE(SetEvent(sync_event.Get()));
- EXPECT_TRUE(ConnectNamedPipe(ph, NULL));
-
- DWORD written;
- EXPECT_TRUE(::WriteFile(ph, kTestData, strlen(kTestData), &written, NULL));
- EXPECT_EQ(strlen(kTestData), written);
- CloseHandle(ph);
- return 0;
-}
-
-#define MoreThanBufferSizeChildMain WriteToPipeMoreThanBufferSizeChildMain
-#define MoreThanBufferSizeChildMainString \
- "WriteToPipeMoreThanBufferSizeChildMain"
-
-MULTIPROCESS_TEST_MAIN(MoreThanBufferSizeChildMain) {
- std::string data(kLargeFileSize, 'c');
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- const FilePath pipe_path = command_line->GetSwitchValuePath("pipe-path");
- std::string switch_string = command_line->GetSwitchValueASCII("sync_event");
- EXPECT_FALSE(switch_string.empty());
- unsigned int switch_uint = 0;
- EXPECT_TRUE(StringToUint(switch_string, &switch_uint));
- win::ScopedHandle sync_event(win::Uint32ToHandle(switch_uint));
-
- HANDLE ph = CreateNamedPipe(pipe_path.value().c_str(), PIPE_ACCESS_OUTBOUND,
- PIPE_WAIT, 1, data.size(), data.size(), 0, NULL);
- EXPECT_NE(ph, INVALID_HANDLE_VALUE);
- EXPECT_TRUE(SetEvent(sync_event.Get()));
- EXPECT_TRUE(ConnectNamedPipe(ph, NULL));
-
- DWORD written;
- EXPECT_TRUE(::WriteFile(ph, data.c_str(), data.size(), &written, NULL));
- EXPECT_EQ(data.size(), written);
- CloseHandle(ph);
- return 0;
-}
-
-TEST_F(FileUtilTest, ReadFileToStringWithNamedPipe) {
- FilePath pipe_path(FILE_PATH_LITERAL("\\\\.\\pipe\\test_pipe"));
- win::ScopedHandle sync_event(CreateEvent(0, false, false, nullptr));
-
- base::CommandLine child_command_line(
- base::GetMultiProcessTestChildBaseCommandLine());
- child_command_line.AppendSwitchPath("pipe-path", pipe_path);
- child_command_line.AppendSwitchASCII(
- "sync_event", UintToString(win::HandleToUint32(sync_event.Get())));
-
- base::LaunchOptions options;
- options.handles_to_inherit.push_back(sync_event.Get());
-
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- ChildMainString, child_command_line, options);
- ASSERT_TRUE(child_process.IsValid());
- // Wait for pipe creation in child process.
- EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(sync_event.Get(), INFINITE));
-
- std::string data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(pipe_path, &data, 2));
- EXPECT_EQ("01", data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- ChildMainString, child_command_line, options);
- ASSERT_TRUE(child_process.IsValid());
- // Wait for pipe creation in child process.
- EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(sync_event.Get(), INFINITE));
-
- std::string data = "temp";
- EXPECT_TRUE(ReadFileToStringWithMaxSize(pipe_path, &data, 6));
- EXPECT_EQ("0123", data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line, options);
- ASSERT_TRUE(child_process.IsValid());
- // Wait for pipe creation in child process.
- EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(sync_event.Get(), INFINITE));
-
- std::string data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(pipe_path, &data, 6));
- EXPECT_EQ("cccccc", data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line, options);
- ASSERT_TRUE(child_process.IsValid());
- // Wait for pipe creation in child process.
- EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(sync_event.Get(), INFINITE));
-
- std::string data = "temp";
- EXPECT_FALSE(
- ReadFileToStringWithMaxSize(pipe_path, &data, kLargeFileSize - 1));
- EXPECT_EQ(std::string(kLargeFileSize - 1, 'c'), data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line, options);
- ASSERT_TRUE(child_process.IsValid());
- // Wait for pipe creation in child process.
- EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(sync_event.Get(), INFINITE));
-
- std::string data = "temp";
- EXPECT_TRUE(ReadFileToStringWithMaxSize(pipe_path, &data, kLargeFileSize));
- EXPECT_EQ(std::string(kLargeFileSize, 'c'), data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
- {
- base::Process child_process = base::SpawnMultiProcessTestChild(
- MoreThanBufferSizeChildMainString, child_command_line, options);
- ASSERT_TRUE(child_process.IsValid());
- // Wait for pipe creation in child process.
- EXPECT_EQ(WAIT_OBJECT_0, WaitForSingleObject(sync_event.Get(), INFINITE));
-
- std::string data = "temp";
- EXPECT_TRUE(
- ReadFileToStringWithMaxSize(pipe_path, &data, kLargeFileSize * 5));
- EXPECT_EQ(std::string(kLargeFileSize, 'c'), data);
-
- int rv = -1;
- ASSERT_TRUE(WaitForMultiprocessTestChildExit(
- child_process, TestTimeouts::action_timeout(), &rv));
- ASSERT_EQ(0, rv);
- }
-}
-#endif // defined(OS_WIN)
-
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-TEST_F(FileUtilTest, ReadFileToStringWithProcFileSystem) {
- FilePath file_path("/proc/cpuinfo");
- std::string data = "temp";
-
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 0));
- EXPECT_EQ(0u, data.length());
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 2));
-#if defined(OS_ANDROID)
- EXPECT_EQ("Pr", data);
-#else
- EXPECT_EQ("pr", data);
-#endif
-
- data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 4));
-#if defined(OS_ANDROID)
- EXPECT_EQ("Proc", data);
-#else
- EXPECT_EQ("proc", data);
-#endif
-
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, nullptr, 4));
-}
-#endif // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-
-TEST_F(FileUtilTest, ReadFileToStringWithLargeFile) {
- std::string data(kLargeFileSize, 'c');
-
- FilePath file_path =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
-
- // Create test file.
- ASSERT_EQ(static_cast<int>(kLargeFileSize),
- WriteFile(file_path, data.c_str(), kLargeFileSize));
-
- std::string actual_data = "temp";
- EXPECT_TRUE(ReadFileToString(file_path, &actual_data));
- EXPECT_EQ(data, actual_data);
-
- actual_data = "temp";
- EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &actual_data, 0));
- EXPECT_EQ(0u, actual_data.length());
-
- // Read more than buffer size.
- actual_data = "temp";
- EXPECT_FALSE(
- ReadFileToStringWithMaxSize(file_path, &actual_data, kLargeFileSize - 1));
- EXPECT_EQ(std::string(kLargeFileSize - 1, 'c'), actual_data);
-}
-
-TEST_F(FileUtilTest, TouchFile) {
- FilePath data_dir =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("FilePathTest"));
-
- // Create a fresh, empty copy of this directory.
- if (PathExists(data_dir)) {
- ASSERT_TRUE(DeleteFile(data_dir, true));
- }
- ASSERT_TRUE(CreateDirectory(data_dir));
-
- FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
- std::string data("hello");
- ASSERT_EQ(static_cast<int>(data.length()),
- WriteFile(foobar, data.c_str(), data.length()));
-
- Time access_time;
- // This timestamp is divisible by one day (in local timezone),
- // to make it work on FAT too.
- ASSERT_TRUE(Time::FromString("Wed, 16 Nov 1994, 00:00:00",
- &access_time));
-
- Time modification_time;
- // Note that this timestamp is divisible by two (seconds) - FAT stores
- // modification times with 2s resolution.
- ASSERT_TRUE(Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT",
- &modification_time));
-
- ASSERT_TRUE(TouchFile(foobar, access_time, modification_time));
- File::Info file_info;
- ASSERT_TRUE(GetFileInfo(foobar, &file_info));
-#if !defined(OS_FUCHSIA)
- // Access time is not supported on Fuchsia, see https://crbug.com/735233.
- EXPECT_EQ(access_time.ToInternalValue(),
- file_info.last_accessed.ToInternalValue());
-#endif
- EXPECT_EQ(modification_time.ToInternalValue(),
- file_info.last_modified.ToInternalValue());
-}
-
-TEST_F(FileUtilTest, IsDirectoryEmpty) {
- FilePath empty_dir =
- temp_dir_.GetPath().Append(FILE_PATH_LITERAL("EmptyDir"));
-
- ASSERT_FALSE(PathExists(empty_dir));
-
- ASSERT_TRUE(CreateDirectory(empty_dir));
-
- EXPECT_TRUE(IsDirectoryEmpty(empty_dir));
-
- FilePath foo(empty_dir.Append(FILE_PATH_LITERAL("foo.txt")));
- std::string bar("baz");
- ASSERT_EQ(static_cast<int>(bar.length()),
- WriteFile(foo, bar.c_str(), bar.length()));
-
- EXPECT_FALSE(IsDirectoryEmpty(empty_dir));
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-TEST_F(FileUtilTest, SetNonBlocking) {
- const int kInvalidFd = 99999;
- EXPECT_FALSE(SetNonBlocking(kInvalidFd));
-
- base::FilePath path;
- ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
- path = path.Append(FPL("file_util")).Append(FPL("original.txt"));
- ScopedFD fd(open(path.value().c_str(), O_RDONLY));
- ASSERT_GE(fd.get(), 0);
- EXPECT_TRUE(SetNonBlocking(fd.get()));
-}
-
-TEST_F(FileUtilTest, SetCloseOnExec) {
- const int kInvalidFd = 99999;
- EXPECT_FALSE(SetCloseOnExec(kInvalidFd));
-
- base::FilePath path;
- ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
- path = path.Append(FPL("file_util")).Append(FPL("original.txt"));
- ScopedFD fd(open(path.value().c_str(), O_RDONLY));
- ASSERT_GE(fd.get(), 0);
- EXPECT_TRUE(SetCloseOnExec(fd.get()));
-}
-
-#endif
-
-#if defined(OS_POSIX)
-
-// Testing VerifyPathControlledByAdmin() is hard, because there is no
-// way a test can make a file owned by root, or change file paths
-// at the root of the file system. VerifyPathControlledByAdmin()
-// is implemented as a call to VerifyPathControlledByUser, which gives
-// us the ability to test with paths under the test's temp directory,
-// using a user id we control.
-// Pull tests of VerifyPathControlledByUserTest() into a separate test class
-// with a common SetUp() method.
-class VerifyPathControlledByUserTest : public FileUtilTest {
- protected:
- void SetUp() override {
- FileUtilTest::SetUp();
-
- // Create a basic structure used by each test.
- // base_dir_
- // |-> sub_dir_
- // |-> text_file_
-
- base_dir_ = temp_dir_.GetPath().AppendASCII("base_dir");
- ASSERT_TRUE(CreateDirectory(base_dir_));
-
- sub_dir_ = base_dir_.AppendASCII("sub_dir");
- ASSERT_TRUE(CreateDirectory(sub_dir_));
-
- text_file_ = sub_dir_.AppendASCII("file.txt");
- CreateTextFile(text_file_, L"This text file has some text in it.");
-
- // Get the user and group files are created with from |base_dir_|.
- struct stat stat_buf;
- ASSERT_EQ(0, stat(base_dir_.value().c_str(), &stat_buf));
- uid_ = stat_buf.st_uid;
- ok_gids_.insert(stat_buf.st_gid);
- bad_gids_.insert(stat_buf.st_gid + 1);
-
- ASSERT_EQ(uid_, getuid()); // This process should be the owner.
-
- // To ensure that umask settings do not cause the initial state
- // of permissions to be different from what we expect, explicitly
- // set permissions on the directories we create.
- // Make all files and directories non-world-writable.
-
- // Users and group can read, write, traverse
- int enabled_permissions =
- FILE_PERMISSION_USER_MASK | FILE_PERMISSION_GROUP_MASK;
- // Other users can't read, write, traverse
- int disabled_permissions = FILE_PERMISSION_OTHERS_MASK;
-
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(
- base_dir_, enabled_permissions, disabled_permissions));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(
- sub_dir_, enabled_permissions, disabled_permissions));
- }
-
- FilePath base_dir_;
- FilePath sub_dir_;
- FilePath text_file_;
- uid_t uid_;
-
- std::set<gid_t> ok_gids_;
- std::set<gid_t> bad_gids_;
-};
-
-TEST_F(VerifyPathControlledByUserTest, BadPaths) {
- // File does not exist.
- FilePath does_not_exist = base_dir_.AppendASCII("does")
- .AppendASCII("not")
- .AppendASCII("exist");
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, does_not_exist, uid_, ok_gids_));
-
- // |base| not a subpath of |path|.
- EXPECT_FALSE(VerifyPathControlledByUser(sub_dir_, base_dir_, uid_, ok_gids_));
-
- // An empty base path will fail to be a prefix for any path.
- FilePath empty;
- EXPECT_FALSE(VerifyPathControlledByUser(empty, base_dir_, uid_, ok_gids_));
-
- // Finding that a bad call fails proves nothing unless a good call succeeds.
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
-}
-
-TEST_F(VerifyPathControlledByUserTest, Symlinks) {
- // Symlinks in the path should cause failure.
-
- // Symlink to the file at the end of the path.
- FilePath file_link = base_dir_.AppendASCII("file_link");
- ASSERT_TRUE(CreateSymbolicLink(text_file_, file_link))
- << "Failed to create symlink.";
-
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, file_link, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(file_link, file_link, uid_, ok_gids_));
-
- // Symlink from one directory to another within the path.
- FilePath link_to_sub_dir = base_dir_.AppendASCII("link_to_sub_dir");
- ASSERT_TRUE(CreateSymbolicLink(sub_dir_, link_to_sub_dir))
- << "Failed to create symlink.";
-
- FilePath file_path_with_link = link_to_sub_dir.AppendASCII("file.txt");
- ASSERT_TRUE(PathExists(file_path_with_link));
-
- EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, file_path_with_link, uid_,
- ok_gids_));
-
- EXPECT_FALSE(VerifyPathControlledByUser(link_to_sub_dir, file_path_with_link,
- uid_, ok_gids_));
-
- // Symlinks in parents of base path are allowed.
- EXPECT_TRUE(VerifyPathControlledByUser(file_path_with_link,
- file_path_with_link, uid_, ok_gids_));
-}
-
-TEST_F(VerifyPathControlledByUserTest, OwnershipChecks) {
- // Get a uid that is not the uid of files we create.
- uid_t bad_uid = uid_ + 1;
-
- // Make all files and directories non-world-writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
-
- // We control these paths.
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Another user does not control these paths.
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, sub_dir_, bad_uid, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, bad_uid, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, bad_uid, ok_gids_));
-
- // Another group does not control the paths.
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, bad_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, bad_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, bad_gids_));
-}
-
-TEST_F(VerifyPathControlledByUserTest, GroupWriteTest) {
- // Make all files and directories writable only by their owner.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH|S_IWGRP));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH|S_IWGRP));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(text_file_, 0u, S_IWOTH|S_IWGRP));
-
- // Any group is okay because the path is not group-writable.
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, bad_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, bad_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, bad_gids_));
-
- // No group is okay, because we don't check the group
- // if no group can write.
- std::set<gid_t> no_gids; // Empty set of gids.
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, no_gids));
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, text_file_, uid_, no_gids));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, no_gids));
-
- // Make all files and directories writable by their group.
- ASSERT_NO_FATAL_FAILURE(ChangePosixFilePermissions(base_dir_, S_IWGRP, 0u));
- ASSERT_NO_FATAL_FAILURE(ChangePosixFilePermissions(sub_dir_, S_IWGRP, 0u));
- ASSERT_NO_FATAL_FAILURE(ChangePosixFilePermissions(text_file_, S_IWGRP, 0u));
-
- // Now |ok_gids_| works, but |bad_gids_| fails.
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, bad_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, bad_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, bad_gids_));
-
- // Because any group in the group set is allowed,
- // the union of good and bad gids passes.
-
- std::set<gid_t> multiple_gids;
- std::set_union(
- ok_gids_.begin(), ok_gids_.end(),
- bad_gids_.begin(), bad_gids_.end(),
- std::inserter(multiple_gids, multiple_gids.begin()));
-
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, multiple_gids));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, multiple_gids));
- EXPECT_TRUE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, multiple_gids));
-}
-
-TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
- // Make all files and directories non-world-writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
-
- // Initialy, we control all parts of the path.
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Make base_dir_ world-writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(base_dir_, S_IWOTH, 0u));
- EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Make sub_dir_ world writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(sub_dir_, S_IWOTH, 0u));
- EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Make text_file_ world writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(text_file_, S_IWOTH, 0u));
- EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Make sub_dir_ non-world writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
- EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Make base_dir_ non-world-writable.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_FALSE(
- VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-
- // Back to the initial state: Nothing is writable, so every path
- // should pass.
- ASSERT_NO_FATAL_FAILURE(
- ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
- EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
- EXPECT_TRUE(
- VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
- EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
-}
-
-#endif // defined(OS_POSIX)
-
-#if defined(OS_ANDROID)
-TEST_F(FileUtilTest, ValidContentUriTest) {
- // Get the test image path.
- FilePath data_dir;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
- data_dir = data_dir.AppendASCII("file_util");
- ASSERT_TRUE(PathExists(data_dir));
- FilePath image_file = data_dir.Append(FILE_PATH_LITERAL("red.png"));
- int64_t image_size;
- GetFileSize(image_file, &image_size);
- ASSERT_GT(image_size, 0);
-
- // Insert the image into MediaStore. MediaStore will do some conversions, and
- // return the content URI.
- FilePath path = InsertImageIntoMediaStore(image_file);
- EXPECT_TRUE(path.IsContentUri());
- EXPECT_TRUE(PathExists(path));
- // The file size may not equal to the input image as MediaStore may convert
- // the image.
- int64_t content_uri_size;
- GetFileSize(path, &content_uri_size);
- EXPECT_EQ(image_size, content_uri_size);
-
- // We should be able to read the file.
- File file = OpenContentUriForRead(path);
- EXPECT_TRUE(file.IsValid());
- auto buffer = std::make_unique<char[]>(image_size);
- EXPECT_TRUE(file.ReadAtCurrentPos(buffer.get(), image_size));
-}
-
-TEST_F(FileUtilTest, NonExistentContentUriTest) {
- FilePath path("content://foo.bar");
- EXPECT_TRUE(path.IsContentUri());
- EXPECT_FALSE(PathExists(path));
- // Size should be smaller than 0.
- int64_t size;
- EXPECT_FALSE(GetFileSize(path, &size));
-
- // We should not be able to read the file.
- File file = OpenContentUriForRead(path);
- EXPECT_FALSE(file.IsValid());
-}
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-TEST(ScopedFD, ScopedFDDoesClose) {
- int fds[2];
- char c = 0;
- ASSERT_EQ(0, pipe(fds));
- const int write_end = fds[1];
- ScopedFD read_end_closer(fds[0]);
- {
- ScopedFD write_end_closer(fds[1]);
- }
- // This is the only thread. This file descriptor should no longer be valid.
- int ret = close(write_end);
- EXPECT_EQ(-1, ret);
- EXPECT_EQ(EBADF, errno);
- // Make sure read(2) won't block.
- ASSERT_EQ(0, fcntl(fds[0], F_SETFL, O_NONBLOCK));
- // Reading the pipe should EOF.
- EXPECT_EQ(0, read(fds[0], &c, 1));
-}
-
-#if defined(GTEST_HAS_DEATH_TEST)
-void CloseWithScopedFD(int fd) {
- ScopedFD fd_closer(fd);
-}
-#endif
-
-TEST(ScopedFD, ScopedFDCrashesOnCloseFailure) {
- int fds[2];
- ASSERT_EQ(0, pipe(fds));
- ScopedFD read_end_closer(fds[0]);
- EXPECT_EQ(0, IGNORE_EINTR(close(fds[1])));
-#if defined(GTEST_HAS_DEATH_TEST)
- // This is the only thread. This file descriptor should no longer be valid.
- // Trying to close it should crash. This is important for security.
- EXPECT_DEATH(CloseWithScopedFD(fds[1]), "");
-#endif
-}
-
-#endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-} // namespace
-
-} // namespace base
diff --git a/base/files/important_file_writer_unittest.cc b/base/files/important_file_writer_unittest.cc
deleted file mode 100644
index 493fb36..0000000
--- a/base/files/important_file_writer_unittest.cc
+++ /dev/null
@@ -1,351 +0,0 @@
-// 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.
-
-#include "base/files/important_file_writer.h"
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/test/histogram_tester.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
-#include "base/timer/mock_timer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-std::string GetFileContent(const FilePath& path) {
- std::string content;
- if (!ReadFileToString(path, &content)) {
- NOTREACHED();
- }
- return content;
-}
-
-class DataSerializer : public ImportantFileWriter::DataSerializer {
- public:
- explicit DataSerializer(const std::string& data) : data_(data) {
- }
-
- bool SerializeData(std::string* output) override {
- output->assign(data_);
- return true;
- }
-
- private:
- const std::string data_;
-};
-
-class FailingDataSerializer : public ImportantFileWriter::DataSerializer {
- public:
- bool SerializeData(std::string* output) override { return false; }
-};
-
-enum WriteCallbackObservationState {
- NOT_CALLED,
- CALLED_WITH_ERROR,
- CALLED_WITH_SUCCESS,
-};
-
-class WriteCallbacksObserver {
- public:
- WriteCallbacksObserver() = default;
-
- // Register OnBeforeWrite() and OnAfterWrite() to be called on the next write
- // of |writer|.
- void ObserveNextWriteCallbacks(ImportantFileWriter* writer);
-
- // Returns the |WriteCallbackObservationState| which was observed, then resets
- // it to |NOT_CALLED|.
- WriteCallbackObservationState GetAndResetObservationState();
-
- private:
- void OnBeforeWrite() {
- EXPECT_FALSE(before_write_called_);
- before_write_called_ = true;
- }
-
- void OnAfterWrite(bool success) {
- EXPECT_EQ(NOT_CALLED, after_write_observation_state_);
- after_write_observation_state_ =
- success ? CALLED_WITH_SUCCESS : CALLED_WITH_ERROR;
- }
-
- bool before_write_called_ = false;
- WriteCallbackObservationState after_write_observation_state_ = NOT_CALLED;
-
- DISALLOW_COPY_AND_ASSIGN(WriteCallbacksObserver);
-};
-
-void WriteCallbacksObserver::ObserveNextWriteCallbacks(
- ImportantFileWriter* writer) {
- writer->RegisterOnNextWriteCallbacks(
- base::Bind(&WriteCallbacksObserver::OnBeforeWrite,
- base::Unretained(this)),
- base::Bind(&WriteCallbacksObserver::OnAfterWrite,
- base::Unretained(this)));
-}
-
-WriteCallbackObservationState
-WriteCallbacksObserver::GetAndResetObservationState() {
- EXPECT_EQ(after_write_observation_state_ != NOT_CALLED, before_write_called_)
- << "The before-write callback should always be called before the "
- "after-write callback";
-
- WriteCallbackObservationState state = after_write_observation_state_;
- before_write_called_ = false;
- after_write_observation_state_ = NOT_CALLED;
- return state;
-}
-
-} // namespace
-
-class ImportantFileWriterTest : public testing::Test {
- public:
- ImportantFileWriterTest() = default;
- void SetUp() override {
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- file_ = temp_dir_.GetPath().AppendASCII("test-file");
- }
-
- protected:
- WriteCallbacksObserver write_callback_observer_;
- FilePath file_;
- MessageLoop loop_;
-
- private:
- ScopedTempDir temp_dir_;
-};
-
-TEST_F(ImportantFileWriterTest, Basic) {
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- EXPECT_FALSE(PathExists(writer.path()));
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
- writer.WriteNow(std::make_unique<std::string>("foo"));
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("foo", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, WriteWithObserver) {
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- EXPECT_FALSE(PathExists(writer.path()));
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
-
- // Confirm that the observer is invoked.
- write_callback_observer_.ObserveNextWriteCallbacks(&writer);
- writer.WriteNow(std::make_unique<std::string>("foo"));
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(CALLED_WITH_SUCCESS,
- write_callback_observer_.GetAndResetObservationState());
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("foo", GetFileContent(writer.path()));
-
- // Confirm that re-installing the observer works for another write.
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
- write_callback_observer_.ObserveNextWriteCallbacks(&writer);
- writer.WriteNow(std::make_unique<std::string>("bar"));
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(CALLED_WITH_SUCCESS,
- write_callback_observer_.GetAndResetObservationState());
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("bar", GetFileContent(writer.path()));
-
- // Confirm that writing again without re-installing the observer doesn't
- // result in a notification.
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
- writer.WriteNow(std::make_unique<std::string>("baz"));
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("baz", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, FailedWriteWithObserver) {
- // Use an invalid file path (relative paths are invalid) to get a
- // FILE_ERROR_ACCESS_DENIED error when trying to write the file.
- ImportantFileWriter writer(FilePath().AppendASCII("bad/../path"),
- ThreadTaskRunnerHandle::Get());
- EXPECT_FALSE(PathExists(writer.path()));
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
- write_callback_observer_.ObserveNextWriteCallbacks(&writer);
- writer.WriteNow(std::make_unique<std::string>("foo"));
- RunLoop().RunUntilIdle();
-
- // Confirm that the write observer was invoked with its boolean parameter set
- // to false.
- EXPECT_EQ(CALLED_WITH_ERROR,
- write_callback_observer_.GetAndResetObservationState());
- EXPECT_FALSE(PathExists(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, CallbackRunsOnWriterThread) {
- base::Thread file_writer_thread("ImportantFileWriter test thread");
- file_writer_thread.Start();
- ImportantFileWriter writer(file_, file_writer_thread.task_runner());
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
-
- // Block execution on |file_writer_thread| to verify that callbacks are
- // executed on it.
- base::WaitableEvent wait_helper(
- base::WaitableEvent::ResetPolicy::MANUAL,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- file_writer_thread.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&base::WaitableEvent::Wait,
- base::Unretained(&wait_helper)));
-
- write_callback_observer_.ObserveNextWriteCallbacks(&writer);
- writer.WriteNow(std::make_unique<std::string>("foo"));
- RunLoop().RunUntilIdle();
-
- // Expect the callback to not have been executed before the
- // |file_writer_thread| is unblocked.
- EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
-
- wait_helper.Signal();
- file_writer_thread.FlushForTesting();
-
- EXPECT_EQ(CALLED_WITH_SUCCESS,
- write_callback_observer_.GetAndResetObservationState());
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("foo", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, ScheduleWrite) {
- constexpr TimeDelta kCommitInterval = TimeDelta::FromSeconds(12345);
- MockTimer timer(true, false);
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get(),
- kCommitInterval);
- writer.SetTimerForTesting(&timer);
- EXPECT_FALSE(writer.HasPendingWrite());
- DataSerializer serializer("foo");
- writer.ScheduleWrite(&serializer);
- EXPECT_TRUE(writer.HasPendingWrite());
- ASSERT_TRUE(timer.IsRunning());
- EXPECT_EQ(kCommitInterval, timer.GetCurrentDelay());
- timer.Fire();
- EXPECT_FALSE(writer.HasPendingWrite());
- EXPECT_FALSE(timer.IsRunning());
- RunLoop().RunUntilIdle();
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("foo", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, DoScheduledWrite) {
- MockTimer timer(true, false);
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- writer.SetTimerForTesting(&timer);
- EXPECT_FALSE(writer.HasPendingWrite());
- DataSerializer serializer("foo");
- writer.ScheduleWrite(&serializer);
- EXPECT_TRUE(writer.HasPendingWrite());
- writer.DoScheduledWrite();
- EXPECT_FALSE(writer.HasPendingWrite());
- RunLoop().RunUntilIdle();
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("foo", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, BatchingWrites) {
- MockTimer timer(true, false);
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- writer.SetTimerForTesting(&timer);
- DataSerializer foo("foo"), bar("bar"), baz("baz");
- writer.ScheduleWrite(&foo);
- writer.ScheduleWrite(&bar);
- writer.ScheduleWrite(&baz);
- ASSERT_TRUE(timer.IsRunning());
- timer.Fire();
- RunLoop().RunUntilIdle();
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("baz", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, ScheduleWrite_FailToSerialize) {
- MockTimer timer(true, false);
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- writer.SetTimerForTesting(&timer);
- EXPECT_FALSE(writer.HasPendingWrite());
- FailingDataSerializer serializer;
- writer.ScheduleWrite(&serializer);
- EXPECT_TRUE(writer.HasPendingWrite());
- ASSERT_TRUE(timer.IsRunning());
- timer.Fire();
- EXPECT_FALSE(writer.HasPendingWrite());
- RunLoop().RunUntilIdle();
- EXPECT_FALSE(PathExists(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, ScheduleWrite_WriteNow) {
- MockTimer timer(true, false);
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- writer.SetTimerForTesting(&timer);
- EXPECT_FALSE(writer.HasPendingWrite());
- DataSerializer serializer("foo");
- writer.ScheduleWrite(&serializer);
- EXPECT_TRUE(writer.HasPendingWrite());
- writer.WriteNow(std::make_unique<std::string>("bar"));
- EXPECT_FALSE(writer.HasPendingWrite());
- EXPECT_FALSE(timer.IsRunning());
-
- RunLoop().RunUntilIdle();
- ASSERT_TRUE(PathExists(writer.path()));
- EXPECT_EQ("bar", GetFileContent(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, DoScheduledWrite_FailToSerialize) {
- MockTimer timer(true, false);
- ImportantFileWriter writer(file_, ThreadTaskRunnerHandle::Get());
- writer.SetTimerForTesting(&timer);
- EXPECT_FALSE(writer.HasPendingWrite());
- FailingDataSerializer serializer;
- writer.ScheduleWrite(&serializer);
- EXPECT_TRUE(writer.HasPendingWrite());
-
- writer.DoScheduledWrite();
- EXPECT_FALSE(timer.IsRunning());
- EXPECT_FALSE(writer.HasPendingWrite());
- RunLoop().RunUntilIdle();
- EXPECT_FALSE(PathExists(writer.path()));
-}
-
-TEST_F(ImportantFileWriterTest, WriteFileAtomicallyHistogramSuffixTest) {
- base::HistogramTester histogram_tester;
- EXPECT_FALSE(PathExists(file_));
- EXPECT_TRUE(ImportantFileWriter::WriteFileAtomically(file_, "baz", "test"));
- EXPECT_TRUE(PathExists(file_));
- EXPECT_EQ("baz", GetFileContent(file_));
- histogram_tester.ExpectTotalCount("ImportantFile.FileCreateError", 0);
- histogram_tester.ExpectTotalCount("ImportantFile.FileCreateError.test", 0);
-
- FilePath invalid_file_ = FilePath().AppendASCII("bad/../non_existent/path");
- EXPECT_FALSE(PathExists(invalid_file_));
- EXPECT_FALSE(
- ImportantFileWriter::WriteFileAtomically(invalid_file_, nullptr));
- histogram_tester.ExpectTotalCount("ImportantFile.FileCreateError", 1);
- histogram_tester.ExpectTotalCount("ImportantFile.FileCreateError.test", 0);
- EXPECT_FALSE(
- ImportantFileWriter::WriteFileAtomically(invalid_file_, nullptr, "test"));
- histogram_tester.ExpectTotalCount("ImportantFile.FileCreateError", 1);
- histogram_tester.ExpectTotalCount("ImportantFile.FileCreateError.test", 1);
-}
-
-} // namespace base
diff --git a/base/files/memory_mapped_file_unittest.cc b/base/files/memory_mapped_file_unittest.cc
deleted file mode 100644
index b7acc61..0000000
--- a/base/files/memory_mapped_file_unittest.cc
+++ /dev/null
@@ -1,243 +0,0 @@
-// Copyright 2014 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 "base/files/memory_mapped_file.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <utility>
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-namespace base {
-
-namespace {
-
-// Create a temporary buffer and fill it with a watermark sequence.
-std::unique_ptr<uint8_t[]> CreateTestBuffer(size_t size, size_t offset) {
- std::unique_ptr<uint8_t[]> buf(new uint8_t[size]);
- for (size_t i = 0; i < size; ++i)
- buf.get()[i] = static_cast<uint8_t>((offset + i) % 253);
- return buf;
-}
-
-// Check that the watermark sequence is consistent with the |offset| provided.
-bool CheckBufferContents(const uint8_t* data, size_t size, size_t offset) {
- std::unique_ptr<uint8_t[]> test_data(CreateTestBuffer(size, offset));
- return memcmp(test_data.get(), data, size) == 0;
-}
-
-class MemoryMappedFileTest : public PlatformTest {
- protected:
- void SetUp() override {
- PlatformTest::SetUp();
- CreateTemporaryFile(&temp_file_path_);
- }
-
- void TearDown() override { EXPECT_TRUE(DeleteFile(temp_file_path_, false)); }
-
- void CreateTemporaryTestFile(size_t size) {
- File file(temp_file_path_,
- File::FLAG_CREATE_ALWAYS | File::FLAG_READ | File::FLAG_WRITE);
- EXPECT_TRUE(file.IsValid());
-
- std::unique_ptr<uint8_t[]> test_data(CreateTestBuffer(size, 0));
- size_t bytes_written =
- file.Write(0, reinterpret_cast<char*>(test_data.get()), size);
- EXPECT_EQ(size, bytes_written);
- file.Close();
- }
-
- const FilePath temp_file_path() const { return temp_file_path_; }
-
- private:
- FilePath temp_file_path_;
-};
-
-TEST_F(MemoryMappedFileTest, MapWholeFileByPath) {
- const size_t kFileSize = 68 * 1024;
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
- map.Initialize(temp_file_path());
- ASSERT_EQ(kFileSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
-}
-
-TEST_F(MemoryMappedFileTest, MapWholeFileByFD) {
- const size_t kFileSize = 68 * 1024;
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
- map.Initialize(File(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ));
- ASSERT_EQ(kFileSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
-}
-
-TEST_F(MemoryMappedFileTest, MapSmallFile) {
- const size_t kFileSize = 127;
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
- map.Initialize(temp_file_path());
- ASSERT_EQ(kFileSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
-}
-
-TEST_F(MemoryMappedFileTest, MapWholeFileUsingRegion) {
- const size_t kFileSize = 157 * 1024;
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
-
- File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
- map.Initialize(std::move(file), MemoryMappedFile::Region::kWholeFile);
- ASSERT_EQ(kFileSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
-}
-
-TEST_F(MemoryMappedFileTest, MapPartialRegionAtBeginning) {
- const size_t kFileSize = 157 * 1024;
- const size_t kPartialSize = 4 * 1024 + 32;
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
-
- File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
- MemoryMappedFile::Region region = {0, kPartialSize};
- map.Initialize(std::move(file), region);
- ASSERT_EQ(kPartialSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, 0));
-}
-
-TEST_F(MemoryMappedFileTest, MapPartialRegionAtEnd) {
- const size_t kFileSize = 157 * 1024;
- const size_t kPartialSize = 5 * 1024 - 32;
- const size_t kOffset = kFileSize - kPartialSize;
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
-
- File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
- MemoryMappedFile::Region region = {kOffset, kPartialSize};
- map.Initialize(std::move(file), region);
- ASSERT_EQ(kPartialSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
-}
-
-TEST_F(MemoryMappedFileTest, MapSmallPartialRegionInTheMiddle) {
- const size_t kFileSize = 157 * 1024;
- const size_t kOffset = 1024 * 5 + 32;
- const size_t kPartialSize = 8;
-
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
-
- File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
- MemoryMappedFile::Region region = {kOffset, kPartialSize};
- map.Initialize(std::move(file), region);
- ASSERT_EQ(kPartialSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
-}
-
-TEST_F(MemoryMappedFileTest, MapLargePartialRegionInTheMiddle) {
- const size_t kFileSize = 157 * 1024;
- const size_t kOffset = 1024 * 5 + 32;
- const size_t kPartialSize = 16 * 1024 - 32;
-
- CreateTemporaryTestFile(kFileSize);
- MemoryMappedFile map;
-
- File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
- MemoryMappedFile::Region region = {kOffset, kPartialSize};
- map.Initialize(std::move(file), region);
- ASSERT_EQ(kPartialSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
-}
-
-TEST_F(MemoryMappedFileTest, WriteableFile) {
- const size_t kFileSize = 127;
- CreateTemporaryTestFile(kFileSize);
-
- {
- MemoryMappedFile map;
- map.Initialize(temp_file_path(), MemoryMappedFile::READ_WRITE);
- ASSERT_EQ(kFileSize, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
-
- uint8_t* bytes = map.data();
- bytes[0] = 'B';
- bytes[1] = 'a';
- bytes[2] = 'r';
- bytes[kFileSize - 1] = '!';
- EXPECT_FALSE(CheckBufferContents(map.data(), kFileSize, 0));
- EXPECT_TRUE(CheckBufferContents(map.data() + 3, kFileSize - 4, 3));
- }
-
- int64_t file_size;
- ASSERT_TRUE(GetFileSize(temp_file_path(), &file_size));
- EXPECT_EQ(static_cast<int64_t>(kFileSize), file_size);
-
- std::string contents;
- ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
- EXPECT_EQ("Bar", contents.substr(0, 3));
- EXPECT_EQ("!", contents.substr(kFileSize - 1, 1));
-}
-
-TEST_F(MemoryMappedFileTest, ExtendableFile) {
- const size_t kFileSize = 127;
- const size_t kFileExtend = 100;
- CreateTemporaryTestFile(kFileSize);
-
- {
- File file(temp_file_path(),
- File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE);
- MemoryMappedFile::Region region = {0, kFileSize + kFileExtend};
- MemoryMappedFile map;
- map.Initialize(std::move(file), region,
- MemoryMappedFile::READ_WRITE_EXTEND);
- EXPECT_EQ(kFileSize + kFileExtend, map.length());
- ASSERT_TRUE(map.data() != nullptr);
- EXPECT_TRUE(map.IsValid());
- ASSERT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
-
- uint8_t* bytes = map.data();
- EXPECT_EQ(0, bytes[kFileSize + 0]);
- EXPECT_EQ(0, bytes[kFileSize + 1]);
- EXPECT_EQ(0, bytes[kFileSize + 2]);
- bytes[kFileSize + 0] = 'B';
- bytes[kFileSize + 1] = 'A';
- bytes[kFileSize + 2] = 'Z';
- EXPECT_TRUE(CheckBufferContents(map.data(), kFileSize, 0));
- }
-
- int64_t file_size;
- ASSERT_TRUE(GetFileSize(temp_file_path(), &file_size));
- EXPECT_LE(static_cast<int64_t>(kFileSize + 3), file_size);
- EXPECT_GE(static_cast<int64_t>(kFileSize + kFileExtend), file_size);
-
- std::string contents;
- ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
- EXPECT_EQ("BAZ", contents.substr(kFileSize, 3));
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/files/scoped_temp_dir_unittest.cc b/base/files/scoped_temp_dir_unittest.cc
deleted file mode 100644
index 84eff6e..0000000
--- a/base/files/scoped_temp_dir_unittest.cc
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright (c) 2011 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 <string>
-
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(ScopedTempDir, FullPath) {
- FilePath test_path;
- base::CreateNewTempDirectory(FILE_PATH_LITERAL("scoped_temp_dir"),
- &test_path);
-
- // Against an existing dir, it should get destroyed when leaving scope.
- EXPECT_TRUE(DirectoryExists(test_path));
- {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.Set(test_path));
- EXPECT_TRUE(dir.IsValid());
- }
- EXPECT_FALSE(DirectoryExists(test_path));
-
- {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.Set(test_path));
- // Now the dir doesn't exist, so ensure that it gets created.
- EXPECT_TRUE(DirectoryExists(test_path));
- // When we call Release(), it shouldn't get destroyed when leaving scope.
- FilePath path = dir.Take();
- EXPECT_EQ(path.value(), test_path.value());
- EXPECT_FALSE(dir.IsValid());
- }
- EXPECT_TRUE(DirectoryExists(test_path));
-
- // Clean up.
- {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.Set(test_path));
- }
- EXPECT_FALSE(DirectoryExists(test_path));
-}
-
-TEST(ScopedTempDir, TempDir) {
- // In this case, just verify that a directory was created and that it's a
- // child of TempDir.
- FilePath test_path;
- {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.CreateUniqueTempDir());
- test_path = dir.GetPath();
- EXPECT_TRUE(DirectoryExists(test_path));
- FilePath tmp_dir;
- EXPECT_TRUE(base::GetTempDir(&tmp_dir));
- EXPECT_TRUE(test_path.value().find(tmp_dir.value()) != std::string::npos);
- }
- EXPECT_FALSE(DirectoryExists(test_path));
-}
-
-TEST(ScopedTempDir, UniqueTempDirUnderPath) {
- // Create a path which will contain a unique temp path.
- FilePath base_path;
- ASSERT_TRUE(base::CreateNewTempDirectory(FILE_PATH_LITERAL("base_dir"),
- &base_path));
-
- FilePath test_path;
- {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.CreateUniqueTempDirUnderPath(base_path));
- test_path = dir.GetPath();
- EXPECT_TRUE(DirectoryExists(test_path));
- EXPECT_TRUE(base_path.IsParent(test_path));
- EXPECT_TRUE(test_path.value().find(base_path.value()) != std::string::npos);
- }
- EXPECT_FALSE(DirectoryExists(test_path));
- base::DeleteFile(base_path, true);
-}
-
-TEST(ScopedTempDir, MultipleInvocations) {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.CreateUniqueTempDir());
- EXPECT_FALSE(dir.CreateUniqueTempDir());
- EXPECT_TRUE(dir.Delete());
- EXPECT_TRUE(dir.CreateUniqueTempDir());
- EXPECT_FALSE(dir.CreateUniqueTempDir());
- ScopedTempDir other_dir;
- EXPECT_TRUE(other_dir.Set(dir.Take()));
- EXPECT_TRUE(dir.CreateUniqueTempDir());
- EXPECT_FALSE(dir.CreateUniqueTempDir());
- EXPECT_FALSE(other_dir.CreateUniqueTempDir());
-}
-
-#if defined(OS_WIN)
-TEST(ScopedTempDir, LockedTempDir) {
- ScopedTempDir dir;
- EXPECT_TRUE(dir.CreateUniqueTempDir());
- base::File file(dir.GetPath().Append(FILE_PATH_LITERAL("temp")),
- base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
- EXPECT_TRUE(file.IsValid());
- EXPECT_EQ(base::File::FILE_OK, file.error_details());
- EXPECT_FALSE(dir.Delete()); // We should not be able to delete.
- EXPECT_FALSE(dir.GetPath().empty()); // We should still have a valid path.
- file.Close();
- // Now, we should be able to delete.
- EXPECT_TRUE(dir.Delete());
-}
-#endif // defined(OS_WIN)
-
-} // namespace base
diff --git a/base/gmock_unittest.cc b/base/gmock_unittest.cc
deleted file mode 100644
index 5c16728..0000000
--- a/base/gmock_unittest.cc
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) 2009 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 test is a simple sanity check to make sure gmock is able to build/link
-// correctly. It just instantiates a mock object and runs through a couple of
-// the basic mock features.
-
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Gmock matchers and actions that we use below.
-using testing::AnyOf;
-using testing::Eq;
-using testing::Return;
-using testing::SetArgPointee;
-using testing::WithArg;
-using testing::_;
-
-namespace {
-
-// Simple class that we can mock out the behavior for. Everything is virtual
-// for easy mocking.
-class SampleClass {
- public:
- SampleClass() = default;
- virtual ~SampleClass() = default;
-
- virtual int ReturnSomething() {
- return -1;
- }
-
- virtual void ReturnNothingConstly() const {
- }
-
- virtual void OutputParam(int* a) {
- }
-
- virtual int ReturnSecond(int a, int b) {
- return b;
- }
-};
-
-// Declare a mock for the class.
-class MockSampleClass : public SampleClass {
- public:
- MOCK_METHOD0(ReturnSomething, int());
- MOCK_CONST_METHOD0(ReturnNothingConstly, void());
- MOCK_METHOD1(OutputParam, void(int* a));
- MOCK_METHOD2(ReturnSecond, int(int a, int b));
-};
-
-// Create a couple of custom actions. Custom actions can be used for adding
-// more complex behavior into your mock...though if you start needing these, ask
-// if you're asking your mock to do too much.
-ACTION(ReturnVal) {
- // Return the first argument received.
- return arg0;
-}
-ACTION(ReturnSecond) {
- // Returns the second argument. This basically implemetns ReturnSecond.
- return arg1;
-}
-
-TEST(GmockTest, SimpleMatchAndActions) {
- // Basic test of some simple gmock matchers, actions, and cardinality
- // expectations.
- MockSampleClass mock;
-
- EXPECT_CALL(mock, ReturnSomething())
- .WillOnce(Return(1))
- .WillOnce(Return(2))
- .WillOnce(Return(3));
- EXPECT_EQ(1, mock.ReturnSomething());
- EXPECT_EQ(2, mock.ReturnSomething());
- EXPECT_EQ(3, mock.ReturnSomething());
-
- EXPECT_CALL(mock, ReturnNothingConstly()).Times(2);
- mock.ReturnNothingConstly();
- mock.ReturnNothingConstly();
-}
-
-TEST(GmockTest, AssignArgument) {
- // Capture an argument for examination.
- MockSampleClass mock;
-
- EXPECT_CALL(mock, OutputParam(_)).WillRepeatedly(SetArgPointee<0>(5));
-
- int arg = 0;
- mock.OutputParam(&arg);
- EXPECT_EQ(5, arg);
-}
-
-TEST(GmockTest, SideEffects) {
- // Capture an argument for examination.
- MockSampleClass mock;
-
- EXPECT_CALL(mock, OutputParam(_)).WillRepeatedly(SetArgPointee<0>(5));
-
- int arg = 0;
- mock.OutputParam(&arg);
- EXPECT_EQ(5, arg);
-}
-
-TEST(GmockTest, CustomAction_ReturnSecond) {
- // Test a mock of the ReturnSecond behavior using an action that provides an
- // alternate implementation of the function. Danger here though, this is
- // starting to add too much behavior of the mock, which means the mock
- // implementation might start to have bugs itself.
- MockSampleClass mock;
-
- EXPECT_CALL(mock, ReturnSecond(_, AnyOf(Eq(4), Eq(5))))
- .WillRepeatedly(ReturnSecond());
- EXPECT_EQ(4, mock.ReturnSecond(-1, 4));
- EXPECT_EQ(5, mock.ReturnSecond(0, 5));
- EXPECT_EQ(4, mock.ReturnSecond(0xdeadbeef, 4));
- EXPECT_EQ(4, mock.ReturnSecond(112358, 4));
- EXPECT_EQ(5, mock.ReturnSecond(1337, 5));
-}
-
-TEST(GmockTest, CustomAction_ReturnVal) {
- // Alternate implemention of ReturnSecond using a more general custom action,
- // and a WithArg adapter to bridge the interfaces.
- MockSampleClass mock;
-
- EXPECT_CALL(mock, ReturnSecond(_, AnyOf(Eq(4), Eq(5))))
- .WillRepeatedly(WithArg<1>(ReturnVal()));
- EXPECT_EQ(4, mock.ReturnSecond(-1, 4));
- EXPECT_EQ(5, mock.ReturnSecond(0, 5));
- EXPECT_EQ(4, mock.ReturnSecond(0xdeadbeef, 4));
- EXPECT_EQ(4, mock.ReturnSecond(112358, 4));
- EXPECT_EQ(5, mock.ReturnSecond(1337, 5));
-}
-
-} // namespace
diff --git a/base/guid_unittest.cc b/base/guid_unittest.cc
deleted file mode 100644
index 8aa56ed..0000000
--- a/base/guid_unittest.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// 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.
-
-#include "base/guid.h"
-
-#include <stdint.h>
-
-#include <limits>
-
-#include "base/strings/string_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-bool IsGUIDv4(const std::string& guid) {
- // The format of GUID version 4 must be xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx,
- // where y is one of [8, 9, A, B].
- return IsValidGUID(guid) && guid[14] == '4' &&
- (guid[19] == '8' || guid[19] == '9' || guid[19] == 'A' ||
- guid[19] == 'a' || guid[19] == 'B' || guid[19] == 'b');
-}
-
-} // namespace
-
-TEST(GUIDTest, GUIDGeneratesAllZeroes) {
- uint64_t bytes[] = {0, 0};
- std::string clientid = RandomDataToGUIDString(bytes);
- EXPECT_EQ("00000000-0000-0000-0000-000000000000", clientid);
-}
-
-TEST(GUIDTest, GUIDGeneratesCorrectly) {
- uint64_t bytes[] = {0x0123456789ABCDEFULL, 0xFEDCBA9876543210ULL};
- std::string clientid = RandomDataToGUIDString(bytes);
- EXPECT_EQ("01234567-89ab-cdef-fedc-ba9876543210", clientid);
-}
-
-TEST(GUIDTest, GUIDCorrectlyFormatted) {
- const int kIterations = 10;
- for (int it = 0; it < kIterations; ++it) {
- std::string guid = GenerateGUID();
- EXPECT_TRUE(IsValidGUID(guid));
- EXPECT_TRUE(IsValidGUIDOutputString(guid));
- EXPECT_TRUE(IsValidGUID(ToLowerASCII(guid)));
- EXPECT_TRUE(IsValidGUID(ToUpperASCII(guid)));
- }
-}
-
-TEST(GUIDTest, GUIDBasicUniqueness) {
- const int kIterations = 10;
- for (int it = 0; it < kIterations; ++it) {
- std::string guid1 = GenerateGUID();
- std::string guid2 = GenerateGUID();
- EXPECT_EQ(36U, guid1.length());
- EXPECT_EQ(36U, guid2.length());
- EXPECT_NE(guid1, guid2);
- EXPECT_TRUE(IsGUIDv4(guid1));
- EXPECT_TRUE(IsGUIDv4(guid2));
- }
-}
-
-} // namespace base
diff --git a/base/hash_unittest.cc b/base/hash_unittest.cc
deleted file mode 100644
index fc8a751..0000000
--- a/base/hash_unittest.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2014 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 "base/hash.h"
-
-#include <string>
-#include <vector>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(HashTest, String) {
- std::string str;
- // Empty string (should hash to 0).
- str = "";
- EXPECT_EQ(0u, Hash(str));
-
- // Simple test.
- str = "hello world";
- EXPECT_EQ(2794219650u, Hash(str));
-
- // Change one bit.
- str = "helmo world";
- EXPECT_EQ(1006697176u, Hash(str));
-
- // Insert a null byte.
- str = "hello world";
- str[5] = '\0';
- EXPECT_EQ(2319902537u, Hash(str));
-
- // Test that the bytes after the null contribute to the hash.
- str = "hello worle";
- str[5] = '\0';
- EXPECT_EQ(553904462u, Hash(str));
-
- // Extremely long string.
- // Also tests strings with high bit set, and null byte.
- std::vector<char> long_string_buffer;
- for (int i = 0; i < 4096; ++i)
- long_string_buffer.push_back((i % 256) - 128);
- str.assign(&long_string_buffer.front(), long_string_buffer.size());
- EXPECT_EQ(2797962408u, Hash(str));
-
- // All possible lengths (mod 4). Tests separate code paths. Also test with
- // final byte high bit set (regression test for http://crbug.com/90659).
- // Note that the 1 and 3 cases have a weird bug where the final byte is
- // treated as a signed char. It was decided on the above bug discussion to
- // enshrine that behaviour as "correct" to avoid invalidating existing hashes.
-
- // Length mod 4 == 0.
- str = "hello w\xab";
- EXPECT_EQ(615571198u, Hash(str));
- // Length mod 4 == 1.
- str = "hello wo\xab";
- EXPECT_EQ(623474296u, Hash(str));
- // Length mod 4 == 2.
- str = "hello wor\xab";
- EXPECT_EQ(4278562408u, Hash(str));
- // Length mod 4 == 3.
- str = "hello worl\xab";
- EXPECT_EQ(3224633008u, Hash(str));
-}
-
-TEST(HashTest, CString) {
- const char* str;
- // Empty string (should hash to 0).
- str = "";
- EXPECT_EQ(0u, Hash(str, strlen(str)));
-
- // Simple test.
- str = "hello world";
- EXPECT_EQ(2794219650u, Hash(str, strlen(str)));
-
- // Ensure that it stops reading after the given length, and does not expect a
- // null byte.
- str = "hello world; don't read this part";
- EXPECT_EQ(2794219650u, Hash(str, strlen("hello world")));
-}
-
-} // namespace base
diff --git a/base/i18n/bidi_line_iterator_unittest.cc b/base/i18n/bidi_line_iterator_unittest.cc
deleted file mode 100644
index d531313..0000000
--- a/base/i18n/bidi_line_iterator_unittest.cc
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2017 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 "base/i18n/bidi_line_iterator.h"
-
-#include "base/macros.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace i18n {
-namespace {
-
-class BiDiLineIteratorTest : public testing::TestWithParam<TextDirection> {
- public:
- BiDiLineIteratorTest() = default;
-
- BiDiLineIterator* iterator() { return &iterator_; }
-
- private:
- BiDiLineIterator iterator_;
-
- DISALLOW_COPY_AND_ASSIGN(BiDiLineIteratorTest);
-};
-
-TEST_P(BiDiLineIteratorTest, OnlyLTR) {
- iterator()->Open(UTF8ToUTF16("abc 😁 测试"), GetParam(),
- BiDiLineIterator::CustomBehavior::NONE);
- ASSERT_EQ(1, iterator()->CountRuns());
-
- int start, length;
- EXPECT_EQ(UBIDI_LTR, iterator()->GetVisualRun(0, &start, &length));
- EXPECT_EQ(0, start);
- EXPECT_EQ(9, length);
-
- int end;
- UBiDiLevel level;
- iterator()->GetLogicalRun(0, &end, &level);
- EXPECT_EQ(9, end);
- if (GetParam() == TextDirection::RIGHT_TO_LEFT)
- EXPECT_EQ(2, level);
- else
- EXPECT_EQ(0, level);
-}
-
-TEST_P(BiDiLineIteratorTest, OnlyRTL) {
- iterator()->Open(UTF8ToUTF16("מה השעה"), GetParam(),
- BiDiLineIterator::CustomBehavior::NONE);
- ASSERT_EQ(1, iterator()->CountRuns());
-
- int start, length;
- EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
- EXPECT_EQ(0, start);
- EXPECT_EQ(7, length);
-
- int end;
- UBiDiLevel level;
- iterator()->GetLogicalRun(0, &end, &level);
- EXPECT_EQ(7, end);
- EXPECT_EQ(1, level);
-}
-
-TEST_P(BiDiLineIteratorTest, Mixed) {
- iterator()->Open(UTF8ToUTF16("אני משתמש ב- Chrome כדפדפן האינטרנט שלי"),
- GetParam(), BiDiLineIterator::CustomBehavior::NONE);
- ASSERT_EQ(3, iterator()->CountRuns());
-
- // We'll get completely different results depending on the top-level paragraph
- // direction.
- if (GetParam() == TextDirection::RIGHT_TO_LEFT) {
- // If para direction is RTL, expect the LTR substring "Chrome" to be nested
- // within the surrounding RTL text.
- int start, length;
- EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
- EXPECT_EQ(19, start);
- EXPECT_EQ(20, length);
- EXPECT_EQ(UBIDI_LTR, iterator()->GetVisualRun(1, &start, &length));
- EXPECT_EQ(13, start);
- EXPECT_EQ(6, length);
- EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(2, &start, &length));
- EXPECT_EQ(0, start);
- EXPECT_EQ(13, length);
-
- int end;
- UBiDiLevel level;
- iterator()->GetLogicalRun(0, &end, &level);
- EXPECT_EQ(13, end);
- EXPECT_EQ(1, level);
- iterator()->GetLogicalRun(13, &end, &level);
- EXPECT_EQ(19, end);
- EXPECT_EQ(2, level);
- iterator()->GetLogicalRun(19, &end, &level);
- EXPECT_EQ(39, end);
- EXPECT_EQ(1, level);
- } else {
- // If the para direction is LTR, expect the LTR substring "- Chrome " to be
- // at the top level, with two nested RTL runs on either side.
- int start, length;
- EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
- EXPECT_EQ(0, start);
- EXPECT_EQ(11, length);
- EXPECT_EQ(UBIDI_LTR, iterator()->GetVisualRun(1, &start, &length));
- EXPECT_EQ(11, start);
- EXPECT_EQ(9, length);
- EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(2, &start, &length));
- EXPECT_EQ(20, start);
- EXPECT_EQ(19, length);
-
- int end;
- UBiDiLevel level;
- iterator()->GetLogicalRun(0, &end, &level);
- EXPECT_EQ(11, end);
- EXPECT_EQ(1, level);
- iterator()->GetLogicalRun(11, &end, &level);
- EXPECT_EQ(20, end);
- EXPECT_EQ(0, level);
- iterator()->GetLogicalRun(20, &end, &level);
- EXPECT_EQ(39, end);
- EXPECT_EQ(1, level);
- }
-}
-
-TEST_P(BiDiLineIteratorTest, RTLPunctuationNoCustomBehavior) {
- // This string features Hebrew characters interleaved with ASCII punctuation.
- iterator()->Open(UTF8ToUTF16("א!ב\"ג#ד$ה%ו&ז'ח(ט)י*ך+כ,ל-ם.מ/"
- "ן:נ;ס<ע=ף>פ?ץ@צ[ק\\ר]ש^ת_א`ב{ג|ד}ה~ו"),
- GetParam(), BiDiLineIterator::CustomBehavior::NONE);
-
- // Expect a single RTL run.
- ASSERT_EQ(1, iterator()->CountRuns());
-
- int start, length;
- EXPECT_EQ(UBIDI_RTL, iterator()->GetVisualRun(0, &start, &length));
- EXPECT_EQ(0, start);
- EXPECT_EQ(65, length);
-
- int end;
- UBiDiLevel level;
- iterator()->GetLogicalRun(0, &end, &level);
- EXPECT_EQ(65, end);
- EXPECT_EQ(1, level);
-}
-
-TEST_P(BiDiLineIteratorTest, RTLPunctuationAsURL) {
- // This string features Hebrew characters interleaved with ASCII punctuation.
- iterator()->Open(UTF8ToUTF16("א!ב\"ג#ד$ה%ו&ז'ח(ט)י*ך+כ,ל-ם.מ/"
- "ן:נ;ס<ע=ף>פ?ץ@צ[ק\\ר]ש^ת_א`ב{ג|ד}ה~ו"),
- GetParam(), BiDiLineIterator::CustomBehavior::AS_URL);
-
- const int kStringSize = 65;
-
- // Expect a primary RTL run, broken up by each of the 8 punctuation marks that
- // are considered strong LTR (17 runs total).
- struct {
- int start;
- UBiDiDirection dir;
- } expected_runs[] = {
- {0, UBIDI_RTL}, {5, UBIDI_LTR}, // '#'
- {6, UBIDI_RTL}, {11, UBIDI_LTR}, // '&'
- {12, UBIDI_RTL}, {27, UBIDI_LTR}, // '.'
- {28, UBIDI_RTL}, {29, UBIDI_LTR}, // '/'
- {30, UBIDI_RTL}, {31, UBIDI_LTR}, // ':'
- {32, UBIDI_RTL}, {37, UBIDI_LTR}, // '='
- {38, UBIDI_RTL}, {41, UBIDI_LTR}, // '?'
- {42, UBIDI_RTL}, {43, UBIDI_LTR}, // '@'
- {44, UBIDI_RTL},
- };
-
- ASSERT_EQ(arraysize(expected_runs),
- static_cast<size_t>(iterator()->CountRuns()));
-
- for (size_t i = 0; i < arraysize(expected_runs); ++i) {
- const auto& expected_run = expected_runs[i];
- int expected_run_end = i >= arraysize(expected_runs) - 1
- ? kStringSize
- : expected_runs[i + 1].start;
-
- size_t visual_index = GetParam() == TextDirection::RIGHT_TO_LEFT
- ? arraysize(expected_runs) - 1 - i
- : i;
- int start, length;
- EXPECT_EQ(expected_run.dir,
- iterator()->GetVisualRun(visual_index, &start, &length))
- << "(i = " << i << ")";
- EXPECT_EQ(expected_run.start, start) << "(i = " << i << ")";
- EXPECT_EQ(expected_run_end - expected_run.start, length)
- << "(i = " << i << ")";
-
- int expected_level =
- expected_run.dir == UBIDI_RTL
- ? 1
- : (GetParam() == TextDirection::RIGHT_TO_LEFT ? 2 : 0);
- int end;
- UBiDiLevel level;
- iterator()->GetLogicalRun(expected_run.start, &end, &level);
- EXPECT_EQ(expected_run_end, end) << "(i = " << i << ")";
- EXPECT_EQ(expected_level, level) << "(i = " << i << ")";
- }
-}
-
-INSTANTIATE_TEST_CASE_P(,
- BiDiLineIteratorTest,
- ::testing::Values(TextDirection::LEFT_TO_RIGHT,
- TextDirection::RIGHT_TO_LEFT));
-
-} // namespace
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/break_iterator_unittest.cc b/base/i18n/break_iterator_unittest.cc
deleted file mode 100644
index 6137e02..0000000
--- a/base/i18n/break_iterator_unittest.cc
+++ /dev/null
@@ -1,461 +0,0 @@
-// Copyright (c) 2011 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 "base/i18n/break_iterator.h"
-
-#include <stddef.h>
-
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace i18n {
-
-TEST(BreakIteratorTest, BreakWordEmpty) {
- string16 empty;
- BreakIterator iter(empty, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakWord) {
- string16 space(UTF8ToUTF16(" "));
- string16 str(UTF8ToUTF16(" foo bar! \npouet boom"));
- BreakIterator iter(str, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(space, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("foo"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(space, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("bar"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("!"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(space, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("\n"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("pouet"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(space, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("boom"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakWide16) {
- // Two greek words separated by space.
- const string16 str(WideToUTF16(
- L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
- L"\x03bf\x03c2\x0020\x0399\x03c3\x03c4\x03cc\x03c2"));
- const string16 word1(str.substr(0, 10));
- const string16 word2(str.substr(11, 5));
- BreakIterator iter(str, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(word1, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16(" "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(word2, iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakWide32) {
- // U+1D49C MATHEMATICAL SCRIPT CAPITAL A
- const char very_wide_char[] = "\xF0\x9D\x92\x9C";
- const string16 str(
- UTF8ToUTF16(base::StringPrintf("%s a", very_wide_char)));
- const string16 very_wide_word(str.substr(0, 2));
-
- BreakIterator iter(str, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(very_wide_word, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16(" "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("a"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakSpaceEmpty) {
- string16 empty;
- BreakIterator iter(empty, BreakIterator::BREAK_SPACE);
- ASSERT_TRUE(iter.Init());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakSpace) {
- string16 str(UTF8ToUTF16(" foo bar! \npouet boom"));
- BreakIterator iter(str, BreakIterator::BREAK_SPACE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16(" "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("foo "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("bar! \n"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("pouet "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("boom"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakSpaceSP) {
- string16 str(UTF8ToUTF16(" foo bar! \npouet boom "));
- BreakIterator iter(str, BreakIterator::BREAK_SPACE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16(" "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("foo "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("bar! \n"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("pouet "), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("boom "), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakSpacekWide16) {
- // Two Greek words.
- const string16 str(WideToUTF16(
- L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
- L"\x03bf\x03c2\x0020\x0399\x03c3\x03c4\x03cc\x03c2"));
- const string16 word1(str.substr(0, 11));
- const string16 word2(str.substr(11, 5));
- BreakIterator iter(str, BreakIterator::BREAK_SPACE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(word1, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(word2, iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakSpaceWide32) {
- // U+1D49C MATHEMATICAL SCRIPT CAPITAL A
- const char very_wide_char[] = "\xF0\x9D\x92\x9C";
- const string16 str(
- UTF8ToUTF16(base::StringPrintf("%s a", very_wide_char)));
- const string16 very_wide_word(str.substr(0, 3));
-
- BreakIterator iter(str, BreakIterator::BREAK_SPACE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(very_wide_word, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("a"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakLineEmpty) {
- string16 empty;
- BreakIterator iter(empty, BreakIterator::BREAK_NEWLINE);
- ASSERT_TRUE(iter.Init());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakLine) {
- string16 nl(UTF8ToUTF16("\n"));
- string16 str(UTF8ToUTF16("\nfoo bar!\n\npouet boom"));
- BreakIterator iter(str, BreakIterator::BREAK_NEWLINE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(nl, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("foo bar!\n"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(nl, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("pouet boom"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakLineNL) {
- string16 nl(UTF8ToUTF16("\n"));
- string16 str(UTF8ToUTF16("\nfoo bar!\n\npouet boom\n"));
- BreakIterator iter(str, BreakIterator::BREAK_NEWLINE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(nl, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("foo bar!\n"), iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(nl, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("pouet boom\n"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakLineWide16) {
- // Two Greek words separated by newline.
- const string16 str(WideToUTF16(
- L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
- L"\x03bf\x03c2\x000a\x0399\x03c3\x03c4\x03cc\x03c2"));
- const string16 line1(str.substr(0, 11));
- const string16 line2(str.substr(11, 5));
- BreakIterator iter(str, BreakIterator::BREAK_NEWLINE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(line1, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(line2, iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakLineWide32) {
- // U+1D49C MATHEMATICAL SCRIPT CAPITAL A
- const char very_wide_char[] = "\xF0\x9D\x92\x9C";
- const string16 str(
- UTF8ToUTF16(base::StringPrintf("%s\na", very_wide_char)));
- const string16 very_wide_line(str.substr(0, 3));
- BreakIterator iter(str, BreakIterator::BREAK_NEWLINE);
- ASSERT_TRUE(iter.Init());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(very_wide_line, iter.GetString());
- EXPECT_TRUE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_EQ(UTF8ToUTF16("a"), iter.GetString());
- EXPECT_FALSE(iter.Advance());
- EXPECT_FALSE(iter.IsWord());
- EXPECT_FALSE(iter.Advance()); // Test unexpected advance after end.
- EXPECT_FALSE(iter.IsWord());
-}
-
-TEST(BreakIteratorTest, BreakCharacter) {
- static const wchar_t* kCharacters[] = {
- // An English word consisting of four ASCII characters.
- L"w", L"o", L"r", L"d", L" ",
- // A Hindi word (which means "Hindi") consisting of three Devanagari
- // characters.
- L"\x0939\x093F", L"\x0928\x094D", L"\x0926\x0940", L" ",
- // A Thai word (which means "feel") consisting of three Thai characters.
- L"\x0E23\x0E39\x0E49", L"\x0E2A\x0E36", L"\x0E01", L" ",
- };
- std::vector<string16> characters;
- string16 text;
- for (size_t i = 0; i < arraysize(kCharacters); ++i) {
- characters.push_back(WideToUTF16(kCharacters[i]));
- text.append(characters.back());
- }
- BreakIterator iter(text, BreakIterator::BREAK_CHARACTER);
- ASSERT_TRUE(iter.Init());
- for (size_t i = 0; i < arraysize(kCharacters); ++i) {
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(characters[i], iter.GetString());
- }
-}
-
-// Test for https://code.google.com/p/chromium/issues/detail?id=411213
-// We should be able to get valid substrings with GetString() function
-// after setting new content by calling SetText().
-TEST(BreakIteratorTest, GetStringAfterSetText) {
- const string16 initial_string(ASCIIToUTF16("str"));
- BreakIterator iter(initial_string, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
-
- const string16 long_string(ASCIIToUTF16("another,string"));
- EXPECT_TRUE(iter.SetText(long_string.c_str(), long_string.size()));
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.Advance()); // Advance to ',' in |long_string|
-
- // Check that the current position is out of bounds of the |initial_string|.
- EXPECT_LT(initial_string.size(), iter.pos());
-
- // Check that we can get a valid substring of |long_string|.
- EXPECT_EQ(ASCIIToUTF16(","), iter.GetString());
-}
-
-TEST(BreakIteratorTest, GetStringPiece) {
- const string16 initial_string(ASCIIToUTF16("some string"));
- BreakIterator iter(initial_string, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
-
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(iter.GetString(), iter.GetStringPiece().as_string());
- EXPECT_EQ(StringPiece16(ASCIIToUTF16("some")), iter.GetStringPiece());
-
- EXPECT_TRUE(iter.Advance());
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(iter.GetString(), iter.GetStringPiece().as_string());
- EXPECT_EQ(StringPiece16(ASCIIToUTF16("string")), iter.GetStringPiece());
-}
-
-// Make sure that when not in RULE_BASED or BREAK_WORD mode we're getting
-// IS_LINE_OR_CHAR_BREAK.
-TEST(BreakIteratorTest, GetWordBreakStatusBreakLine) {
- // A string containing the English word "foo", followed by two Khmer
- // characters, the English word "Can", and then two Russian characters and
- // punctuation.
- base::string16 text(
- base::WideToUTF16(L"foo \x1791\x17C1 \nCan \x041C\x0438..."));
- BreakIterator iter(text, BreakIterator::BREAK_LINE);
- ASSERT_TRUE(iter.Init());
-
- EXPECT_TRUE(iter.Advance());
- // Finds "foo" and the space.
- EXPECT_EQ(base::UTF8ToUTF16("foo "), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_LINE_OR_CHAR_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds the Khmer characters, the next space, and the newline.
- EXPECT_EQ(base::WideToUTF16(L"\x1791\x17C1 \n"), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_LINE_OR_CHAR_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds "Can" and the space.
- EXPECT_EQ(base::UTF8ToUTF16("Can "), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_LINE_OR_CHAR_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds the Russian characters and periods.
- EXPECT_EQ(base::WideToUTF16(L"\x041C\x0438..."), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_LINE_OR_CHAR_BREAK);
- EXPECT_FALSE(iter.Advance());
-}
-
-// Make sure that in BREAK_WORD mode we're getting IS_WORD_BREAK and
-// IS_SKIPPABLE_WORD when we should be. IS_WORD_BREAK should be returned when we
-// finish going over non-punctuation characters while IS_SKIPPABLE_WORD should
-// be returned on punctuation and spaces.
-TEST(BreakIteratorTest, GetWordBreakStatusBreakWord) {
- // A string containing the English word "foo", followed by two Khmer
- // characters, the English word "Can", and then two Russian characters and
- // punctuation.
- base::string16 text(
- base::WideToUTF16(L"foo \x1791\x17C1 \nCan \x041C\x0438..."));
- BreakIterator iter(text, BreakIterator::BREAK_WORD);
- ASSERT_TRUE(iter.Init());
-
- EXPECT_TRUE(iter.Advance());
- // Finds "foo".
- EXPECT_EQ(base::UTF8ToUTF16("foo"), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_WORD_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds the space, and the Khmer characters.
- EXPECT_EQ(base::UTF8ToUTF16(" "), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(base::WideToUTF16(L"\x1791\x17C1"), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_WORD_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds the space and the newline.
- EXPECT_EQ(base::UTF8ToUTF16(" "), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(base::UTF8ToUTF16("\n"), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_TRUE(iter.Advance());
- // Finds "Can".
- EXPECT_EQ(base::UTF8ToUTF16("Can"), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_WORD_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds the space and the Russian characters.
- EXPECT_EQ(base::UTF8ToUTF16(" "), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(base::WideToUTF16(L"\x041C\x0438"), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_WORD_BREAK);
- EXPECT_TRUE(iter.Advance());
- // Finds the trailing periods.
- EXPECT_EQ(base::UTF8ToUTF16("."), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(base::UTF8ToUTF16("."), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_TRUE(iter.Advance());
- EXPECT_EQ(base::UTF8ToUTF16("."), iter.GetString());
- EXPECT_EQ(iter.GetWordBreakStatus(), BreakIterator::IS_SKIPPABLE_WORD);
- EXPECT_FALSE(iter.Advance());
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/case_conversion_unittest.cc b/base/i18n/case_conversion_unittest.cc
deleted file mode 100644
index ee795bc..0000000
--- a/base/i18n/case_conversion_unittest.cc
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) 2011 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 "base/i18n/case_conversion.h"
-#include "base/i18n/rtl.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/test/icu_test_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/icu/source/i18n/unicode/usearch.h"
-
-namespace base {
-namespace i18n {
-
-namespace {
-
-const wchar_t kNonASCIIMixed[] =
- L"\xC4\xD6\xE4\xF6\x20\xCF\xEF\x20\xF7\x25"
- L"\xA4\x23\x2A\x5E\x60\x40\xA3\x24\x2030\x201A\x7E\x20\x1F07\x1F0F"
- L"\x20\x1E00\x1E01";
-const wchar_t kNonASCIILower[] =
- L"\xE4\xF6\xE4\xF6\x20\xEF\xEF"
- L"\x20\xF7\x25\xA4\x23\x2A\x5E\x60\x40\xA3\x24\x2030\x201A\x7E\x20\x1F07"
- L"\x1F07\x20\x1E01\x1E01";
-const wchar_t kNonASCIIUpper[] =
- L"\xC4\xD6\xC4\xD6\x20\xCF\xCF"
- L"\x20\xF7\x25\xA4\x23\x2A\x5E\x60\x40\xA3\x24\x2030\x201A\x7E\x20\x1F0F"
- L"\x1F0F\x20\x1E00\x1E00";
-
-} // namespace
-
-// Test upper and lower case string conversion.
-TEST(CaseConversionTest, UpperLower) {
- const string16 mixed(ASCIIToUTF16("Text with UPPer & lowER casE."));
- const string16 expected_lower(ASCIIToUTF16("text with upper & lower case."));
- const string16 expected_upper(ASCIIToUTF16("TEXT WITH UPPER & LOWER CASE."));
-
- string16 result = ToLower(mixed);
- EXPECT_EQ(expected_lower, result);
-
- result = ToUpper(mixed);
- EXPECT_EQ(expected_upper, result);
-}
-
-TEST(CaseConversionTest, NonASCII) {
- const string16 mixed(WideToUTF16(kNonASCIIMixed));
- const string16 expected_lower(WideToUTF16(kNonASCIILower));
- const string16 expected_upper(WideToUTF16(kNonASCIIUpper));
-
- string16 result = ToLower(mixed);
- EXPECT_EQ(expected_lower, result);
-
- result = ToUpper(mixed);
- EXPECT_EQ(expected_upper, result);
-}
-
-TEST(CaseConversionTest, TurkishLocaleConversion) {
- const string16 mixed(WideToUTF16(L"\x49\x131"));
- const string16 expected_lower(WideToUTF16(L"\x69\x131"));
- const string16 expected_upper(WideToUTF16(L"\x49\x49"));
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_US");
-
- string16 result = ToLower(mixed);
- EXPECT_EQ(expected_lower, result);
-
- result = ToUpper(mixed);
- EXPECT_EQ(expected_upper, result);
-
- i18n::SetICUDefaultLocale("tr");
-
- const string16 expected_lower_turkish(WideToUTF16(L"\x131\x131"));
- const string16 expected_upper_turkish(WideToUTF16(L"\x49\x49"));
-
- result = ToLower(mixed);
- EXPECT_EQ(expected_lower_turkish, result);
-
- result = ToUpper(mixed);
- EXPECT_EQ(expected_upper_turkish, result);
-}
-
-TEST(CaseConversionTest, FoldCase) {
- // Simple ASCII, should lower-case.
- EXPECT_EQ(ASCIIToUTF16("hello, world"),
- FoldCase(ASCIIToUTF16("Hello, World")));
-
- // Non-ASCII cases from above. They should all fold to the same result.
- EXPECT_EQ(FoldCase(WideToUTF16(kNonASCIIMixed)),
- FoldCase(WideToUTF16(kNonASCIILower)));
- EXPECT_EQ(FoldCase(WideToUTF16(kNonASCIIMixed)),
- FoldCase(WideToUTF16(kNonASCIIUpper)));
-
- // Turkish cases from above. This is the lower-case expected result from the
- // US locale. It should be the same even when the current locale is Turkish.
- const string16 turkish(WideToUTF16(L"\x49\x131"));
- const string16 turkish_expected(WideToUTF16(L"\x69\x131"));
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_US");
- EXPECT_EQ(turkish_expected, FoldCase(turkish));
-
- i18n::SetICUDefaultLocale("tr");
- EXPECT_EQ(turkish_expected, FoldCase(turkish));
-
- // Test a case that gets bigger when processed.
- // U+130 = LATIN CAPITAL LETTER I WITH DOT ABOVE gets folded to a lower case
- // "i" followed by U+307 COMBINING DOT ABOVE.
- EXPECT_EQ(WideToUTF16(L"i\u0307j"), FoldCase(WideToUTF16(L"\u0130j")));
-
- // U+00DF (SHARP S) and U+1E9E (CAPIRAL SHARP S) are both folded to "ss".
- EXPECT_EQ(ASCIIToUTF16("ssss"), FoldCase(WideToUTF16(L"\u00DF\u1E9E")));
-}
-
-} // namespace i18n
-} // namespace base
-
-
-
diff --git a/base/i18n/char_iterator_unittest.cc b/base/i18n/char_iterator_unittest.cc
deleted file mode 100644
index 0cf8e6c..0000000
--- a/base/i18n/char_iterator_unittest.cc
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2011 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 "base/i18n/char_iterator.h"
-
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace i18n {
-
-TEST(CharIteratorsTest, TestUTF8) {
- std::string empty;
- UTF8CharIterator empty_iter(&empty);
- ASSERT_TRUE(empty_iter.end());
- ASSERT_EQ(0, empty_iter.array_pos());
- ASSERT_EQ(0, empty_iter.char_pos());
- ASSERT_FALSE(empty_iter.Advance());
-
- std::string str("s\303\273r"); // [u with circumflex]
- UTF8CharIterator iter(&str);
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(0, iter.array_pos());
- ASSERT_EQ(0, iter.char_pos());
- ASSERT_EQ('s', iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(1, iter.array_pos());
- ASSERT_EQ(1, iter.char_pos());
- ASSERT_EQ(251, iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(3, iter.array_pos());
- ASSERT_EQ(2, iter.char_pos());
- ASSERT_EQ('r', iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_TRUE(iter.end());
- ASSERT_EQ(4, iter.array_pos());
- ASSERT_EQ(3, iter.char_pos());
-
- // Don't care what it returns, but this shouldn't crash
- iter.get();
-
- ASSERT_FALSE(iter.Advance());
-}
-
-TEST(CharIteratorsTest, TestUTF16) {
- string16 empty = UTF8ToUTF16("");
- UTF16CharIterator empty_iter(&empty);
- ASSERT_TRUE(empty_iter.end());
- ASSERT_EQ(0, empty_iter.array_pos());
- ASSERT_EQ(0, empty_iter.char_pos());
- ASSERT_FALSE(empty_iter.Advance());
-
- // This test string contains 4 characters:
- // x
- // u with circumflex - 2 bytes in UTF8, 1 codeword in UTF16
- // math double-struck A - 4 bytes in UTF8, 2 codewords in UTF16
- // z
- string16 str = UTF8ToUTF16("x\303\273\360\235\224\270z");
- UTF16CharIterator iter(&str);
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(0, iter.array_pos());
- ASSERT_EQ(0, iter.char_pos());
- ASSERT_EQ('x', iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(1, iter.array_pos());
- ASSERT_EQ(1, iter.char_pos());
- ASSERT_EQ(251, iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(2, iter.array_pos());
- ASSERT_EQ(2, iter.char_pos());
- ASSERT_EQ(120120, iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_FALSE(iter.end());
- ASSERT_EQ(4, iter.array_pos());
- ASSERT_EQ(3, iter.char_pos());
- ASSERT_EQ('z', iter.get());
- ASSERT_TRUE(iter.Advance());
-
- ASSERT_TRUE(iter.end());
- ASSERT_EQ(5, iter.array_pos());
- ASSERT_EQ(4, iter.char_pos());
-
- // Don't care what it returns, but this shouldn't crash
- iter.get();
-
- ASSERT_FALSE(iter.Advance());
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/character_encoding_unittest.cc b/base/i18n/character_encoding_unittest.cc
deleted file mode 100644
index 3c11ba3..0000000
--- a/base/i18n/character_encoding_unittest.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2016 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 "base/i18n/character_encoding.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(CharacterEncodingTest, GetCanonicalEncodingNameByAliasName) {
- EXPECT_EQ("Big5", GetCanonicalEncodingNameByAliasName("Big5"));
- EXPECT_EQ("windows-874", GetCanonicalEncodingNameByAliasName("windows-874"));
- EXPECT_EQ("ISO-8859-8", GetCanonicalEncodingNameByAliasName("ISO-8859-8"));
-
- // Non-canonical alias names should be converted to a canonical one.
- EXPECT_EQ("UTF-8", GetCanonicalEncodingNameByAliasName("utf8"));
- EXPECT_EQ("gb18030", GetCanonicalEncodingNameByAliasName("GB18030"));
- EXPECT_EQ("windows-874", GetCanonicalEncodingNameByAliasName("tis-620"));
- EXPECT_EQ("EUC-KR", GetCanonicalEncodingNameByAliasName("ks_c_5601-1987"));
-}
-
-} // namespace base
diff --git a/base/i18n/file_util_icu_unittest.cc b/base/i18n/file_util_icu_unittest.cc
deleted file mode 100644
index f1c2ecc..0000000
--- a/base/i18n/file_util_icu_unittest.cc
+++ /dev/null
@@ -1,140 +0,0 @@
-// 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.
-
-#include "base/i18n/file_util_icu.h"
-
-#include <stddef.h>
-
-#include "base/files/file_util.h"
-#include "base/macros.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-namespace base {
-namespace i18n {
-
-// file_util winds up using autoreleased objects on the Mac, so this needs
-// to be a PlatformTest
-class FileUtilICUTest : public PlatformTest {
-};
-
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
-
-// On linux, file path is parsed and filtered as UTF-8.
-static const struct GoodBadPairLinux {
- const char* bad_name;
- const char* good_name;
-} kLinuxIllegalCharacterCases[] = {
- {"bad*\\/file:name?.jpg", "bad---file-name-.jpg"},
- {"**********::::.txt", "--------------.txt"},
- {"\xe9\xf0zzzz.\xff", "\xe9\xf0zzzz.\xff"},
- {" _ ", "-_-"},
- {".", "-"},
- {" .( ). ", "-.( ).-"},
- {" ", "- -"},
-};
-
-TEST_F(FileUtilICUTest, ReplaceIllegalCharactersInPathLinuxTest) {
- for (size_t i = 0; i < arraysize(kLinuxIllegalCharacterCases); ++i) {
- std::string bad_name(kLinuxIllegalCharacterCases[i].bad_name);
- ReplaceIllegalCharactersInPath(&bad_name, '-');
- EXPECT_EQ(kLinuxIllegalCharacterCases[i].good_name, bad_name);
- }
-}
-
-#endif
-
-// For Mac & Windows, which both do Unicode validation on filenames. These
-// characters are given as wide strings since its more convenient to specify
-// unicode characters. For Mac they should be converted to UTF-8.
-static const struct goodbad_pair {
- const wchar_t* bad_name;
- const wchar_t* good_name;
-} kIllegalCharacterCases[] = {
- {L"bad*file:name?.jpg", L"bad-file-name-.jpg"},
- {L"**********::::.txt", L"--------------.txt"},
- // We can't use UCNs (universal character names) for C0/C1 characters and
- // U+007F, but \x escape is interpreted by MSVC and gcc as we intend.
- {L"bad\x0003\x0091 file\u200E\u200Fname.png", L"bad-- file--name.png"},
- {L"bad*file\\?name.jpg", L"bad-file--name.jpg"},
- {L"\t bad*file\\name/.jpg", L"- bad-file-name-.jpg"},
- {L"this_file_name is okay!.mp3", L"this_file_name is okay!.mp3"},
- {L"\u4E00\uAC00.mp3", L"\u4E00\uAC00.mp3"},
- {L"\u0635\u200C\u0644.mp3", L"\u0635-\u0644.mp3"},
- {L"\U00010330\U00010331.mp3", L"\U00010330\U00010331.mp3"},
- // Unassigned codepoints are ok.
- {L"\u0378\U00040001.mp3", L"\u0378\U00040001.mp3"},
- // Non-characters are not allowed.
- {L"bad\uFFFFfile\U0010FFFEname.jpg", L"bad-file-name.jpg"},
- {L"bad\uFDD0file\uFDEFname.jpg", L"bad-file-name.jpg"},
- // CVE-2014-9390
- {L"(\u200C.\u200D.\u200E.\u200F.\u202A.\u202B.\u202C.\u202D.\u202E.\u206A."
- L"\u206B.\u206C.\u206D.\u206F.\uFEFF)",
- L"(-.-.-.-.-.-.-.-.-.-.-.-.-.-.-)"},
- {L"config~1", L"config-1"},
- {L" _ ", L"-_-"},
- {L" ", L"-"},
- {L"\u2008.(\u2007).\u3000", L"-.(\u2007).-"},
- {L" ", L"- -"},
- {L". ", L"- -"}
-};
-
-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_POSIX)
-
-TEST_F(FileUtilICUTest, ReplaceIllegalCharactersInPathTest) {
- for (size_t i = 0; i < arraysize(kIllegalCharacterCases); ++i) {
-#if defined(OS_WIN)
- std::wstring bad_name(kIllegalCharacterCases[i].bad_name);
- ReplaceIllegalCharactersInPath(&bad_name, '-');
- EXPECT_EQ(kIllegalCharacterCases[i].good_name, bad_name);
-#else
- std::string bad_name(WideToUTF8(kIllegalCharacterCases[i].bad_name));
- ReplaceIllegalCharactersInPath(&bad_name, '-');
- EXPECT_EQ(WideToUTF8(kIllegalCharacterCases[i].good_name), bad_name);
-#endif
- }
-}
-
-#endif
-
-TEST_F(FileUtilICUTest, IsFilenameLegalTest) {
- EXPECT_TRUE(IsFilenameLegal(string16()));
-
- for (const auto& test_case : kIllegalCharacterCases) {
- string16 bad_name = WideToUTF16(test_case.bad_name);
- string16 good_name = WideToUTF16(test_case.good_name);
-
- EXPECT_TRUE(IsFilenameLegal(good_name)) << good_name;
- if (good_name != bad_name)
- EXPECT_FALSE(IsFilenameLegal(bad_name)) << bad_name;
- }
-}
-
-#if defined(OS_CHROMEOS)
-static const struct normalize_name_encoding_test_cases {
- const char* original_path;
- const char* normalized_path;
-} kNormalizeFileNameEncodingTestCases[] = {
- { "foo_na\xcc\x88me.foo", "foo_n\xc3\xa4me.foo"},
- { "foo_dir_na\xcc\x88me/foo_na\xcc\x88me.foo",
- "foo_dir_na\xcc\x88me/foo_n\xc3\xa4me.foo"},
- { "", ""},
- { "foo_dir_na\xcc\x88me/", "foo_dir_n\xc3\xa4me"}
-};
-
-TEST_F(FileUtilICUTest, NormalizeFileNameEncoding) {
- for (size_t i = 0; i < arraysize(kNormalizeFileNameEncodingTestCases); i++) {
- FilePath path(kNormalizeFileNameEncodingTestCases[i].original_path);
- NormalizeFileNameEncoding(&path);
- EXPECT_EQ(FilePath(kNormalizeFileNameEncodingTestCases[i].normalized_path),
- path);
- }
-}
-
-#endif
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/icu_string_conversions_unittest.cc b/base/i18n/icu_string_conversions_unittest.cc
deleted file mode 100644
index 871f18b..0000000
--- a/base/i18n/icu_string_conversions_unittest.cc
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright (c) 2011 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 <math.h>
-#include <stdarg.h>
-#include <stddef.h>
-
-#include <limits>
-#include <sstream>
-
-#include "base/format_macros.h"
-#include "base/i18n/icu_string_conversions.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Given a null-terminated string of wchar_t with each wchar_t representing
-// a UTF-16 code unit, returns a string16 made up of wchar_t's in the input.
-// Each wchar_t should be <= 0xFFFF and a non-BMP character (> U+FFFF)
-// should be represented as a surrogate pair (two UTF-16 units)
-// *even* where wchar_t is 32-bit (Linux and Mac).
-//
-// This is to help write tests for functions with string16 params until
-// the C++ 0x UTF-16 literal is well-supported by compilers.
-string16 BuildString16(const wchar_t* s) {
-#if defined(WCHAR_T_IS_UTF16)
- return string16(s);
-#elif defined(WCHAR_T_IS_UTF32)
- string16 u16;
- while (*s != 0) {
- DCHECK_LE(static_cast<unsigned int>(*s), 0xFFFFu);
- u16.push_back(*s++);
- }
- return u16;
-#endif
-}
-
-} // namespace
-
-// kConverterCodepageCases is not comprehensive. There are a number of cases
-// to add if we really want to have a comprehensive coverage of various
-// codepages and their 'idiosyncrasies'. Currently, the only implementation
-// for CodepageTo* and *ToCodepage uses ICU, which has a very extensive
-// set of tests for the charset conversion. So, we can get away with a
-// relatively small number of cases listed below.
-//
-// Note about |u16_wide| in the following struct.
-// On Windows, the field is always identical to |wide|. On Mac and Linux,
-// it's identical as long as there's no character outside the
-// BMP (<= U+FFFF). When there is, it is different from |wide| and
-// is not a real wide string (UTF-32 string) in that each wchar_t in
-// the string is a UTF-16 code unit zero-extended to be 32-bit
-// even when the code unit belongs to a surrogate pair.
-// For instance, a Unicode string (U+0041 U+010000) is represented as
-// L"\x0041\xD800\xDC00" instead of L"\x0041\x10000".
-// To avoid the clutter, |u16_wide| will be set to NULL
-// if it's identical to |wide| on *all* platforms.
-
-static const struct {
- const char* codepage_name;
- const char* encoded;
- OnStringConversionError::Type on_error;
- bool success;
- const wchar_t* wide;
- const wchar_t* u16_wide;
-} kConvertCodepageCases[] = {
- // Test a case where the input cannot be decoded, using SKIP, FAIL
- // and SUBSTITUTE error handling rules. "A7 41" is valid, but "A6" isn't.
- {"big5", "\xA7\x41\xA6", OnStringConversionError::FAIL, false, L"",
- nullptr},
- {"big5", "\xA7\x41\xA6", OnStringConversionError::SKIP, true, L"\x4F60",
- nullptr},
- {"big5", "\xA7\x41\xA6", OnStringConversionError::SUBSTITUTE, true,
- L"\x4F60\xFFFD", nullptr},
- // Arabic (ISO-8859)
- {"iso-8859-6",
- "\xC7\xEE\xE4\xD3\xF1\xEE\xE4\xC7\xE5\xEF"
- " "
- "\xD9\xEE\xE4\xEE\xEA\xF2\xE3\xEF\xE5\xF2",
- OnStringConversionError::FAIL, true,
- L"\x0627\x064E\x0644\x0633\x0651\x064E\x0644\x0627\x0645\x064F"
- L" "
- L"\x0639\x064E\x0644\x064E\x064A\x0652\x0643\x064F\x0645\x0652",
- nullptr},
- // Chinese Simplified (GB2312)
- {"gb2312", "\xC4\xE3\xBA\xC3", OnStringConversionError::FAIL, true,
- L"\x4F60\x597D", nullptr},
- // Chinese (GB18030) : 4 byte sequences mapped to BMP characters
- {"gb18030", "\x81\x30\x84\x36\xA1\xA7", OnStringConversionError::FAIL, true,
- L"\x00A5\x00A8", nullptr},
- // Chinese (GB18030) : A 4 byte sequence mapped to plane 2 (U+20000)
- {"gb18030", "\x95\x32\x82\x36\xD2\xBB", OnStringConversionError::FAIL, true,
-#if defined(WCHAR_T_IS_UTF16)
- L"\xD840\xDC00\x4E00",
-#elif defined(WCHAR_T_IS_UTF32)
- L"\x20000\x4E00",
-#endif
- L"\xD840\xDC00\x4E00"},
- {"big5", "\xA7\x41\xA6\x6E", OnStringConversionError::FAIL, true,
- L"\x4F60\x597D", nullptr},
- // Greek (ISO-8859)
- {"iso-8859-7",
- "\xE3\xE5\xE9\xDC"
- " "
- "\xF3\xEF\xF5",
- OnStringConversionError::FAIL, true,
- L"\x03B3\x03B5\x03B9\x03AC"
- L" "
- L"\x03C3\x03BF\x03C5",
- nullptr},
- // Hebrew (Windows)
- {"windows-1255", "\xF9\xD1\xC8\xEC\xE5\xC9\xED",
- OnStringConversionError::FAIL, true,
- L"\x05E9\x05C1\x05B8\x05DC\x05D5\x05B9\x05DD", nullptr},
- // Korean (EUC)
- {"euc-kr", "\xBE\xC8\xB3\xE7\xC7\xCF\xBC\xBC\xBF\xE4",
- OnStringConversionError::FAIL, true, L"\xC548\xB155\xD558\xC138\xC694",
- nullptr},
- // Japanese (EUC)
- {"euc-jp", "\xA4\xB3\xA4\xF3\xA4\xCB\xA4\xC1\xA4\xCF\xB0\xEC\x8E\xA6",
- OnStringConversionError::FAIL, true,
- L"\x3053\x3093\x306B\x3061\x306F\x4E00\xFF66", nullptr},
- // Japanese (ISO-2022)
- {"iso-2022-jp",
- "\x1B$B"
- "\x24\x33\x24\x73\x24\x4B\x24\x41\x24\x4F\x30\x6C"
- "\x1B(B"
- "ab"
- "\x1B(J"
- "\x5C\x7E#$"
- "\x1B(B",
- OnStringConversionError::FAIL, true,
- L"\x3053\x3093\x306B\x3061\x306F\x4E00"
- L"ab\x00A5\x203E#$",
- nullptr},
- // Japanese (Shift-JIS)
- {"sjis", "\x82\xB1\x82\xF1\x82\xC9\x82\xBF\x82\xCD\x88\xEA\xA6",
- OnStringConversionError::FAIL, true,
- L"\x3053\x3093\x306B\x3061\x306F\x4E00\xFF66", nullptr},
- // Russian (KOI8)
- {"koi8-r", "\xDA\xC4\xD2\xC1\xD7\xD3\xD4\xD7\xD5\xCA\xD4\xC5",
- OnStringConversionError::FAIL, true,
- L"\x0437\x0434\x0440\x0430\x0432\x0441\x0442\x0432"
- L"\x0443\x0439\x0442\x0435",
- nullptr},
- // Thai (windows-874)
- {"windows-874",
- "\xCA\xC7\xD1\xCA\xB4\xD5"
- "\xA4\xC3\xD1\xBA",
- OnStringConversionError::FAIL, true,
- L"\x0E2A\x0E27\x0E31\x0E2A\x0E14\x0E35"
- L"\x0E04\x0E23\x0e31\x0E1A",
- nullptr},
-};
-
-TEST(ICUStringConversionsTest, ConvertBetweenCodepageAndUTF16) {
- for (size_t i = 0; i < arraysize(kConvertCodepageCases); ++i) {
- SCOPED_TRACE(base::StringPrintf(
- "Test[%" PRIuS "]: <encoded: %s> <codepage: %s>", i,
- kConvertCodepageCases[i].encoded,
- kConvertCodepageCases[i].codepage_name));
-
- string16 utf16;
- bool success = CodepageToUTF16(kConvertCodepageCases[i].encoded,
- kConvertCodepageCases[i].codepage_name,
- kConvertCodepageCases[i].on_error,
- &utf16);
- string16 utf16_expected;
- if (kConvertCodepageCases[i].u16_wide == nullptr)
- utf16_expected = BuildString16(kConvertCodepageCases[i].wide);
- else
- utf16_expected = BuildString16(kConvertCodepageCases[i].u16_wide);
- EXPECT_EQ(kConvertCodepageCases[i].success, success);
- EXPECT_EQ(utf16_expected, utf16);
-
- // When decoding was successful and nothing was skipped, we also check the
- // reverse conversion. See also the corresponding comment in
- // ConvertBetweenCodepageAndWide.
- if (success &&
- kConvertCodepageCases[i].on_error == OnStringConversionError::FAIL) {
- std::string encoded;
- success = UTF16ToCodepage(utf16, kConvertCodepageCases[i].codepage_name,
- kConvertCodepageCases[i].on_error, &encoded);
- EXPECT_EQ(kConvertCodepageCases[i].success, success);
- EXPECT_EQ(kConvertCodepageCases[i].encoded, encoded);
- }
- }
-}
-
-static const struct {
- const char* encoded;
- const char* codepage_name;
- bool expected_success;
- const char* expected_value;
-} kConvertAndNormalizeCases[] = {
- {"foo-\xe4.html", "iso-8859-1", true, "foo-\xc3\xa4.html"},
- {"foo-\xe4.html", "iso-8859-7", true, "foo-\xce\xb4.html"},
- {"foo-\xe4.html", "foo-bar", false, ""},
- // HTML Encoding spec treats US-ASCII as synonymous with windows-1252
- {"foo-\xff.html", "ascii", true, "foo-\xc3\xbf.html"},
- {"foo.html", "ascii", true, "foo.html"},
- {"foo-a\xcc\x88.html", "utf-8", true, "foo-\xc3\xa4.html"},
- {"\x95\x32\x82\x36\xD2\xBB", "gb18030", true, "\xF0\xA0\x80\x80\xE4\xB8\x80"},
- {"\xA7\x41\xA6\x6E", "big5", true, "\xE4\xBD\xA0\xE5\xA5\xBD"},
- // Windows-1258 does have a combining character at xD2 (which is U+0309).
- // The sequence of (U+00E2, U+0309) is also encoded as U+1EA9.
- {"foo\xE2\xD2", "windows-1258", true, "foo\xE1\xBA\xA9"},
- {"", "iso-8859-1", true, ""},
-};
-TEST(ICUStringConversionsTest, ConvertToUtf8AndNormalize) {
- std::string result;
- for (size_t i = 0; i < arraysize(kConvertAndNormalizeCases); ++i) {
- SCOPED_TRACE(base::StringPrintf(
- "Test[%" PRIuS "]: <encoded: %s> <codepage: %s>", i,
- kConvertAndNormalizeCases[i].encoded,
- kConvertAndNormalizeCases[i].codepage_name));
-
- bool success = ConvertToUtf8AndNormalize(
- kConvertAndNormalizeCases[i].encoded,
- kConvertAndNormalizeCases[i].codepage_name, &result);
- EXPECT_EQ(kConvertAndNormalizeCases[i].expected_success, success);
- EXPECT_EQ(kConvertAndNormalizeCases[i].expected_value, result);
- }
-}
-
-} // namespace base
diff --git a/base/i18n/message_formatter_unittest.cc b/base/i18n/message_formatter_unittest.cc
deleted file mode 100644
index a6f4613..0000000
--- a/base/i18n/message_formatter_unittest.cc
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright 2015 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 "base/i18n/message_formatter.h"
-
-#include <memory>
-
-#include "base/i18n/rtl.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/icu/source/common/unicode/unistr.h"
-#include "third_party/icu/source/i18n/unicode/datefmt.h"
-#include "third_party/icu/source/i18n/unicode/msgfmt.h"
-
-typedef testing::Test MessageFormatterTest;
-
-namespace base {
-namespace i18n {
-
-class MessageFormatterTest : public testing::Test {
- protected:
- MessageFormatterTest() {
- original_locale_ = GetConfiguredLocale();
- SetICUDefaultLocale("en-US");
- }
- ~MessageFormatterTest() override {
- SetICUDefaultLocale(original_locale_);
- }
-
- private:
- std::string original_locale_;
-};
-
-namespace {
-
-void AppendFormattedDateTime(const std::unique_ptr<icu::DateFormat>& df,
- const Time& now,
- std::string* result) {
- icu::UnicodeString formatted;
- df->format(static_cast<UDate>(now.ToJsTime()), formatted).
- toUTF8String(*result);
-}
-
-} // namespace
-
-TEST_F(MessageFormatterTest, PluralNamedArgs) {
- const string16 pattern = ASCIIToUTF16(
- "{num_people, plural, "
- "=0 {I met nobody in {place}.}"
- "=1 {I met a person in {place}.}"
- "other {I met # people in {place}.}}");
-
- std::string result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 0, "place", "Paris"));
- EXPECT_EQ("I met nobody in Paris.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 1, "place", "Paris"));
- EXPECT_EQ("I met a person in Paris.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 5, "place", "Paris"));
- EXPECT_EQ("I met 5 people in Paris.", result);
-}
-
-TEST_F(MessageFormatterTest, PluralNamedArgsWithOffset) {
- const string16 pattern = ASCIIToUTF16(
- "{num_people, plural, offset:1 "
- "=0 {I met nobody in {place}.}"
- "=1 {I met {person} in {place}.}"
- "=2 {I met {person} and one other person in {place}.}"
- "=13 {I met {person} and a dozen other people in {place}.}"
- "other {I met {person} and # other people in {place}.}}");
-
- std::string result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 0, "place", "Paris"));
- EXPECT_EQ("I met nobody in Paris.", result);
- // {person} is ignored if {num_people} is 0.
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 0, "place", "Paris", "person", "Peter"));
- EXPECT_EQ("I met nobody in Paris.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 1, "place", "Paris", "person", "Peter"));
- EXPECT_EQ("I met Peter in Paris.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 2, "place", "Paris", "person", "Peter"));
- EXPECT_EQ("I met Peter and one other person in Paris.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 13, "place", "Paris", "person", "Peter"));
- EXPECT_EQ("I met Peter and a dozen other people in Paris.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNamedArgs(
- pattern, "num_people", 50, "place", "Paris", "person", "Peter"));
- EXPECT_EQ("I met Peter and 49 other people in Paris.", result);
-}
-
-TEST_F(MessageFormatterTest, PluralNumberedArgs) {
- const string16 pattern = ASCIIToUTF16(
- "{1, plural, "
- "=1 {The cert for {0} expired yesterday.}"
- "=7 {The cert for {0} expired a week ago.}"
- "other {The cert for {0} expired # days ago.}}");
-
- std::string result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "example.com", 1));
- EXPECT_EQ("The cert for example.com expired yesterday.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "example.com", 7));
- EXPECT_EQ("The cert for example.com expired a week ago.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "example.com", 15));
- EXPECT_EQ("The cert for example.com expired 15 days ago.", result);
-}
-
-TEST_F(MessageFormatterTest, PluralNumberedArgsWithDate) {
- const string16 pattern = ASCIIToUTF16(
- "{1, plural, "
- "=1 {The cert for {0} expired yesterday. Today is {2,date,full}}"
- "other {The cert for {0} expired # days ago. Today is {2,date,full}}}");
-
- base::Time now = base::Time::Now();
- using icu::DateFormat;
- std::unique_ptr<DateFormat> df(
- DateFormat::createDateInstance(DateFormat::FULL));
- std::string second_sentence = " Today is ";
- AppendFormattedDateTime(df, now, &second_sentence);
-
- std::string result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "example.com", 1, now));
- EXPECT_EQ("The cert for example.com expired yesterday." + second_sentence,
- result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "example.com", 15, now));
- EXPECT_EQ("The cert for example.com expired 15 days ago." + second_sentence,
- result);
-}
-
-TEST_F(MessageFormatterTest, DateTimeAndNumber) {
- // Note that using 'mph' for all locales is not a good i18n practice.
- const string16 pattern = ASCIIToUTF16(
- "At {0,time, short} on {0,date, medium}, "
- "there was {1} at building {2,number,integer}. "
- "The speed of the wind was {3,number,###.#} mph.");
-
- using icu::DateFormat;
- std::unique_ptr<DateFormat> tf(
- DateFormat::createTimeInstance(DateFormat::SHORT));
- std::unique_ptr<DateFormat> df(
- DateFormat::createDateInstance(DateFormat::MEDIUM));
-
- base::Time now = base::Time::Now();
- std::string expected = "At ";
- AppendFormattedDateTime(tf, now, &expected);
- expected.append(" on ");
- AppendFormattedDateTime(df, now, &expected);
- expected.append(", there was an explosion at building 3. "
- "The speed of the wind was 37.4 mph.");
-
- EXPECT_EQ(expected, UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, now, "an explosion", 3, 37.413)));
-}
-
-TEST_F(MessageFormatterTest, SelectorSingleOrMultiple) {
- const string16 pattern = ASCIIToUTF16(
- "{0, select,"
- "single {Select a file to upload.}"
- "multiple {Select files to upload.}"
- "other {UNUSED}}");
-
- std::string result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "single"));
- EXPECT_EQ("Select a file to upload.", result);
- result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "multiple"));
- EXPECT_EQ("Select files to upload.", result);
-
- // fallback if a parameter is not selectors specified in the message pattern.
- result = UTF16ToASCII(MessageFormatter::FormatWithNumberedArgs(
- pattern, "foobar"));
- EXPECT_EQ("UNUSED", result);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/number_formatting_unittest.cc b/base/i18n/number_formatting_unittest.cc
deleted file mode 100644
index 71b15a5..0000000
--- a/base/i18n/number_formatting_unittest.cc
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) 2011 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 <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-
-#include "base/i18n/number_formatting.h"
-#include "base/i18n/rtl.h"
-#include "base/macros.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/test/icu_test_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/icu/source/i18n/unicode/usearch.h"
-
-namespace base {
-namespace {
-
-TEST(NumberFormattingTest, FormatNumber) {
- static const struct {
- int64_t number;
- const char* expected_english;
- const char* expected_german;
- } cases[] = {
- {0, "0", "0"},
- {1024, "1,024", "1.024"},
- {std::numeric_limits<int64_t>::max(),
- "9,223,372,036,854,775,807", "9.223.372.036.854.775.807"},
- {std::numeric_limits<int64_t>::min(),
- "-9,223,372,036,854,775,808", "-9.223.372.036.854.775.808"},
- {-42, "-42", "-42"},
- };
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- i18n::SetICUDefaultLocale("en");
- testing::ResetFormatters();
- EXPECT_EQ(cases[i].expected_english,
- UTF16ToUTF8(FormatNumber(cases[i].number)));
- i18n::SetICUDefaultLocale("de");
- testing::ResetFormatters();
- EXPECT_EQ(cases[i].expected_german,
- UTF16ToUTF8(FormatNumber(cases[i].number)));
- }
-}
-
-TEST(NumberFormattingTest, FormatDouble) {
- static const struct {
- double number;
- int frac_digits;
- const char* expected_english;
- const char* expected_german;
- } cases[] = {
- {0.0, 0, "0", "0"},
-#if !defined(OS_ANDROID)
- // Bionic can't printf negative zero correctly.
- {-0.0, 4, "-0.0000", "-0,0000"},
-#endif
- {1024.2, 0, "1,024", "1.024"},
- {-1024.223, 2, "-1,024.22", "-1.024,22"},
- {std::numeric_limits<double>::max(), 6,
- "179,769,313,486,231,570,000,000,000,000,000,000,000,000,000,000,000,"
- "000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,"
- "000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,"
- "000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,"
- "000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,"
- "000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,"
- "000.000000",
- "179.769.313.486.231.570.000.000.000.000.000.000.000.000.000.000.000."
- "000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000."
- "000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000."
- "000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000."
- "000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000."
- "000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000."
- "000,000000"},
- {std::numeric_limits<double>::min(), 2, "0.00", "0,00"},
- {-42.7, 3, "-42.700", "-42,700"},
- };
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- for (size_t i = 0; i < arraysize(cases); ++i) {
- i18n::SetICUDefaultLocale("en");
- testing::ResetFormatters();
- EXPECT_EQ(cases[i].expected_english,
- UTF16ToUTF8(FormatDouble(cases[i].number, cases[i].frac_digits)));
- i18n::SetICUDefaultLocale("de");
- testing::ResetFormatters();
- EXPECT_EQ(cases[i].expected_german,
- UTF16ToUTF8(FormatDouble(cases[i].number, cases[i].frac_digits)));
- }
-}
-
-TEST(NumberFormattingTest, FormatPercent) {
- static const struct {
- int64_t number;
- const char* expected_english;
- const wchar_t* expected_german; // Note: Space before % isn't \x20.
- // Note: Eastern Arabic-Indic digits (U+06Fx) for Persian and
- // Arabic-Indic digits (U+066x) for Arabic.
- // See https://unicode.org/cldr/trac/ticket/9040 for details.
- // See also https://unicode.org/cldr/trac/ticket/10176 .
- // For now, take what CLDR 32 has (percent sign to the right of
- // a number in Persian).
- const wchar_t* expected_persian;
- const wchar_t* expected_arabic;
- } cases[] = {
- {0, "0%", L"0\xa0%", L"\x6f0\x66a", L"\x660\x66a\x61c"},
- {42, "42%", L"42\xa0%", L"\x6f4\x6f2\x66a", L"\x664\x662\x66a\x61c"},
- {1024, "1,024%", L"1.024\xa0%", L"\x6f1\x66c\x6f0\x6f2\x6f4\x66a",
- L"\x661\x66c\x660\x662\x664\x66a\x61c"},
- };
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- for (size_t i = 0; i < arraysize(cases); ++i) {
- i18n::SetICUDefaultLocale("en");
- EXPECT_EQ(ASCIIToUTF16(cases[i].expected_english),
- FormatPercent(cases[i].number));
- i18n::SetICUDefaultLocale("de");
- EXPECT_EQ(WideToUTF16(cases[i].expected_german),
- FormatPercent(cases[i].number));
- i18n::SetICUDefaultLocale("fa");
- EXPECT_EQ(WideToUTF16(cases[i].expected_persian),
- FormatPercent(cases[i].number));
- i18n::SetICUDefaultLocale("ar");
- EXPECT_EQ(WideToUTF16(cases[i].expected_arabic),
- FormatPercent(cases[i].number));
- }
-}
-
-} // namespace
-} // namespace base
diff --git a/base/i18n/rtl_unittest.cc b/base/i18n/rtl_unittest.cc
deleted file mode 100644
index 88ae36a..0000000
--- a/base/i18n/rtl_unittest.cc
+++ /dev/null
@@ -1,567 +0,0 @@
-// Copyright (c) 2011 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 "base/i18n/rtl.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/strings/string_util.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/test/icu_test_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-#include "third_party/icu/source/common/unicode/locid.h"
-#include "third_party/icu/source/i18n/unicode/usearch.h"
-
-namespace base {
-namespace i18n {
-
-namespace {
-
-// A test utility function to set the application default text direction.
-void SetRTL(bool rtl) {
- // Override the current locale/direction.
- SetICUDefaultLocale(rtl ? "he" : "en");
- EXPECT_EQ(rtl, IsRTL());
-}
-
-} // namespace
-
-class RTLTest : public PlatformTest {
-};
-
-TEST_F(RTLTest, GetFirstStrongCharacterDirection) {
- struct {
- const wchar_t* text;
- TextDirection direction;
- } cases[] = {
- // Test pure LTR string.
- { L"foo bar", LEFT_TO_RIGHT },
- // Test pure RTL string.
- { L"\x05d0\x05d1\x05d2 \x05d3\x0d4\x05d5", RIGHT_TO_LEFT},
- // Test bidi string in which the first character with strong directionality
- // is a character with type L.
- { L"foo \x05d0 bar", LEFT_TO_RIGHT },
- // Test bidi string in which the first character with strong directionality
- // is a character with type R.
- { L"\x05d0 foo bar", RIGHT_TO_LEFT },
- // Test bidi string which starts with a character with weak directionality
- // and in which the first character with strong directionality is a
- // character with type L.
- { L"!foo \x05d0 bar", LEFT_TO_RIGHT },
- // Test bidi string which starts with a character with weak directionality
- // and in which the first character with strong directionality is a
- // character with type R.
- { L",\x05d0 foo bar", RIGHT_TO_LEFT },
- // Test bidi string in which the first character with strong directionality
- // is a character with type LRE.
- { L"\x202a \x05d0 foo bar", LEFT_TO_RIGHT },
- // Test bidi string in which the first character with strong directionality
- // is a character with type LRO.
- { L"\x202d \x05d0 foo bar", LEFT_TO_RIGHT },
- // Test bidi string in which the first character with strong directionality
- // is a character with type RLE.
- { L"\x202b foo \x05d0 bar", RIGHT_TO_LEFT },
- // Test bidi string in which the first character with strong directionality
- // is a character with type RLO.
- { L"\x202e foo \x05d0 bar", RIGHT_TO_LEFT },
- // Test bidi string in which the first character with strong directionality
- // is a character with type AL.
- { L"\x0622 foo \x05d0 bar", RIGHT_TO_LEFT },
- // Test a string without strong directionality characters.
- { L",!.{}", LEFT_TO_RIGHT },
- // Test empty string.
- { L"", LEFT_TO_RIGHT },
- // Test characters in non-BMP (e.g. Phoenician letters. Please refer to
- // http://demo.icu-project.org/icu-bin/ubrowse?scr=151&b=10910 for more
- // information).
- {
-#if defined(WCHAR_T_IS_UTF32)
- L" ! \x10910" L"abc 123",
-#elif defined(WCHAR_T_IS_UTF16)
- L" ! \xd802\xdd10" L"abc 123",
-#else
-#error wchar_t should be either UTF-16 or UTF-32
-#endif
- RIGHT_TO_LEFT },
- {
-#if defined(WCHAR_T_IS_UTF32)
- L" ! \x10401" L"abc 123",
-#elif defined(WCHAR_T_IS_UTF16)
- L" ! \xd801\xdc01" L"abc 123",
-#else
-#error wchar_t should be either UTF-16 or UTF-32
-#endif
- LEFT_TO_RIGHT },
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].direction,
- GetFirstStrongCharacterDirection(WideToUTF16(cases[i].text)));
-}
-
-
-// Note that the cases with LRE, LRO, RLE and RLO are invalid for
-// GetLastStrongCharacterDirection because they should be followed by PDF
-// character.
-TEST_F(RTLTest, GetLastStrongCharacterDirection) {
- struct {
- const wchar_t* text;
- TextDirection direction;
- } cases[] = {
- // Test pure LTR string.
- { L"foo bar", LEFT_TO_RIGHT },
- // Test pure RTL string.
- { L"\x05d0\x05d1\x05d2 \x05d3\x0d4\x05d5", RIGHT_TO_LEFT},
- // Test bidi string in which the last character with strong directionality
- // is a character with type L.
- { L"foo \x05d0 bar", LEFT_TO_RIGHT },
- // Test bidi string in which the last character with strong directionality
- // is a character with type R.
- { L"\x05d0 foo bar \x05d3", RIGHT_TO_LEFT },
- // Test bidi string which ends with a character with weak directionality
- // and in which the last character with strong directionality is a
- // character with type L.
- { L"!foo \x05d0 bar!", LEFT_TO_RIGHT },
- // Test bidi string which ends with a character with weak directionality
- // and in which the last character with strong directionality is a
- // character with type R.
- { L",\x05d0 foo bar \x05d1,", RIGHT_TO_LEFT },
- // Test bidi string in which the last character with strong directionality
- // is a character with type AL.
- { L"\x0622 foo \x05d0 bar \x0622", RIGHT_TO_LEFT },
- // Test a string without strong directionality characters.
- { L",!.{}", LEFT_TO_RIGHT },
- // Test empty string.
- { L"", LEFT_TO_RIGHT },
- // Test characters in non-BMP (e.g. Phoenician letters. Please refer to
- // http://demo.icu-project.org/icu-bin/ubrowse?scr=151&b=10910 for more
- // information).
- {
-#if defined(WCHAR_T_IS_UTF32)
- L"abc 123" L" ! \x10910 !",
-#elif defined(WCHAR_T_IS_UTF16)
- L"abc 123" L" ! \xd802\xdd10 !",
-#else
-#error wchar_t should be either UTF-16 or UTF-32
-#endif
- RIGHT_TO_LEFT },
- {
-#if defined(WCHAR_T_IS_UTF32)
- L"abc 123" L" ! \x10401 !",
-#elif defined(WCHAR_T_IS_UTF16)
- L"abc 123" L" ! \xd801\xdc01 !",
-#else
-#error wchar_t should be either UTF-16 or UTF-32
-#endif
- LEFT_TO_RIGHT },
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].direction,
- GetLastStrongCharacterDirection(WideToUTF16(cases[i].text)));
-}
-
-TEST_F(RTLTest, GetStringDirection) {
- struct {
- const wchar_t* text;
- TextDirection direction;
- } cases[] = {
- // Test pure LTR string.
- { L"foobar", LEFT_TO_RIGHT },
- { L".foobar", LEFT_TO_RIGHT },
- { L"foo, bar", LEFT_TO_RIGHT },
- // Test pure LTR with strong directionality characters of type LRE.
- { L"\x202a\x202a", LEFT_TO_RIGHT },
- { L".\x202a\x202a", LEFT_TO_RIGHT },
- { L"\x202a, \x202a", LEFT_TO_RIGHT },
- // Test pure LTR with strong directionality characters of type LRO.
- { L"\x202d\x202d", LEFT_TO_RIGHT },
- { L".\x202d\x202d", LEFT_TO_RIGHT },
- { L"\x202d, \x202d", LEFT_TO_RIGHT },
- // Test pure LTR with various types of strong directionality characters.
- { L"foo \x202a\x202d", LEFT_TO_RIGHT },
- { L".\x202d foo \x202a", LEFT_TO_RIGHT },
- { L"\x202a, \x202d foo", LEFT_TO_RIGHT },
- // Test pure RTL with strong directionality characters of type R.
- { L"\x05d0\x05d0", RIGHT_TO_LEFT },
- { L".\x05d0\x05d0", RIGHT_TO_LEFT },
- { L"\x05d0, \x05d0", RIGHT_TO_LEFT },
- // Test pure RTL with strong directionality characters of type RLE.
- { L"\x202b\x202b", RIGHT_TO_LEFT },
- { L".\x202b\x202b", RIGHT_TO_LEFT },
- { L"\x202b, \x202b", RIGHT_TO_LEFT },
- // Test pure RTL with strong directionality characters of type RLO.
- { L"\x202e\x202e", RIGHT_TO_LEFT },
- { L".\x202e\x202e", RIGHT_TO_LEFT },
- { L"\x202e, \x202e", RIGHT_TO_LEFT },
- // Test pure RTL with strong directionality characters of type AL.
- { L"\x0622\x0622", RIGHT_TO_LEFT },
- { L".\x0622\x0622", RIGHT_TO_LEFT },
- { L"\x0622, \x0622", RIGHT_TO_LEFT },
- // Test pure RTL with various types of strong directionality characters.
- { L"\x05d0\x202b\x202e\x0622", RIGHT_TO_LEFT },
- { L".\x202b\x202e\x0622\x05d0", RIGHT_TO_LEFT },
- { L"\x0622\x202e, \x202b\x05d0", RIGHT_TO_LEFT },
- // Test bidi strings.
- { L"foo \x05d0 bar", UNKNOWN_DIRECTION },
- { L"\x202b foo bar", UNKNOWN_DIRECTION },
- { L"!foo \x0622 bar", UNKNOWN_DIRECTION },
- { L"\x202a\x202b", UNKNOWN_DIRECTION },
- { L"\x202e\x202d", UNKNOWN_DIRECTION },
- { L"\x0622\x202a", UNKNOWN_DIRECTION },
- { L"\x202d\x05d0", UNKNOWN_DIRECTION },
- // Test a string without strong directionality characters.
- { L",!.{}", LEFT_TO_RIGHT },
- // Test empty string.
- { L"", LEFT_TO_RIGHT },
- {
-#if defined(WCHAR_T_IS_UTF32)
- L" ! \x10910" L"abc 123",
-#elif defined(WCHAR_T_IS_UTF16)
- L" ! \xd802\xdd10" L"abc 123",
-#else
-#error wchar_t should be either UTF-16 or UTF-32
-#endif
- UNKNOWN_DIRECTION },
- {
-#if defined(WCHAR_T_IS_UTF32)
- L" ! \x10401" L"abc 123",
-#elif defined(WCHAR_T_IS_UTF16)
- L" ! \xd801\xdc01" L"abc 123",
-#else
-#error wchar_t should be either UTF-16 or UTF-32
-#endif
- LEFT_TO_RIGHT },
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].direction,
- GetStringDirection(WideToUTF16(cases[i].text)));
-}
-
-TEST_F(RTLTest, WrapPathWithLTRFormatting) {
- const wchar_t* cases[] = {
- // Test common path, such as "c:\foo\bar".
- L"c:/foo/bar",
- // Test path with file name, such as "c:\foo\bar\test.jpg".
- L"c:/foo/bar/test.jpg",
- // Test path ending with punctuation, such as "c:\(foo)\bar.".
- L"c:/(foo)/bar.",
- // Test path ending with separator, such as "c:\foo\bar\".
- L"c:/foo/bar/",
- // Test path with RTL character.
- L"c:/\x05d0",
- // Test path with 2 level RTL directory names.
- L"c:/\x05d0/\x0622",
- // Test path with mixed RTL/LTR directory names and ending with punctuation.
- L"c:/\x05d0/\x0622/(foo)/b.a.r.",
- // Test path without driver name, such as "/foo/bar/test/jpg".
- L"/foo/bar/test.jpg",
- // Test path start with current directory, such as "./foo".
- L"./foo",
- // Test path start with parent directory, such as "../foo/bar.jpg".
- L"../foo/bar.jpg",
- // Test absolute path, such as "//foo/bar.jpg".
- L"//foo/bar.jpg",
- // Test path with mixed RTL/LTR directory names.
- L"c:/foo/\x05d0/\x0622/\x05d1.jpg",
- // Test empty path.
- L""
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- FilePath path;
-#if defined(OS_WIN)
- std::wstring win_path(cases[i]);
- std::replace(win_path.begin(), win_path.end(), '/', '\\');
- path = FilePath(win_path);
- std::wstring wrapped_expected =
- std::wstring(L"\x202a") + win_path + L"\x202c";
-#else
- path = FilePath(base::SysWideToNativeMB(cases[i]));
- std::wstring wrapped_expected =
- std::wstring(L"\x202a") + cases[i] + L"\x202c";
-#endif
- string16 localized_file_path_string;
- WrapPathWithLTRFormatting(path, &localized_file_path_string);
-
- std::wstring wrapped_actual = UTF16ToWide(localized_file_path_string);
- EXPECT_EQ(wrapped_expected, wrapped_actual);
- }
-}
-
-TEST_F(RTLTest, WrapString) {
- const wchar_t* cases[] = {
- L" . ",
- L"abc",
- L"a" L"\x5d0\x5d1",
- L"a" L"\x5d1" L"b",
- L"\x5d0\x5d1\x5d2",
- L"\x5d0\x5d1" L"a",
- L"\x5d0" L"a" L"\x5d1",
- };
-
- const bool was_rtl = IsRTL();
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- for (size_t i = 0; i < 2; ++i) {
- // Toggle the application default text direction (to try each direction).
- SetRTL(!IsRTL());
-
- string16 empty;
- WrapStringWithLTRFormatting(&empty);
- EXPECT_TRUE(empty.empty());
- WrapStringWithRTLFormatting(&empty);
- EXPECT_TRUE(empty.empty());
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- string16 input = WideToUTF16(cases[i]);
- string16 ltr_wrap = input;
- WrapStringWithLTRFormatting(<r_wrap);
- EXPECT_EQ(ltr_wrap[0], kLeftToRightEmbeddingMark);
- EXPECT_EQ(ltr_wrap.substr(1, ltr_wrap.length() - 2), input);
- EXPECT_EQ(ltr_wrap[ltr_wrap.length() -1], kPopDirectionalFormatting);
-
- string16 rtl_wrap = input;
- WrapStringWithRTLFormatting(&rtl_wrap);
- EXPECT_EQ(rtl_wrap[0], kRightToLeftEmbeddingMark);
- EXPECT_EQ(rtl_wrap.substr(1, rtl_wrap.length() - 2), input);
- EXPECT_EQ(rtl_wrap[rtl_wrap.length() -1], kPopDirectionalFormatting);
- }
- }
-
- EXPECT_EQ(was_rtl, IsRTL());
-}
-
-TEST_F(RTLTest, GetDisplayStringInLTRDirectionality) {
- struct {
- const wchar_t* path;
- bool wrap_ltr;
- bool wrap_rtl;
- } cases[] = {
- { L"test", false, true },
- { L"test.html", false, true },
- { L"\x05d0\x05d1\x05d2", true, true },
- { L"\x05d0\x05d1\x05d2.txt", true, true },
- { L"\x05d0" L"abc", true, true },
- { L"\x05d0" L"abc.txt", true, true },
- { L"abc\x05d0\x05d1", false, true },
- { L"abc\x05d0\x05d1.jpg", false, true },
- };
-
- const bool was_rtl = IsRTL();
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- for (size_t i = 0; i < 2; ++i) {
- // Toggle the application default text direction (to try each direction).
- SetRTL(!IsRTL());
- for (size_t i = 0; i < arraysize(cases); ++i) {
- string16 input = WideToUTF16(cases[i].path);
- string16 output = GetDisplayStringInLTRDirectionality(input);
- // Test the expected wrapping behavior for the current UI directionality.
- if (IsRTL() ? cases[i].wrap_rtl : cases[i].wrap_ltr)
- EXPECT_NE(output, input);
- else
- EXPECT_EQ(output, input);
- }
- }
-
- EXPECT_EQ(was_rtl, IsRTL());
-}
-
-TEST_F(RTLTest, GetTextDirection) {
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("ar"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("ar_EG"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("he"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("he_IL"));
- // iw is an obsolete code for Hebrew.
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("iw"));
- // Although we're not yet localized to Farsi and Urdu, we
- // do have the text layout direction information for them.
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("fa"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("ur"));
-#if 0
- // Enable these when we include the minimal locale data for Azerbaijani
- // written in Arabic and Dhivehi. At the moment, our copy of
- // ICU data does not have entries for them.
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("az_Arab"));
- // Dhivehi that uses Thaana script.
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocale("dv"));
-#endif
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocale("en"));
- // Chinese in China with '-'.
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocale("zh-CN"));
- // Filipino : 3-letter code
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocale("fil"));
- // Russian
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocale("ru"));
- // Japanese that uses multiple scripts
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocale("ja"));
-}
-
-TEST_F(RTLTest, GetTextDirectionForLocaleInStartUp) {
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("ar"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("ar_EG"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("he"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("he_IL"));
- // iw is an obsolete code for Hebrew.
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("iw"));
- // Although we're not yet localized to Farsi and Urdu, we
- // do have the text layout direction information for them.
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("fa"));
- EXPECT_EQ(RIGHT_TO_LEFT, GetTextDirectionForLocaleInStartUp("ur"));
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocaleInStartUp("en"));
- // Chinese in China with '-'.
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocaleInStartUp("zh-CN"));
- // Filipino : 3-letter code
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocaleInStartUp("fil"));
- // Russian
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocaleInStartUp("ru"));
- // Japanese that uses multiple scripts
- EXPECT_EQ(LEFT_TO_RIGHT, GetTextDirectionForLocaleInStartUp("ja"));
-}
-
-TEST_F(RTLTest, UnadjustStringForLocaleDirection) {
- // These test strings are borrowed from WrapPathWithLTRFormatting
- const wchar_t* cases[] = {
- L"foo bar",
- L"foo \x05d0 bar",
- L"\x05d0 foo bar",
- L"!foo \x05d0 bar",
- L",\x05d0 foo bar",
- L"\x202a \x05d0 foo bar",
- L"\x202d \x05d0 foo bar",
- L"\x202b foo \x05d0 bar",
- L"\x202e foo \x05d0 bar",
- L"\x0622 foo \x05d0 bar",
- };
-
- const bool was_rtl = IsRTL();
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- for (size_t i = 0; i < 2; ++i) {
- // Toggle the application default text direction (to try each direction).
- SetRTL(!IsRTL());
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- string16 test_case = WideToUTF16(cases[i]);
- string16 adjusted_string = test_case;
-
- if (!AdjustStringForLocaleDirection(&adjusted_string))
- continue;
-
- EXPECT_NE(test_case, adjusted_string);
- EXPECT_TRUE(UnadjustStringForLocaleDirection(&adjusted_string));
- EXPECT_EQ(test_case, adjusted_string) << " for test case [" << test_case
- << "] with IsRTL() == " << IsRTL();
- }
- }
-
- EXPECT_EQ(was_rtl, IsRTL());
-}
-
-TEST_F(RTLTest, EnsureTerminatedDirectionalFormatting) {
- struct {
- const wchar_t* unformated_text;
- const wchar_t* formatted_text;
- } cases[] = {
- // Tests string without any dir-formatting characters.
- {L"google.com", L"google.com"},
- // Tests string with properly terminated dir-formatting character.
- {L"\x202egoogle.com\x202c", L"\x202egoogle.com\x202c"},
- // Tests string with over-terminated dir-formatting characters.
- {L"\x202egoogle\x202c.com\x202c", L"\x202egoogle\x202c.com\x202c"},
- // Tests string beginning with a dir-formatting character.
- {L"\x202emoc.elgoog", L"\x202emoc.elgoog\x202c"},
- // Tests string that over-terminates then re-opens.
- {L"\x202egoogle\x202c\x202c.\x202eom",
- L"\x202egoogle\x202c\x202c.\x202eom\x202c"},
- // Tests string containing a dir-formatting character in the middle.
- {L"google\x202e.com", L"google\x202e.com\x202c"},
- // Tests string with multiple dir-formatting characters.
- {L"\x202egoogle\x202e.com/\x202eguest",
- L"\x202egoogle\x202e.com/\x202eguest\x202c\x202c\x202c"},
- // Test the other dir-formatting characters (U+202A, U+202B, and U+202D).
- {L"\x202agoogle.com", L"\x202agoogle.com\x202c"},
- {L"\x202bgoogle.com", L"\x202bgoogle.com\x202c"},
- {L"\x202dgoogle.com", L"\x202dgoogle.com\x202c"},
- };
-
- const bool was_rtl = IsRTL();
-
- test::ScopedRestoreICUDefaultLocale restore_locale;
- for (size_t i = 0; i < 2; ++i) {
- // Toggle the application default text direction (to try each direction).
- SetRTL(!IsRTL());
- for (size_t i = 0; i < arraysize(cases); ++i) {
- string16 unsanitized_text = WideToUTF16(cases[i].unformated_text);
- string16 sanitized_text = WideToUTF16(cases[i].formatted_text);
- EnsureTerminatedDirectionalFormatting(&unsanitized_text);
- EXPECT_EQ(sanitized_text, unsanitized_text);
- }
- }
- EXPECT_EQ(was_rtl, IsRTL());
-}
-
-TEST_F(RTLTest, SanitizeUserSuppliedString) {
- struct {
- const wchar_t* unformatted_text;
- const wchar_t* formatted_text;
- } cases[] = {
- // Tests RTL string with properly terminated dir-formatting character.
- {L"\x202eكبير Google التطبيق\x202c", L"\x202eكبير Google التطبيق\x202c"},
- // Tests RTL string with over-terminated dir-formatting characters.
- {L"\x202eكبير Google\x202cالتطبيق\x202c",
- L"\x202eكبير Google\x202cالتطبيق\x202c"},
- // Tests RTL string that over-terminates then re-opens.
- {L"\x202eكبير Google\x202c\x202cالتطبيق\x202e",
- L"\x202eكبير Google\x202c\x202cالتطبيق\x202e\x202c"},
- // Tests RTL string with multiple dir-formatting characters.
- {L"\x202eك\x202eبير Google الت\x202eطبيق",
- L"\x202eك\x202eبير Google الت\x202eطبيق\x202c\x202c\x202c"},
- // Test the other dir-formatting characters (U+202A, U+202B, and U+202D).
- {L"\x202aكبير Google التطبيق", L"\x202aكبير Google التطبيق\x202c"},
- {L"\x202bكبير Google التطبيق", L"\x202bكبير Google التطبيق\x202c"},
- {L"\x202dكبير Google التطبيق", L"\x202dكبير Google التطبيق\x202c"},
-
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- // On Windows for an LTR locale, no changes to the string are made.
- string16 prefix, suffix = WideToUTF16(L"");
-#if !defined(OS_WIN)
- prefix = WideToUTF16(L"\x200e\x202b");
- suffix = WideToUTF16(L"\x202c\x200e");
-#endif // !OS_WIN
- string16 unsanitized_text = WideToUTF16(cases[i].unformatted_text);
- string16 sanitized_text =
- prefix + WideToUTF16(cases[i].formatted_text) + suffix;
- SanitizeUserSuppliedString(&unsanitized_text);
- EXPECT_EQ(sanitized_text, unsanitized_text);
- }
-}
-
-class SetICULocaleTest : public PlatformTest {};
-
-TEST_F(SetICULocaleTest, OverlongLocaleId) {
- test::ScopedRestoreICUDefaultLocale restore_locale;
- std::string id("fr-ca-x-foo");
- while (id.length() < 152)
- id.append("-x-foo");
- SetICUDefaultLocale(id);
- EXPECT_STRNE("en_US", icu::Locale::getDefault().getName());
- id.append("zzz");
- SetICUDefaultLocale(id);
- EXPECT_STREQ("en_US", icu::Locale::getDefault().getName());
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/streaming_utf8_validator_unittest.cc b/base/i18n/streaming_utf8_validator_unittest.cc
deleted file mode 100644
index f9772d0..0000000
--- a/base/i18n/streaming_utf8_validator_unittest.cc
+++ /dev/null
@@ -1,412 +0,0 @@
-// Copyright 2014 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 "base/i18n/streaming_utf8_validator.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <string>
-
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Define BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST to verify that this class
-// accepts exactly the same set of 4-byte strings as ICU-based validation. This
-// tests every possible 4-byte string, so it is too slow to run routinely on
-// low-powered machines.
-//
-// #define BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
-
-#ifdef BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversion_utils.h"
-#include "base/synchronization/lock.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/task_scheduler/task_scheduler.h"
-#include "third_party/icu/source/common/unicode/utf8.h"
-
-#endif // BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
-
-namespace base {
-namespace {
-
-// Avoid having to qualify the enum values in the tests.
-const StreamingUtf8Validator::State VALID_ENDPOINT =
- StreamingUtf8Validator::VALID_ENDPOINT;
-const StreamingUtf8Validator::State VALID_MIDPOINT =
- StreamingUtf8Validator::VALID_MIDPOINT;
-const StreamingUtf8Validator::State INVALID = StreamingUtf8Validator::INVALID;
-
-#ifdef BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
-
-const uint32_t kThoroughTestChunkSize = 1 << 24;
-
-class StreamingUtf8ValidatorThoroughTest : public ::testing::Test {
- protected:
- StreamingUtf8ValidatorThoroughTest()
- : tasks_dispatched_(0), tasks_finished_(0) {}
-
- // This uses the same logic as base::IsStringUTF8 except it considers
- // non-characters valid (and doesn't require a string as input).
- static bool IsStringUtf8(const char* src, int32_t src_len) {
- int32_t char_index = 0;
-
- while (char_index < src_len) {
- int32_t code_point;
- U8_NEXT(src, char_index, src_len, code_point);
- if (!base::IsValidCodepoint(code_point))
- return false;
- }
- return true;
- }
-
- // Converts the passed-in integer to a 4 byte string and then
- // verifies that IsStringUtf8 and StreamingUtf8Validator agree on
- // whether it is valid UTF-8 or not.
- void TestNumber(uint32_t n) const {
- char test[sizeof n];
- memcpy(test, &n, sizeof n);
- StreamingUtf8Validator validator;
- EXPECT_EQ(IsStringUtf8(test, sizeof n),
- validator.AddBytes(test, sizeof n) == VALID_ENDPOINT)
- << "Difference of opinion for \""
- << base::StringPrintf("\\x%02X\\x%02X\\x%02X\\x%02X",
- test[0] & 0xFF,
- test[1] & 0xFF,
- test[2] & 0xFF,
- test[3] & 0xFF) << "\"";
- }
-
- public:
- // Tests the 4-byte sequences corresponding to the |size| integers
- // starting at |begin|. This is intended to be run from a worker
- // pool. Signals |all_done_| at the end if it thinks all tasks are
- // finished.
- void TestRange(uint32_t begin, uint32_t size) {
- for (uint32_t i = 0; i < size; ++i) {
- TestNumber(begin + i);
- }
- base::AutoLock al(lock_);
- ++tasks_finished_;
- LOG(INFO) << tasks_finished_ << " / " << tasks_dispatched_
- << " tasks done\n";
- }
-
- protected:
- base::Lock lock_;
- int tasks_dispatched_;
- int tasks_finished_;
-};
-
-TEST_F(StreamingUtf8ValidatorThoroughTest, TestEverything) {
- base::TaskScheduler::CreateAndStartWithDefaultParams(
- "StreamingUtf8ValidatorThoroughTest");
- {
- base::AutoLock al(lock_);
- uint32_t begin = 0;
- do {
- base::PostTaskWithTraits(
- FROM_HERE, {base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
- base::BindOnce(&StreamingUtf8ValidatorThoroughTest::TestRange,
- base::Unretained(this), begin,
- kThoroughTestChunkSize));
- ++tasks_dispatched_;
- begin += kThoroughTestChunkSize;
- } while (begin != 0);
- }
- base::TaskScheduler::GetInstance()->Shutdown();
- base::TaskScheduler::GetInstance()->JoinForTesting();
- base::TaskScheduler::SetInstance(nullptr);
-}
-
-#endif // BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
-
-// These valid and invalid UTF-8 sequences are based on the tests from
-// base/strings/string_util_unittest.cc
-
-// All of the strings in |valid| must represent a single codepoint, because
-// partial sequences are constructed by taking non-empty prefixes of these
-// strings.
-const char* const valid[] = {"\r", "\n", "a",
- "\xc2\x81", "\xe1\x80\xbf", "\xf1\x80\xa0\xbf",
- "\xef\xbb\xbf", // UTF-8 BOM
-};
-
-const char* const* const valid_end = valid + arraysize(valid);
-
-const char* const invalid[] = {
- // always invalid bytes
- "\xc0", "\xc1",
- "\xf5", "\xf6", "\xf7",
- "\xf8", "\xf9", "\xfa", "\xfb", "\xfc", "\xfd", "\xfe", "\xff",
- // surrogate code points
- "\xed\xa0\x80", "\xed\x0a\x8f", "\xed\xbf\xbf",
- //
- // overlong sequences
- "\xc0\x80", // U+0000
- "\xc1\x80", // "A"
- "\xc1\x81", // "B"
- "\xe0\x80\x80", // U+0000
- "\xe0\x82\x80", // U+0080
- "\xe0\x9f\xbf", // U+07ff
- "\xf0\x80\x80\x8D", // U+000D
- "\xf0\x80\x82\x91", // U+0091
- "\xf0\x80\xa0\x80", // U+0800
- "\xf0\x8f\xbb\xbf", // U+FEFF (BOM)
- "\xf8\x80\x80\x80\xbf", // U+003F
- "\xfc\x80\x80\x80\xa0\xa5",
- //
- // Beyond U+10FFFF
- "\xf4\x90\x80\x80", // U+110000
- "\xf8\xa0\xbf\x80\xbf", // 5 bytes
- "\xfc\x9c\xbf\x80\xbf\x80", // 6 bytes
- //
- // BOMs in UTF-16(BE|LE)
- "\xfe\xff", "\xff\xfe",
-};
-
-const char* const* const invalid_end = invalid + arraysize(invalid);
-
-// A ForwardIterator which returns all the non-empty prefixes of the elements of
-// "valid".
-class PartialIterator {
- public:
- // The constructor returns the first iterator, ie. it is equivalent to
- // begin().
- PartialIterator() : index_(0), prefix_length_(0) { Advance(); }
- // The trivial destructor left intentionally undefined.
- // This is a value type; the default copy constructor and assignment operator
- // generated by the compiler are used.
-
- static PartialIterator end() { return PartialIterator(arraysize(valid), 1); }
-
- PartialIterator& operator++() {
- Advance();
- return *this;
- }
-
- base::StringPiece operator*() const {
- return base::StringPiece(valid[index_], prefix_length_);
- }
-
- bool operator==(const PartialIterator& rhs) const {
- return index_ == rhs.index_ && prefix_length_ == rhs.prefix_length_;
- }
-
- bool operator!=(const PartialIterator& rhs) const { return !(rhs == *this); }
-
- private:
- // This constructor is used by the end() method.
- PartialIterator(size_t index, size_t prefix_length)
- : index_(index), prefix_length_(prefix_length) {}
-
- void Advance() {
- if (index_ < arraysize(valid) && prefix_length_ < strlen(valid[index_]))
- ++prefix_length_;
- while (index_ < arraysize(valid) &&
- prefix_length_ == strlen(valid[index_])) {
- ++index_;
- prefix_length_ = 1;
- }
- }
-
- // The UTF-8 sequence, as an offset into the |valid| array.
- size_t index_;
- size_t prefix_length_;
-};
-
-// A test fixture for tests which test one UTF-8 sequence (or invalid
-// byte sequence) at a time.
-class StreamingUtf8ValidatorSingleSequenceTest : public ::testing::Test {
- protected:
- // Iterator must be convertible when de-referenced to StringPiece.
- template <typename Iterator>
- void CheckRange(Iterator begin,
- Iterator end,
- StreamingUtf8Validator::State expected) {
- for (Iterator it = begin; it != end; ++it) {
- StreamingUtf8Validator validator;
- base::StringPiece sequence = *it;
- EXPECT_EQ(expected,
- validator.AddBytes(sequence.data(), sequence.size()))
- << "Failed for \"" << sequence << "\"";
- }
- }
-
- // Adding input a byte at a time should make absolutely no difference.
- template <typename Iterator>
- void CheckRangeByteAtATime(Iterator begin,
- Iterator end,
- StreamingUtf8Validator::State expected) {
- for (Iterator it = begin; it != end; ++it) {
- StreamingUtf8Validator validator;
- base::StringPiece sequence = *it;
- StreamingUtf8Validator::State state = VALID_ENDPOINT;
- for (base::StringPiece::const_iterator cit = sequence.begin();
- cit != sequence.end();
- ++cit) {
- state = validator.AddBytes(&*cit, 1);
- }
- EXPECT_EQ(expected, state) << "Failed for \"" << sequence << "\"";
- }
- }
-};
-
-// A test fixture for tests which test the concatenation of byte sequences.
-class StreamingUtf8ValidatorDoubleSequenceTest : public ::testing::Test {
- protected:
- // Check every possible concatenation of byte sequences from two
- // ranges, and verify that the combination matches the expected
- // state.
- template <typename Iterator1, typename Iterator2>
- void CheckCombinations(Iterator1 begin1,
- Iterator1 end1,
- Iterator2 begin2,
- Iterator2 end2,
- StreamingUtf8Validator::State expected) {
- StreamingUtf8Validator validator;
- for (Iterator1 it1 = begin1; it1 != end1; ++it1) {
- base::StringPiece c1 = *it1;
- for (Iterator2 it2 = begin2; it2 != end2; ++it2) {
- base::StringPiece c2 = *it2;
- validator.AddBytes(c1.data(), c1.size());
- EXPECT_EQ(expected, validator.AddBytes(c2.data(), c2.size()))
- << "Failed for \"" << c1 << c2 << "\"";
- validator.Reset();
- }
- }
- }
-};
-
-TEST(StreamingUtf8ValidatorTest, NothingIsValid) {
- static const char kNothing[] = "";
- EXPECT_EQ(VALID_ENDPOINT, StreamingUtf8Validator().AddBytes(kNothing, 0));
-}
-
-// Because the members of the |valid| array need to be non-zero length
-// sequences and are measured with strlen(), |valid| cannot be used it
-// to test the NUL character '\0', so the NUL character gets its own
-// test.
-TEST(StreamingUtf8ValidatorTest, NulIsValid) {
- static const char kNul[] = "\x00";
- EXPECT_EQ(VALID_ENDPOINT, StreamingUtf8Validator().AddBytes(kNul, 1));
-}
-
-// Just a basic sanity test before we start getting fancy.
-TEST(StreamingUtf8ValidatorTest, HelloWorld) {
- static const char kHelloWorld[] = "Hello, World!";
- EXPECT_EQ(
- VALID_ENDPOINT,
- StreamingUtf8Validator().AddBytes(kHelloWorld, strlen(kHelloWorld)));
-}
-
-// Check that the Reset() method works.
-TEST(StreamingUtf8ValidatorTest, ResetWorks) {
- StreamingUtf8Validator validator;
- EXPECT_EQ(INVALID, validator.AddBytes("\xC0", 1));
- EXPECT_EQ(INVALID, validator.AddBytes("a", 1));
- validator.Reset();
- EXPECT_EQ(VALID_ENDPOINT, validator.AddBytes("a", 1));
-}
-
-TEST_F(StreamingUtf8ValidatorSingleSequenceTest, Valid) {
- CheckRange(valid, valid_end, VALID_ENDPOINT);
-}
-
-TEST_F(StreamingUtf8ValidatorSingleSequenceTest, Partial) {
- CheckRange(PartialIterator(), PartialIterator::end(), VALID_MIDPOINT);
-}
-
-TEST_F(StreamingUtf8ValidatorSingleSequenceTest, Invalid) {
- CheckRange(invalid, invalid_end, INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorSingleSequenceTest, ValidByByte) {
- CheckRangeByteAtATime(valid, valid_end, VALID_ENDPOINT);
-}
-
-TEST_F(StreamingUtf8ValidatorSingleSequenceTest, PartialByByte) {
- CheckRangeByteAtATime(
- PartialIterator(), PartialIterator::end(), VALID_MIDPOINT);
-}
-
-TEST_F(StreamingUtf8ValidatorSingleSequenceTest, InvalidByByte) {
- CheckRangeByteAtATime(invalid, invalid_end, INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, ValidPlusValidIsValid) {
- CheckCombinations(valid, valid_end, valid, valid_end, VALID_ENDPOINT);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, ValidPlusPartialIsPartial) {
- CheckCombinations(valid,
- valid_end,
- PartialIterator(),
- PartialIterator::end(),
- VALID_MIDPOINT);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, PartialPlusValidIsInvalid) {
- CheckCombinations(
- PartialIterator(), PartialIterator::end(), valid, valid_end, INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, PartialPlusPartialIsInvalid) {
- CheckCombinations(PartialIterator(),
- PartialIterator::end(),
- PartialIterator(),
- PartialIterator::end(),
- INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, ValidPlusInvalidIsInvalid) {
- CheckCombinations(valid, valid_end, invalid, invalid_end, INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, InvalidPlusValidIsInvalid) {
- CheckCombinations(invalid, invalid_end, valid, valid_end, INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, InvalidPlusInvalidIsInvalid) {
- CheckCombinations(invalid, invalid_end, invalid, invalid_end, INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, InvalidPlusPartialIsInvalid) {
- CheckCombinations(
- invalid, invalid_end, PartialIterator(), PartialIterator::end(), INVALID);
-}
-
-TEST_F(StreamingUtf8ValidatorDoubleSequenceTest, PartialPlusInvalidIsInvalid) {
- CheckCombinations(
- PartialIterator(), PartialIterator::end(), invalid, invalid_end, INVALID);
-}
-
-TEST(StreamingUtf8ValidatorValidateTest, EmptyIsValid) {
- EXPECT_TRUE(StreamingUtf8Validator::Validate(std::string()));
-}
-
-TEST(StreamingUtf8ValidatorValidateTest, SimpleValidCase) {
- EXPECT_TRUE(StreamingUtf8Validator::Validate("\xc2\x81"));
-}
-
-TEST(StreamingUtf8ValidatorValidateTest, SimpleInvalidCase) {
- EXPECT_FALSE(StreamingUtf8Validator::Validate("\xc0\x80"));
-}
-
-TEST(StreamingUtf8ValidatorValidateTest, TruncatedIsInvalid) {
- EXPECT_FALSE(StreamingUtf8Validator::Validate("\xc2"));
-}
-
-} // namespace
-} // namespace base
diff --git a/base/i18n/string_search_unittest.cc b/base/i18n/string_search_unittest.cc
deleted file mode 100644
index 69501d6..0000000
--- a/base/i18n/string_search_unittest.cc
+++ /dev/null
@@ -1,228 +0,0 @@
-// Copyright (c) 2011 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 <stddef.h>
-
-#include <string>
-
-#include "base/i18n/rtl.h"
-#include "base/i18n/string_search.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/icu/source/i18n/unicode/usearch.h"
-
-namespace base {
-namespace i18n {
-
-// Note on setting default locale for testing: The current default locale on
-// the Mac trybot is en_US_POSIX, with which primary-level collation strength
-// string search is case-sensitive, when normally it should be
-// case-insensitive. In other locales (including en_US which English speakers
-// in the U.S. use), this search would be case-insensitive as expected.
-
-TEST(StringSearchTest, ASCII) {
- std::string default_locale(uloc_getDefault());
- bool locale_is_posix = (default_locale == "en_US_POSIX");
- if (locale_is_posix)
- SetICUDefaultLocale("en_US");
-
- size_t index = 0;
- size_t length = 0;
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- ASCIIToUTF16("hello"), ASCIIToUTF16("hello world"), &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(5U, length);
-
- EXPECT_FALSE(StringSearchIgnoringCaseAndAccents(
- ASCIIToUTF16("h e l l o"), ASCIIToUTF16("h e l l o"),
- &index, &length));
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- ASCIIToUTF16("aabaaa"), ASCIIToUTF16("aaabaabaaa"), &index, &length));
- EXPECT_EQ(4U, index);
- EXPECT_EQ(6U, length);
-
- EXPECT_FALSE(StringSearchIgnoringCaseAndAccents(
- ASCIIToUTF16("searching within empty string"), string16(),
- &index, &length));
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- string16(), ASCIIToUTF16("searching for empty string"), &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(0U, length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- ASCIIToUTF16("case insensitivity"), ASCIIToUTF16("CaSe InSeNsItIvItY"),
- &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(18U, length);
-
- if (locale_is_posix)
- SetICUDefaultLocale(default_locale.data());
-}
-
-TEST(StringSearchTest, UnicodeLocaleIndependent) {
- // Base characters
- const string16 e_base = WideToUTF16(L"e");
- const string16 E_base = WideToUTF16(L"E");
- const string16 a_base = WideToUTF16(L"a");
-
- // Composed characters
- const string16 e_with_acute_accent = WideToUTF16(L"\u00e9");
- const string16 E_with_acute_accent = WideToUTF16(L"\u00c9");
- const string16 e_with_grave_accent = WideToUTF16(L"\u00e8");
- const string16 E_with_grave_accent = WideToUTF16(L"\u00c8");
- const string16 a_with_acute_accent = WideToUTF16(L"\u00e1");
-
- // Decomposed characters
- const string16 e_with_acute_combining_mark = WideToUTF16(L"e\u0301");
- const string16 E_with_acute_combining_mark = WideToUTF16(L"E\u0301");
- const string16 e_with_grave_combining_mark = WideToUTF16(L"e\u0300");
- const string16 E_with_grave_combining_mark = WideToUTF16(L"E\u0300");
- const string16 a_with_acute_combining_mark = WideToUTF16(L"a\u0301");
-
- std::string default_locale(uloc_getDefault());
- bool locale_is_posix = (default_locale == "en_US_POSIX");
- if (locale_is_posix)
- SetICUDefaultLocale("en_US");
-
- size_t index = 0;
- size_t length = 0;
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_base, e_with_acute_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_acute_accent, e_base, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_base.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_base, e_with_acute_combining_mark, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_combining_mark.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_acute_combining_mark, e_base, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_base.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_acute_combining_mark, e_with_acute_accent,
- &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_acute_accent, e_with_acute_combining_mark,
- &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_combining_mark.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_acute_combining_mark, e_with_grave_combining_mark,
- &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_grave_combining_mark.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_grave_combining_mark, e_with_acute_combining_mark,
- &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_combining_mark.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_acute_combining_mark, e_with_grave_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_grave_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- e_with_grave_accent, e_with_acute_combining_mark, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_combining_mark.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- E_with_acute_accent, e_with_acute_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- E_with_grave_accent, e_with_acute_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- E_with_acute_combining_mark, e_with_grave_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_grave_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- E_with_grave_combining_mark, e_with_acute_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_acute_accent.size(), length);
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(
- E_base, e_with_grave_accent, &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(e_with_grave_accent.size(), length);
-
- EXPECT_FALSE(StringSearchIgnoringCaseAndAccents(
- a_with_acute_accent, e_with_acute_accent, &index, &length));
-
- EXPECT_FALSE(StringSearchIgnoringCaseAndAccents(
- a_with_acute_combining_mark, e_with_acute_combining_mark,
- &index, &length));
-
- if (locale_is_posix)
- SetICUDefaultLocale(default_locale.data());
-}
-
-TEST(StringSearchTest, UnicodeLocaleDependent) {
- // Base characters
- const string16 a_base = WideToUTF16(L"a");
-
- // Composed characters
- const string16 a_with_ring = WideToUTF16(L"\u00e5");
-
- EXPECT_TRUE(StringSearchIgnoringCaseAndAccents(a_base, a_with_ring, nullptr,
- nullptr));
-
- const char* default_locale = uloc_getDefault();
- SetICUDefaultLocale("da");
-
- EXPECT_FALSE(StringSearchIgnoringCaseAndAccents(a_base, a_with_ring, nullptr,
- nullptr));
-
- SetICUDefaultLocale(default_locale);
-}
-
-TEST(StringSearchTest, FixedPatternMultipleSearch) {
- std::string default_locale(uloc_getDefault());
- bool locale_is_posix = (default_locale == "en_US_POSIX");
- if (locale_is_posix)
- SetICUDefaultLocale("en_US");
-
- size_t index = 0;
- size_t length = 0;
-
- // Search "hello" over multiple texts.
- FixedPatternStringSearchIgnoringCaseAndAccents query(ASCIIToUTF16("hello"));
- EXPECT_TRUE(query.Search(ASCIIToUTF16("12hello34"), &index, &length));
- EXPECT_EQ(2U, index);
- EXPECT_EQ(5U, length);
- EXPECT_FALSE(query.Search(ASCIIToUTF16("bye"), &index, &length));
- EXPECT_TRUE(query.Search(ASCIIToUTF16("hELLo"), &index, &length));
- EXPECT_EQ(0U, index);
- EXPECT_EQ(5U, length);
-
- if (locale_is_posix)
- SetICUDefaultLocale(default_locale.data());
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/time_formatting_unittest.cc b/base/i18n/time_formatting_unittest.cc
deleted file mode 100644
index 027b7c9..0000000
--- a/base/i18n/time_formatting_unittest.cc
+++ /dev/null
@@ -1,434 +0,0 @@
-// Copyright (c) 2011 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 "base/i18n/time_formatting.h"
-
-#include <memory>
-
-#include "base/i18n/rtl.h"
-#include "base/i18n/unicodestring.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/test/icu_test_util.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/icu/source/common/unicode/uversion.h"
-#include "third_party/icu/source/i18n/unicode/calendar.h"
-#include "third_party/icu/source/i18n/unicode/timezone.h"
-#include "third_party/icu/source/i18n/unicode/tzfmt.h"
-
-namespace base {
-namespace {
-
-const Time::Exploded kTestDateTimeExploded = {
- 2011, 4, 6, 30, // Sat, Apr 30, 2011
- 22, 42, 7, 0 // 22:42:07.000 in UTC = 15:42:07 in US PDT.
-};
-
-// Returns difference between the local time and GMT formatted as string.
-// This function gets |time| because the difference depends on time,
-// see https://en.wikipedia.org/wiki/Daylight_saving_time for details.
-string16 GetShortTimeZone(const Time& time) {
- UErrorCode status = U_ZERO_ERROR;
- std::unique_ptr<icu::TimeZone> zone(icu::TimeZone::createDefault());
- std::unique_ptr<icu::TimeZoneFormat> zone_formatter(
- icu::TimeZoneFormat::createInstance(icu::Locale::getDefault(), status));
- EXPECT_TRUE(U_SUCCESS(status));
- icu::UnicodeString name;
- zone_formatter->format(UTZFMT_STYLE_SPECIFIC_SHORT, *zone,
- static_cast<UDate>(time.ToDoubleT() * 1000),
- name, nullptr);
- return i18n::UnicodeStringToString16(name);
-}
-
-// Calls TimeDurationFormat() with |delta| and |width| and returns the resulting
-// string. On failure, adds a failed expectation and returns an empty string.
-string16 TimeDurationFormatString(const TimeDelta& delta,
- DurationFormatWidth width) {
- string16 str;
- EXPECT_TRUE(TimeDurationFormat(delta, width, &str))
- << "Failed to format " << delta.ToInternalValue() << " with width "
- << width;
- return str;
-}
-
-// Calls TimeDurationFormatWithSeconds() with |delta| and |width| and returns
-// the resulting string. On failure, adds a failed expectation and returns an
-// empty string.
-string16 TimeDurationFormatWithSecondsString(const TimeDelta& delta,
- DurationFormatWidth width) {
- string16 str;
- EXPECT_TRUE(TimeDurationFormatWithSeconds(delta, width, &str))
- << "Failed to format " << delta.ToInternalValue() << " with width "
- << width;
- return str;
-}
-
-class ScopedRestoreDefaultTimezone {
- public:
- ScopedRestoreDefaultTimezone(const char* zoneid) {
- original_zone_.reset(icu::TimeZone::createDefault());
- icu::TimeZone::adoptDefault(icu::TimeZone::createTimeZone(zoneid));
- }
- ~ScopedRestoreDefaultTimezone() {
- icu::TimeZone::adoptDefault(original_zone_.release());
- }
-
- ScopedRestoreDefaultTimezone(const ScopedRestoreDefaultTimezone&) = delete;
- ScopedRestoreDefaultTimezone& operator=(const ScopedRestoreDefaultTimezone&) =
- delete;
-
- private:
- std::unique_ptr<icu::TimeZone> original_zone_;
-};
-
-TEST(TimeFormattingTest, TimeFormatTimeOfDayDefault12h) {
- // Test for a locale defaulted to 12h clock.
- // As an instance, we use third_party/icu/source/data/locales/en.txt.
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_US");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
- string16 clock24h(ASCIIToUTF16("15:42"));
- string16 clock12h_pm(ASCIIToUTF16("3:42 PM"));
- string16 clock12h(ASCIIToUTF16("3:42"));
- string16 clock24h_millis(ASCIIToUTF16("15:42:07.000"));
-
- // The default is 12h clock.
- EXPECT_EQ(clock12h_pm, TimeFormatTimeOfDay(time));
- EXPECT_EQ(clock24h_millis, TimeFormatTimeOfDayWithMilliseconds(time));
- EXPECT_EQ(k12HourClock, GetHourClockType());
- // k{Keep,Drop}AmPm should not affect for 24h clock.
- EXPECT_EQ(clock24h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k24HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock24h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k24HourClock,
- kDropAmPm));
- // k{Keep,Drop}AmPm affects for 12h clock.
- EXPECT_EQ(clock12h_pm,
- TimeFormatTimeOfDayWithHourClockType(time,
- k12HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock12h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k12HourClock,
- kDropAmPm));
-}
-
-TEST(TimeFormattingTest, TimeFormatTimeOfDayDefault24h) {
- // Test for a locale defaulted to 24h clock.
- // As an instance, we use third_party/icu/source/data/locales/en_GB.txt.
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_GB");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
- string16 clock24h(ASCIIToUTF16("15:42"));
- string16 clock12h_pm(ASCIIToUTF16("3:42 pm"));
- string16 clock12h(ASCIIToUTF16("3:42"));
- string16 clock24h_millis(ASCIIToUTF16("15:42:07.000"));
-
- // The default is 24h clock.
- EXPECT_EQ(clock24h, TimeFormatTimeOfDay(time));
- EXPECT_EQ(clock24h_millis, TimeFormatTimeOfDayWithMilliseconds(time));
- EXPECT_EQ(k24HourClock, GetHourClockType());
- // k{Keep,Drop}AmPm should not affect for 24h clock.
- EXPECT_EQ(clock24h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k24HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock24h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k24HourClock,
- kDropAmPm));
- // k{Keep,Drop}AmPm affects for 12h clock.
- EXPECT_EQ(clock12h_pm,
- TimeFormatTimeOfDayWithHourClockType(time,
- k12HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock12h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k12HourClock,
- kDropAmPm));
-}
-
-TEST(TimeFormattingTest, TimeFormatTimeOfDayJP) {
- // Test for a locale that uses different mark than "AM" and "PM".
- // As an instance, we use third_party/icu/source/data/locales/ja.txt.
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("ja_JP");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
- string16 clock24h(ASCIIToUTF16("15:42"));
- string16 clock12h_pm(UTF8ToUTF16(u8"午後3:42"));
- string16 clock12h(ASCIIToUTF16("3:42"));
-
- // The default is 24h clock.
- EXPECT_EQ(clock24h, TimeFormatTimeOfDay(time));
- EXPECT_EQ(k24HourClock, GetHourClockType());
- // k{Keep,Drop}AmPm should not affect for 24h clock.
- EXPECT_EQ(clock24h, TimeFormatTimeOfDayWithHourClockType(time, k24HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock24h, TimeFormatTimeOfDayWithHourClockType(time, k24HourClock,
- kDropAmPm));
- // k{Keep,Drop}AmPm affects for 12h clock.
- EXPECT_EQ(clock12h_pm, TimeFormatTimeOfDayWithHourClockType(
- time, k12HourClock, kKeepAmPm));
- EXPECT_EQ(clock12h, TimeFormatTimeOfDayWithHourClockType(time, k12HourClock,
- kDropAmPm));
-}
-
-TEST(TimeFormattingTest, TimeFormatTimeOfDayDE) {
- // Test for a locale that uses different mark than "AM" and "PM".
- // As an instance, we use third_party/icu/source/data/locales/de.txt.
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("de");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
- string16 clock24h(ASCIIToUTF16("15:42"));
- string16 clock12h_pm(UTF8ToUTF16("3:42 nachm."));
- string16 clock12h(ASCIIToUTF16("3:42"));
-
- // The default is 24h clock.
- EXPECT_EQ(clock24h, TimeFormatTimeOfDay(time));
- EXPECT_EQ(k24HourClock, GetHourClockType());
- // k{Keep,Drop}AmPm should not affect for 24h clock.
- EXPECT_EQ(clock24h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k24HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock24h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k24HourClock,
- kDropAmPm));
- // k{Keep,Drop}AmPm affects for 12h clock.
- EXPECT_EQ(clock12h_pm,
- TimeFormatTimeOfDayWithHourClockType(time,
- k12HourClock,
- kKeepAmPm));
- EXPECT_EQ(clock12h,
- TimeFormatTimeOfDayWithHourClockType(time,
- k12HourClock,
- kDropAmPm));
-}
-
-TEST(TimeFormattingTest, TimeFormatDateUS) {
- // See third_party/icu/source/data/locales/en.txt.
- // The date patterns are "EEEE, MMMM d, y", "MMM d, y", and "M/d/yy".
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_US");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
-
- EXPECT_EQ(ASCIIToUTF16("Apr 30, 2011"), TimeFormatShortDate(time));
- EXPECT_EQ(ASCIIToUTF16("4/30/11"), TimeFormatShortDateNumeric(time));
-
- EXPECT_EQ(ASCIIToUTF16("4/30/11, 3:42:07 PM"),
- TimeFormatShortDateAndTime(time));
- EXPECT_EQ(ASCIIToUTF16("4/30/11, 3:42:07 PM ") + GetShortTimeZone(time),
- TimeFormatShortDateAndTimeWithTimeZone(time));
-
- EXPECT_EQ(ASCIIToUTF16("April 2011"), TimeFormatMonthAndYear(time));
-
- EXPECT_EQ(ASCIIToUTF16("Saturday, April 30, 2011 at 3:42:07 PM"),
- TimeFormatFriendlyDateAndTime(time));
-
- EXPECT_EQ(ASCIIToUTF16("Saturday, April 30, 2011"),
- TimeFormatFriendlyDate(time));
-}
-
-TEST(TimeFormattingTest, TimeFormatDateGB) {
- // See third_party/icu/source/data/locales/en_GB.txt.
- // The date patterns are "EEEE, d MMMM y", "d MMM y", and "dd/MM/yyyy".
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_GB");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
-
- EXPECT_EQ(ASCIIToUTF16("30 Apr 2011"), TimeFormatShortDate(time));
- EXPECT_EQ(ASCIIToUTF16("30/04/2011"), TimeFormatShortDateNumeric(time));
- EXPECT_EQ(ASCIIToUTF16("30/04/2011, 15:42:07"),
- TimeFormatShortDateAndTime(time));
- EXPECT_EQ(ASCIIToUTF16("30/04/2011, 15:42:07 ") + GetShortTimeZone(time),
- TimeFormatShortDateAndTimeWithTimeZone(time));
- EXPECT_EQ(ASCIIToUTF16("April 2011"), TimeFormatMonthAndYear(time));
- EXPECT_EQ(ASCIIToUTF16("Saturday, 30 April 2011 at 15:42:07"),
- TimeFormatFriendlyDateAndTime(time));
- EXPECT_EQ(ASCIIToUTF16("Saturday, 30 April 2011"),
- TimeFormatFriendlyDate(time));
-}
-
-TEST(TimeFormattingTest, TimeFormatWithPattern) {
- test::ScopedRestoreICUDefaultLocale restore_locale;
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &time));
-
- i18n::SetICUDefaultLocale("en_US");
- EXPECT_EQ(ASCIIToUTF16("Apr 30, 2011"), TimeFormatWithPattern(time, "yMMMd"));
- EXPECT_EQ(ASCIIToUTF16("April 30, 3:42:07 PM"),
- TimeFormatWithPattern(time, "MMMMdjmmss"));
-
- i18n::SetICUDefaultLocale("en_GB");
- EXPECT_EQ(ASCIIToUTF16("30 Apr 2011"), TimeFormatWithPattern(time, "yMMMd"));
- EXPECT_EQ(ASCIIToUTF16("30 April, 15:42:07"),
- TimeFormatWithPattern(time, "MMMMdjmmss"));
-
- i18n::SetICUDefaultLocale("ja_JP");
- EXPECT_EQ(UTF8ToUTF16(u8"2011年4月30日"),
- TimeFormatWithPattern(time, "yMMMd"));
- EXPECT_EQ(UTF8ToUTF16(u8"4月30日 15:42:07"),
- TimeFormatWithPattern(time, "MMMMdjmmss"));
-}
-
-TEST(TimeFormattingTest, TimeDurationFormat) {
- test::ScopedRestoreICUDefaultLocale restore_locale;
- TimeDelta delta = TimeDelta::FromMinutes(15 * 60 + 42);
-
- // US English.
- i18n::SetICUDefaultLocale("en_US");
- EXPECT_EQ(ASCIIToUTF16("15 hours, 42 minutes"),
- TimeDurationFormatString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(ASCIIToUTF16("15 hr, 42 min"),
- TimeDurationFormatString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(ASCIIToUTF16("15h 42m"),
- TimeDurationFormatString(delta, DURATION_WIDTH_NARROW));
- EXPECT_EQ(ASCIIToUTF16("15:42"),
- TimeDurationFormatString(delta, DURATION_WIDTH_NUMERIC));
-
- // Danish, with Latin alphabet but different abbreviations and punctuation.
- i18n::SetICUDefaultLocale("da");
- EXPECT_EQ(ASCIIToUTF16("15 timer og 42 minutter"),
- TimeDurationFormatString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(ASCIIToUTF16("15 t og 42 min."),
- TimeDurationFormatString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(ASCIIToUTF16("15 t og 42 min"),
- TimeDurationFormatString(delta, DURATION_WIDTH_NARROW));
- EXPECT_EQ(ASCIIToUTF16("15.42"),
- TimeDurationFormatString(delta, DURATION_WIDTH_NUMERIC));
-
- // Persian, with non-Arabic numbers.
- i18n::SetICUDefaultLocale("fa");
- string16 fa_wide = UTF8ToUTF16(
- u8"\u06f1\u06f5 \u0633\u0627\u0639\u062a \u0648 \u06f4\u06f2 \u062f\u0642"
- u8"\u06cc\u0642\u0647");
- string16 fa_short = UTF8ToUTF16(
- u8"\u06f1\u06f5 \u0633\u0627\u0639\u062a\u060c\u200f \u06f4\u06f2 \u062f"
- u8"\u0642\u06cc\u0642\u0647");
- string16 fa_narrow = UTF8ToUTF16(
- u8"\u06f1\u06f5 \u0633\u0627\u0639\u062a \u06f4\u06f2 \u062f\u0642\u06cc"
- u8"\u0642\u0647");
- string16 fa_numeric = UTF8ToUTF16(u8"\u06f1\u06f5:\u06f4\u06f2");
- EXPECT_EQ(fa_wide, TimeDurationFormatString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(fa_short, TimeDurationFormatString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(fa_narrow, TimeDurationFormatString(delta, DURATION_WIDTH_NARROW));
- EXPECT_EQ(fa_numeric,
- TimeDurationFormatString(delta, DURATION_WIDTH_NUMERIC));
-}
-
-TEST(TimeFormattingTest, TimeDurationFormatWithSeconds) {
- test::ScopedRestoreICUDefaultLocale restore_locale;
-
- // US English.
- i18n::SetICUDefaultLocale("en_US");
-
- // Test different formats.
- TimeDelta delta = TimeDelta::FromSeconds(15 * 3600 + 42 * 60 + 30);
- EXPECT_EQ(ASCIIToUTF16("15 hours, 42 minutes, 30 seconds"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(ASCIIToUTF16("15 hr, 42 min, 30 sec"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(ASCIIToUTF16("15h 42m 30s"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NARROW));
- EXPECT_EQ(ASCIIToUTF16("15:42:30"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NUMERIC));
-
- // Test edge case when hour >= 100.
- delta = TimeDelta::FromSeconds(125 * 3600 + 42 * 60 + 30);
- EXPECT_EQ(ASCIIToUTF16("125 hours, 42 minutes, 30 seconds"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(ASCIIToUTF16("125 hr, 42 min, 30 sec"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(ASCIIToUTF16("125h 42m 30s"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NARROW));
-
- // Test edge case when minute = 0.
- delta = TimeDelta::FromSeconds(15 * 3600 + 0 * 60 + 30);
- EXPECT_EQ(ASCIIToUTF16("15 hours, 0 minutes, 30 seconds"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(ASCIIToUTF16("15 hr, 0 min, 30 sec"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(ASCIIToUTF16("15h 0m 30s"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NARROW));
- EXPECT_EQ(ASCIIToUTF16("15:00:30"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NUMERIC));
-
- // Test edge case when second = 0.
- delta = TimeDelta::FromSeconds(15 * 3600 + 42 * 60 + 0);
- EXPECT_EQ(ASCIIToUTF16("15 hours, 42 minutes, 0 seconds"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_WIDE));
- EXPECT_EQ(ASCIIToUTF16("15 hr, 42 min, 0 sec"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_SHORT));
- EXPECT_EQ(ASCIIToUTF16("15h 42m 0s"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NARROW));
- EXPECT_EQ(ASCIIToUTF16("15:42:00"),
- TimeDurationFormatWithSecondsString(delta, DURATION_WIDTH_NUMERIC));
-}
-
-TEST(TimeFormattingTest, TimeIntervalFormat) {
- test::ScopedRestoreICUDefaultLocale restore_locale;
- i18n::SetICUDefaultLocale("en_US");
- ScopedRestoreDefaultTimezone la_time("America/Los_Angeles");
-
- const Time::Exploded kTestIntervalEndTimeExploded = {
- 2011, 5, 6, 28, // Sat, May 28, 2012
- 22, 42, 7, 0 // 22:42:07.000
- };
-
- Time begin_time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestDateTimeExploded, &begin_time));
- Time end_time;
- EXPECT_TRUE(Time::FromUTCExploded(kTestIntervalEndTimeExploded, &end_time));
-
- EXPECT_EQ(
- UTF8ToUTF16(u8"Saturday, April 30 – Saturday, May 28"),
- DateIntervalFormat(begin_time, end_time, DATE_FORMAT_MONTH_WEEKDAY_DAY));
-
- const Time::Exploded kTestIntervalBeginTimeExploded = {
- 2011, 5, 1, 16, // Mon, May 16, 2012
- 22, 42, 7, 0 // 22:42:07.000
- };
- EXPECT_TRUE(
- Time::FromUTCExploded(kTestIntervalBeginTimeExploded, &begin_time));
- EXPECT_EQ(
- UTF8ToUTF16(u8"Monday, May 16 – Saturday, May 28"),
- DateIntervalFormat(begin_time, end_time, DATE_FORMAT_MONTH_WEEKDAY_DAY));
-
- i18n::SetICUDefaultLocale("en_GB");
- EXPECT_EQ(
- UTF8ToUTF16(u8"Monday 16 – Saturday 28 May"),
- DateIntervalFormat(begin_time, end_time, DATE_FORMAT_MONTH_WEEKDAY_DAY));
-
- i18n::SetICUDefaultLocale("ja");
- EXPECT_EQ(
- UTF8ToUTF16(u8"5月16日(月曜日)～28日(土曜日)"),
- DateIntervalFormat(begin_time, end_time, DATE_FORMAT_MONTH_WEEKDAY_DAY));
-}
-
-} // namespace
-} // namespace base
diff --git a/base/i18n/timezone_unittest.cc b/base/i18n/timezone_unittest.cc
deleted file mode 100644
index 57467dc..0000000
--- a/base/i18n/timezone_unittest.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 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 "base/i18n/timezone.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-TEST(TimezoneTest, CountryCodeForCurrentTimezone) {
- std::string country_code = CountryCodeForCurrentTimezone();
- // On some systems (such as Android or some flavors of Linux), ICU may come up
- // empty. With https://chromium-review.googlesource.com/c/512282/ , ICU will
- // not fail any more. See also http://bugs.icu-project.org/trac/ticket/13208 .
- // Even with that, ICU returns '001' (world) for region-agnostic timezones
- // such as Etc/UTC and |CountryCodeForCurrentTimezone| returns an empty
- // string so that the next fallback can be tried by a customer.
- // TODO(jshin): Revise this to test for actual timezones using
- // use ScopedRestoreICUDefaultTimezone.
- if (!country_code.empty())
- EXPECT_EQ(2U, country_code.size()) << "country_code = " << country_code;
-}
-
-} // namespace
-} // namespace base
diff --git a/base/json/json_parser_unittest.cc b/base/json/json_parser_unittest.cc
deleted file mode 100644
index 0da3db8..0000000
--- a/base/json/json_parser_unittest.cc
+++ /dev/null
@@ -1,462 +0,0 @@
-// 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.
-
-#include "base/json/json_parser.h"
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/json/json_reader.h"
-#include "base/memory/ptr_util.h"
-#include "base/optional.h"
-#include "base/strings/stringprintf.h"
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-class JSONParserTest : public testing::Test {
- public:
- JSONParser* NewTestParser(const std::string& input,
- int options = JSON_PARSE_RFC) {
- JSONParser* parser = new JSONParser(options);
- parser->input_ = input;
- parser->index_ = 0;
- return parser;
- }
-
- // MSan will do a better job detecting over-read errors if the input is
- // not nul-terminated on the heap. This will copy |input| to a new buffer
- // owned by |owner|, returning a StringPiece to |owner|.
- StringPiece MakeNotNullTerminatedInput(const char* input,
- std::unique_ptr<char[]>* owner) {
- size_t str_len = strlen(input);
- owner->reset(new char[str_len]);
- memcpy(owner->get(), input, str_len);
- return StringPiece(owner->get(), str_len);
- }
-
- void TestLastThree(JSONParser* parser) {
- EXPECT_EQ(',', *parser->PeekChar());
- parser->ConsumeChar();
- EXPECT_EQ('|', *parser->PeekChar());
- parser->ConsumeChar();
- EXPECT_EQ('\0', *parser->pos());
- EXPECT_EQ(static_cast<size_t>(parser->index_), parser->input_.length());
- }
-};
-
-TEST_F(JSONParserTest, NextChar) {
- std::string input("Hello world");
- std::unique_ptr<JSONParser> parser(NewTestParser(input));
-
- EXPECT_EQ('H', *parser->pos());
- for (size_t i = 1; i < input.length(); ++i) {
- parser->ConsumeChar();
- EXPECT_EQ(input[i], *parser->PeekChar());
- }
- parser->ConsumeChar();
- EXPECT_EQ('\0', *parser->pos());
- EXPECT_EQ(static_cast<size_t>(parser->index_), parser->input_.length());
-}
-
-TEST_F(JSONParserTest, ConsumeString) {
- std::string input("\"test\",|");
- std::unique_ptr<JSONParser> parser(NewTestParser(input));
- Optional<Value> value(parser->ConsumeString());
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- std::string str;
- EXPECT_TRUE(value->GetAsString(&str));
- EXPECT_EQ("test", str);
-}
-
-TEST_F(JSONParserTest, ConsumeList) {
- std::string input("[true, false],|");
- std::unique_ptr<JSONParser> parser(NewTestParser(input));
- Optional<Value> value(parser->ConsumeList());
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- base::ListValue* list;
- EXPECT_TRUE(value->GetAsList(&list));
- EXPECT_EQ(2u, list->GetSize());
-}
-
-TEST_F(JSONParserTest, ConsumeDictionary) {
- std::string input("{\"abc\":\"def\"},|");
- std::unique_ptr<JSONParser> parser(NewTestParser(input));
- Optional<Value> value(parser->ConsumeDictionary());
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- base::DictionaryValue* dict;
- EXPECT_TRUE(value->GetAsDictionary(&dict));
- std::string str;
- EXPECT_TRUE(dict->GetString("abc", &str));
- EXPECT_EQ("def", str);
-}
-
-TEST_F(JSONParserTest, ConsumeLiterals) {
- // Literal |true|.
- std::string input("true,|");
- std::unique_ptr<JSONParser> parser(NewTestParser(input));
- Optional<Value> value(parser->ConsumeLiteral());
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- bool bool_value = false;
- EXPECT_TRUE(value->GetAsBoolean(&bool_value));
- EXPECT_TRUE(bool_value);
-
- // Literal |false|.
- input = "false,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeLiteral();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- EXPECT_TRUE(value->GetAsBoolean(&bool_value));
- EXPECT_FALSE(bool_value);
-
- // Literal |null|.
- input = "null,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeLiteral();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- EXPECT_TRUE(value->is_none());
-}
-
-TEST_F(JSONParserTest, ConsumeNumbers) {
- // Integer.
- std::string input("1234,|");
- std::unique_ptr<JSONParser> parser(NewTestParser(input));
- Optional<Value> value(parser->ConsumeNumber());
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- int number_i;
- EXPECT_TRUE(value->GetAsInteger(&number_i));
- EXPECT_EQ(1234, number_i);
-
- // Negative integer.
- input = "-1234,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeNumber();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- EXPECT_TRUE(value->GetAsInteger(&number_i));
- EXPECT_EQ(-1234, number_i);
-
- // Double.
- input = "12.34,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeNumber();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- double number_d;
- EXPECT_TRUE(value->GetAsDouble(&number_d));
- EXPECT_EQ(12.34, number_d);
-
- // Scientific.
- input = "42e3,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeNumber();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- EXPECT_TRUE(value->GetAsDouble(&number_d));
- EXPECT_EQ(42000, number_d);
-
- // Negative scientific.
- input = "314159e-5,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeNumber();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- EXPECT_TRUE(value->GetAsDouble(&number_d));
- EXPECT_EQ(3.14159, number_d);
-
- // Positive scientific.
- input = "0.42e+3,|";
- parser.reset(NewTestParser(input));
- value = parser->ConsumeNumber();
- EXPECT_EQ(',', *parser->pos());
-
- TestLastThree(parser.get());
-
- ASSERT_TRUE(value);
- EXPECT_TRUE(value->GetAsDouble(&number_d));
- EXPECT_EQ(420, number_d);
-}
-
-TEST_F(JSONParserTest, ErrorMessages) {
- // Error strings should not be modified in case of success.
- std::string error_message;
- int error_code = 0;
- std::unique_ptr<Value> root = JSONReader::ReadAndReturnError(
- "[42]", JSON_PARSE_RFC, &error_code, &error_message);
- EXPECT_TRUE(error_message.empty());
- EXPECT_EQ(0, error_code);
-
- // Test line and column counting
- const char big_json[] = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]";
- // error here ----------------------------------^
- root = JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, &error_code,
- &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError),
- error_message);
- EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code);
-
- error_code = 0;
- error_message = "";
- // Test line and column counting with "\r\n" line ending
- const char big_json_crlf[] =
- "[\r\n0,\r\n1,\r\n2,\r\n3,4,5,6 7,\r\n8,\r\n9\r\n]";
- // error here ----------------------^
- root = JSONReader::ReadAndReturnError(big_json_crlf, JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError),
- error_message);
- EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code);
-
- // Test each of the error conditions
- root = JSONReader::ReadAndReturnError("{},{}", JSON_PARSE_RFC, &error_code,
- &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 3,
- JSONReader::kUnexpectedDataAfterRoot), error_message);
- EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, error_code);
-
- std::string nested_json;
- for (int i = 0; i < 201; ++i) {
- nested_json.insert(nested_json.begin(), '[');
- nested_json.append(1, ']');
- }
- root = JSONReader::ReadAndReturnError(nested_json, JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 200, JSONReader::kTooMuchNesting),
- error_message);
- EXPECT_EQ(JSONReader::JSON_TOO_MUCH_NESTING, error_code);
-
- root = JSONReader::ReadAndReturnError("[1,]", JSON_PARSE_RFC, &error_code,
- &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 4, JSONReader::kTrailingComma),
- error_message);
- EXPECT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
-
- root = JSONReader::ReadAndReturnError("{foo:\"bar\"}", JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2,
- JSONReader::kUnquotedDictionaryKey), error_message);
- EXPECT_EQ(JSONReader::JSON_UNQUOTED_DICTIONARY_KEY, error_code);
-
- root = JSONReader::ReadAndReturnError("{\"foo\":\"bar\",}", JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 14, JSONReader::kTrailingComma),
- error_message);
-
- root = JSONReader::ReadAndReturnError("[nu]", JSON_PARSE_RFC, &error_code,
- &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2, JSONReader::kSyntaxError),
- error_message);
- EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code);
-
- root = JSONReader::ReadAndReturnError("[\"xxx\\xq\"]", JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
- error_message);
- EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
-
- root = JSONReader::ReadAndReturnError("[\"xxx\\uq\"]", JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
- error_message);
- EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
-
- root = JSONReader::ReadAndReturnError("[\"xxx\\q\"]", JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_FALSE(root.get());
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
- error_message);
- EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
-
- root = JSONReader::ReadAndReturnError(("[\"\\ufffe\"]"), JSON_PARSE_RFC,
- &error_code, &error_message);
- EXPECT_EQ(JSONParser::FormatErrorMessage(1, 8, JSONReader::kInvalidEscape),
- error_message);
- EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
-}
-
-TEST_F(JSONParserTest, Decode4ByteUtf8Char) {
- // This test strings contains a 4 byte unicode character (a smiley!) that the
- // reader should be able to handle (the character is \xf0\x9f\x98\x87).
- const char kUtf8Data[] =
- "[\"😇\",[],[],[],{\"google:suggesttype\":[]}]";
- std::string error_message;
- int error_code = 0;
- std::unique_ptr<Value> root = JSONReader::ReadAndReturnError(
- kUtf8Data, JSON_PARSE_RFC, &error_code, &error_message);
- EXPECT_TRUE(root.get()) << error_message;
-}
-
-TEST_F(JSONParserTest, DecodeUnicodeNonCharacter) {
- // Tests Unicode code points (encoded as escaped UTF-16) that are not valid
- // characters.
- EXPECT_FALSE(JSONReader::Read("[\"\\ufdd0\"]"));
- EXPECT_FALSE(JSONReader::Read("[\"\\ufffe\"]"));
- EXPECT_FALSE(JSONReader::Read("[\"\\ud83f\\udffe\"]"));
-
- EXPECT_TRUE(
- JSONReader::Read("[\"\\ufdd0\"]", JSON_REPLACE_INVALID_CHARACTERS));
- EXPECT_TRUE(
- JSONReader::Read("[\"\\ufffe\"]", JSON_REPLACE_INVALID_CHARACTERS));
-}
-
-TEST_F(JSONParserTest, DecodeNegativeEscapeSequence) {
- EXPECT_FALSE(JSONReader::Read("[\"\\x-A\"]"));
- EXPECT_FALSE(JSONReader::Read("[\"\\u-00A\"]"));
-}
-
-// Verifies invalid utf-8 characters are replaced.
-TEST_F(JSONParserTest, ReplaceInvalidCharacters) {
- const std::string bogus_char = "";
- const std::string quoted_bogus_char = "\"" + bogus_char + "\"";
- std::unique_ptr<JSONParser> parser(
- NewTestParser(quoted_bogus_char, JSON_REPLACE_INVALID_CHARACTERS));
- Optional<Value> value(parser->ConsumeString());
- ASSERT_TRUE(value);
- std::string str;
- EXPECT_TRUE(value->GetAsString(&str));
- EXPECT_EQ(kUnicodeReplacementString, str);
-}
-
-TEST_F(JSONParserTest, ReplaceInvalidUTF16EscapeSequence) {
- const std::string invalid = "\"\\ufffe\"";
- std::unique_ptr<JSONParser> parser(
- NewTestParser(invalid, JSON_REPLACE_INVALID_CHARACTERS));
- Optional<Value> value(parser->ConsumeString());
- ASSERT_TRUE(value);
- std::string str;
- EXPECT_TRUE(value->GetAsString(&str));
- EXPECT_EQ(kUnicodeReplacementString, str);
-}
-
-TEST_F(JSONParserTest, ParseNumberErrors) {
- const struct {
- const char* input;
- bool parse_success;
- double value;
- } kCases[] = {
- // clang-format off
- {"1", true, 1},
- {"2.", false, 0},
- {"42", true, 42},
- {"6e", false, 0},
- {"43e2", true, 4300},
- {"43e-", false, 0},
- {"9e-3", true, 0.009},
- {"2e+", false, 0},
- {"2e+2", true, 200},
- // clang-format on
- };
-
- for (unsigned int i = 0; i < arraysize(kCases); ++i) {
- auto test_case = kCases[i];
- SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case.input));
-
- std::unique_ptr<char[]> input_owner;
- StringPiece input =
- MakeNotNullTerminatedInput(test_case.input, &input_owner);
-
- std::unique_ptr<Value> result = JSONReader::Read(input);
- if (test_case.parse_success) {
- EXPECT_TRUE(result);
- } else {
- EXPECT_FALSE(result);
- }
-
- if (!result)
- continue;
-
- double double_value = 0;
- EXPECT_TRUE(result->GetAsDouble(&double_value));
- EXPECT_EQ(test_case.value, double_value);
- }
-}
-
-TEST_F(JSONParserTest, UnterminatedInputs) {
- const char* kCases[] = {
- // clang-format off
- "/",
- "//",
- "/*",
- "\"xxxxxx",
- "\"",
- "{ ",
- "[\t",
- "tru",
- "fals",
- "nul",
- "\"\\x",
- "\"\\x2",
- "\"\\u123",
- "\"\\uD803\\u",
- "\"\\",
- "\"\\/",
- // clang-format on
- };
-
- for (unsigned int i = 0; i < arraysize(kCases); ++i) {
- auto* test_case = kCases[i];
- SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case));
-
- std::unique_ptr<char[]> input_owner;
- StringPiece input = MakeNotNullTerminatedInput(test_case, &input_owner);
-
- EXPECT_FALSE(JSONReader::Read(input));
- }
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/json/json_reader_unittest.cc b/base/json/json_reader_unittest.cc
deleted file mode 100644
index 828fba0..0000000
--- a/base/json/json_reader_unittest.cc
+++ /dev/null
@@ -1,665 +0,0 @@
-// 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.
-
-#include "base/json/json_reader.h"
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/base_paths.h"
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/path_service.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(JSONReaderTest, Whitespace) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue(" null ");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_none());
-}
-
-TEST(JSONReaderTest, InvalidString) {
- EXPECT_FALSE(JSONReader().ReadToValue("nu"));
-}
-
-TEST(JSONReaderTest, SimpleBool) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("true ");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_bool());
-}
-
-TEST(JSONReaderTest, EmbeddedComments) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("/* comment */null");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_none());
- root = JSONReader().ReadToValue("40 /* comment */");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_int());
- root = JSONReader().ReadToValue("true // comment");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_bool());
- root = JSONReader().ReadToValue("/* comment */\"sample string\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string value;
- EXPECT_TRUE(root->GetAsString(&value));
- EXPECT_EQ("sample string", value);
- std::unique_ptr<ListValue> list =
- ListValue::From(JSONReader().ReadToValue("[1, /* comment, 2 ] */ \n 3]"));
- ASSERT_TRUE(list);
- EXPECT_EQ(2u, list->GetSize());
- int int_val = 0;
- EXPECT_TRUE(list->GetInteger(0, &int_val));
- EXPECT_EQ(1, int_val);
- EXPECT_TRUE(list->GetInteger(1, &int_val));
- EXPECT_EQ(3, int_val);
- list = ListValue::From(JSONReader().ReadToValue("[1, /*a*/2, 3]"));
- ASSERT_TRUE(list);
- EXPECT_EQ(3u, list->GetSize());
- root = JSONReader().ReadToValue("/* comment **/42");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_int());
- EXPECT_TRUE(root->GetAsInteger(&int_val));
- EXPECT_EQ(42, int_val);
- root = JSONReader().ReadToValue(
- "/* comment **/\n"
- "// */ 43\n"
- "44");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_int());
- EXPECT_TRUE(root->GetAsInteger(&int_val));
- EXPECT_EQ(44, int_val);
-}
-
-TEST(JSONReaderTest, Ints) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("43");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_int());
- int int_val = 0;
- EXPECT_TRUE(root->GetAsInteger(&int_val));
- EXPECT_EQ(43, int_val);
-}
-
-TEST(JSONReaderTest, NonDecimalNumbers) {
- // According to RFC4627, oct, hex, and leading zeros are invalid JSON.
- EXPECT_FALSE(JSONReader().ReadToValue("043"));
- EXPECT_FALSE(JSONReader().ReadToValue("0x43"));
- EXPECT_FALSE(JSONReader().ReadToValue("00"));
-}
-
-TEST(JSONReaderTest, NumberZero) {
- // Test 0 (which needs to be special cased because of the leading zero
- // clause).
- std::unique_ptr<Value> root = JSONReader().ReadToValue("0");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_int());
- int int_val = 1;
- EXPECT_TRUE(root->GetAsInteger(&int_val));
- EXPECT_EQ(0, int_val);
-}
-
-TEST(JSONReaderTest, LargeIntPromotion) {
- // Numbers that overflow ints should succeed, being internally promoted to
- // storage as doubles
- std::unique_ptr<Value> root = JSONReader().ReadToValue("2147483648");
- ASSERT_TRUE(root);
- double double_val;
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(2147483648.0, double_val);
- root = JSONReader().ReadToValue("-2147483649");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(-2147483649.0, double_val);
-}
-
-TEST(JSONReaderTest, Doubles) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("43.1");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(43.1, double_val);
-
- root = JSONReader().ReadToValue("4.3e-1");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(.43, double_val);
-
- root = JSONReader().ReadToValue("2.1e0");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(2.1, double_val);
-
- root = JSONReader().ReadToValue("2.1e+0001");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(21.0, double_val);
-
- root = JSONReader().ReadToValue("0.01");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(0.01, double_val);
-
- root = JSONReader().ReadToValue("1.00");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_double());
- double_val = 0.0;
- EXPECT_TRUE(root->GetAsDouble(&double_val));
- EXPECT_DOUBLE_EQ(1.0, double_val);
-}
-
-TEST(JSONReaderTest, FractionalNumbers) {
- // Fractional parts must have a digit before and after the decimal point.
- EXPECT_FALSE(JSONReader().ReadToValue("1."));
- EXPECT_FALSE(JSONReader().ReadToValue(".1"));
- EXPECT_FALSE(JSONReader().ReadToValue("1.e10"));
-}
-
-TEST(JSONReaderTest, ExponentialNumbers) {
- // Exponent must have a digit following the 'e'.
- EXPECT_FALSE(JSONReader().ReadToValue("1e"));
- EXPECT_FALSE(JSONReader().ReadToValue("1E"));
- EXPECT_FALSE(JSONReader().ReadToValue("1e1."));
- EXPECT_FALSE(JSONReader().ReadToValue("1e1.0"));
-}
-
-TEST(JSONReaderTest, InvalidNAN) {
- EXPECT_FALSE(JSONReader().ReadToValue("1e1000"));
- EXPECT_FALSE(JSONReader().ReadToValue("-1e1000"));
- EXPECT_FALSE(JSONReader().ReadToValue("NaN"));
- EXPECT_FALSE(JSONReader().ReadToValue("nan"));
- EXPECT_FALSE(JSONReader().ReadToValue("inf"));
-}
-
-TEST(JSONReaderTest, InvalidNumbers) {
- EXPECT_FALSE(JSONReader().ReadToValue("4.3.1"));
- EXPECT_FALSE(JSONReader().ReadToValue("4e3.1"));
- EXPECT_FALSE(JSONReader().ReadToValue("4.a"));
-}
-
-TEST(JSONReader, SimpleString) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("\"hello world\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ("hello world", str_val);
-}
-
-TEST(JSONReaderTest, EmptyString) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ("", str_val);
-}
-
-TEST(JSONReaderTest, BasicStringEscapes) {
- std::unique_ptr<Value> root =
- JSONReader().ReadToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ(" \"\\/\b\f\n\r\t\v", str_val);
-}
-
-TEST(JSONReaderTest, UnicodeEscapes) {
- // Test hex and unicode escapes including the null character.
- std::unique_ptr<Value> root =
- JSONReader().ReadToValue("\"\\x41\\x00\\u1234\\u0000\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ(std::wstring(L"A\0\x1234\0", 4), UTF8ToWide(str_val));
-}
-
-TEST(JSONReaderTest, InvalidStrings) {
- EXPECT_FALSE(JSONReader().ReadToValue("\"no closing quote"));
- EXPECT_FALSE(JSONReader().ReadToValue("\"\\z invalid escape char\""));
- EXPECT_FALSE(JSONReader().ReadToValue("\"\\xAQ invalid hex code\""));
- EXPECT_FALSE(JSONReader().ReadToValue("not enough hex chars\\x1\""));
- EXPECT_FALSE(JSONReader().ReadToValue("\"not enough escape chars\\u123\""));
- EXPECT_FALSE(
- JSONReader().ReadToValue("\"extra backslash at end of input\\\""));
-}
-
-TEST(JSONReaderTest, BasicArray) {
- std::unique_ptr<ListValue> list =
- ListValue::From(JSONReader::Read("[true, false, null]"));
- ASSERT_TRUE(list);
- EXPECT_EQ(3U, list->GetSize());
-
- // Test with trailing comma. Should be parsed the same as above.
- std::unique_ptr<Value> root2 =
- JSONReader::Read("[true, false, null, ]", JSON_ALLOW_TRAILING_COMMAS);
- EXPECT_TRUE(list->Equals(root2.get()));
-}
-
-TEST(JSONReaderTest, EmptyArray) {
- std::unique_ptr<ListValue> list = ListValue::From(JSONReader::Read("[]"));
- ASSERT_TRUE(list);
- EXPECT_EQ(0U, list->GetSize());
-}
-
-TEST(JSONReaderTest, NestedArrays) {
- std::unique_ptr<ListValue> list = ListValue::From(
- JSONReader::Read("[[true], [], [false, [], [null]], null]"));
- ASSERT_TRUE(list);
- EXPECT_EQ(4U, list->GetSize());
-
- // Lots of trailing commas.
- std::unique_ptr<Value> root2 =
- JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]",
- JSON_ALLOW_TRAILING_COMMAS);
- EXPECT_TRUE(list->Equals(root2.get()));
-}
-
-TEST(JSONReaderTest, InvalidArrays) {
- // Missing close brace.
- EXPECT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null"));
-
- // Too many commas.
- EXPECT_FALSE(JSONReader::Read("[true,, null]"));
- EXPECT_FALSE(JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS));
-
- // No commas.
- EXPECT_FALSE(JSONReader::Read("[true null]"));
-
- // Trailing comma.
- EXPECT_FALSE(JSONReader::Read("[true,]"));
-}
-
-TEST(JSONReaderTest, ArrayTrailingComma) {
- // Valid if we set |allow_trailing_comma| to true.
- std::unique_ptr<ListValue> list =
- ListValue::From(JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS));
- ASSERT_TRUE(list);
- EXPECT_EQ(1U, list->GetSize());
- Value* tmp_value = nullptr;
- ASSERT_TRUE(list->Get(0, &tmp_value));
- EXPECT_TRUE(tmp_value->is_bool());
- bool bool_value = false;
- EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value));
- EXPECT_TRUE(bool_value);
-}
-
-TEST(JSONReaderTest, ArrayTrailingCommaNoEmptyElements) {
- // Don't allow empty elements, even if |allow_trailing_comma| is
- // true.
- EXPECT_FALSE(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS));
- EXPECT_FALSE(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS));
- EXPECT_FALSE(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS));
- EXPECT_FALSE(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS));
-}
-
-TEST(JSONReaderTest, EmptyDictionary) {
- std::unique_ptr<DictionaryValue> dict_val =
- DictionaryValue::From(JSONReader::Read("{}"));
- ASSERT_TRUE(dict_val);
-}
-
-TEST(JSONReaderTest, CompleteDictionary) {
- auto dict_val = DictionaryValue::From(JSONReader::Read(
- "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }"));
- ASSERT_TRUE(dict_val);
- double double_val = 0.0;
- EXPECT_TRUE(dict_val->GetDouble("number", &double_val));
- EXPECT_DOUBLE_EQ(9.87654321, double_val);
- Value* null_val = nullptr;
- ASSERT_TRUE(dict_val->Get("null", &null_val));
- EXPECT_TRUE(null_val->is_none());
- std::string str_val;
- EXPECT_TRUE(dict_val->GetString("S", &str_val));
- EXPECT_EQ("str", str_val);
-
- std::unique_ptr<Value> root2 = JSONReader::Read(
- "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }",
- JSON_ALLOW_TRAILING_COMMAS);
- ASSERT_TRUE(root2);
- EXPECT_TRUE(dict_val->Equals(root2.get()));
-
- // Test newline equivalence.
- root2 = JSONReader::Read(
- "{\n"
- " \"number\":9.87654321,\n"
- " \"null\":null,\n"
- " \"\\x53\":\"str\",\n"
- "}\n",
- JSON_ALLOW_TRAILING_COMMAS);
- ASSERT_TRUE(root2);
- EXPECT_TRUE(dict_val->Equals(root2.get()));
-
- root2 = JSONReader::Read(
- "{\r\n"
- " \"number\":9.87654321,\r\n"
- " \"null\":null,\r\n"
- " \"\\x53\":\"str\",\r\n"
- "}\r\n",
- JSON_ALLOW_TRAILING_COMMAS);
- ASSERT_TRUE(root2);
- EXPECT_TRUE(dict_val->Equals(root2.get()));
-}
-
-TEST(JSONReaderTest, NestedDictionaries) {
- std::unique_ptr<DictionaryValue> dict_val =
- DictionaryValue::From(JSONReader::Read(
- "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}"));
- ASSERT_TRUE(dict_val);
- DictionaryValue* inner_dict = nullptr;
- ASSERT_TRUE(dict_val->GetDictionary("inner", &inner_dict));
- ListValue* inner_array = nullptr;
- ASSERT_TRUE(inner_dict->GetList("array", &inner_array));
- EXPECT_EQ(1U, inner_array->GetSize());
- bool bool_value = true;
- EXPECT_TRUE(dict_val->GetBoolean("false", &bool_value));
- EXPECT_FALSE(bool_value);
- inner_dict = nullptr;
- EXPECT_TRUE(dict_val->GetDictionary("d", &inner_dict));
-
- std::unique_ptr<Value> root2 = JSONReader::Read(
- "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}",
- JSON_ALLOW_TRAILING_COMMAS);
- EXPECT_TRUE(dict_val->Equals(root2.get()));
-}
-
-TEST(JSONReaderTest, DictionaryKeysWithPeriods) {
- std::unique_ptr<DictionaryValue> dict_val = DictionaryValue::From(
- JSONReader::Read("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}"));
- ASSERT_TRUE(dict_val);
- int integer_value = 0;
- EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value));
- EXPECT_EQ(3, integer_value);
- EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("c", &integer_value));
- EXPECT_EQ(2, integer_value);
- DictionaryValue* inner_dict = nullptr;
- ASSERT_TRUE(
- dict_val->GetDictionaryWithoutPathExpansion("d.e.f", &inner_dict));
- EXPECT_EQ(1U, inner_dict->size());
- EXPECT_TRUE(
- inner_dict->GetIntegerWithoutPathExpansion("g.h.i.j", &integer_value));
- EXPECT_EQ(1, integer_value);
-
- dict_val =
- DictionaryValue::From(JSONReader::Read("{\"a\":{\"b\":2},\"a.b\":1}"));
- ASSERT_TRUE(dict_val);
- EXPECT_TRUE(dict_val->GetInteger("a.b", &integer_value));
- EXPECT_EQ(2, integer_value);
- EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value));
- EXPECT_EQ(1, integer_value);
-}
-
-TEST(JSONReaderTest, InvalidDictionaries) {
- // No closing brace.
- EXPECT_FALSE(JSONReader::Read("{\"a\": true"));
-
- // Keys must be quoted strings.
- EXPECT_FALSE(JSONReader::Read("{foo:true}"));
- EXPECT_FALSE(JSONReader::Read("{1234: false}"));
- EXPECT_FALSE(JSONReader::Read("{:false}"));
-
- // Trailing comma.
- EXPECT_FALSE(JSONReader::Read("{\"a\":true,}"));
-
- // Too many commas.
- EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}"));
- EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
- JSON_ALLOW_TRAILING_COMMAS));
-
- // No separator.
- EXPECT_FALSE(JSONReader::Read("{\"a\" \"b\"}"));
-
- // Lone comma.
- EXPECT_FALSE(JSONReader::Read("{,}"));
- EXPECT_FALSE(JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS));
- EXPECT_FALSE(JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS));
- EXPECT_FALSE(JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS));
- EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
- JSON_ALLOW_TRAILING_COMMAS));
-}
-
-TEST(JSONReaderTest, StackOverflow) {
- std::string evil(1000000, '[');
- evil.append(std::string(1000000, ']'));
- EXPECT_FALSE(JSONReader::Read(evil));
-
- // A few thousand adjacent lists is fine.
- std::string not_evil("[");
- not_evil.reserve(15010);
- for (int i = 0; i < 5000; ++i)
- not_evil.append("[],");
- not_evil.append("[]]");
- std::unique_ptr<ListValue> list = ListValue::From(JSONReader::Read(not_evil));
- ASSERT_TRUE(list);
- EXPECT_EQ(5001U, list->GetSize());
-}
-
-TEST(JSONReaderTest, UTF8Input) {
- std::unique_ptr<Value> root =
- JSONReader().ReadToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));
-
- std::unique_ptr<DictionaryValue> dict_val =
- DictionaryValue::From(JSONReader().ReadToValue(
- "{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}"));
- ASSERT_TRUE(dict_val);
- EXPECT_TRUE(dict_val->GetString("path", &str_val));
- EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", str_val);
-}
-
-TEST(JSONReaderTest, InvalidUTF8Input) {
- EXPECT_FALSE(JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\""));
- EXPECT_FALSE(JSONReader().ReadToValue("\"123\xc0\x81\""));
- EXPECT_FALSE(JSONReader().ReadToValue("\"abc\xc0\xae\""));
-}
-
-TEST(JSONReaderTest, UTF16Escapes) {
- std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\\u20ac3,14\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ(
- "\xe2\x82\xac"
- "3,14",
- str_val);
-
- root = JSONReader().ReadToValue("\"\\ud83d\\udca9\\ud83d\\udc6c\"");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_string());
- str_val.clear();
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", str_val);
-}
-
-TEST(JSONReaderTest, InvalidUTF16Escapes) {
- const char* const cases[] = {
- "\"\\u123\"", // Invalid scalar.
- "\"\\ud83d\"", // Invalid scalar.
- "\"\\u$%@!\"", // Invalid scalar.
- "\"\\uzz89\"", // Invalid scalar.
- "\"\\ud83d\\udca\"", // Invalid lower surrogate.
- "\"\\ud83d\\ud83d\"", // Invalid lower surrogate.
- "\"\\ud83d\\uaaaZ\"" // Invalid lower surrogate.
- "\"\\ud83foo\"", // No lower surrogate.
- "\"\\ud83d\\foo\"" // No lower surrogate.
- "\"\\ud83\\foo\"" // Invalid upper surrogate.
- "\"\\ud83d\\u1\"" // No lower surrogate.
- "\"\\ud83\\u1\"" // Invalid upper surrogate.
- };
- std::unique_ptr<Value> root;
- for (size_t i = 0; i < arraysize(cases); ++i) {
- root = JSONReader().ReadToValue(cases[i]);
- EXPECT_FALSE(root) << cases[i];
- }
-}
-
-TEST(JSONReaderTest, LiteralRoots) {
- std::unique_ptr<Value> root = JSONReader::Read("null");
- ASSERT_TRUE(root);
- EXPECT_TRUE(root->is_none());
-
- root = JSONReader::Read("true");
- ASSERT_TRUE(root);
- bool bool_value;
- EXPECT_TRUE(root->GetAsBoolean(&bool_value));
- EXPECT_TRUE(bool_value);
-
- root = JSONReader::Read("10");
- ASSERT_TRUE(root);
- int integer_value;
- EXPECT_TRUE(root->GetAsInteger(&integer_value));
- EXPECT_EQ(10, integer_value);
-
- root = JSONReader::Read("\"root\"");
- ASSERT_TRUE(root);
- std::string str_val;
- EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ("root", str_val);
-}
-
-TEST(JSONReaderTest, ReadFromFile) {
- FilePath path;
- ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
- path = path.AppendASCII("json");
- ASSERT_TRUE(base::PathExists(path));
-
- std::string input;
- ASSERT_TRUE(ReadFileToString(path.AppendASCII("bom_feff.json"), &input));
-
- JSONReader reader;
- std::unique_ptr<Value> root(reader.ReadToValue(input));
- ASSERT_TRUE(root) << reader.GetErrorMessage();
- EXPECT_TRUE(root->is_dict());
-}
-
-// Tests that the root of a JSON object can be deleted safely while its
-// children outlive it.
-TEST(JSONReaderTest, StringOptimizations) {
- std::unique_ptr<Value> dict_literal_0;
- std::unique_ptr<Value> dict_literal_1;
- std::unique_ptr<Value> dict_string_0;
- std::unique_ptr<Value> dict_string_1;
- std::unique_ptr<Value> list_value_0;
- std::unique_ptr<Value> list_value_1;
-
- {
- std::unique_ptr<Value> root = JSONReader::Read(
- "{"
- " \"test\": {"
- " \"foo\": true,"
- " \"bar\": 3.14,"
- " \"baz\": \"bat\","
- " \"moo\": \"cow\""
- " },"
- " \"list\": ["
- " \"a\","
- " \"b\""
- " ]"
- "}",
- JSON_PARSE_RFC);
- ASSERT_TRUE(root);
-
- DictionaryValue* root_dict = nullptr;
- ASSERT_TRUE(root->GetAsDictionary(&root_dict));
-
- DictionaryValue* dict = nullptr;
- ListValue* list = nullptr;
-
- ASSERT_TRUE(root_dict->GetDictionary("test", &dict));
- ASSERT_TRUE(root_dict->GetList("list", &list));
-
- ASSERT_TRUE(dict->Remove("foo", &dict_literal_0));
- ASSERT_TRUE(dict->Remove("bar", &dict_literal_1));
- ASSERT_TRUE(dict->Remove("baz", &dict_string_0));
- ASSERT_TRUE(dict->Remove("moo", &dict_string_1));
-
- ASSERT_EQ(2u, list->GetSize());
- ASSERT_TRUE(list->Remove(0, &list_value_0));
- ASSERT_TRUE(list->Remove(0, &list_value_1));
- }
-
- bool b = false;
- double d = 0;
- std::string s;
-
- EXPECT_TRUE(dict_literal_0->GetAsBoolean(&b));
- EXPECT_TRUE(b);
-
- EXPECT_TRUE(dict_literal_1->GetAsDouble(&d));
- EXPECT_EQ(3.14, d);
-
- EXPECT_TRUE(dict_string_0->GetAsString(&s));
- EXPECT_EQ("bat", s);
-
- EXPECT_TRUE(dict_string_1->GetAsString(&s));
- EXPECT_EQ("cow", s);
-
- EXPECT_TRUE(list_value_0->GetAsString(&s));
- EXPECT_EQ("a", s);
- EXPECT_TRUE(list_value_1->GetAsString(&s));
- EXPECT_EQ("b", s);
-}
-
-// A smattering of invalid JSON designed to test specific portions of the
-// parser implementation against buffer overflow. Best run with DCHECKs so
-// that the one in NextChar fires.
-TEST(JSONReaderTest, InvalidSanity) {
- const char* const kInvalidJson[] = {
- "/* test *", "{\"foo\"", "{\"foo\":", " [", "\"\\u123g\"", "{\n\"eh:\n}",
- };
-
- for (size_t i = 0; i < arraysize(kInvalidJson); ++i) {
- JSONReader reader;
- LOG(INFO) << "Sanity test " << i << ": <" << kInvalidJson[i] << ">";
- EXPECT_FALSE(reader.ReadToValue(kInvalidJson[i]));
- EXPECT_NE(JSONReader::JSON_NO_ERROR, reader.error_code());
- EXPECT_NE("", reader.GetErrorMessage());
- }
-}
-
-TEST(JSONReaderTest, IllegalTrailingNull) {
- const char json[] = { '"', 'n', 'u', 'l', 'l', '"', '\0' };
- std::string json_string(json, sizeof(json));
- JSONReader reader;
- EXPECT_FALSE(reader.ReadToValue(json_string));
- EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, reader.error_code());
-}
-
-TEST(JSONReaderTest, MaxNesting) {
- std::string json(R"({"outer": { "inner": {"foo": true}}})");
- std::unique_ptr<Value> root;
- root = JSONReader::Read(json, JSON_PARSE_RFC, 3);
- ASSERT_FALSE(root);
- root = JSONReader::Read(json, JSON_PARSE_RFC, 4);
- ASSERT_TRUE(root);
-}
-
-} // namespace base
diff --git a/base/json/json_value_converter_unittest.cc b/base/json/json_value_converter_unittest.cc
deleted file mode 100644
index 322f5f0..0000000
--- a/base/json/json_value_converter_unittest.cc
+++ /dev/null
@@ -1,255 +0,0 @@
-// 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.
-
-#include "base/json/json_value_converter.h"
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/json/json_reader.h"
-#include "base/strings/string_piece.h"
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-// Very simple messages.
-struct SimpleMessage {
- enum SimpleEnum {
- FOO, BAR,
- };
- int foo;
- std::string bar;
- bool baz;
- bool bstruct;
- SimpleEnum simple_enum;
- std::vector<std::unique_ptr<int>> ints;
- std::vector<std::unique_ptr<std::string>> string_values;
- SimpleMessage() : foo(0), baz(false), bstruct(false), simple_enum(FOO) {}
-
- static bool ParseSimpleEnum(StringPiece value, SimpleEnum* field) {
- if (value == "foo") {
- *field = FOO;
- return true;
- } else if (value == "bar") {
- *field = BAR;
- return true;
- }
- return false;
- }
-
- static bool HasFieldPresent(const base::Value* value, bool* result) {
- *result = value != nullptr;
- return true;
- }
-
- static bool GetValueString(const base::Value* value, std::string* result) {
- const base::DictionaryValue* dict = nullptr;
- if (!value->GetAsDictionary(&dict))
- return false;
-
- if (!dict->GetString("val", result))
- return false;
-
- return true;
- }
-
- static void RegisterJSONConverter(
- base::JSONValueConverter<SimpleMessage>* converter) {
- converter->RegisterIntField("foo", &SimpleMessage::foo);
- converter->RegisterStringField("bar", &SimpleMessage::bar);
- converter->RegisterBoolField("baz", &SimpleMessage::baz);
- converter->RegisterCustomField<SimpleEnum>(
- "simple_enum", &SimpleMessage::simple_enum, &ParseSimpleEnum);
- converter->RegisterRepeatedInt("ints", &SimpleMessage::ints);
- converter->RegisterCustomValueField<bool>("bstruct",
- &SimpleMessage::bstruct,
- &HasFieldPresent);
- converter->RegisterRepeatedCustomValue<std::string>(
- "string_values",
- &SimpleMessage::string_values,
- &GetValueString);
- }
-};
-
-// For nested messages.
-struct NestedMessage {
- double foo;
- SimpleMessage child;
- std::vector<std::unique_ptr<SimpleMessage>> children;
-
- NestedMessage() : foo(0) {}
-
- static void RegisterJSONConverter(
- base::JSONValueConverter<NestedMessage>* converter) {
- converter->RegisterDoubleField("foo", &NestedMessage::foo);
- converter->RegisterNestedField("child", &NestedMessage::child);
- converter->RegisterRepeatedMessage("children", &NestedMessage::children);
- }
-};
-
-} // namespace
-
-TEST(JSONValueConverterTest, ParseSimpleMessage) {
- const char normal_data[] =
- "{\n"
- " \"foo\": 1,\n"
- " \"bar\": \"bar\",\n"
- " \"baz\": true,\n"
- " \"bstruct\": {},\n"
- " \"string_values\": [{\"val\": \"value_1\"}, {\"val\": \"value_2\"}],"
- " \"simple_enum\": \"foo\","
- " \"ints\": [1, 2]"
- "}\n";
-
- std::unique_ptr<Value> value = base::JSONReader::Read(normal_data);
- SimpleMessage message;
- base::JSONValueConverter<SimpleMessage> converter;
- EXPECT_TRUE(converter.Convert(*value.get(), &message));
-
- EXPECT_EQ(1, message.foo);
- EXPECT_EQ("bar", message.bar);
- EXPECT_TRUE(message.baz);
- EXPECT_EQ(SimpleMessage::FOO, message.simple_enum);
- EXPECT_EQ(2, static_cast<int>(message.ints.size()));
- ASSERT_EQ(2U, message.string_values.size());
- EXPECT_EQ("value_1", *message.string_values[0]);
- EXPECT_EQ("value_2", *message.string_values[1]);
- EXPECT_EQ(1, *(message.ints[0]));
- EXPECT_EQ(2, *(message.ints[1]));
-}
-
-TEST(JSONValueConverterTest, ParseNestedMessage) {
- const char normal_data[] =
- "{\n"
- " \"foo\": 1.0,\n"
- " \"child\": {\n"
- " \"foo\": 1,\n"
- " \"bar\": \"bar\",\n"
- " \"bstruct\": {},\n"
- " \"string_values\": [{\"val\": \"value_1\"}, {\"val\": \"value_2\"}],"
- " \"baz\": true\n"
- " },\n"
- " \"children\": [{\n"
- " \"foo\": 2,\n"
- " \"bar\": \"foobar\",\n"
- " \"bstruct\": \"\",\n"
- " \"string_values\": [{\"val\": \"value_1\"}],"
- " \"baz\": true\n"
- " },\n"
- " {\n"
- " \"foo\": 3,\n"
- " \"bar\": \"barbaz\",\n"
- " \"baz\": false\n"
- " }]\n"
- "}\n";
-
- std::unique_ptr<Value> value = base::JSONReader::Read(normal_data);
- NestedMessage message;
- base::JSONValueConverter<NestedMessage> converter;
- EXPECT_TRUE(converter.Convert(*value.get(), &message));
-
- EXPECT_EQ(1.0, message.foo);
- EXPECT_EQ(1, message.child.foo);
- EXPECT_EQ("bar", message.child.bar);
- EXPECT_TRUE(message.child.baz);
- EXPECT_TRUE(message.child.bstruct);
- ASSERT_EQ(2U, message.child.string_values.size());
- EXPECT_EQ("value_1", *message.child.string_values[0]);
- EXPECT_EQ("value_2", *message.child.string_values[1]);
-
- EXPECT_EQ(2, static_cast<int>(message.children.size()));
- const SimpleMessage* first_child = message.children[0].get();
- ASSERT_TRUE(first_child);
- EXPECT_EQ(2, first_child->foo);
- EXPECT_EQ("foobar", first_child->bar);
- EXPECT_TRUE(first_child->baz);
- EXPECT_TRUE(first_child->bstruct);
- ASSERT_EQ(1U, first_child->string_values.size());
- EXPECT_EQ("value_1", *first_child->string_values[0]);
-
- const SimpleMessage* second_child = message.children[1].get();
- ASSERT_TRUE(second_child);
- EXPECT_EQ(3, second_child->foo);
- EXPECT_EQ("barbaz", second_child->bar);
- EXPECT_FALSE(second_child->baz);
- EXPECT_FALSE(second_child->bstruct);
- EXPECT_EQ(0U, second_child->string_values.size());
-}
-
-TEST(JSONValueConverterTest, ParseFailures) {
- const char normal_data[] =
- "{\n"
- " \"foo\": 1,\n"
- " \"bar\": 2,\n" // "bar" is an integer here.
- " \"baz\": true,\n"
- " \"ints\": [1, 2]"
- "}\n";
-
- std::unique_ptr<Value> value = base::JSONReader::Read(normal_data);
- SimpleMessage message;
- base::JSONValueConverter<SimpleMessage> converter;
- EXPECT_FALSE(converter.Convert(*value.get(), &message));
- // Do not check the values below. |message| may be modified during
- // Convert() even it fails.
-}
-
-TEST(JSONValueConverterTest, ParseWithMissingFields) {
- const char normal_data[] =
- "{\n"
- " \"foo\": 1,\n"
- " \"baz\": true,\n"
- " \"ints\": [1, 2]"
- "}\n";
-
- std::unique_ptr<Value> value = base::JSONReader::Read(normal_data);
- SimpleMessage message;
- base::JSONValueConverter<SimpleMessage> converter;
- // Convert() still succeeds even if the input doesn't have "bar" field.
- EXPECT_TRUE(converter.Convert(*value.get(), &message));
-
- EXPECT_EQ(1, message.foo);
- EXPECT_TRUE(message.baz);
- EXPECT_EQ(2, static_cast<int>(message.ints.size()));
- EXPECT_EQ(1, *(message.ints[0]));
- EXPECT_EQ(2, *(message.ints[1]));
-}
-
-TEST(JSONValueConverterTest, EnumParserFails) {
- const char normal_data[] =
- "{\n"
- " \"foo\": 1,\n"
- " \"bar\": \"bar\",\n"
- " \"baz\": true,\n"
- " \"simple_enum\": \"baz\","
- " \"ints\": [1, 2]"
- "}\n";
-
- std::unique_ptr<Value> value = base::JSONReader::Read(normal_data);
- SimpleMessage message;
- base::JSONValueConverter<SimpleMessage> converter;
- EXPECT_FALSE(converter.Convert(*value.get(), &message));
- // No check the values as mentioned above.
-}
-
-TEST(JSONValueConverterTest, RepeatedValueErrorInTheMiddle) {
- const char normal_data[] =
- "{\n"
- " \"foo\": 1,\n"
- " \"bar\": \"bar\",\n"
- " \"baz\": true,\n"
- " \"simple_enum\": \"baz\","
- " \"ints\": [1, false]"
- "}\n";
-
- std::unique_ptr<Value> value = base::JSONReader::Read(normal_data);
- SimpleMessage message;
- base::JSONValueConverter<SimpleMessage> converter;
- EXPECT_FALSE(converter.Convert(*value.get(), &message));
- // No check the values as mentioned above.
-}
-
-} // namespace base
diff --git a/base/json/json_value_serializer_unittest.cc b/base/json/json_value_serializer_unittest.cc
deleted file mode 100644
index b358dec..0000000
--- a/base/json/json_value_serializer_unittest.cc
+++ /dev/null
@@ -1,487 +0,0 @@
-// 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.
-
-#include <memory>
-#include <string>
-
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/json/json_file_value_serializer.h"
-#include "base/json/json_reader.h"
-#include "base/json/json_string_value_serializer.h"
-#include "base/json/json_writer.h"
-#include "base/path_service.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Some proper JSON to test with:
-const char kProperJSON[] =
- "{\n"
- " \"compound\": {\n"
- " \"a\": 1,\n"
- " \"b\": 2\n"
- " },\n"
- " \"some_String\": \"1337\",\n"
- " \"some_int\": 42,\n"
- " \"the_list\": [ \"val1\", \"val2\" ]\n"
- "}\n";
-
-// Some proper JSON with trailing commas:
-const char kProperJSONWithCommas[] =
- "{\n"
- "\t\"some_int\": 42,\n"
- "\t\"some_String\": \"1337\",\n"
- "\t\"the_list\": [\"val1\", \"val2\", ],\n"
- "\t\"compound\": { \"a\": 1, \"b\": 2, },\n"
- "}\n";
-
-// kProperJSON with a few misc characters at the begin and end.
-const char kProperJSONPadded[] =
- ")]}'\n"
- "{\n"
- " \"compound\": {\n"
- " \"a\": 1,\n"
- " \"b\": 2\n"
- " },\n"
- " \"some_String\": \"1337\",\n"
- " \"some_int\": 42,\n"
- " \"the_list\": [ \"val1\", \"val2\" ]\n"
- "}\n"
- "?!ab\n";
-
-const char kWinLineEnds[] = "\r\n";
-const char kLinuxLineEnds[] = "\n";
-
-// Verifies the generated JSON against the expected output.
-void CheckJSONIsStillTheSame(const Value& value) {
- // Serialize back the output.
- std::string serialized_json;
- JSONStringValueSerializer str_serializer(&serialized_json);
- str_serializer.set_pretty_print(true);
- ASSERT_TRUE(str_serializer.Serialize(value));
- // Unify line endings between platforms.
- ReplaceSubstringsAfterOffset(&serialized_json, 0,
- kWinLineEnds, kLinuxLineEnds);
- // Now compare the input with the output.
- ASSERT_EQ(kProperJSON, serialized_json);
-}
-
-void ValidateJsonList(const std::string& json) {
- std::unique_ptr<ListValue> list = ListValue::From(JSONReader::Read(json));
- ASSERT_TRUE(list);
- ASSERT_EQ(1U, list->GetSize());
- Value* elt = nullptr;
- ASSERT_TRUE(list->Get(0, &elt));
- int value = 0;
- ASSERT_TRUE(elt && elt->GetAsInteger(&value));
- ASSERT_EQ(1, value);
-}
-
-// Test proper JSON deserialization from string is working.
-TEST(JSONValueDeserializerTest, ReadProperJSONFromString) {
- // Try to deserialize it through the serializer.
- JSONStringValueDeserializer str_deserializer(kProperJSON);
-
- int error_code = 0;
- std::string error_message;
- std::unique_ptr<Value> value =
- str_deserializer.Deserialize(&error_code, &error_message);
- ASSERT_TRUE(value);
- ASSERT_EQ(0, error_code);
- ASSERT_TRUE(error_message.empty());
- // Verify if the same JSON is still there.
- CheckJSONIsStillTheSame(*value);
-}
-
-// Test proper JSON deserialization from a StringPiece substring.
-TEST(JSONValueDeserializerTest, ReadProperJSONFromStringPiece) {
- // Create a StringPiece for the substring of kProperJSONPadded that matches
- // kProperJSON.
- StringPiece proper_json(kProperJSONPadded);
- proper_json = proper_json.substr(5, proper_json.length() - 10);
- JSONStringValueDeserializer str_deserializer(proper_json);
-
- int error_code = 0;
- std::string error_message;
- std::unique_ptr<Value> value =
- str_deserializer.Deserialize(&error_code, &error_message);
- ASSERT_TRUE(value);
- ASSERT_EQ(0, error_code);
- ASSERT_TRUE(error_message.empty());
- // Verify if the same JSON is still there.
- CheckJSONIsStillTheSame(*value);
-}
-
-// Test that trialing commas are only properly deserialized from string when
-// the proper flag for that is set.
-TEST(JSONValueDeserializerTest, ReadJSONWithTrailingCommasFromString) {
- // Try to deserialize it through the serializer.
- JSONStringValueDeserializer str_deserializer(kProperJSONWithCommas);
-
- int error_code = 0;
- std::string error_message;
- std::unique_ptr<Value> value =
- str_deserializer.Deserialize(&error_code, &error_message);
- ASSERT_FALSE(value);
- ASSERT_NE(0, error_code);
- ASSERT_FALSE(error_message.empty());
- // Repeat with commas allowed.
- JSONStringValueDeserializer str_deserializer2(kProperJSONWithCommas,
- JSON_ALLOW_TRAILING_COMMAS);
- value = str_deserializer2.Deserialize(&error_code, &error_message);
- ASSERT_TRUE(value);
- ASSERT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
- // Verify if the same JSON is still there.
- CheckJSONIsStillTheSame(*value);
-}
-
-// Test proper JSON deserialization from file is working.
-TEST(JSONValueDeserializerTest, ReadProperJSONFromFile) {
- ScopedTempDir tempdir;
- ASSERT_TRUE(tempdir.CreateUniqueTempDir());
- // Write it down in the file.
- FilePath temp_file(tempdir.GetPath().AppendASCII("test.json"));
- ASSERT_EQ(static_cast<int>(strlen(kProperJSON)),
- WriteFile(temp_file, kProperJSON, strlen(kProperJSON)));
-
- // Try to deserialize it through the serializer.
- JSONFileValueDeserializer file_deserializer(temp_file);
-
- int error_code = 0;
- std::string error_message;
- std::unique_ptr<Value> value =
- file_deserializer.Deserialize(&error_code, &error_message);
- ASSERT_TRUE(value);
- ASSERT_EQ(0, error_code);
- ASSERT_TRUE(error_message.empty());
- // Verify if the same JSON is still there.
- CheckJSONIsStillTheSame(*value);
-}
-
-// Test that trialing commas are only properly deserialized from file when
-// the proper flag for that is set.
-TEST(JSONValueDeserializerTest, ReadJSONWithCommasFromFile) {
- ScopedTempDir tempdir;
- ASSERT_TRUE(tempdir.CreateUniqueTempDir());
- // Write it down in the file.
- FilePath temp_file(tempdir.GetPath().AppendASCII("test.json"));
- ASSERT_EQ(static_cast<int>(strlen(kProperJSONWithCommas)),
- WriteFile(temp_file, kProperJSONWithCommas,
- strlen(kProperJSONWithCommas)));
-
- // Try to deserialize it through the serializer.
- JSONFileValueDeserializer file_deserializer(temp_file);
- // This must fail without the proper flag.
- int error_code = 0;
- std::string error_message;
- std::unique_ptr<Value> value =
- file_deserializer.Deserialize(&error_code, &error_message);
- ASSERT_FALSE(value);
- ASSERT_NE(0, error_code);
- ASSERT_FALSE(error_message.empty());
- // Repeat with commas allowed.
- JSONFileValueDeserializer file_deserializer2(temp_file,
- JSON_ALLOW_TRAILING_COMMAS);
- value = file_deserializer2.Deserialize(&error_code, &error_message);
- ASSERT_TRUE(value);
- ASSERT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
- // Verify if the same JSON is still there.
- CheckJSONIsStillTheSame(*value);
-}
-
-TEST(JSONValueDeserializerTest, AllowTrailingComma) {
- static const char kTestWithCommas[] = "{\"key\": [true,],}";
- static const char kTestNoCommas[] = "{\"key\": [true]}";
-
- JSONStringValueDeserializer deserializer(kTestWithCommas,
- JSON_ALLOW_TRAILING_COMMAS);
- JSONStringValueDeserializer deserializer_expected(kTestNoCommas);
- std::unique_ptr<Value> root = deserializer.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(root);
- std::unique_ptr<Value> root_expected;
- root_expected = deserializer_expected.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(root_expected);
- ASSERT_TRUE(root->Equals(root_expected.get()));
-}
-
-TEST(JSONValueSerializerTest, Roundtrip) {
- static const char kOriginalSerialization[] =
- "{\"bool\":true,\"double\":3.14,\"int\":42,\"list\":[1,2],\"null\":null}";
- JSONStringValueDeserializer deserializer(kOriginalSerialization);
- std::unique_ptr<DictionaryValue> root_dict =
- DictionaryValue::From(deserializer.Deserialize(nullptr, nullptr));
- ASSERT_TRUE(root_dict);
-
- Value* null_value = nullptr;
- ASSERT_TRUE(root_dict->Get("null", &null_value));
- ASSERT_TRUE(null_value);
- ASSERT_TRUE(null_value->is_none());
-
- bool bool_value = false;
- ASSERT_TRUE(root_dict->GetBoolean("bool", &bool_value));
- ASSERT_TRUE(bool_value);
-
- int int_value = 0;
- ASSERT_TRUE(root_dict->GetInteger("int", &int_value));
- ASSERT_EQ(42, int_value);
-
- double double_value = 0.0;
- ASSERT_TRUE(root_dict->GetDouble("double", &double_value));
- ASSERT_DOUBLE_EQ(3.14, double_value);
-
- std::string test_serialization;
- JSONStringValueSerializer mutable_serializer(&test_serialization);
- ASSERT_TRUE(mutable_serializer.Serialize(*root_dict));
- ASSERT_EQ(kOriginalSerialization, test_serialization);
-
- mutable_serializer.set_pretty_print(true);
- ASSERT_TRUE(mutable_serializer.Serialize(*root_dict));
- // JSON output uses a different newline style on Windows than on other
- // platforms.
-#if defined(OS_WIN)
-#define JSON_NEWLINE "\r\n"
-#else
-#define JSON_NEWLINE "\n"
-#endif
- const std::string pretty_serialization =
- "{" JSON_NEWLINE
- " \"bool\": true," JSON_NEWLINE
- " \"double\": 3.14," JSON_NEWLINE
- " \"int\": 42," JSON_NEWLINE
- " \"list\": [ 1, 2 ]," JSON_NEWLINE
- " \"null\": null" JSON_NEWLINE
- "}" JSON_NEWLINE;
-#undef JSON_NEWLINE
- ASSERT_EQ(pretty_serialization, test_serialization);
-}
-
-TEST(JSONValueSerializerTest, StringEscape) {
- string16 all_chars;
- for (int i = 1; i < 256; ++i) {
- all_chars += static_cast<char16>(i);
- }
- // Generated in in Firefox using the following js (with an extra backslash for
- // double quote):
- // var s = '';
- // for (var i = 1; i < 256; ++i) { s += String.fromCharCode(i); }
- // uneval(s).replace(/\\/g, "\\\\");
- std::string all_chars_expected =
- "\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000B\\f\\r"
- "\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017"
- "\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F !\\\"#$%&'()*+,"
- "-./0123456789:;\\u003C=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcde"
- "fghijklmnopqrstuvwxyz{|}~\x7F\xC2\x80\xC2\x81\xC2\x82\xC2\x83\xC2\x84"
- "\xC2\x85\xC2\x86\xC2\x87\xC2\x88\xC2\x89\xC2\x8A\xC2\x8B\xC2\x8C\xC2\x8D"
- "\xC2\x8E\xC2\x8F\xC2\x90\xC2\x91\xC2\x92\xC2\x93\xC2\x94\xC2\x95\xC2\x96"
- "\xC2\x97\xC2\x98\xC2\x99\xC2\x9A\xC2\x9B\xC2\x9C\xC2\x9D\xC2\x9E\xC2\x9F"
- "\xC2\xA0\xC2\xA1\xC2\xA2\xC2\xA3\xC2\xA4\xC2\xA5\xC2\xA6\xC2\xA7\xC2\xA8"
- "\xC2\xA9\xC2\xAA\xC2\xAB\xC2\xAC\xC2\xAD\xC2\xAE\xC2\xAF\xC2\xB0\xC2\xB1"
- "\xC2\xB2\xC2\xB3\xC2\xB4\xC2\xB5\xC2\xB6\xC2\xB7\xC2\xB8\xC2\xB9\xC2\xBA"
- "\xC2\xBB\xC2\xBC\xC2\xBD\xC2\xBE\xC2\xBF\xC3\x80\xC3\x81\xC3\x82\xC3\x83"
- "\xC3\x84\xC3\x85\xC3\x86\xC3\x87\xC3\x88\xC3\x89\xC3\x8A\xC3\x8B\xC3\x8C"
- "\xC3\x8D\xC3\x8E\xC3\x8F\xC3\x90\xC3\x91\xC3\x92\xC3\x93\xC3\x94\xC3\x95"
- "\xC3\x96\xC3\x97\xC3\x98\xC3\x99\xC3\x9A\xC3\x9B\xC3\x9C\xC3\x9D\xC3\x9E"
- "\xC3\x9F\xC3\xA0\xC3\xA1\xC3\xA2\xC3\xA3\xC3\xA4\xC3\xA5\xC3\xA6\xC3\xA7"
- "\xC3\xA8\xC3\xA9\xC3\xAA\xC3\xAB\xC3\xAC\xC3\xAD\xC3\xAE\xC3\xAF\xC3\xB0"
- "\xC3\xB1\xC3\xB2\xC3\xB3\xC3\xB4\xC3\xB5\xC3\xB6\xC3\xB7\xC3\xB8\xC3\xB9"
- "\xC3\xBA\xC3\xBB\xC3\xBC\xC3\xBD\xC3\xBE\xC3\xBF";
-
- std::string expected_output = "{\"all_chars\":\"" + all_chars_expected +
- "\"}";
- // Test JSONWriter interface
- std::string output_js;
- DictionaryValue valueRoot;
- valueRoot.SetString("all_chars", all_chars);
- JSONWriter::Write(valueRoot, &output_js);
- ASSERT_EQ(expected_output, output_js);
-
- // Test JSONValueSerializer interface (uses JSONWriter).
- JSONStringValueSerializer serializer(&output_js);
- ASSERT_TRUE(serializer.Serialize(valueRoot));
- ASSERT_EQ(expected_output, output_js);
-}
-
-TEST(JSONValueSerializerTest, UnicodeStrings) {
- // unicode string json -> escaped ascii text
- DictionaryValue root;
- string16 test(WideToUTF16(L"\x7F51\x9875"));
- root.SetString("web", test);
-
- static const char kExpected[] = "{\"web\":\"\xE7\xBD\x91\xE9\xA1\xB5\"}";
-
- std::string actual;
- JSONStringValueSerializer serializer(&actual);
- ASSERT_TRUE(serializer.Serialize(root));
- ASSERT_EQ(kExpected, actual);
-
- // escaped ascii text -> json
- JSONStringValueDeserializer deserializer(kExpected);
- std::unique_ptr<Value> deserial_root =
- deserializer.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(deserial_root);
- DictionaryValue* dict_root =
- static_cast<DictionaryValue*>(deserial_root.get());
- string16 web_value;
- ASSERT_TRUE(dict_root->GetString("web", &web_value));
- ASSERT_EQ(test, web_value);
-}
-
-TEST(JSONValueSerializerTest, HexStrings) {
- // hex string json -> escaped ascii text
- DictionaryValue root;
- string16 test(WideToUTF16(L"\x01\x02"));
- root.SetString("test", test);
-
- static const char kExpected[] = "{\"test\":\"\\u0001\\u0002\"}";
-
- std::string actual;
- JSONStringValueSerializer serializer(&actual);
- ASSERT_TRUE(serializer.Serialize(root));
- ASSERT_EQ(kExpected, actual);
-
- // escaped ascii text -> json
- JSONStringValueDeserializer deserializer(kExpected);
- std::unique_ptr<Value> deserial_root =
- deserializer.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(deserial_root);
- DictionaryValue* dict_root =
- static_cast<DictionaryValue*>(deserial_root.get());
- string16 test_value;
- ASSERT_TRUE(dict_root->GetString("test", &test_value));
- ASSERT_EQ(test, test_value);
-
- // Test converting escaped regular chars
- static const char kEscapedChars[] = "{\"test\":\"\\u0067\\u006f\"}";
- JSONStringValueDeserializer deserializer2(kEscapedChars);
- deserial_root = deserializer2.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(deserial_root);
- dict_root = static_cast<DictionaryValue*>(deserial_root.get());
- ASSERT_TRUE(dict_root->GetString("test", &test_value));
- ASSERT_EQ(ASCIIToUTF16("go"), test_value);
-}
-
-TEST(JSONValueSerializerTest, JSONReaderComments) {
- ValidateJsonList("[ // 2, 3, ignore me ] \n1 ]");
- ValidateJsonList("[ /* 2, \n3, ignore me ]*/ \n1 ]");
- ValidateJsonList("//header\n[ // 2, \n// 3, \n1 ]// footer");
- ValidateJsonList("/*\n[ // 2, \n// 3, \n1 ]*/[1]");
- ValidateJsonList("[ 1 /* one */ ] /* end */");
- ValidateJsonList("[ 1 //// ,2\r\n ]");
-
- // It's ok to have a comment in a string.
- std::unique_ptr<ListValue> list =
- ListValue::From(JSONReader::Read("[\"// ok\\n /* foo */ \"]"));
- ASSERT_TRUE(list);
- ASSERT_EQ(1U, list->GetSize());
- Value* elt = nullptr;
- ASSERT_TRUE(list->Get(0, &elt));
- std::string value;
- ASSERT_TRUE(elt && elt->GetAsString(&value));
- ASSERT_EQ("// ok\n /* foo */ ", value);
-
- // You can't nest comments.
- ASSERT_FALSE(JSONReader::Read("/* /* inner */ outer */ [ 1 ]"));
-
- // Not a open comment token.
- ASSERT_FALSE(JSONReader::Read("/ * * / [1]"));
-}
-
-class JSONFileValueSerializerTest : public testing::Test {
- protected:
- void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
-
- ScopedTempDir temp_dir_;
-};
-
-TEST_F(JSONFileValueSerializerTest, Roundtrip) {
- FilePath original_file_path;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &original_file_path));
- original_file_path = original_file_path.AppendASCII("serializer_test.json");
-
- ASSERT_TRUE(PathExists(original_file_path));
-
- JSONFileValueDeserializer deserializer(original_file_path);
- std::unique_ptr<DictionaryValue> root_dict =
- DictionaryValue::From(deserializer.Deserialize(nullptr, nullptr));
- ASSERT_TRUE(root_dict);
-
- Value* null_value = nullptr;
- ASSERT_TRUE(root_dict->Get("null", &null_value));
- ASSERT_TRUE(null_value);
- ASSERT_TRUE(null_value->is_none());
-
- bool bool_value = false;
- ASSERT_TRUE(root_dict->GetBoolean("bool", &bool_value));
- ASSERT_TRUE(bool_value);
-
- int int_value = 0;
- ASSERT_TRUE(root_dict->GetInteger("int", &int_value));
- ASSERT_EQ(42, int_value);
-
- std::string string_value;
- ASSERT_TRUE(root_dict->GetString("string", &string_value));
- ASSERT_EQ("hello", string_value);
-
- // Now try writing.
- const FilePath written_file_path =
- temp_dir_.GetPath().AppendASCII("test_output.js");
-
- ASSERT_FALSE(PathExists(written_file_path));
- JSONFileValueSerializer serializer(written_file_path);
- ASSERT_TRUE(serializer.Serialize(*root_dict));
- ASSERT_TRUE(PathExists(written_file_path));
-
- // Now compare file contents.
- EXPECT_TRUE(TextContentsEqual(original_file_path, written_file_path));
- EXPECT_TRUE(DeleteFile(written_file_path, false));
-}
-
-TEST_F(JSONFileValueSerializerTest, RoundtripNested) {
- FilePath original_file_path;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &original_file_path));
- original_file_path =
- original_file_path.AppendASCII("serializer_nested_test.json");
-
- ASSERT_TRUE(PathExists(original_file_path));
-
- JSONFileValueDeserializer deserializer(original_file_path);
- std::unique_ptr<Value> root = deserializer.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(root);
-
- // Now try writing.
- FilePath written_file_path =
- temp_dir_.GetPath().AppendASCII("test_output.json");
-
- ASSERT_FALSE(PathExists(written_file_path));
- JSONFileValueSerializer serializer(written_file_path);
- ASSERT_TRUE(serializer.Serialize(*root));
- ASSERT_TRUE(PathExists(written_file_path));
-
- // Now compare file contents.
- EXPECT_TRUE(TextContentsEqual(original_file_path, written_file_path));
- EXPECT_TRUE(DeleteFile(written_file_path, false));
-}
-
-TEST_F(JSONFileValueSerializerTest, NoWhitespace) {
- FilePath source_file_path;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &source_file_path));
- source_file_path =
- source_file_path.AppendASCII("serializer_test_nowhitespace.json");
- ASSERT_TRUE(PathExists(source_file_path));
- JSONFileValueDeserializer deserializer(source_file_path);
- std::unique_ptr<Value> root = deserializer.Deserialize(nullptr, nullptr);
- ASSERT_TRUE(root);
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/json/json_writer_unittest.cc b/base/json/json_writer_unittest.cc
deleted file mode 100644
index b90c3ea..0000000
--- a/base/json/json_writer_unittest.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-// 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.
-
-#include "base/json/json_writer.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/values.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(JSONWriterTest, BasicTypes) {
- std::string output_js;
-
- // Test null.
- EXPECT_TRUE(JSONWriter::Write(Value(), &output_js));
- EXPECT_EQ("null", output_js);
-
- // Test empty dict.
- EXPECT_TRUE(JSONWriter::Write(DictionaryValue(), &output_js));
- EXPECT_EQ("{}", output_js);
-
- // Test empty list.
- EXPECT_TRUE(JSONWriter::Write(ListValue(), &output_js));
- EXPECT_EQ("[]", output_js);
-
- // Test integer values.
- EXPECT_TRUE(JSONWriter::Write(Value(42), &output_js));
- EXPECT_EQ("42", output_js);
-
- // Test boolean values.
- EXPECT_TRUE(JSONWriter::Write(Value(true), &output_js));
- EXPECT_EQ("true", output_js);
-
- // Test Real values should always have a decimal or an 'e'.
- EXPECT_TRUE(JSONWriter::Write(Value(1.0), &output_js));
- EXPECT_EQ("1.0", output_js);
-
- // Test Real values in the the range (-1, 1) must have leading zeros
- EXPECT_TRUE(JSONWriter::Write(Value(0.2), &output_js));
- EXPECT_EQ("0.2", output_js);
-
- // Test Real values in the the range (-1, 1) must have leading zeros
- EXPECT_TRUE(JSONWriter::Write(Value(-0.8), &output_js));
- EXPECT_EQ("-0.8", output_js);
-
- // Test String values.
- EXPECT_TRUE(JSONWriter::Write(Value("foo"), &output_js));
- EXPECT_EQ("\"foo\"", output_js);
-}
-
-TEST(JSONWriterTest, NestedTypes) {
- std::string output_js;
-
- // Writer unittests like empty list/dict nesting,
- // list list nesting, etc.
- DictionaryValue root_dict;
- std::unique_ptr<ListValue> list(new ListValue());
- std::unique_ptr<DictionaryValue> inner_dict(new DictionaryValue());
- inner_dict->SetInteger("inner int", 10);
- list->Append(std::move(inner_dict));
- list->Append(std::make_unique<ListValue>());
- list->AppendBoolean(true);
- root_dict.Set("list", std::move(list));
-
- // Test the pretty-printer.
- EXPECT_TRUE(JSONWriter::Write(root_dict, &output_js));
- EXPECT_EQ("{\"list\":[{\"inner int\":10},[],true]}", output_js);
- EXPECT_TRUE(JSONWriter::WriteWithOptions(
- root_dict, JSONWriter::OPTIONS_PRETTY_PRINT, &output_js));
-
- // The pretty-printer uses a different newline style on Windows than on
- // other platforms.
-#if defined(OS_WIN)
-#define JSON_NEWLINE "\r\n"
-#else
-#define JSON_NEWLINE "\n"
-#endif
- EXPECT_EQ("{" JSON_NEWLINE
- " \"list\": [ {" JSON_NEWLINE
- " \"inner int\": 10" JSON_NEWLINE
- " }, [ ], true ]" JSON_NEWLINE
- "}" JSON_NEWLINE,
- output_js);
-#undef JSON_NEWLINE
-}
-
-TEST(JSONWriterTest, KeysWithPeriods) {
- std::string output_js;
-
- DictionaryValue period_dict;
- period_dict.SetKey("a.b", base::Value(3));
- period_dict.SetKey("c", base::Value(2));
- std::unique_ptr<DictionaryValue> period_dict2(new DictionaryValue());
- period_dict2->SetKey("g.h.i.j", base::Value(1));
- period_dict.SetWithoutPathExpansion("d.e.f", std::move(period_dict2));
- EXPECT_TRUE(JSONWriter::Write(period_dict, &output_js));
- EXPECT_EQ("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}", output_js);
-
- DictionaryValue period_dict3;
- period_dict3.SetInteger("a.b", 2);
- period_dict3.SetKey("a.b", base::Value(1));
- EXPECT_TRUE(JSONWriter::Write(period_dict3, &output_js));
- EXPECT_EQ("{\"a\":{\"b\":2},\"a.b\":1}", output_js);
-}
-
-TEST(JSONWriterTest, BinaryValues) {
- std::string output_js;
-
- // Binary values should return errors unless suppressed via the
- // OPTIONS_OMIT_BINARY_VALUES flag.
- std::unique_ptr<Value> root(Value::CreateWithCopiedBuffer("asdf", 4));
- EXPECT_FALSE(JSONWriter::Write(*root, &output_js));
- EXPECT_TRUE(JSONWriter::WriteWithOptions(
- *root, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
- EXPECT_TRUE(output_js.empty());
-
- ListValue binary_list;
- binary_list.Append(Value::CreateWithCopiedBuffer("asdf", 4));
- binary_list.Append(std::make_unique<Value>(5));
- binary_list.Append(Value::CreateWithCopiedBuffer("asdf", 4));
- binary_list.Append(std::make_unique<Value>(2));
- binary_list.Append(Value::CreateWithCopiedBuffer("asdf", 4));
- EXPECT_FALSE(JSONWriter::Write(binary_list, &output_js));
- EXPECT_TRUE(JSONWriter::WriteWithOptions(
- binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
- EXPECT_EQ("[5,2]", output_js);
-
- DictionaryValue binary_dict;
- binary_dict.Set("a", Value::CreateWithCopiedBuffer("asdf", 4));
- binary_dict.SetInteger("b", 5);
- binary_dict.Set("c", Value::CreateWithCopiedBuffer("asdf", 4));
- binary_dict.SetInteger("d", 2);
- binary_dict.Set("e", Value::CreateWithCopiedBuffer("asdf", 4));
- EXPECT_FALSE(JSONWriter::Write(binary_dict, &output_js));
- EXPECT_TRUE(JSONWriter::WriteWithOptions(
- binary_dict, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
- EXPECT_EQ("{\"b\":5,\"d\":2}", output_js);
-}
-
-TEST(JSONWriterTest, DoublesAsInts) {
- std::string output_js;
-
- // Test allowing a double with no fractional part to be written as an integer.
- Value double_value(1e10);
- EXPECT_TRUE(JSONWriter::WriteWithOptions(
- double_value, JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
- &output_js));
- EXPECT_EQ("10000000000", output_js);
-}
-
-} // namespace base
diff --git a/base/json/string_escape_unittest.cc b/base/json/string_escape_unittest.cc
deleted file mode 100644
index 1e962c6..0000000
--- a/base/json/string_escape_unittest.cc
+++ /dev/null
@@ -1,189 +0,0 @@
-// 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 "base/json/string_escape.h"
-
-#include <stddef.h>
-
-#include "base/macros.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(JSONStringEscapeTest, EscapeUTF8) {
- const struct {
- const char* to_escape;
- const char* escaped;
- } cases[] = {
- {"\b\001aZ\"\\wee", "\\b\\u0001aZ\\\"\\\\wee"},
- {"a\b\f\n\r\t\v\1\\.\"z", "a\\b\\f\\n\\r\\t\\u000B\\u0001\\\\.\\\"z"},
- {"b\x0f\x7f\xf0\xff!", // \xf0\xff is not a valid UTF-8 unit.
- "b\\u000F\x7F\xEF\xBF\xBD\xEF\xBF\xBD!"},
- {"c<>d", "c\\u003C>d"},
- {"Hello\xe2\x80\xa8world", "Hello\\u2028world"},
- {"\xe2\x80\xa9purple", "\\u2029purple"},
- {"\xF3\xBF\xBF\xBF", "\xEF\xBF\xBD"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- const char* in_ptr = cases[i].to_escape;
- std::string in_str = in_ptr;
-
- std::string out;
- EscapeJSONString(in_ptr, false, &out);
- EXPECT_EQ(std::string(cases[i].escaped), out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- out.erase();
- bool convert_ok = EscapeJSONString(in_str, false, &out);
- EXPECT_EQ(std::string(cases[i].escaped), out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- if (convert_ok) {
- std::string fooout = GetQuotedJSONString(in_str);
- EXPECT_EQ("\"" + std::string(cases[i].escaped) + "\"", fooout);
- EXPECT_TRUE(IsStringUTF8(out));
- }
- }
-
- std::string in = cases[0].to_escape;
- std::string out;
- EscapeJSONString(in, false, &out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- // test quoting
- std::string out_quoted;
- EscapeJSONString(in, true, &out_quoted);
- EXPECT_EQ(out.length() + 2, out_quoted.length());
- EXPECT_EQ(out_quoted.find(out), 1U);
- EXPECT_TRUE(IsStringUTF8(out_quoted));
-
- // now try with a NULL in the string
- std::string null_prepend = "test";
- null_prepend.push_back(0);
- in = null_prepend + in;
- std::string expected = "test\\u0000";
- expected += cases[0].escaped;
- out.clear();
- EscapeJSONString(in, false, &out);
- EXPECT_EQ(expected, out);
- EXPECT_TRUE(IsStringUTF8(out));
-}
-
-TEST(JSONStringEscapeTest, EscapeUTF16) {
- const struct {
- const wchar_t* to_escape;
- const char* escaped;
- } cases[] = {
- {L"b\uffb1\u00ff", "b\xEF\xBE\xB1\xC3\xBF"},
- {L"\b\001aZ\"\\wee", "\\b\\u0001aZ\\\"\\\\wee"},
- {L"a\b\f\n\r\t\v\1\\.\"z",
- "a\\b\\f\\n\\r\\t\\u000B\\u0001\\\\.\\\"z"},
- {L"b\x0f\x7f\xf0\xff!", "b\\u000F\x7F\xC3\xB0\xC3\xBF!"},
- {L"c<>d", "c\\u003C>d"},
- {L"Hello\u2028world", "Hello\\u2028world"},
- {L"\u2029purple", "\\u2029purple"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- string16 in = WideToUTF16(cases[i].to_escape);
-
- std::string out;
- EscapeJSONString(in, false, &out);
- EXPECT_EQ(std::string(cases[i].escaped), out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- out = GetQuotedJSONString(in);
- EXPECT_EQ("\"" + std::string(cases[i].escaped) + "\"", out);
- EXPECT_TRUE(IsStringUTF8(out));
- }
-
- string16 in = WideToUTF16(cases[0].to_escape);
- std::string out;
- EscapeJSONString(in, false, &out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- // test quoting
- std::string out_quoted;
- EscapeJSONString(in, true, &out_quoted);
- EXPECT_EQ(out.length() + 2, out_quoted.length());
- EXPECT_EQ(out_quoted.find(out), 1U);
- EXPECT_TRUE(IsStringUTF8(out));
-
- // now try with a NULL in the string
- string16 null_prepend = WideToUTF16(L"test");
- null_prepend.push_back(0);
- in = null_prepend + in;
- std::string expected = "test\\u0000";
- expected += cases[0].escaped;
- out.clear();
- EscapeJSONString(in, false, &out);
- EXPECT_EQ(expected, out);
- EXPECT_TRUE(IsStringUTF8(out));
-}
-
-TEST(JSONStringEscapeTest, EscapeUTF16OutsideBMP) {
- {
- // {a, U+10300, !}, SMP.
- string16 test;
- test.push_back('a');
- test.push_back(0xD800);
- test.push_back(0xDF00);
- test.push_back('!');
- std::string actual;
- EXPECT_TRUE(EscapeJSONString(test, false, &actual));
- EXPECT_EQ("a\xF0\x90\x8C\x80!", actual);
- }
- {
- // {U+20021, U+2002B}, SIP.
- string16 test;
- test.push_back(0xD840);
- test.push_back(0xDC21);
- test.push_back(0xD840);
- test.push_back(0xDC2B);
- std::string actual;
- EXPECT_TRUE(EscapeJSONString(test, false, &actual));
- EXPECT_EQ("\xF0\xA0\x80\xA1\xF0\xA0\x80\xAB", actual);
- }
- {
- // {?, U+D800, @}, lone surrogate.
- string16 test;
- test.push_back('?');
- test.push_back(0xD800);
- test.push_back('@');
- std::string actual;
- EXPECT_FALSE(EscapeJSONString(test, false, &actual));
- EXPECT_EQ("?\xEF\xBF\xBD@", actual);
- }
-}
-
-TEST(JSONStringEscapeTest, EscapeBytes) {
- const struct {
- const char* to_escape;
- const char* escaped;
- } cases[] = {
- {"b\x0f\x7f\xf0\xff!", "b\\u000F\\u007F\\u00F0\\u00FF!"},
- {"\xe5\xc4\x4f\x05\xb6\xfd", "\\u00E5\\u00C4O\\u0005\\u00B6\\u00FD"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- std::string in = std::string(cases[i].to_escape);
- EXPECT_FALSE(IsStringUTF8(in));
-
- EXPECT_EQ(std::string(cases[i].escaped),
- EscapeBytesAsInvalidJSONString(in, false));
- EXPECT_EQ("\"" + std::string(cases[i].escaped) + "\"",
- EscapeBytesAsInvalidJSONString(in, true));
- }
-
- const char kEmbedNull[] = { '\xab', '\x39', '\0', '\x9f', '\xab' };
- std::string in(kEmbedNull, arraysize(kEmbedNull));
- EXPECT_FALSE(IsStringUTF8(in));
- EXPECT_EQ(std::string("\\u00AB9\\u0000\\u009F\\u00AB"),
- EscapeBytesAsInvalidJSONString(in, false));
-}
-
-} // namespace base
diff --git a/base/lazy_instance_unittest.cc b/base/lazy_instance_unittest.cc
deleted file mode 100644
index 242e8b5..0000000
--- a/base/lazy_instance_unittest.cc
+++ /dev/null
@@ -1,322 +0,0 @@
-// 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.
-
-#include <stddef.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/at_exit.h"
-#include "base/atomic_sequence_num.h"
-#include "base/atomicops.h"
-#include "base/barrier_closure.h"
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/sys_info.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-base::AtomicSequenceNumber constructed_seq_;
-base::AtomicSequenceNumber destructed_seq_;
-
-class ConstructAndDestructLogger {
- public:
- ConstructAndDestructLogger() {
- constructed_seq_.GetNext();
- }
- ~ConstructAndDestructLogger() {
- destructed_seq_.GetNext();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(ConstructAndDestructLogger);
-};
-
-class SlowConstructor {
- public:
- SlowConstructor() : some_int_(0) {
- // Sleep for 1 second to try to cause a race.
- base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
- ++constructed;
- some_int_ = 12;
- }
- int some_int() const { return some_int_; }
-
- static int constructed;
- private:
- int some_int_;
-
- DISALLOW_COPY_AND_ASSIGN(SlowConstructor);
-};
-
-// static
-int SlowConstructor::constructed = 0;
-
-class SlowDelegate : public base::DelegateSimpleThread::Delegate {
- public:
- explicit SlowDelegate(
- base::LazyInstance<SlowConstructor>::DestructorAtExit* lazy)
- : lazy_(lazy) {}
-
- void Run() override {
- EXPECT_EQ(12, lazy_->Get().some_int());
- EXPECT_EQ(12, lazy_->Pointer()->some_int());
- }
-
- private:
- base::LazyInstance<SlowConstructor>::DestructorAtExit* lazy_;
-
- DISALLOW_COPY_AND_ASSIGN(SlowDelegate);
-};
-
-} // namespace
-
-base::LazyInstance<ConstructAndDestructLogger>::DestructorAtExit lazy_logger =
- LAZY_INSTANCE_INITIALIZER;
-
-TEST(LazyInstanceTest, Basic) {
- {
- base::ShadowingAtExitManager shadow;
-
- EXPECT_FALSE(lazy_logger.IsCreated());
- EXPECT_EQ(0, constructed_seq_.GetNext());
- EXPECT_EQ(0, destructed_seq_.GetNext());
-
- lazy_logger.Get();
- EXPECT_TRUE(lazy_logger.IsCreated());
- EXPECT_EQ(2, constructed_seq_.GetNext());
- EXPECT_EQ(1, destructed_seq_.GetNext());
-
- lazy_logger.Pointer();
- EXPECT_TRUE(lazy_logger.IsCreated());
- EXPECT_EQ(3, constructed_seq_.GetNext());
- EXPECT_EQ(2, destructed_seq_.GetNext());
- }
- EXPECT_FALSE(lazy_logger.IsCreated());
- EXPECT_EQ(4, constructed_seq_.GetNext());
- EXPECT_EQ(4, destructed_seq_.GetNext());
-}
-
-base::LazyInstance<SlowConstructor>::DestructorAtExit lazy_slow =
- LAZY_INSTANCE_INITIALIZER;
-
-TEST(LazyInstanceTest, ConstructorThreadSafety) {
- {
- base::ShadowingAtExitManager shadow;
-
- SlowDelegate delegate(&lazy_slow);
- EXPECT_EQ(0, SlowConstructor::constructed);
-
- base::DelegateSimpleThreadPool pool("lazy_instance_cons", 5);
- pool.AddWork(&delegate, 20);
- EXPECT_EQ(0, SlowConstructor::constructed);
-
- pool.Start();
- pool.JoinAll();
- EXPECT_EQ(1, SlowConstructor::constructed);
- }
-}
-
-namespace {
-
-// DeleteLogger is an object which sets a flag when it's destroyed.
-// It accepts a bool* and sets the bool to true when the dtor runs.
-class DeleteLogger {
- public:
- DeleteLogger() : deleted_(nullptr) {}
- ~DeleteLogger() { *deleted_ = true; }
-
- void SetDeletedPtr(bool* deleted) {
- deleted_ = deleted;
- }
-
- private:
- bool* deleted_;
-};
-
-} // anonymous namespace
-
-TEST(LazyInstanceTest, LeakyLazyInstance) {
- // Check that using a plain LazyInstance causes the dtor to run
- // when the AtExitManager finishes.
- bool deleted1 = false;
- {
- base::ShadowingAtExitManager shadow;
- static base::LazyInstance<DeleteLogger>::DestructorAtExit test =
- LAZY_INSTANCE_INITIALIZER;
- test.Get().SetDeletedPtr(&deleted1);
- }
- EXPECT_TRUE(deleted1);
-
- // Check that using a *leaky* LazyInstance makes the dtor not run
- // when the AtExitManager finishes.
- bool deleted2 = false;
- {
- base::ShadowingAtExitManager shadow;
- static base::LazyInstance<DeleteLogger>::Leaky
- test = LAZY_INSTANCE_INITIALIZER;
- test.Get().SetDeletedPtr(&deleted2);
- }
- EXPECT_FALSE(deleted2);
-}
-
-namespace {
-
-template <size_t alignment>
-class AlignedData {
- public:
- AlignedData() = default;
- ~AlignedData() = default;
- alignas(alignment) char data_[alignment];
-};
-
-} // namespace
-
-#define EXPECT_ALIGNED(ptr, align) \
- EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
-
-TEST(LazyInstanceTest, Alignment) {
- using base::LazyInstance;
-
- // Create some static instances with increasing sizes and alignment
- // requirements. By ordering this way, the linker will need to do some work to
- // ensure proper alignment of the static data.
- static LazyInstance<AlignedData<4>>::DestructorAtExit align4 =
- LAZY_INSTANCE_INITIALIZER;
- static LazyInstance<AlignedData<32>>::DestructorAtExit align32 =
- LAZY_INSTANCE_INITIALIZER;
- static LazyInstance<AlignedData<4096>>::DestructorAtExit align4096 =
- LAZY_INSTANCE_INITIALIZER;
-
- EXPECT_ALIGNED(align4.Pointer(), 4);
- EXPECT_ALIGNED(align32.Pointer(), 32);
- EXPECT_ALIGNED(align4096.Pointer(), 4096);
-}
-
-namespace {
-
-// A class whose constructor busy-loops until it is told to complete
-// construction.
-class BlockingConstructor {
- public:
- BlockingConstructor() {
- EXPECT_FALSE(WasConstructorCalled());
- base::subtle::NoBarrier_Store(&constructor_called_, 1);
- EXPECT_TRUE(WasConstructorCalled());
- while (!base::subtle::NoBarrier_Load(&complete_construction_))
- base::PlatformThread::YieldCurrentThread();
- done_construction_ = true;
- }
-
- ~BlockingConstructor() {
- // Restore static state for the next test.
- base::subtle::NoBarrier_Store(&constructor_called_, 0);
- base::subtle::NoBarrier_Store(&complete_construction_, 0);
- }
-
- // Returns true if BlockingConstructor() was entered.
- static bool WasConstructorCalled() {
- return base::subtle::NoBarrier_Load(&constructor_called_);
- }
-
- // Instructs BlockingConstructor() that it may now unblock its construction.
- static void CompleteConstructionNow() {
- base::subtle::NoBarrier_Store(&complete_construction_, 1);
- }
-
- bool done_construction() { return done_construction_; }
-
- private:
- // Use Atomic32 instead of AtomicFlag for them to be trivially initialized.
- static base::subtle::Atomic32 constructor_called_;
- static base::subtle::Atomic32 complete_construction_;
-
- bool done_construction_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(BlockingConstructor);
-};
-
-// A SimpleThread running at |thread_priority| which invokes |before_get|
-// (optional) and then invokes Get() on the LazyInstance it's assigned.
-class BlockingConstructorThread : public base::SimpleThread {
- public:
- BlockingConstructorThread(
- base::ThreadPriority thread_priority,
- base::LazyInstance<BlockingConstructor>::DestructorAtExit* lazy,
- base::OnceClosure before_get)
- : SimpleThread("BlockingConstructorThread", Options(thread_priority)),
- lazy_(lazy),
- before_get_(std::move(before_get)) {}
-
- void Run() override {
- if (before_get_)
- std::move(before_get_).Run();
- EXPECT_TRUE(lazy_->Get().done_construction());
- }
-
- private:
- base::LazyInstance<BlockingConstructor>::DestructorAtExit* lazy_;
- base::OnceClosure before_get_;
-
- DISALLOW_COPY_AND_ASSIGN(BlockingConstructorThread);
-};
-
-// static
-base::subtle::Atomic32 BlockingConstructor::constructor_called_ = 0;
-// static
-base::subtle::Atomic32 BlockingConstructor::complete_construction_ = 0;
-
-base::LazyInstance<BlockingConstructor>::DestructorAtExit lazy_blocking =
- LAZY_INSTANCE_INITIALIZER;
-
-} // namespace
-
-// Tests that if the thread assigned to construct the LazyInstance runs at
-// background priority : the foreground threads will yield to it enough for it
-// to eventually complete construction.
-// This is a regression test for https://crbug.com/797129.
-TEST(LazyInstanceTest, PriorityInversionAtInitializationResolves) {
- base::TimeTicks test_begin = base::TimeTicks::Now();
-
- // Construct BlockingConstructor from a background thread.
- BlockingConstructorThread background_getter(
- base::ThreadPriority::BACKGROUND, &lazy_blocking, base::OnceClosure());
- background_getter.Start();
-
- while (!BlockingConstructor::WasConstructorCalled())
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
-
- // Spin 4 foreground thread per core contending to get the already under
- // construction LazyInstance. When they are all running and poking at it :
- // allow the background thread to complete its work.
- const int kNumForegroundThreads = 4 * base::SysInfo::NumberOfProcessors();
- std::vector<std::unique_ptr<base::SimpleThread>> foreground_threads;
- base::RepeatingClosure foreground_thread_ready_callback =
- base::BarrierClosure(
- kNumForegroundThreads,
- base::BindOnce(&BlockingConstructor::CompleteConstructionNow));
- for (int i = 0; i < kNumForegroundThreads; ++i) {
- foreground_threads.push_back(std::make_unique<BlockingConstructorThread>(
- base::ThreadPriority::NORMAL, &lazy_blocking,
- foreground_thread_ready_callback));
- foreground_threads.back()->Start();
- }
-
- // This test will hang if the foreground threads become stuck in
- // LazyInstance::Get() per the background thread never being scheduled to
- // complete construction.
- for (auto& foreground_thread : foreground_threads)
- foreground_thread->Join();
- background_getter.Join();
-
- // Fail if this test takes more than 5 seconds (it takes 5-10 seconds on a
- // Z840 without r527445 but is expected to be fast (~30ms) with the fix).
- EXPECT_LT(base::TimeTicks::Now() - test_begin,
- base::TimeDelta::FromSeconds(5));
-}
diff --git a/base/logging_unittest.cc b/base/logging_unittest.cc
deleted file mode 100644
index 0264012..0000000
--- a/base/logging_unittest.cc
+++ /dev/null
@@ -1,676 +0,0 @@
-// Copyright (c) 2011 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 "base/logging.h"
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/test/scoped_feature_list.h"
-#include "build_config.h"
-
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include <signal.h>
-#include <unistd.h>
-#include "base/posix/eintr_wrapper.h"
-#endif // OS_POSIX
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#include <ucontext.h>
-#endif
-
-#if defined(OS_WIN)
-#include <excpt.h>
-#include <windows.h>
-#endif // OS_WIN
-
-#if defined(OS_FUCHSIA)
-#include "base/fuchsia/fuchsia_logging.h"
-#endif
-
-namespace logging {
-
-namespace {
-
-using ::testing::Return;
-using ::testing::_;
-
-// Needs to be global since log assert handlers can't maintain state.
-int g_log_sink_call_count = 0;
-
-#if !defined(OFFICIAL_BUILD) || defined(DCHECK_ALWAYS_ON) || !defined(NDEBUG)
-void LogSink(const char* file,
- int line,
- const base::StringPiece message,
- const base::StringPiece stack_trace) {
- ++g_log_sink_call_count;
-}
-#endif
-
-// Class to make sure any manipulations we do to the min log level are
-// contained (i.e., do not affect other unit tests).
-class LogStateSaver {
- public:
- LogStateSaver() : old_min_log_level_(GetMinLogLevel()) {}
-
- ~LogStateSaver() {
- SetMinLogLevel(old_min_log_level_);
- g_log_sink_call_count = 0;
- }
-
- private:
- int old_min_log_level_;
-
- DISALLOW_COPY_AND_ASSIGN(LogStateSaver);
-};
-
-class LoggingTest : public testing::Test {
- private:
- LogStateSaver log_state_saver_;
-};
-
-class MockLogSource {
- public:
- MOCK_METHOD0(Log, const char*());
-};
-
-class MockLogAssertHandler {
- public:
- MOCK_METHOD4(
- HandleLogAssert,
- void(const char*, int, const base::StringPiece, const base::StringPiece));
-};
-
-TEST_F(LoggingTest, BasicLogging) {
- MockLogSource mock_log_source;
- EXPECT_CALL(mock_log_source, Log())
- .Times(DCHECK_IS_ON() ? 16 : 8)
- .WillRepeatedly(Return("log message"));
-
- SetMinLogLevel(LOG_INFO);
-
- EXPECT_TRUE(LOG_IS_ON(INFO));
- EXPECT_TRUE((DCHECK_IS_ON() != 0) == DLOG_IS_ON(INFO));
- EXPECT_TRUE(VLOG_IS_ON(0));
-
- LOG(INFO) << mock_log_source.Log();
- LOG_IF(INFO, true) << mock_log_source.Log();
- PLOG(INFO) << mock_log_source.Log();
- PLOG_IF(INFO, true) << mock_log_source.Log();
- VLOG(0) << mock_log_source.Log();
- VLOG_IF(0, true) << mock_log_source.Log();
- VPLOG(0) << mock_log_source.Log();
- VPLOG_IF(0, true) << mock_log_source.Log();
-
- DLOG(INFO) << mock_log_source.Log();
- DLOG_IF(INFO, true) << mock_log_source.Log();
- DPLOG(INFO) << mock_log_source.Log();
- DPLOG_IF(INFO, true) << mock_log_source.Log();
- DVLOG(0) << mock_log_source.Log();
- DVLOG_IF(0, true) << mock_log_source.Log();
- DVPLOG(0) << mock_log_source.Log();
- DVPLOG_IF(0, true) << mock_log_source.Log();
-}
-
-TEST_F(LoggingTest, LogIsOn) {
-#if defined(NDEBUG)
- const bool kDfatalIsFatal = false;
-#else // defined(NDEBUG)
- const bool kDfatalIsFatal = true;
-#endif // defined(NDEBUG)
-
- SetMinLogLevel(LOG_INFO);
- EXPECT_TRUE(LOG_IS_ON(INFO));
- EXPECT_TRUE(LOG_IS_ON(WARNING));
- EXPECT_TRUE(LOG_IS_ON(ERROR));
- EXPECT_TRUE(LOG_IS_ON(FATAL));
- EXPECT_TRUE(LOG_IS_ON(DFATAL));
-
- SetMinLogLevel(LOG_WARNING);
- EXPECT_FALSE(LOG_IS_ON(INFO));
- EXPECT_TRUE(LOG_IS_ON(WARNING));
- EXPECT_TRUE(LOG_IS_ON(ERROR));
- EXPECT_TRUE(LOG_IS_ON(FATAL));
- EXPECT_TRUE(LOG_IS_ON(DFATAL));
-
- SetMinLogLevel(LOG_ERROR);
- EXPECT_FALSE(LOG_IS_ON(INFO));
- EXPECT_FALSE(LOG_IS_ON(WARNING));
- EXPECT_TRUE(LOG_IS_ON(ERROR));
- EXPECT_TRUE(LOG_IS_ON(FATAL));
- EXPECT_TRUE(LOG_IS_ON(DFATAL));
-
- // LOG_IS_ON(FATAL) should always be true.
- SetMinLogLevel(LOG_FATAL + 1);
- EXPECT_FALSE(LOG_IS_ON(INFO));
- EXPECT_FALSE(LOG_IS_ON(WARNING));
- EXPECT_FALSE(LOG_IS_ON(ERROR));
- EXPECT_TRUE(LOG_IS_ON(FATAL));
- EXPECT_EQ(kDfatalIsFatal, LOG_IS_ON(DFATAL));
-}
-
-TEST_F(LoggingTest, LoggingIsLazyBySeverity) {
- MockLogSource mock_log_source;
- EXPECT_CALL(mock_log_source, Log()).Times(0);
-
- SetMinLogLevel(LOG_WARNING);
-
- EXPECT_FALSE(LOG_IS_ON(INFO));
- EXPECT_FALSE(DLOG_IS_ON(INFO));
- EXPECT_FALSE(VLOG_IS_ON(1));
-
- LOG(INFO) << mock_log_source.Log();
- LOG_IF(INFO, false) << mock_log_source.Log();
- PLOG(INFO) << mock_log_source.Log();
- PLOG_IF(INFO, false) << mock_log_source.Log();
- VLOG(1) << mock_log_source.Log();
- VLOG_IF(1, true) << mock_log_source.Log();
- VPLOG(1) << mock_log_source.Log();
- VPLOG_IF(1, true) << mock_log_source.Log();
-
- DLOG(INFO) << mock_log_source.Log();
- DLOG_IF(INFO, true) << mock_log_source.Log();
- DPLOG(INFO) << mock_log_source.Log();
- DPLOG_IF(INFO, true) << mock_log_source.Log();
- DVLOG(1) << mock_log_source.Log();
- DVLOG_IF(1, true) << mock_log_source.Log();
- DVPLOG(1) << mock_log_source.Log();
- DVPLOG_IF(1, true) << mock_log_source.Log();
-}
-
-TEST_F(LoggingTest, LoggingIsLazyByDestination) {
- MockLogSource mock_log_source;
- MockLogSource mock_log_source_error;
- EXPECT_CALL(mock_log_source, Log()).Times(0);
-
- // Severity >= ERROR is always printed to stderr.
- EXPECT_CALL(mock_log_source_error, Log()).Times(1).
- WillRepeatedly(Return("log message"));
-
- LoggingSettings settings;
- settings.logging_dest = LOG_NONE;
- InitLogging(settings);
-
- LOG(INFO) << mock_log_source.Log();
- LOG(WARNING) << mock_log_source.Log();
- LOG(ERROR) << mock_log_source_error.Log();
-}
-
-// Official builds have CHECKs directly call BreakDebugger.
-#if !defined(OFFICIAL_BUILD)
-
-// https://crbug.com/709067 tracks test flakiness on iOS.
-#if defined(OS_IOS)
-#define MAYBE_CheckStreamsAreLazy DISABLED_CheckStreamsAreLazy
-#else
-#define MAYBE_CheckStreamsAreLazy CheckStreamsAreLazy
-#endif
-TEST_F(LoggingTest, MAYBE_CheckStreamsAreLazy) {
- MockLogSource mock_log_source, uncalled_mock_log_source;
- EXPECT_CALL(mock_log_source, Log()).Times(8).
- WillRepeatedly(Return("check message"));
- EXPECT_CALL(uncalled_mock_log_source, Log()).Times(0);
-
- ScopedLogAssertHandler scoped_assert_handler(base::Bind(LogSink));
-
- CHECK(mock_log_source.Log()) << uncalled_mock_log_source.Log();
- PCHECK(!mock_log_source.Log()) << mock_log_source.Log();
- CHECK_EQ(mock_log_source.Log(), mock_log_source.Log())
- << uncalled_mock_log_source.Log();
- CHECK_NE(mock_log_source.Log(), mock_log_source.Log())
- << mock_log_source.Log();
-}
-
-#endif
-
-#if defined(OFFICIAL_BUILD) && defined(OS_WIN)
-NOINLINE void CheckContainingFunc(int death_location) {
- CHECK(death_location != 1);
- CHECK(death_location != 2);
- CHECK(death_location != 3);
-}
-
-int GetCheckExceptionData(EXCEPTION_POINTERS* p, DWORD* code, void** addr) {
- *code = p->ExceptionRecord->ExceptionCode;
- *addr = p->ExceptionRecord->ExceptionAddress;
- return EXCEPTION_EXECUTE_HANDLER;
-}
-
-TEST_F(LoggingTest, CheckCausesDistinctBreakpoints) {
- DWORD code1 = 0;
- DWORD code2 = 0;
- DWORD code3 = 0;
- void* addr1 = nullptr;
- void* addr2 = nullptr;
- void* addr3 = nullptr;
-
- // Record the exception code and addresses.
- __try {
- CheckContainingFunc(1);
- } __except (
- GetCheckExceptionData(GetExceptionInformation(), &code1, &addr1)) {
- }
-
- __try {
- CheckContainingFunc(2);
- } __except (
- GetCheckExceptionData(GetExceptionInformation(), &code2, &addr2)) {
- }
-
- __try {
- CheckContainingFunc(3);
- } __except (
- GetCheckExceptionData(GetExceptionInformation(), &code3, &addr3)) {
- }
-
- // Ensure that the exception codes are correct (in particular, breakpoints,
- // not access violations).
- EXPECT_EQ(STATUS_BREAKPOINT, code1);
- EXPECT_EQ(STATUS_BREAKPOINT, code2);
- EXPECT_EQ(STATUS_BREAKPOINT, code3);
-
- // Ensure that none of the CHECKs are colocated.
- EXPECT_NE(addr1, addr2);
- EXPECT_NE(addr1, addr3);
- EXPECT_NE(addr2, addr3);
-}
-
-#elif defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_IOS) && \
- !defined(OS_FUCHSIA) && \
- (defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM_FAMILY))
-
-int g_child_crash_pipe;
-
-void CheckCrashTestSighandler(int, siginfo_t* info, void* context_ptr) {
- // Conversely to what clearly stated in "man 2 sigaction", some Linux kernels
- // do NOT populate the |info->si_addr| in the case of a SIGTRAP. Hence we
- // need the arch-specific boilerplate below, which is inspired by breakpad.
- // At the same time, on OSX, ucontext.h is deprecated but si_addr works fine.
- uintptr_t crash_addr = 0;
-#if defined(OS_MACOSX)
- crash_addr = reinterpret_cast<uintptr_t>(info->si_addr);
-#else // OS_POSIX && !OS_MACOSX
- ucontext_t* context = reinterpret_cast<ucontext_t*>(context_ptr);
-#if defined(ARCH_CPU_X86)
- crash_addr = static_cast<uintptr_t>(context->uc_mcontext.gregs[REG_EIP]);
-#elif defined(ARCH_CPU_X86_64)
- crash_addr = static_cast<uintptr_t>(context->uc_mcontext.gregs[REG_RIP]);
-#elif defined(ARCH_CPU_ARMEL)
- crash_addr = static_cast<uintptr_t>(context->uc_mcontext.arm_pc);
-#elif defined(ARCH_CPU_ARM64)
- crash_addr = static_cast<uintptr_t>(context->uc_mcontext.pc);
-#endif // ARCH_*
-#endif // OS_POSIX && !OS_MACOSX
- HANDLE_EINTR(write(g_child_crash_pipe, &crash_addr, sizeof(uintptr_t)));
- _exit(0);
-}
-
-// CHECK causes a direct crash (without jumping to another function) only in
-// official builds. Unfortunately, continuous test coverage on official builds
-// is lower. DO_CHECK here falls back on a home-brewed implementation in
-// non-official builds, to catch regressions earlier in the CQ.
-#if defined(OFFICIAL_BUILD)
-#define DO_CHECK CHECK
-#else
-#define DO_CHECK(cond) \
- if (!(cond)) \
- IMMEDIATE_CRASH()
-#endif
-
-void CrashChildMain(int death_location) {
- struct sigaction act = {};
- act.sa_sigaction = CheckCrashTestSighandler;
- act.sa_flags = SA_SIGINFO;
- ASSERT_EQ(0, sigaction(SIGTRAP, &act, nullptr));
- ASSERT_EQ(0, sigaction(SIGBUS, &act, nullptr));
- ASSERT_EQ(0, sigaction(SIGILL, &act, nullptr));
- DO_CHECK(death_location != 1);
- DO_CHECK(death_location != 2);
- printf("\n");
- DO_CHECK(death_location != 3);
-
- // Should never reach this point.
- const uintptr_t failed = 0;
- HANDLE_EINTR(write(g_child_crash_pipe, &failed, sizeof(uintptr_t)));
-};
-
-void SpawnChildAndCrash(int death_location, uintptr_t* child_crash_addr) {
- int pipefd[2];
- ASSERT_EQ(0, pipe(pipefd));
-
- int pid = fork();
- ASSERT_GE(pid, 0);
-
- if (pid == 0) { // child process.
- close(pipefd[0]); // Close reader (parent) end.
- g_child_crash_pipe = pipefd[1];
- CrashChildMain(death_location);
- FAIL() << "The child process was supposed to crash. It didn't.";
- }
-
- close(pipefd[1]); // Close writer (child) end.
- DCHECK(child_crash_addr);
- int res = HANDLE_EINTR(read(pipefd[0], child_crash_addr, sizeof(uintptr_t)));
- ASSERT_EQ(static_cast<int>(sizeof(uintptr_t)), res);
-}
-
-TEST_F(LoggingTest, CheckCausesDistinctBreakpoints) {
- uintptr_t child_crash_addr_1 = 0;
- uintptr_t child_crash_addr_2 = 0;
- uintptr_t child_crash_addr_3 = 0;
-
- SpawnChildAndCrash(1, &child_crash_addr_1);
- SpawnChildAndCrash(2, &child_crash_addr_2);
- SpawnChildAndCrash(3, &child_crash_addr_3);
-
- ASSERT_NE(0u, child_crash_addr_1);
- ASSERT_NE(0u, child_crash_addr_2);
- ASSERT_NE(0u, child_crash_addr_3);
- ASSERT_NE(child_crash_addr_1, child_crash_addr_2);
- ASSERT_NE(child_crash_addr_1, child_crash_addr_3);
- ASSERT_NE(child_crash_addr_2, child_crash_addr_3);
-}
-#endif // OS_POSIX
-
-TEST_F(LoggingTest, DebugLoggingReleaseBehavior) {
-#if DCHECK_IS_ON()
- int debug_only_variable = 1;
-#endif
- // These should avoid emitting references to |debug_only_variable|
- // in release mode.
- DLOG_IF(INFO, debug_only_variable) << "test";
- DLOG_ASSERT(debug_only_variable) << "test";
- DPLOG_IF(INFO, debug_only_variable) << "test";
- DVLOG_IF(1, debug_only_variable) << "test";
-}
-
-TEST_F(LoggingTest, DcheckStreamsAreLazy) {
- MockLogSource mock_log_source;
- EXPECT_CALL(mock_log_source, Log()).Times(0);
-#if DCHECK_IS_ON()
- DCHECK(true) << mock_log_source.Log();
- DCHECK_EQ(0, 0) << mock_log_source.Log();
-#else
- DCHECK(mock_log_source.Log()) << mock_log_source.Log();
- DPCHECK(mock_log_source.Log()) << mock_log_source.Log();
- DCHECK_EQ(0, 0) << mock_log_source.Log();
- DCHECK_EQ(mock_log_source.Log(), static_cast<const char*>(nullptr))
- << mock_log_source.Log();
-#endif
-}
-
-void DcheckEmptyFunction1() {
- // Provide a body so that Release builds do not cause the compiler to
- // optimize DcheckEmptyFunction1 and DcheckEmptyFunction2 as a single
- // function, which breaks the Dcheck tests below.
- LOG(INFO) << "DcheckEmptyFunction1";
-}
-void DcheckEmptyFunction2() {}
-
-#if DCHECK_IS_CONFIGURABLE
-class ScopedDcheckSeverity {
- public:
- ScopedDcheckSeverity(LogSeverity new_severity) : old_severity_(LOG_DCHECK) {
- LOG_DCHECK = new_severity;
- }
-
- ~ScopedDcheckSeverity() { LOG_DCHECK = old_severity_; }
-
- private:
- LogSeverity old_severity_;
-};
-#endif // DCHECK_IS_CONFIGURABLE
-
-// https://crbug.com/709067 tracks test flakiness on iOS.
-#if defined(OS_IOS)
-#define MAYBE_Dcheck DISABLED_Dcheck
-#else
-#define MAYBE_Dcheck Dcheck
-#endif
-TEST_F(LoggingTest, MAYBE_Dcheck) {
-#if DCHECK_IS_CONFIGURABLE
- // DCHECKs are enabled, and LOG_DCHECK is mutable, but defaults to non-fatal.
- // Set it to LOG_FATAL to get the expected behavior from the rest of this
- // test.
- ScopedDcheckSeverity dcheck_severity(LOG_FATAL);
-#endif // DCHECK_IS_CONFIGURABLE
-
-#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
- // Release build.
- EXPECT_FALSE(DCHECK_IS_ON());
- EXPECT_FALSE(DLOG_IS_ON(DCHECK));
-#elif defined(NDEBUG) && defined(DCHECK_ALWAYS_ON)
- // Release build with real DCHECKS.
- ScopedLogAssertHandler scoped_assert_handler(base::Bind(LogSink));
- EXPECT_TRUE(DCHECK_IS_ON());
- EXPECT_TRUE(DLOG_IS_ON(DCHECK));
-#else
- // Debug build.
- ScopedLogAssertHandler scoped_assert_handler(base::Bind(LogSink));
- EXPECT_TRUE(DCHECK_IS_ON());
- EXPECT_TRUE(DLOG_IS_ON(DCHECK));
-#endif
-
- // DCHECKs are fatal iff they're compiled in DCHECK_IS_ON() and the DCHECK
- // log level is set to fatal.
- const bool dchecks_are_fatal = DCHECK_IS_ON() && LOG_DCHECK == LOG_FATAL;
- EXPECT_EQ(0, g_log_sink_call_count);
- DCHECK(false);
- EXPECT_EQ(dchecks_are_fatal ? 1 : 0, g_log_sink_call_count);
- DPCHECK(false);
- EXPECT_EQ(dchecks_are_fatal ? 2 : 0, g_log_sink_call_count);
- DCHECK_EQ(0, 1);
- EXPECT_EQ(dchecks_are_fatal ? 3 : 0, g_log_sink_call_count);
-
- // Test DCHECK on std::nullptr_t
- g_log_sink_call_count = 0;
- const void* p_null = nullptr;
- const void* p_not_null = &p_null;
- DCHECK_EQ(p_null, nullptr);
- DCHECK_EQ(nullptr, p_null);
- DCHECK_NE(p_not_null, nullptr);
- DCHECK_NE(nullptr, p_not_null);
- EXPECT_EQ(0, g_log_sink_call_count);
-
- // Test DCHECK on a scoped enum.
- enum class Animal { DOG, CAT };
- DCHECK_EQ(Animal::DOG, Animal::DOG);
- EXPECT_EQ(0, g_log_sink_call_count);
- DCHECK_EQ(Animal::DOG, Animal::CAT);
- EXPECT_EQ(dchecks_are_fatal ? 1 : 0, g_log_sink_call_count);
-
- // Test DCHECK on functions and function pointers.
- g_log_sink_call_count = 0;
- struct MemberFunctions {
- void MemberFunction1() {
- // See the comment in DcheckEmptyFunction1().
- LOG(INFO) << "Do not merge with MemberFunction2.";
- }
- void MemberFunction2() {}
- };
- void (MemberFunctions::*mp1)() = &MemberFunctions::MemberFunction1;
- void (MemberFunctions::*mp2)() = &MemberFunctions::MemberFunction2;
- void (*fp1)() = DcheckEmptyFunction1;
- void (*fp2)() = DcheckEmptyFunction2;
- void (*fp3)() = DcheckEmptyFunction1;
- DCHECK_EQ(fp1, fp3);
- EXPECT_EQ(0, g_log_sink_call_count);
- DCHECK_EQ(mp1, &MemberFunctions::MemberFunction1);
- EXPECT_EQ(0, g_log_sink_call_count);
- DCHECK_EQ(mp2, &MemberFunctions::MemberFunction2);
- EXPECT_EQ(0, g_log_sink_call_count);
- DCHECK_EQ(fp1, fp2);
- EXPECT_EQ(dchecks_are_fatal ? 1 : 0, g_log_sink_call_count);
- DCHECK_EQ(mp2, &MemberFunctions::MemberFunction1);
- EXPECT_EQ(dchecks_are_fatal ? 2 : 0, g_log_sink_call_count);
-}
-
-TEST_F(LoggingTest, DcheckReleaseBehavior) {
- int some_variable = 1;
- // These should still reference |some_variable| so we don't get
- // unused variable warnings.
- DCHECK(some_variable) << "test";
- DPCHECK(some_variable) << "test";
- DCHECK_EQ(some_variable, 1) << "test";
-}
-
-TEST_F(LoggingTest, DCheckEqStatements) {
- bool reached = false;
- if (false)
- DCHECK_EQ(false, true); // Unreached.
- else
- DCHECK_EQ(true, reached = true); // Reached, passed.
- ASSERT_EQ(DCHECK_IS_ON() ? true : false, reached);
-
- if (false)
- DCHECK_EQ(false, true); // Unreached.
-}
-
-TEST_F(LoggingTest, CheckEqStatements) {
- bool reached = false;
- if (false)
- CHECK_EQ(false, true); // Unreached.
- else
- CHECK_EQ(true, reached = true); // Reached, passed.
- ASSERT_TRUE(reached);
-
- if (false)
- CHECK_EQ(false, true); // Unreached.
-}
-
-TEST_F(LoggingTest, NestedLogAssertHandlers) {
- ::testing::InSequence dummy;
- ::testing::StrictMock<MockLogAssertHandler> handler_a, handler_b;
-
- EXPECT_CALL(
- handler_a,
- HandleLogAssert(
- _, _, base::StringPiece("First assert must be caught by handler_a"),
- _));
- EXPECT_CALL(
- handler_b,
- HandleLogAssert(
- _, _, base::StringPiece("Second assert must be caught by handler_b"),
- _));
- EXPECT_CALL(
- handler_a,
- HandleLogAssert(
- _, _,
- base::StringPiece("Last assert must be caught by handler_a again"),
- _));
-
- logging::ScopedLogAssertHandler scoped_handler_a(base::Bind(
- &MockLogAssertHandler::HandleLogAssert, base::Unretained(&handler_a)));
-
- // Using LOG(FATAL) rather than CHECK(false) here since log messages aren't
- // preserved for CHECKs in official builds.
- LOG(FATAL) << "First assert must be caught by handler_a";
-
- {
- logging::ScopedLogAssertHandler scoped_handler_b(base::Bind(
- &MockLogAssertHandler::HandleLogAssert, base::Unretained(&handler_b)));
- LOG(FATAL) << "Second assert must be caught by handler_b";
- }
-
- LOG(FATAL) << "Last assert must be caught by handler_a again";
-}
-
-// Test that defining an operator<< for a type in a namespace doesn't prevent
-// other code in that namespace from calling the operator<<(ostream, wstring)
-// defined by logging.h. This can fail if operator<<(ostream, wstring) can't be
-// found by ADL, since defining another operator<< prevents name lookup from
-// looking in the global namespace.
-namespace nested_test {
- class Streamable {};
- ALLOW_UNUSED_TYPE std::ostream& operator<<(std::ostream& out,
- const Streamable&) {
- return out << "Streamable";
- }
- TEST_F(LoggingTest, StreamingWstringFindsCorrectOperator) {
- std::wstring wstr = L"Hello World";
- std::ostringstream ostr;
- ostr << wstr;
- EXPECT_EQ("Hello World", ostr.str());
- }
-} // namespace nested_test
-
-#if DCHECK_IS_CONFIGURABLE
-TEST_F(LoggingTest, ConfigurableDCheck) {
- // Verify that DCHECKs default to non-fatal in configurable-DCHECK builds.
- // Note that we require only that DCHECK is non-fatal by default, rather
- // than requiring that it be exactly INFO, ERROR, etc level.
- EXPECT_LT(LOG_DCHECK, LOG_FATAL);
- DCHECK(false);
-
- // Verify that DCHECK* aren't hard-wired to crash on failure.
- LOG_DCHECK = LOG_INFO;
- DCHECK(false);
- DCHECK_EQ(1, 2);
-
- // Verify that DCHECK does crash if LOG_DCHECK is set to LOG_FATAL.
- LOG_DCHECK = LOG_FATAL;
-
- ::testing::StrictMock<MockLogAssertHandler> handler;
- EXPECT_CALL(handler, HandleLogAssert(_, _, _, _)).Times(2);
- {
- logging::ScopedLogAssertHandler scoped_handler_b(base::Bind(
- &MockLogAssertHandler::HandleLogAssert, base::Unretained(&handler)));
- DCHECK(false);
- DCHECK_EQ(1, 2);
- }
-}
-
-TEST_F(LoggingTest, ConfigurableDCheckFeature) {
- // Initialize FeatureList with and without DcheckIsFatal, and verify the
- // value of LOG_DCHECK. Note that we don't require that DCHECK take a
- // specific value when the feature is off, only that it is non-fatal.
-
- {
- base::test::ScopedFeatureList feature_list;
- feature_list.InitFromCommandLine("DcheckIsFatal", "");
- EXPECT_EQ(LOG_DCHECK, LOG_FATAL);
- }
-
- {
- base::test::ScopedFeatureList feature_list;
- feature_list.InitFromCommandLine("", "DcheckIsFatal");
- EXPECT_LT(LOG_DCHECK, LOG_FATAL);
- }
-
- // The default case is last, so we leave LOG_DCHECK in the default state.
- {
- base::test::ScopedFeatureList feature_list;
- feature_list.InitFromCommandLine("", "");
- EXPECT_LT(LOG_DCHECK, LOG_FATAL);
- }
-}
-#endif // DCHECK_IS_CONFIGURABLE
-
-#if defined(OS_FUCHSIA)
-TEST_F(LoggingTest, FuchsiaLogging) {
- MockLogSource mock_log_source;
- EXPECT_CALL(mock_log_source, Log())
- .Times(DCHECK_IS_ON() ? 2 : 1)
- .WillRepeatedly(Return("log message"));
-
- SetMinLogLevel(LOG_INFO);
-
- EXPECT_TRUE(LOG_IS_ON(INFO));
- EXPECT_TRUE((DCHECK_IS_ON() != 0) == DLOG_IS_ON(INFO));
-
- ZX_LOG(INFO, ZX_ERR_INTERNAL) << mock_log_source.Log();
- ZX_DLOG(INFO, ZX_ERR_INTERNAL) << mock_log_source.Log();
-
- ZX_CHECK(true, ZX_ERR_INTERNAL);
- ZX_DCHECK(true, ZX_ERR_INTERNAL);
-}
-#endif // defined(OS_FUCHSIA)
-
-} // namespace
-
-} // namespace logging
diff --git a/base/mac/dispatch_source_mach_unittest.cc b/base/mac/dispatch_source_mach_unittest.cc
deleted file mode 100644
index 738a137..0000000
--- a/base/mac/dispatch_source_mach_unittest.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright 2014 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 "base/mac/dispatch_source_mach.h"
-
-#include <mach/mach.h>
-
-#include <memory>
-
-#include "base/logging.h"
-#include "base/mac/scoped_mach_port.h"
-#include "base/test/test_timeouts.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class DispatchSourceMachTest : public testing::Test {
- public:
- void SetUp() override {
- mach_port_t port = MACH_PORT_NULL;
- ASSERT_EQ(KERN_SUCCESS, mach_port_allocate(mach_task_self(),
- MACH_PORT_RIGHT_RECEIVE, &port));
- receive_right_.reset(port);
-
- ASSERT_EQ(KERN_SUCCESS, mach_port_insert_right(mach_task_self(), port,
- port, MACH_MSG_TYPE_MAKE_SEND));
- send_right_.reset(port);
- }
-
- mach_port_t GetPort() { return receive_right_.get(); }
-
- void WaitForSemaphore(dispatch_semaphore_t semaphore) {
- dispatch_semaphore_wait(semaphore, dispatch_time(
- DISPATCH_TIME_NOW,
- TestTimeouts::action_timeout().InSeconds() * NSEC_PER_SEC));
- }
-
- private:
- base::mac::ScopedMachReceiveRight receive_right_;
- base::mac::ScopedMachSendRight send_right_;
-};
-
-TEST_F(DispatchSourceMachTest, ReceiveAfterResume) {
- dispatch_semaphore_t signal = dispatch_semaphore_create(0);
- mach_port_t port = GetPort();
-
- bool __block did_receive = false;
- DispatchSourceMach source("org.chromium.base.test.ReceiveAfterResume",
- port, ^{
- mach_msg_empty_rcv_t msg = {{0}};
- msg.header.msgh_size = sizeof(msg);
- msg.header.msgh_local_port = port;
- mach_msg_receive(&msg.header);
- did_receive = true;
-
- dispatch_semaphore_signal(signal);
- });
-
- mach_msg_empty_send_t msg = {{0}};
- msg.header.msgh_size = sizeof(msg);
- msg.header.msgh_remote_port = port;
- msg.header.msgh_bits = MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_COPY_SEND);
- ASSERT_EQ(KERN_SUCCESS, mach_msg_send(&msg.header));
-
- EXPECT_FALSE(did_receive);
-
- source.Resume();
-
- WaitForSemaphore(signal);
- dispatch_release(signal);
-
- EXPECT_TRUE(did_receive);
-}
-
-TEST_F(DispatchSourceMachTest, NoMessagesAfterDestruction) {
- mach_port_t port = GetPort();
-
- std::unique_ptr<int> count(new int(0));
- int* __block count_ptr = count.get();
-
- std::unique_ptr<DispatchSourceMach> source(new DispatchSourceMach(
- "org.chromium.base.test.NoMessagesAfterDestruction", port, ^{
- mach_msg_empty_rcv_t msg = {{0}};
- msg.header.msgh_size = sizeof(msg);
- msg.header.msgh_local_port = port;
- mach_msg_receive(&msg.header);
- LOG(INFO) << "Receieve " << *count_ptr;
- ++(*count_ptr);
- }));
- source->Resume();
-
- dispatch_queue_t queue =
- dispatch_queue_create("org.chromium.base.test.MessageSend", NULL);
- dispatch_semaphore_t signal = dispatch_semaphore_create(0);
- for (int i = 0; i < 30; ++i) {
- dispatch_async(queue, ^{
- mach_msg_empty_send_t msg = {{0}};
- msg.header.msgh_size = sizeof(msg);
- msg.header.msgh_remote_port = port;
- msg.header.msgh_bits =
- MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_COPY_SEND);
- mach_msg_send(&msg.header);
- });
-
- // After sending five messages, shut down the source and taint the
- // pointer the handler dereferences. The test will crash if |count_ptr|
- // is being used after "free".
- if (i == 5) {
- std::unique_ptr<DispatchSourceMach>* source_ptr = &source;
- dispatch_async(queue, ^{
- source_ptr->reset();
- count_ptr = reinterpret_cast<int*>(0xdeaddead);
- dispatch_semaphore_signal(signal);
- });
- }
- }
-
- WaitForSemaphore(signal);
- dispatch_release(signal);
-
- dispatch_release(queue);
-}
-
-} // namespace base
diff --git a/base/mac/mach_port_broker_unittest.cc b/base/mac/mach_port_broker_unittest.cc
deleted file mode 100644
index bff8eb6..0000000
--- a/base/mac/mach_port_broker_unittest.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2016 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 "base/mac/mach_port_broker.h"
-
-#include "base/command_line.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace base {
-
-namespace {
-const char kBootstrapPortName[] = "thisisatest";
-}
-
-class MachPortBrokerTest : public testing::Test,
- public base::PortProvider::Observer {
- public:
- MachPortBrokerTest()
- : broker_(kBootstrapPortName),
- event_(base::WaitableEvent::ResetPolicy::MANUAL,
- base::WaitableEvent::InitialState::NOT_SIGNALED),
- received_process_(kNullProcessHandle) {
- broker_.AddObserver(this);
- }
- ~MachPortBrokerTest() override {
- broker_.RemoveObserver(this);
- }
-
- // Helper function to acquire/release locks and call |PlaceholderForPid()|.
- void AddPlaceholderForPid(base::ProcessHandle pid) {
- base::AutoLock lock(broker_.GetLock());
- broker_.AddPlaceholderForPid(pid);
- }
-
- // Helper function to acquire/release locks and call |FinalizePid()|.
- void FinalizePid(base::ProcessHandle pid,
- mach_port_t task_port) {
- base::AutoLock lock(broker_.GetLock());
- broker_.FinalizePid(pid, task_port);
- }
-
- void WaitForTaskPort() {
- event_.Wait();
- }
-
- // base::PortProvider::Observer:
- void OnReceivedTaskPort(ProcessHandle process) override {
- received_process_ = process;
- event_.Signal();
- }
-
- protected:
- MachPortBroker broker_;
- WaitableEvent event_;
- ProcessHandle received_process_;
-};
-
-TEST_F(MachPortBrokerTest, Locks) {
- // Acquire and release the locks. Nothing bad should happen.
- base::AutoLock lock(broker_.GetLock());
-}
-
-TEST_F(MachPortBrokerTest, AddPlaceholderAndFinalize) {
- // Add a placeholder for PID 1.
- AddPlaceholderForPid(1);
- EXPECT_EQ(0u, broker_.TaskForPid(1));
-
- // Finalize PID 1.
- FinalizePid(1, 100u);
- EXPECT_EQ(100u, broker_.TaskForPid(1));
-
- // Should be no entry for PID 2.
- EXPECT_EQ(0u, broker_.TaskForPid(2));
-}
-
-TEST_F(MachPortBrokerTest, FinalizeUnknownPid) {
- // Finalizing an entry for an unknown pid should not add it to the map.
- FinalizePid(1u, 100u);
- EXPECT_EQ(0u, broker_.TaskForPid(1u));
-}
-
-MULTIPROCESS_TEST_MAIN(MachPortBrokerTestChild) {
- CHECK(base::MachPortBroker::ChildSendTaskPortToParent(kBootstrapPortName));
- return 0;
-}
-
-TEST_F(MachPortBrokerTest, ReceivePortFromChild) {
- ASSERT_TRUE(broker_.Init());
- CommandLine command_line(
- base::GetMultiProcessTestChildBaseCommandLine());
- broker_.GetLock().Acquire();
- base::Process test_child_process = base::SpawnMultiProcessTestChild(
- "MachPortBrokerTestChild", command_line, LaunchOptions());
- broker_.AddPlaceholderForPid(test_child_process.Handle());
- broker_.GetLock().Release();
-
- WaitForTaskPort();
- EXPECT_EQ(test_child_process.Handle(), received_process_);
-
- int rv = -1;
- ASSERT_TRUE(test_child_process.WaitForExitWithTimeout(
- TestTimeouts::action_timeout(), &rv));
- EXPECT_EQ(0, rv);
-
- EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL),
- broker_.TaskForPid(test_child_process.Handle()));
-}
-
-TEST_F(MachPortBrokerTest, ReceivePortFromChildWithoutAdding) {
- ASSERT_TRUE(broker_.Init());
- CommandLine command_line(
- base::GetMultiProcessTestChildBaseCommandLine());
- broker_.GetLock().Acquire();
- base::Process test_child_process = base::SpawnMultiProcessTestChild(
- "MachPortBrokerTestChild", command_line, LaunchOptions());
- broker_.GetLock().Release();
-
- int rv = -1;
- ASSERT_TRUE(test_child_process.WaitForExitWithTimeout(
- TestTimeouts::action_timeout(), &rv));
- EXPECT_EQ(0, rv);
-
- EXPECT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL),
- broker_.TaskForPid(test_child_process.Handle()));
-}
-
-} // namespace base
diff --git a/base/md5_unittest.cc b/base/md5_unittest.cc
deleted file mode 100644
index b27efe9..0000000
--- a/base/md5_unittest.cc
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright (c) 2011 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 "base/md5.h"
-
-#include <string.h>
-
-#include <memory>
-#include <string>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(MD5, DigestToBase16) {
- MD5Digest digest;
-
- int data[] = {
- 0xd4, 0x1d, 0x8c, 0xd9,
- 0x8f, 0x00, 0xb2, 0x04,
- 0xe9, 0x80, 0x09, 0x98,
- 0xec, 0xf8, 0x42, 0x7e
- };
-
- for (int i = 0; i < 16; ++i)
- digest.a[i] = data[i] & 0xff;
-
- std::string actual = MD5DigestToBase16(digest);
- std::string expected = "d41d8cd98f00b204e9800998ecf8427e";
-
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5SumEmtpyData) {
- MD5Digest digest;
- const char data[] = "";
-
- MD5Sum(data, strlen(data), &digest);
-
- int expected[] = {
- 0xd4, 0x1d, 0x8c, 0xd9,
- 0x8f, 0x00, 0xb2, 0x04,
- 0xe9, 0x80, 0x09, 0x98,
- 0xec, 0xf8, 0x42, 0x7e
- };
-
- for (int i = 0; i < 16; ++i)
- EXPECT_EQ(expected[i], digest.a[i] & 0xFF);
-}
-
-TEST(MD5, MD5SumOneByteData) {
- MD5Digest digest;
- const char data[] = "a";
-
- MD5Sum(data, strlen(data), &digest);
-
- int expected[] = {
- 0x0c, 0xc1, 0x75, 0xb9,
- 0xc0, 0xf1, 0xb6, 0xa8,
- 0x31, 0xc3, 0x99, 0xe2,
- 0x69, 0x77, 0x26, 0x61
- };
-
- for (int i = 0; i < 16; ++i)
- EXPECT_EQ(expected[i], digest.a[i] & 0xFF);
-}
-
-TEST(MD5, MD5SumLongData) {
- const int length = 10 * 1024 * 1024 + 1;
- std::unique_ptr<char[]> data(new char[length]);
-
- for (int i = 0; i < length; ++i)
- data[i] = i & 0xFF;
-
- MD5Digest digest;
- MD5Sum(data.get(), length, &digest);
-
- int expected[] = {
- 0x90, 0xbd, 0x6a, 0xd9,
- 0x0a, 0xce, 0xf5, 0xad,
- 0xaa, 0x92, 0x20, 0x3e,
- 0x21, 0xc7, 0xa1, 0x3e
- };
-
- for (int i = 0; i < 16; ++i)
- EXPECT_EQ(expected[i], digest.a[i] & 0xFF);
-}
-
-TEST(MD5, ContextWithEmptyData) {
- MD5Context ctx;
- MD5Init(&ctx);
-
- MD5Digest digest;
- MD5Final(&digest, &ctx);
-
- int expected[] = {
- 0xd4, 0x1d, 0x8c, 0xd9,
- 0x8f, 0x00, 0xb2, 0x04,
- 0xe9, 0x80, 0x09, 0x98,
- 0xec, 0xf8, 0x42, 0x7e
- };
-
- for (int i = 0; i < 16; ++i)
- EXPECT_EQ(expected[i], digest.a[i] & 0xFF);
-}
-
-TEST(MD5, ContextWithLongData) {
- MD5Context ctx;
- MD5Init(&ctx);
-
- const int length = 10 * 1024 * 1024 + 1;
- std::unique_ptr<char[]> data(new char[length]);
-
- for (int i = 0; i < length; ++i)
- data[i] = i & 0xFF;
-
- int total = 0;
- while (total < length) {
- int len = 4097; // intentionally not 2^k.
- if (len > length - total)
- len = length - total;
-
- MD5Update(&ctx,
- StringPiece(reinterpret_cast<char*>(data.get() + total), len));
- total += len;
- }
-
- EXPECT_EQ(length, total);
-
- MD5Digest digest;
- MD5Final(&digest, &ctx);
-
- int expected[] = {
- 0x90, 0xbd, 0x6a, 0xd9,
- 0x0a, 0xce, 0xf5, 0xad,
- 0xaa, 0x92, 0x20, 0x3e,
- 0x21, 0xc7, 0xa1, 0x3e
- };
-
- for (int i = 0; i < 16; ++i)
- EXPECT_EQ(expected[i], digest.a[i] & 0xFF);
-}
-
-// Example data from http://www.ietf.org/rfc/rfc1321.txt A.5 Test Suite
-TEST(MD5, MD5StringTestSuite1) {
- std::string actual = MD5String("");
- std::string expected = "d41d8cd98f00b204e9800998ecf8427e";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5StringTestSuite2) {
- std::string actual = MD5String("a");
- std::string expected = "0cc175b9c0f1b6a831c399e269772661";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5StringTestSuite3) {
- std::string actual = MD5String("abc");
- std::string expected = "900150983cd24fb0d6963f7d28e17f72";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5StringTestSuite4) {
- std::string actual = MD5String("message digest");
- std::string expected = "f96b697d7cb7938d525a2f31aaf161d0";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5StringTestSuite5) {
- std::string actual = MD5String("abcdefghijklmnopqrstuvwxyz");
- std::string expected = "c3fcd3d76192e4007dfb496cca67e13b";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5StringTestSuite6) {
- std::string actual = MD5String("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz"
- "0123456789");
- std::string expected = "d174ab98d277d9f5a5611c2c9f419d9f";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, MD5StringTestSuite7) {
- std::string actual = MD5String("12345678901234567890"
- "12345678901234567890"
- "12345678901234567890"
- "12345678901234567890");
- std::string expected = "57edf4a22be3c955ac49da2e2107b67a";
- EXPECT_EQ(expected, actual);
-}
-
-TEST(MD5, ContextWithStringData) {
- MD5Context ctx;
- MD5Init(&ctx);
-
- MD5Update(&ctx, "abc");
-
- MD5Digest digest;
- MD5Final(&digest, &ctx);
-
- std::string actual = MD5DigestToBase16(digest);
- std::string expected = "900150983cd24fb0d6963f7d28e17f72";
-
- EXPECT_EQ(expected, actual);
-}
-
-// Test that a digest generated by MD5IntermediateFinal() gives the same results
-// as an independently-calculated digest, and also does not modify the context.
-TEST(MD5, IntermediateFinal) {
- // Independent context over the header.
- MD5Context check_header_context;
- MD5Init(&check_header_context);
-
- // Independent context over entire input.
- MD5Context check_full_context;
- MD5Init(&check_full_context);
-
- // Context intermediate digest will be calculated from.
- MD5Context context;
- MD5Init(&context);
-
- static const char kHeader[] = "header data";
- static const char kBody[] = "payload data";
-
- MD5Update(&context, kHeader);
- MD5Update(&check_header_context, kHeader);
- MD5Update(&check_full_context, kHeader);
-
- MD5Digest check_header_digest;
- MD5Final(&check_header_digest, &check_header_context);
-
- MD5Digest header_digest;
- MD5IntermediateFinal(&header_digest, &context);
-
- MD5Update(&context, kBody);
- MD5Update(&check_full_context, kBody);
-
- MD5Digest check_full_digest;
- MD5Final(&check_full_digest, &check_full_context);
-
- MD5Digest digest;
- MD5Final(&digest, &context);
-
- // The header and full digest pairs are the same, and they aren't the same as
- // each other.
- EXPECT_TRUE(!memcmp(&header_digest, &check_header_digest,
- sizeof(header_digest)));
- EXPECT_TRUE(!memcmp(&digest, &check_full_digest, sizeof(digest)));
- EXPECT_TRUE(memcmp(&digest, &header_digest, sizeof(digest)));
-}
-
-} // namespace base
diff --git a/base/memory/aligned_memory_unittest.cc b/base/memory/aligned_memory_unittest.cc
deleted file mode 100644
index 29ed706..0000000
--- a/base/memory/aligned_memory_unittest.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// 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.
-
-#include "base/memory/aligned_memory.h"
-
-#include <memory>
-
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#define EXPECT_ALIGNED(ptr, align) \
- EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
-
-namespace base {
-
-TEST(AlignedMemoryTest, DynamicAllocation) {
- void* p = AlignedAlloc(8, 8);
- EXPECT_TRUE(p);
- EXPECT_ALIGNED(p, 8);
- AlignedFree(p);
-
- p = AlignedAlloc(8, 16);
- EXPECT_TRUE(p);
- EXPECT_ALIGNED(p, 16);
- AlignedFree(p);
-
- p = AlignedAlloc(8, 256);
- EXPECT_TRUE(p);
- EXPECT_ALIGNED(p, 256);
- AlignedFree(p);
-
- p = AlignedAlloc(8, 4096);
- EXPECT_TRUE(p);
- EXPECT_ALIGNED(p, 4096);
- AlignedFree(p);
-}
-
-TEST(AlignedMemoryTest, ScopedDynamicAllocation) {
- std::unique_ptr<float, AlignedFreeDeleter> p(
- static_cast<float*>(AlignedAlloc(8, 8)));
- EXPECT_TRUE(p.get());
- EXPECT_ALIGNED(p.get(), 8);
-}
-
-} // namespace base
diff --git a/base/memory/discardable_shared_memory_unittest.cc b/base/memory/discardable_shared_memory_unittest.cc
deleted file mode 100644
index bda37f6..0000000
--- a/base/memory/discardable_shared_memory_unittest.cc
+++ /dev/null
@@ -1,456 +0,0 @@
-// Copyright 2014 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 <fcntl.h>
-#include <stdint.h>
-
-#include "base/files/scoped_file.h"
-#include "base/memory/discardable_shared_memory.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/process/process_metrics.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class TestDiscardableSharedMemory : public DiscardableSharedMemory {
- public:
- TestDiscardableSharedMemory() = default;
-
- explicit TestDiscardableSharedMemory(UnsafeSharedMemoryRegion region)
- : DiscardableSharedMemory(std::move(region)) {}
-
- void SetNow(Time now) { now_ = now; }
-
- private:
- // Overriden from DiscardableSharedMemory:
- Time Now() const override { return now_; }
-
- Time now_;
-};
-
-TEST(DiscardableSharedMemoryTest, CreateAndMap) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory;
- bool rv = memory.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
- EXPECT_GE(memory.mapped_size(), kDataSize);
- EXPECT_TRUE(memory.IsMemoryLocked());
-}
-
-TEST(DiscardableSharedMemoryTest, CreateFromHandle) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(kDataSize);
- ASSERT_TRUE(rv);
- EXPECT_TRUE(memory2.IsMemoryLocked());
-}
-
-TEST(DiscardableSharedMemoryTest, LockAndUnlock) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- // Memory is initially locked. Unlock it.
- memory1.SetNow(Time::FromDoubleT(1));
- memory1.Unlock(0, 0);
- EXPECT_FALSE(memory1.IsMemoryLocked());
-
- // Lock and unlock memory.
- DiscardableSharedMemory::LockResult lock_rv = memory1.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
- memory1.SetNow(Time::FromDoubleT(2));
- memory1.Unlock(0, 0);
-
- // Lock again before duplicating and passing ownership to new instance.
- lock_rv = memory1.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
- EXPECT_TRUE(memory1.IsMemoryLocked());
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(kDataSize);
- ASSERT_TRUE(rv);
-
- // Unlock second instance.
- memory2.SetNow(Time::FromDoubleT(3));
- memory2.Unlock(0, 0);
-
- // Both memory instances should be unlocked now.
- EXPECT_FALSE(memory2.IsMemoryLocked());
- EXPECT_FALSE(memory1.IsMemoryLocked());
-
- // Lock second instance before passing ownership back to first instance.
- lock_rv = memory2.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
-
- // Memory should still be resident and locked.
- rv = memory1.IsMemoryResident();
- EXPECT_TRUE(rv);
- EXPECT_TRUE(memory1.IsMemoryLocked());
-
- // Unlock first instance.
- memory1.SetNow(Time::FromDoubleT(4));
- memory1.Unlock(0, 0);
-}
-
-TEST(DiscardableSharedMemoryTest, Purge) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(kDataSize);
- ASSERT_TRUE(rv);
-
- // This should fail as memory is locked.
- rv = memory1.Purge(Time::FromDoubleT(1));
- EXPECT_FALSE(rv);
-
- memory2.SetNow(Time::FromDoubleT(2));
- memory2.Unlock(0, 0);
-
- ASSERT_TRUE(memory2.IsMemoryResident());
-
- // Memory is unlocked, but our usage timestamp is incorrect.
- rv = memory1.Purge(Time::FromDoubleT(3));
- EXPECT_FALSE(rv);
-
- ASSERT_TRUE(memory2.IsMemoryResident());
-
- // Memory is unlocked and our usage timestamp should be correct.
- rv = memory1.Purge(Time::FromDoubleT(4));
- EXPECT_TRUE(rv);
-
- // Lock should fail as memory has been purged.
- DiscardableSharedMemory::LockResult lock_rv = memory2.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
-
- ASSERT_FALSE(memory2.IsMemoryResident());
-}
-
-TEST(DiscardableSharedMemoryTest, LastUsed) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(kDataSize);
- ASSERT_TRUE(rv);
-
- memory2.SetNow(Time::FromDoubleT(1));
- memory2.Unlock(0, 0);
-
- EXPECT_EQ(memory2.last_known_usage(), Time::FromDoubleT(1));
-
- DiscardableSharedMemory::LockResult lock_rv = memory2.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
-
- // This should fail as memory is locked.
- rv = memory1.Purge(Time::FromDoubleT(2));
- ASSERT_FALSE(rv);
-
- // Last usage should have been updated to timestamp passed to Purge above.
- EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(2));
-
- memory2.SetNow(Time::FromDoubleT(3));
- memory2.Unlock(0, 0);
-
- // Usage time should be correct for |memory2| instance.
- EXPECT_EQ(memory2.last_known_usage(), Time::FromDoubleT(3));
-
- // However, usage time has not changed as far as |memory1| instance knows.
- EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(2));
-
- // Memory is unlocked, but our usage timestamp is incorrect.
- rv = memory1.Purge(Time::FromDoubleT(4));
- EXPECT_FALSE(rv);
-
- // The failed purge attempt should have updated usage time to the correct
- // value.
- EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(3));
-
- // Purge memory through |memory2| instance. The last usage time should be
- // set to 0 as a result of this.
- rv = memory2.Purge(Time::FromDoubleT(5));
- EXPECT_TRUE(rv);
- EXPECT_TRUE(memory2.last_known_usage().is_null());
-
- // This should fail as memory has already been purged and |memory1|'s usage
- // time is incorrect as a result.
- rv = memory1.Purge(Time::FromDoubleT(6));
- EXPECT_FALSE(rv);
-
- // The failed purge attempt should have updated usage time to the correct
- // value.
- EXPECT_TRUE(memory1.last_known_usage().is_null());
-
- // Purge should succeed now that usage time is correct.
- rv = memory1.Purge(Time::FromDoubleT(7));
- EXPECT_TRUE(rv);
-}
-
-TEST(DiscardableSharedMemoryTest, LockShouldAlwaysFailAfterSuccessfulPurge) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(kDataSize);
- ASSERT_TRUE(rv);
-
- memory2.SetNow(Time::FromDoubleT(1));
- memory2.Unlock(0, 0);
-
- rv = memory2.Purge(Time::FromDoubleT(2));
- EXPECT_TRUE(rv);
-
- // Lock should fail as memory has been purged.
- DiscardableSharedMemory::LockResult lock_rv = memory2.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
-}
-
-#if defined(OS_ANDROID)
-TEST(DiscardableSharedMemoryTest, LockShouldFailIfPlatformLockPagesFails) {
- const uint32_t kDataSize = 1024;
-
- DiscardableSharedMemory memory1;
- bool rv1 = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv1);
-
- base::UnsafeSharedMemoryRegion region = memory1.DuplicateRegion();
- int fd = region.GetPlatformHandle();
- DiscardableSharedMemory memory2(std::move(region));
- bool rv2 = memory2.Map(kDataSize);
- ASSERT_TRUE(rv2);
-
- // Unlock() the first page of memory, so we can test Lock()ing it.
- memory2.Unlock(0, base::GetPageSize());
- // To cause ashmem_pin_region() to fail, we arrange for it to be called with
- // an invalid file-descriptor, which requires a valid-looking fd (i.e. we
- // can't just Close() |memory|), but one on which the operation is invalid.
- // We can overwrite the |memory| fd with a handle to a different file using
- // dup2(), which has the nice properties that |memory| still has a valid fd
- // that it can close, etc without errors, but on which ashmem_pin_region()
- // will fail.
- base::ScopedFD null(open("/dev/null", O_RDONLY));
- ASSERT_EQ(fd, dup2(null.get(), fd));
-
- // Now re-Lock()ing the first page should fail.
- DiscardableSharedMemory::LockResult lock_rv =
- memory2.Lock(0, base::GetPageSize());
- EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
-}
-#endif // defined(OS_ANDROID)
-
-TEST(DiscardableSharedMemoryTest, LockAndUnlockRange) {
- const uint32_t kDataSize = 32;
-
- uint32_t data_size_in_bytes = kDataSize * base::GetPageSize();
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(data_size_in_bytes);
- ASSERT_TRUE(rv);
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(data_size_in_bytes);
- ASSERT_TRUE(rv);
-
- // Unlock first page.
- memory2.SetNow(Time::FromDoubleT(1));
- memory2.Unlock(0, base::GetPageSize());
-
- rv = memory1.Purge(Time::FromDoubleT(2));
- EXPECT_FALSE(rv);
-
- // Lock first page again.
- memory2.SetNow(Time::FromDoubleT(3));
- DiscardableSharedMemory::LockResult lock_rv =
- memory2.Lock(0, base::GetPageSize());
- EXPECT_NE(DiscardableSharedMemory::FAILED, lock_rv);
-
- // Unlock first page.
- memory2.SetNow(Time::FromDoubleT(4));
- memory2.Unlock(0, base::GetPageSize());
-
- rv = memory1.Purge(Time::FromDoubleT(5));
- EXPECT_FALSE(rv);
-
- // Unlock second page.
- memory2.SetNow(Time::FromDoubleT(6));
- memory2.Unlock(base::GetPageSize(), base::GetPageSize());
-
- rv = memory1.Purge(Time::FromDoubleT(7));
- EXPECT_FALSE(rv);
-
- // Unlock anything onwards.
- memory2.SetNow(Time::FromDoubleT(8));
- memory2.Unlock(2 * base::GetPageSize(), 0);
-
- // Memory is unlocked, but our usage timestamp is incorrect.
- rv = memory1.Purge(Time::FromDoubleT(9));
- EXPECT_FALSE(rv);
-
- // The failed purge attempt should have updated usage time to the correct
- // value.
- EXPECT_EQ(Time::FromDoubleT(8), memory1.last_known_usage());
-
- // Purge should now succeed.
- rv = memory1.Purge(Time::FromDoubleT(10));
- EXPECT_TRUE(rv);
-}
-
-TEST(DiscardableSharedMemoryTest, MappedSize) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory;
- bool rv = memory.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- EXPECT_LE(kDataSize, memory.mapped_size());
-
- // Mapped size should be 0 after memory segment has been unmapped.
- rv = memory.Unmap();
- EXPECT_TRUE(rv);
- EXPECT_EQ(0u, memory.mapped_size());
-}
-
-TEST(DiscardableSharedMemoryTest, Close) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory;
- bool rv = memory.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- // Mapped size should be unchanged after memory segment has been closed.
- memory.Close();
- EXPECT_LE(kDataSize, memory.mapped_size());
-
- // Memory is initially locked. Unlock it.
- memory.SetNow(Time::FromDoubleT(1));
- memory.Unlock(0, 0);
-
- // Lock and unlock memory.
- DiscardableSharedMemory::LockResult lock_rv = memory.Lock(0, 0);
- EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
- memory.SetNow(Time::FromDoubleT(2));
- memory.Unlock(0, 0);
-}
-
-TEST(DiscardableSharedMemoryTest, ZeroSize) {
- TestDiscardableSharedMemory memory;
- bool rv = memory.CreateAndMap(0);
- ASSERT_TRUE(rv);
-
- EXPECT_LE(0u, memory.mapped_size());
-
- // Memory is initially locked. Unlock it.
- memory.SetNow(Time::FromDoubleT(1));
- memory.Unlock(0, 0);
-
- // Lock and unlock memory.
- DiscardableSharedMemory::LockResult lock_rv = memory.Lock(0, 0);
- EXPECT_NE(DiscardableSharedMemory::FAILED, lock_rv);
- memory.SetNow(Time::FromDoubleT(2));
- memory.Unlock(0, 0);
-}
-
-// This test checks that zero-filled pages are returned after purging a segment
-// when DISCARDABLE_SHARED_MEMORY_ZERO_FILL_ON_DEMAND_PAGES_AFTER_PURGE is
-// defined and MADV_REMOVE is supported.
-#if defined(DISCARDABLE_SHARED_MEMORY_ZERO_FILL_ON_DEMAND_PAGES_AFTER_PURGE)
-TEST(DiscardableSharedMemoryTest, ZeroFilledPagesAfterPurge) {
- const uint32_t kDataSize = 1024;
-
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- UnsafeSharedMemoryRegion shared_region = memory1.DuplicateRegion();
- ASSERT_TRUE(shared_region.IsValid());
-
- TestDiscardableSharedMemory memory2(std::move(shared_region));
- rv = memory2.Map(kDataSize);
- ASSERT_TRUE(rv);
-
- // Initialize all memory to '0xaa'.
- memset(memory2.memory(), 0xaa, kDataSize);
-
- // Unlock memory.
- memory2.SetNow(Time::FromDoubleT(1));
- memory2.Unlock(0, 0);
- EXPECT_FALSE(memory1.IsMemoryLocked());
-
- // Memory is unlocked, but our usage timestamp is incorrect.
- rv = memory1.Purge(Time::FromDoubleT(2));
- EXPECT_FALSE(rv);
- rv = memory1.Purge(Time::FromDoubleT(3));
- EXPECT_TRUE(rv);
-
- // Check that reading memory after it has been purged is returning
- // zero-filled pages.
- uint8_t expected_data[kDataSize] = {};
- EXPECT_EQ(memcmp(memory2.memory(), expected_data, kDataSize), 0);
-}
-#endif
-
-TEST(DiscardableSharedMemoryTest, TracingOwnershipEdges) {
- const uint32_t kDataSize = 1024;
- TestDiscardableSharedMemory memory1;
- bool rv = memory1.CreateAndMap(kDataSize);
- ASSERT_TRUE(rv);
-
- base::trace_event::MemoryDumpArgs args = {
- base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
- trace_event::ProcessMemoryDump pmd(nullptr, args);
- trace_event::MemoryAllocatorDump* client_dump =
- pmd.CreateAllocatorDump("discardable_manager/map1");
- const bool is_owned = false;
- memory1.CreateSharedMemoryOwnershipEdge(client_dump, &pmd, is_owned);
- const auto* shm_dump = pmd.GetAllocatorDump(
- SharedMemoryTracker::GetDumpNameForTracing(memory1.mapped_id()));
- EXPECT_TRUE(shm_dump);
- EXPECT_EQ(shm_dump->GetSizeInternal(), client_dump->GetSizeInternal());
- const auto edges = pmd.allocator_dumps_edges();
- EXPECT_EQ(2u, edges.size());
- EXPECT_NE(edges.end(), edges.find(shm_dump->guid()));
- EXPECT_NE(edges.end(), edges.find(client_dump->guid()));
- // TODO(ssid): test for weak global dump once the
- // CreateWeakSharedMemoryOwnershipEdge() is fixed, crbug.com/661257.
-}
-
-} // namespace base
diff --git a/base/memory/linked_ptr_unittest.cc b/base/memory/linked_ptr_unittest.cc
deleted file mode 100644
index 344ffa4..0000000
--- a/base/memory/linked_ptr_unittest.cc
+++ /dev/null
@@ -1,108 +0,0 @@
-// 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.
-
-#include <string>
-
-#include "base/memory/linked_ptr.h"
-#include "base/strings/stringprintf.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-int num = 0;
-
-std::string history;
-
-// Class which tracks allocation/deallocation
-struct A {
- A(): mynum(num++) { history += base::StringPrintf("A%d ctor\n", mynum); }
- virtual ~A() { history += base::StringPrintf("A%d dtor\n", mynum); }
- virtual void Use() { history += base::StringPrintf("A%d use\n", mynum); }
- int mynum;
-};
-
-// Subclass
-struct B: public A {
- B() { history += base::StringPrintf("B%d ctor\n", mynum); }
- ~B() override { history += base::StringPrintf("B%d dtor\n", mynum); }
- void Use() override { history += base::StringPrintf("B%d use\n", mynum); }
-};
-
-} // namespace
-
-TEST(LinkedPtrTest, Test) {
- {
- linked_ptr<A> a0, a1, a2;
- a0 = *&a0; // The *& defeats Clang's -Wself-assign warning.
- a1 = a2;
- ASSERT_EQ(a0.get(), static_cast<A*>(nullptr));
- ASSERT_EQ(a1.get(), static_cast<A*>(nullptr));
- ASSERT_EQ(a2.get(), static_cast<A*>(nullptr));
- ASSERT_TRUE(a0 == nullptr);
- ASSERT_TRUE(a1 == nullptr);
- ASSERT_TRUE(a2 == nullptr);
-
- {
- linked_ptr<A> a3(new A);
- a0 = a3;
- ASSERT_TRUE(a0 == a3);
- ASSERT_TRUE(a0 != nullptr);
- ASSERT_TRUE(a0.get() == a3);
- ASSERT_TRUE(a0 == a3.get());
- linked_ptr<A> a4(a0);
- a1 = a4;
- linked_ptr<A> a5(new A);
- ASSERT_TRUE(a5.get() != a3);
- ASSERT_TRUE(a5 != a3.get());
- a2 = a5;
- linked_ptr<B> b0(new B);
- linked_ptr<A> a6(b0);
- ASSERT_TRUE(b0 == a6);
- ASSERT_TRUE(a6 == b0);
- ASSERT_TRUE(b0 != nullptr);
- a5 = b0;
- a5 = b0;
- a3->Use();
- a4->Use();
- a5->Use();
- a6->Use();
- b0->Use();
- (*b0).Use();
- b0.get()->Use();
- }
-
- a0->Use();
- a1->Use();
- a2->Use();
-
- a1 = a2;
- a2.reset(new A);
- a0.reset();
-
- linked_ptr<A> a7;
- }
-
- ASSERT_EQ(history,
- "A0 ctor\n"
- "A1 ctor\n"
- "A2 ctor\n"
- "B2 ctor\n"
- "A0 use\n"
- "A0 use\n"
- "B2 use\n"
- "B2 use\n"
- "B2 use\n"
- "B2 use\n"
- "B2 use\n"
- "B2 dtor\n"
- "A2 dtor\n"
- "A0 use\n"
- "A0 use\n"
- "A1 use\n"
- "A3 ctor\n"
- "A0 dtor\n"
- "A3 dtor\n"
- "A1 dtor\n"
- );
-}
diff --git a/base/memory/memory_coordinator_client_registry_unittest.cc b/base/memory/memory_coordinator_client_registry_unittest.cc
deleted file mode 100644
index 37ed767..0000000
--- a/base/memory/memory_coordinator_client_registry_unittest.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2017 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 "base/memory/memory_coordinator_client_registry.h"
-
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class TestMemoryCoordinatorClient : public MemoryCoordinatorClient {
- public:
- void OnMemoryStateChange(MemoryState state) override { state_ = state; }
-
- void OnPurgeMemory() override { ++purge_count_; }
-
- MemoryState state() const { return state_; }
- size_t purge_count() const { return purge_count_; }
-
- private:
- MemoryState state_ = MemoryState::UNKNOWN;
- size_t purge_count_ = 0;
-};
-
-void RunUntilIdle() {
- base::RunLoop loop;
- loop.RunUntilIdle();
-}
-
-TEST(MemoryCoordinatorClientRegistryTest, NotifyStateChange) {
- MessageLoop loop;
- auto* registry = MemoryCoordinatorClientRegistry::GetInstance();
- TestMemoryCoordinatorClient client;
- registry->Register(&client);
- registry->Notify(MemoryState::THROTTLED);
- RunUntilIdle();
- ASSERT_EQ(MemoryState::THROTTLED, client.state());
- registry->Unregister(&client);
-}
-
-TEST(MemoryCoordinatorClientRegistryTest, PurgeMemory) {
- MessageLoop loop;
- auto* registry = MemoryCoordinatorClientRegistry::GetInstance();
- TestMemoryCoordinatorClient client;
- registry->Register(&client);
- registry->PurgeMemory();
- RunUntilIdle();
- ASSERT_EQ(1u, client.purge_count());
- registry->Unregister(&client);
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/memory/memory_pressure_listener_unittest.cc b/base/memory/memory_pressure_listener_unittest.cc
deleted file mode 100644
index 87d5f4c..0000000
--- a/base/memory/memory_pressure_listener_unittest.cc
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2015 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 "base/memory/memory_pressure_listener.h"
-
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace base {
-
-using MemoryPressureLevel = MemoryPressureListener::MemoryPressureLevel;
-
-class MemoryPressureListenerTest : public testing::Test {
- public:
- void SetUp() override {
- message_loop_.reset(new MessageLoopForUI());
- listener_.reset(new MemoryPressureListener(
- Bind(&MemoryPressureListenerTest::OnMemoryPressure, Unretained(this))));
- }
-
- void TearDown() override {
- listener_.reset();
- message_loop_.reset();
- }
-
- protected:
- void ExpectNotification(
- void (*notification_function)(MemoryPressureLevel),
- MemoryPressureLevel level) {
- EXPECT_CALL(*this, OnMemoryPressure(level)).Times(1);
- notification_function(level);
- RunLoop().RunUntilIdle();
- }
-
- void ExpectNoNotification(
- void (*notification_function)(MemoryPressureLevel),
- MemoryPressureLevel level) {
- EXPECT_CALL(*this, OnMemoryPressure(testing::_)).Times(0);
- notification_function(level);
- RunLoop().RunUntilIdle();
- }
-
- private:
- MOCK_METHOD1(OnMemoryPressure,
- void(MemoryPressureListener::MemoryPressureLevel));
-
- std::unique_ptr<MessageLoopForUI> message_loop_;
- std::unique_ptr<MemoryPressureListener> listener_;
-};
-
-TEST_F(MemoryPressureListenerTest, NotifyMemoryPressure) {
- // Memory pressure notifications are not suppressed by default.
- EXPECT_FALSE(MemoryPressureListener::AreNotificationsSuppressed());
- ExpectNotification(&MemoryPressureListener::NotifyMemoryPressure,
- MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_MODERATE);
- ExpectNotification(&MemoryPressureListener::SimulatePressureNotification,
- MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_MODERATE);
-
- // Enable suppressing memory pressure notifications.
- MemoryPressureListener::SetNotificationsSuppressed(true);
- EXPECT_TRUE(MemoryPressureListener::AreNotificationsSuppressed());
- ExpectNoNotification(&MemoryPressureListener::NotifyMemoryPressure,
- MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_MODERATE);
- ExpectNotification(&MemoryPressureListener::SimulatePressureNotification,
- MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_MODERATE);
-
- // Disable suppressing memory pressure notifications.
- MemoryPressureListener::SetNotificationsSuppressed(false);
- EXPECT_FALSE(MemoryPressureListener::AreNotificationsSuppressed());
- ExpectNotification(&MemoryPressureListener::NotifyMemoryPressure,
- MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL);
- ExpectNotification(&MemoryPressureListener::SimulatePressureNotification,
- MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL);
-}
-
-} // namespace base
diff --git a/base/memory/memory_pressure_monitor_chromeos_unittest.cc b/base/memory/memory_pressure_monitor_chromeos_unittest.cc
deleted file mode 100644
index ee00091..0000000
--- a/base/memory/memory_pressure_monitor_chromeos_unittest.cc
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2014 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 "base/memory/memory_pressure_monitor_chromeos.h"
-
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/sys_info.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace chromeos {
-
-namespace {
-
-// True if the memory notifier got called.
-// Do not read/modify value directly.
-bool on_memory_pressure_called = false;
-
-// If the memory notifier got called, this is the memory pressure reported.
-MemoryPressureListener::MemoryPressureLevel on_memory_pressure_level =
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-
-// Processes OnMemoryPressure calls.
-void OnMemoryPressure(MemoryPressureListener::MemoryPressureLevel level) {
- on_memory_pressure_called = true;
- on_memory_pressure_level = level;
-}
-
-// Resets the indicator for memory pressure.
-void ResetOnMemoryPressureCalled() {
- on_memory_pressure_called = false;
-}
-
-// Returns true when OnMemoryPressure was called (and resets it).
-bool WasOnMemoryPressureCalled() {
- bool b = on_memory_pressure_called;
- ResetOnMemoryPressureCalled();
- return b;
-}
-
-} // namespace
-
-class TestMemoryPressureMonitor : public MemoryPressureMonitor {
- public:
- TestMemoryPressureMonitor()
- : MemoryPressureMonitor(THRESHOLD_DEFAULT),
- memory_in_percent_override_(0) {
- // Disable any timers which are going on and set a special memory reporting
- // function.
- StopObserving();
- }
- ~TestMemoryPressureMonitor() override = default;
-
- void SetMemoryInPercentOverride(int percent) {
- memory_in_percent_override_ = percent;
- }
-
- void CheckMemoryPressureForTest() {
- CheckMemoryPressure();
- }
-
- private:
- int GetUsedMemoryInPercent() override {
- return memory_in_percent_override_;
- }
-
- int memory_in_percent_override_;
- DISALLOW_COPY_AND_ASSIGN(TestMemoryPressureMonitor);
-};
-
-// This test tests the various transition states from memory pressure, looking
-// for the correct behavior on event reposting as well as state updates.
-TEST(ChromeOSMemoryPressureMonitorTest, CheckMemoryPressure) {
- // crbug.com/844102:
- if (base::SysInfo::IsRunningOnChromeOS())
- return;
-
- base::MessageLoopForUI message_loop;
- std::unique_ptr<TestMemoryPressureMonitor> monitor(
- new TestMemoryPressureMonitor);
- std::unique_ptr<MemoryPressureListener> listener(
- new MemoryPressureListener(base::Bind(&OnMemoryPressure)));
- // Checking the memory pressure while 0% are used should not produce any
- // events.
- monitor->SetMemoryInPercentOverride(0);
- ResetOnMemoryPressureCalled();
-
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_FALSE(WasOnMemoryPressureCalled());
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- monitor->GetCurrentPressureLevel());
-
- // Setting the memory level to 80% should produce a moderate pressure level.
- monitor->SetMemoryInPercentOverride(80);
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(WasOnMemoryPressureCalled());
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->GetCurrentPressureLevel());
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- on_memory_pressure_level);
-
- // We need to check that the event gets reposted after a while.
- int i = 0;
- for (; i < 100; i++) {
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->GetCurrentPressureLevel());
- if (WasOnMemoryPressureCalled()) {
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- on_memory_pressure_level);
- break;
- }
- }
- // Should be more than 5 and less than 100.
- EXPECT_LE(5, i);
- EXPECT_GE(99, i);
-
- // Setting the memory usage to 99% should produce critical levels.
- monitor->SetMemoryInPercentOverride(99);
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(WasOnMemoryPressureCalled());
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- on_memory_pressure_level);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- monitor->GetCurrentPressureLevel());
-
- // Calling it again should immediately produce a second call.
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(WasOnMemoryPressureCalled());
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- on_memory_pressure_level);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- monitor->GetCurrentPressureLevel());
-
- // When lowering the pressure again we should not get an event, but the
- // pressure should go back to moderate.
- monitor->SetMemoryInPercentOverride(80);
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_FALSE(WasOnMemoryPressureCalled());
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->GetCurrentPressureLevel());
-
- // We should need exactly the same amount of calls as before, before the next
- // call comes in.
- int j = 0;
- for (; j < 100; j++) {
- monitor->CheckMemoryPressureForTest();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->GetCurrentPressureLevel());
- if (WasOnMemoryPressureCalled()) {
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- on_memory_pressure_level);
- break;
- }
- }
- // We should have needed exactly the same amount of checks as before.
- EXPECT_EQ(j, i);
-}
-
-} // namespace chromeos
-} // namespace base
diff --git a/base/memory/memory_pressure_monitor_mac_unittest.cc b/base/memory/memory_pressure_monitor_mac_unittest.cc
deleted file mode 100644
index ff464fb..0000000
--- a/base/memory/memory_pressure_monitor_mac_unittest.cc
+++ /dev/null
@@ -1,228 +0,0 @@
-// Copyright 2015 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 "base/memory/memory_pressure_monitor_mac.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/mac/scoped_cftyperef.h"
-#include "base/macros.h"
-#include "base/test/histogram_tester.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace mac {
-
-class TestMemoryPressureMonitor : public MemoryPressureMonitor {
- public:
- using MemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel;
-
- // A HistogramTester for verifying correct UMA stat generation.
- base::HistogramTester tester;
-
- TestMemoryPressureMonitor() { }
-
- // Clears the next run loop update time so that the next pass of the run
- // loop checks the memory pressure level immediately. Normally there's a
- // 5 second delay between pressure readings.
- void ResetRunLoopUpdateTime() { next_run_loop_update_time_ = 0; }
-
- // Sets the last UMA stat report time. Time spent in memory pressure is
- // recorded in 5-second "ticks" from the last time statistics were recorded.
- void SetLastStatisticReportTime(CFTimeInterval time) {
- last_statistic_report_time_ = time;
- }
-
- // Sets the raw macOS memory pressure level read by the memory pressure
- // monitor.
- int macos_pressure_level_for_testing_;
-
- // Exposes the UpdatePressureLevel() method for testing.
- void UpdatePressureLevel() { MemoryPressureMonitor::UpdatePressureLevel(); }
-
- // Returns the number of seconds left over from the last UMA tick
- // calculation.
- int SubTickSeconds() { return subtick_seconds_; }
-
- // Returns the number of seconds per UMA tick.
- static int GetSecondsPerUMATick() {
- return MemoryPressureMonitor::GetSecondsPerUMATick();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TestMemoryPressureMonitor);
-
- int GetMacMemoryPressureLevel() override {
- return macos_pressure_level_for_testing_;
- }
-};
-
-TEST(MacMemoryPressureMonitorTest, MemoryPressureFromMacMemoryPressure) {
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- DISPATCH_MEMORYPRESSURE_NORMAL));
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- DISPATCH_MEMORYPRESSURE_WARN));
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- DISPATCH_MEMORYPRESSURE_CRITICAL));
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- 0));
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- 3));
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- 5));
- EXPECT_EQ(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- TestMemoryPressureMonitor::MemoryPressureLevelForMacMemoryPressureLevel(
- -1));
-}
-
-TEST(MacMemoryPressureMonitorTest, CurrentMemoryPressure) {
- TestMemoryPressureMonitor monitor;
-
- MemoryPressureListener::MemoryPressureLevel memory_pressure =
- monitor.GetCurrentPressureLevel();
- EXPECT_TRUE(memory_pressure ==
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE ||
- memory_pressure ==
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE ||
- memory_pressure ==
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
-}
-
-TEST(MacMemoryPressureMonitorTest, MemoryPressureConversion) {
- TestMemoryPressureMonitor monitor;
-
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_NORMAL;
- monitor.UpdatePressureLevel();
- MemoryPressureListener::MemoryPressureLevel memory_pressure =
- monitor.GetCurrentPressureLevel();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- memory_pressure);
-
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_WARN;
- monitor.UpdatePressureLevel();
- memory_pressure = monitor.GetCurrentPressureLevel();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- memory_pressure);
-
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_CRITICAL;
- monitor.UpdatePressureLevel();
- memory_pressure = monitor.GetCurrentPressureLevel();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- memory_pressure);
-}
-
-TEST(MacMemoryPressureMonitorTest, MemoryPressureRunLoopChecking) {
- TestMemoryPressureMonitor monitor;
-
- // To test grabbing the memory presure at the end of the run loop, we have to
- // run the run loop, but to do that the run loop needs a run loop source. Add
- // a timer as the source. We know that the exit observer is attached to
- // the kMessageLoopExclusiveRunLoopMode mode, so use that mode.
- ScopedCFTypeRef<CFRunLoopTimerRef> timer_ref(CFRunLoopTimerCreate(
- NULL, CFAbsoluteTimeGetCurrent() + 10, 0, 0, 0, nullptr, nullptr));
- CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer_ref,
- kMessageLoopExclusiveRunLoopMode);
-
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_WARN;
- monitor.ResetRunLoopUpdateTime();
- CFRunLoopRunInMode(kMessageLoopExclusiveRunLoopMode, 0, true);
- EXPECT_EQ(monitor.GetCurrentPressureLevel(),
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
-
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_CRITICAL;
- monitor.ResetRunLoopUpdateTime();
- CFRunLoopRunInMode(kMessageLoopExclusiveRunLoopMode, 0, true);
- EXPECT_EQ(monitor.GetCurrentPressureLevel(),
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
-
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_NORMAL;
- monitor.ResetRunLoopUpdateTime();
- CFRunLoopRunInMode(kMessageLoopExclusiveRunLoopMode, 0, true);
- EXPECT_EQ(monitor.GetCurrentPressureLevel(),
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
-
- CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), timer_ref,
- kMessageLoopExclusiveRunLoopMode);
-}
-
-TEST(MacMemoryPressureMonitorTest, RecordMemoryPressureStats) {
- TestMemoryPressureMonitor monitor;
- const char* kHistogram = "Memory.PressureLevel";
- CFTimeInterval now = CFAbsoluteTimeGetCurrent();
- const int seconds_per_tick =
- TestMemoryPressureMonitor::GetSecondsPerUMATick();
-
- // Set the initial pressure level.
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_NORMAL;
- // Incur one UMA tick of time (and include one extra second of elapsed time).
- monitor.SetLastStatisticReportTime(now - (seconds_per_tick + 1));
- monitor.UpdatePressureLevel();
- monitor.tester.ExpectTotalCount(kHistogram, 1);
- monitor.tester.ExpectBucketCount(kHistogram, 0, 1);
- // The report time above included an extra second so there should be 1
- // sub-tick second left over.
- EXPECT_EQ(1, monitor.SubTickSeconds());
-
- // Simulate sitting in normal pressure for 1 second less than 6 UMA tick
- // seconds and then elevating to warning. With the left over sub-tick second
- // from above, the total elapsed ticks should be an even 6 UMA ticks.
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_WARN;
- monitor.SetLastStatisticReportTime(now - (seconds_per_tick * 6 - 1));
- monitor.UpdatePressureLevel();
- monitor.tester.ExpectTotalCount(kHistogram, 7);
- monitor.tester.ExpectBucketCount(kHistogram, 0, 7);
- monitor.tester.ExpectBucketCount(kHistogram, 1, 0);
- EXPECT_EQ(0, monitor.SubTickSeconds());
-
- // Simulate sitting in warning pressure for 20 UMA ticks and 2 seconds, and
- // then elevating to critical.
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_CRITICAL;
- monitor.SetLastStatisticReportTime(now - (20 * seconds_per_tick + 2));
- monitor.UpdatePressureLevel();
- monitor.tester.ExpectTotalCount(kHistogram, 27);
- monitor.tester.ExpectBucketCount(kHistogram, 0, 7);
- monitor.tester.ExpectBucketCount(kHistogram, 1, 20);
- monitor.tester.ExpectBucketCount(kHistogram, 2, 0);
- EXPECT_EQ(2, monitor.SubTickSeconds());
-
- // A quick update while critical - the stats should not budge because less
- // than 1 tick of time has elapsed.
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_CRITICAL;
- monitor.SetLastStatisticReportTime(now - 1);
- monitor.UpdatePressureLevel();
- monitor.tester.ExpectTotalCount(kHistogram, 27);
- monitor.tester.ExpectBucketCount(kHistogram, 0, 7);
- monitor.tester.ExpectBucketCount(kHistogram, 1, 20);
- monitor.tester.ExpectBucketCount(kHistogram, 2, 0);
- EXPECT_EQ(3, monitor.SubTickSeconds());
-
- // A quick change back to normal. Less than 1 tick of time has elapsed, but
- // in this case the pressure level changed, so the critical bucket should
- // get another sample (otherwise we could miss quick level changes).
- monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_NORMAL;
- monitor.SetLastStatisticReportTime(now - 1);
- monitor.UpdatePressureLevel();
- monitor.tester.ExpectTotalCount(kHistogram, 28);
- monitor.tester.ExpectBucketCount(kHistogram, 0, 7);
- monitor.tester.ExpectBucketCount(kHistogram, 1, 20);
- monitor.tester.ExpectBucketCount(kHistogram, 2, 1);
- // When less than 1 tick of time has elapsed but the pressure level changed,
- // the subtick remainder gets zeroed out.
- EXPECT_EQ(0, monitor.SubTickSeconds());
-}
-} // namespace mac
-} // namespace base
diff --git a/base/memory/memory_pressure_monitor_unittest.cc b/base/memory/memory_pressure_monitor_unittest.cc
deleted file mode 100644
index e974741..0000000
--- a/base/memory/memory_pressure_monitor_unittest.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2016 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 "base/memory/memory_pressure_monitor.h"
-
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-#include "base/test/histogram_tester.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(MemoryPressureMonitorTest, RecordMemoryPressure) {
- base::HistogramTester tester;
- const char* kHistogram = "Memory.PressureLevel";
-
- MemoryPressureMonitor::RecordMemoryPressure(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE, 3);
- tester.ExpectTotalCount(kHistogram, 3);
- tester.ExpectBucketCount(kHistogram, 0, 3);
-
- MemoryPressureMonitor::RecordMemoryPressure(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE, 2);
- tester.ExpectTotalCount(kHistogram, 5);
- tester.ExpectBucketCount(kHistogram, 1, 2);
-
- MemoryPressureMonitor::RecordMemoryPressure(
- MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL, 1);
- tester.ExpectTotalCount(kHistogram, 6);
- tester.ExpectBucketCount(kHistogram, 2, 1);
-}
-} // namespace base
diff --git a/base/memory/memory_pressure_monitor_win_unittest.cc b/base/memory/memory_pressure_monitor_win_unittest.cc
deleted file mode 100644
index 1002a01..0000000
--- a/base/memory/memory_pressure_monitor_win_unittest.cc
+++ /dev/null
@@ -1,299 +0,0 @@
-// Copyright 2015 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 "base/memory/memory_pressure_monitor_win.h"
-
-#include "base/macros.h"
-#include "base/memory/memory_pressure_listener.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-struct PressureSettings {
- int phys_left_mb;
- MemoryPressureListener::MemoryPressureLevel level;
-};
-
-} // namespace
-
-// This is outside of the anonymous namespace so that it can be seen as a friend
-// to the monitor class.
-class TestMemoryPressureMonitor : public MemoryPressureMonitor {
- public:
- using MemoryPressureMonitor::CalculateCurrentPressureLevel;
- using MemoryPressureMonitor::CheckMemoryPressure;
-
- static const DWORDLONG kMBBytes = 1024 * 1024;
-
- explicit TestMemoryPressureMonitor(bool large_memory)
- : mem_status_() {
- // Generate a plausible amount of memory.
- mem_status_.ullTotalPhys =
- static_cast<DWORDLONG>(GenerateTotalMemoryMb(large_memory)) * kMBBytes;
-
- // Rerun InferThresholds using the test fixture's GetSystemMemoryStatus.
- InferThresholds();
- // Stop the timer.
- StopObserving();
- }
-
- TestMemoryPressureMonitor(int system_memory_mb,
- int moderate_threshold_mb,
- int critical_threshold_mb)
- : MemoryPressureMonitor(moderate_threshold_mb, critical_threshold_mb),
- mem_status_() {
- // Set the amount of system memory.
- mem_status_.ullTotalPhys = static_cast<DWORDLONG>(
- system_memory_mb * kMBBytes);
-
- // Stop the timer.
- StopObserving();
- }
-
- virtual ~TestMemoryPressureMonitor() {}
-
- MOCK_METHOD1(OnMemoryPressure,
- void(MemoryPressureListener::MemoryPressureLevel level));
-
- // Generates an amount of total memory that is consistent with the requested
- // memory model.
- int GenerateTotalMemoryMb(bool large_memory) {
- int total_mb = 64;
- while (total_mb < MemoryPressureMonitor::kLargeMemoryThresholdMb)
- total_mb *= 2;
- if (large_memory)
- return total_mb * 2;
- return total_mb / 2;
- }
-
- // Sets up the memory status to reflect the provided absolute memory left.
- void SetMemoryFree(int phys_left_mb) {
- // ullTotalPhys is set in the constructor and not modified.
-
- // Set the amount of available memory.
- mem_status_.ullAvailPhys =
- static_cast<DWORDLONG>(phys_left_mb) * kMBBytes;
- DCHECK_LT(mem_status_.ullAvailPhys, mem_status_.ullTotalPhys);
-
- // These fields are unused.
- mem_status_.dwMemoryLoad = 0;
- mem_status_.ullTotalPageFile = 0;
- mem_status_.ullAvailPageFile = 0;
- mem_status_.ullTotalVirtual = 0;
- mem_status_.ullAvailVirtual = 0;
- }
-
- void SetNone() {
- SetMemoryFree(moderate_threshold_mb() + 1);
- }
-
- void SetModerate() {
- SetMemoryFree(moderate_threshold_mb() - 1);
- }
-
- void SetCritical() {
- SetMemoryFree(critical_threshold_mb() - 1);
- }
-
- private:
- bool GetSystemMemoryStatus(MEMORYSTATUSEX* mem_status) override {
- // Simply copy the memory status set by the test fixture.
- *mem_status = mem_status_;
- return true;
- }
-
- MEMORYSTATUSEX mem_status_;
-
- DISALLOW_COPY_AND_ASSIGN(TestMemoryPressureMonitor);
-};
-
-class WinMemoryPressureMonitorTest : public testing::Test {
- protected:
- void CalculateCurrentMemoryPressureLevelTest(
- TestMemoryPressureMonitor* monitor) {
-
- int mod = monitor->moderate_threshold_mb();
- monitor->SetMemoryFree(mod + 1);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- monitor->CalculateCurrentPressureLevel());
-
- monitor->SetMemoryFree(mod);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->CalculateCurrentPressureLevel());
-
- monitor->SetMemoryFree(mod - 1);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->CalculateCurrentPressureLevel());
-
- int crit = monitor->critical_threshold_mb();
- monitor->SetMemoryFree(crit + 1);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor->CalculateCurrentPressureLevel());
-
- monitor->SetMemoryFree(crit);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- monitor->CalculateCurrentPressureLevel());
-
- monitor->SetMemoryFree(crit - 1);
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- monitor->CalculateCurrentPressureLevel());
- }
-
- base::MessageLoopForUI message_loop_;
-};
-
-// Tests the fundamental direct calculation of memory pressure with automatic
-// small-memory thresholds.
-TEST_F(WinMemoryPressureMonitorTest, CalculateCurrentMemoryPressureLevelSmall) {
- static const int kModerateMb =
- MemoryPressureMonitor::kSmallMemoryDefaultModerateThresholdMb;
- static const int kCriticalMb =
- MemoryPressureMonitor::kSmallMemoryDefaultCriticalThresholdMb;
-
- TestMemoryPressureMonitor monitor(false); // Small-memory model.
-
- EXPECT_EQ(kModerateMb, monitor.moderate_threshold_mb());
- EXPECT_EQ(kCriticalMb, monitor.critical_threshold_mb());
-
- ASSERT_NO_FATAL_FAILURE(CalculateCurrentMemoryPressureLevelTest(&monitor));
-}
-
-// Tests the fundamental direct calculation of memory pressure with automatic
-// large-memory thresholds.
-TEST_F(WinMemoryPressureMonitorTest, CalculateCurrentMemoryPressureLevelLarge) {
- static const int kModerateMb =
- MemoryPressureMonitor::kLargeMemoryDefaultModerateThresholdMb;
- static const int kCriticalMb =
- MemoryPressureMonitor::kLargeMemoryDefaultCriticalThresholdMb;
-
- TestMemoryPressureMonitor monitor(true); // Large-memory model.
-
- EXPECT_EQ(kModerateMb, monitor.moderate_threshold_mb());
- EXPECT_EQ(kCriticalMb, monitor.critical_threshold_mb());
-
- ASSERT_NO_FATAL_FAILURE(CalculateCurrentMemoryPressureLevelTest(&monitor));
-}
-
-// Tests the fundamental direct calculation of memory pressure with manually
-// specified threshold levels.
-TEST_F(WinMemoryPressureMonitorTest,
- CalculateCurrentMemoryPressureLevelCustom) {
- static const int kSystemMb = 512;
- static const int kModerateMb = 256;
- static const int kCriticalMb = 128;
-
- TestMemoryPressureMonitor monitor(kSystemMb, kModerateMb, kCriticalMb);
-
- EXPECT_EQ(kModerateMb, monitor.moderate_threshold_mb());
- EXPECT_EQ(kCriticalMb, monitor.critical_threshold_mb());
-
- ASSERT_NO_FATAL_FAILURE(CalculateCurrentMemoryPressureLevelTest(&monitor));
-}
-
-// This test tests the various transition states from memory pressure, looking
-// for the correct behavior on event reposting as well as state updates.
-TEST_F(WinMemoryPressureMonitorTest, CheckMemoryPressure) {
- // Large-memory.
- testing::StrictMock<TestMemoryPressureMonitor> monitor(true);
- MemoryPressureListener listener(
- base::Bind(&TestMemoryPressureMonitor::OnMemoryPressure,
- base::Unretained(&monitor)));
-
- // Checking the memory pressure at 0% load should not produce any
- // events.
- monitor.SetNone();
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- monitor.GetCurrentPressureLevel());
-
- // Setting the memory level to 80% should produce a moderate pressure level.
- EXPECT_CALL(monitor,
- OnMemoryPressure(MemoryPressureListener::
- MEMORY_PRESSURE_LEVEL_MODERATE));
- monitor.SetModerate();
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
-
- // Check that the event gets reposted after a while.
- for (int i = 0; i < monitor.kModeratePressureCooldownCycles; ++i) {
- if (i + 1 == monitor.kModeratePressureCooldownCycles) {
- EXPECT_CALL(monitor,
- OnMemoryPressure(MemoryPressureListener::
- MEMORY_PRESSURE_LEVEL_MODERATE));
- }
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
- }
-
- // Setting the memory usage to 99% should produce critical levels.
- EXPECT_CALL(monitor,
- OnMemoryPressure(MemoryPressureListener::
- MEMORY_PRESSURE_LEVEL_CRITICAL));
- monitor.SetCritical();
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
-
- // Calling it again should immediately produce a second call.
- EXPECT_CALL(monitor,
- OnMemoryPressure(MemoryPressureListener::
- MEMORY_PRESSURE_LEVEL_CRITICAL));
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
-
- // When lowering the pressure again there should be a notification and the
- // pressure should go back to moderate.
- EXPECT_CALL(monitor,
- OnMemoryPressure(MemoryPressureListener::
- MEMORY_PRESSURE_LEVEL_MODERATE));
- monitor.SetModerate();
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
-
- // Check that the event gets reposted after a while.
- for (int i = 0; i < monitor.kModeratePressureCooldownCycles; ++i) {
- if (i + 1 == monitor.kModeratePressureCooldownCycles) {
- EXPECT_CALL(monitor,
- OnMemoryPressure(MemoryPressureListener::
- MEMORY_PRESSURE_LEVEL_MODERATE));
- }
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
- }
-
- // Going down to no pressure should not produce an notification.
- monitor.SetNone();
- monitor.CheckMemoryPressure();
- RunLoop().RunUntilIdle();
- EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
- monitor.GetCurrentPressureLevel());
- testing::Mock::VerifyAndClearExpectations(&monitor);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/memory/platform_shared_memory_region_unittest.cc b/base/memory/platform_shared_memory_region_unittest.cc
deleted file mode 100644
index f4d3071..0000000
--- a/base/memory/platform_shared_memory_region_unittest.cc
+++ /dev/null
@@ -1,288 +0,0 @@
-// Copyright 2018 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 "base/memory/platform_shared_memory_region.h"
-
-#include "base/memory/shared_memory_mapping.h"
-#include "base/process/process_metrics.h"
-#include "base/sys_info.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_shared_memory_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-#include <mach/mach_vm.h>
-#endif
-
-namespace base {
-namespace subtle {
-
-const size_t kRegionSize = 1024;
-
-class PlatformSharedMemoryRegionTest : public ::testing::Test {};
-
-// Tests that a default constructed region is invalid and produces invalid
-// mappings.
-TEST_F(PlatformSharedMemoryRegionTest, DefaultConstructedRegionIsInvalid) {
- PlatformSharedMemoryRegion region;
- EXPECT_FALSE(region.IsValid());
- WritableSharedMemoryMapping mapping = MapForTesting(®ion);
- EXPECT_FALSE(mapping.IsValid());
- PlatformSharedMemoryRegion duplicate = region.Duplicate();
- EXPECT_FALSE(duplicate.IsValid());
- EXPECT_FALSE(region.ConvertToReadOnly());
-}
-
-// Tests that creating a region of 0 size returns an invalid region.
-TEST_F(PlatformSharedMemoryRegionTest, CreateRegionOfZeroSizeIsInvalid) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(0);
- EXPECT_FALSE(region.IsValid());
-
- PlatformSharedMemoryRegion region2 =
- PlatformSharedMemoryRegion::CreateUnsafe(0);
- EXPECT_FALSE(region2.IsValid());
-}
-
-// Tests that creating a region of size bigger than the integer max value
-// returns an invalid region.
-TEST_F(PlatformSharedMemoryRegionTest, CreateTooLargeRegionIsInvalid) {
- size_t too_large_region_size =
- static_cast<size_t>(std::numeric_limits<int>::max()) + 1;
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(too_large_region_size);
- EXPECT_FALSE(region.IsValid());
-
- PlatformSharedMemoryRegion region2 =
- PlatformSharedMemoryRegion::CreateUnsafe(too_large_region_size);
- EXPECT_FALSE(region2.IsValid());
-}
-
-// Tests that regions consistently report their size as the size requested at
-// creation time even if their allocation size is larger due to platform
-// constraints.
-TEST_F(PlatformSharedMemoryRegionTest, ReportedSizeIsRequestedSize) {
- constexpr size_t kTestSizes[] = {1, 2, 3, 64, 4096, 1024 * 1024};
- for (size_t size : kTestSizes) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(size);
- EXPECT_EQ(region.GetSize(), size);
-
- region.ConvertToReadOnly();
- EXPECT_EQ(region.GetSize(), size);
- }
-}
-
-// Tests that the platform-specific handle converted to read-only cannot be used
-// to perform a writable mapping with low-level system APIs like mmap().
-TEST_F(PlatformSharedMemoryRegionTest, ReadOnlyHandleIsNotWritable) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- EXPECT_TRUE(region.ConvertToReadOnly());
- EXPECT_EQ(region.GetMode(), PlatformSharedMemoryRegion::Mode::kReadOnly);
- EXPECT_TRUE(
- CheckReadOnlyPlatformSharedMemoryRegionForTesting(std::move(region)));
-}
-
-// Tests that the PassPlatformHandle() call invalidates the region.
-TEST_F(PlatformSharedMemoryRegionTest, InvalidAfterPass) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- ignore_result(region.PassPlatformHandle());
- EXPECT_FALSE(region.IsValid());
-}
-
-// Tests that the region is invalid after move.
-TEST_F(PlatformSharedMemoryRegionTest, InvalidAfterMove) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- PlatformSharedMemoryRegion moved_region = std::move(region);
- EXPECT_FALSE(region.IsValid());
- EXPECT_TRUE(moved_region.IsValid());
-}
-
-// Tests that calling Take() with the size parameter equal to zero returns an
-// invalid region.
-TEST_F(PlatformSharedMemoryRegionTest, TakeRegionOfZeroSizeIsInvalid) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- PlatformSharedMemoryRegion region2 = PlatformSharedMemoryRegion::Take(
- region.PassPlatformHandle(), region.GetMode(), 0, region.GetGUID());
- EXPECT_FALSE(region2.IsValid());
-}
-
-// Tests that calling Take() with the size parameter bigger than the integer max
-// value returns an invalid region.
-TEST_F(PlatformSharedMemoryRegionTest, TakeTooLargeRegionIsInvalid) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- PlatformSharedMemoryRegion region2 = PlatformSharedMemoryRegion::Take(
- region.PassPlatformHandle(), region.GetMode(),
- static_cast<size_t>(std::numeric_limits<int>::max()) + 1,
- region.GetGUID());
- EXPECT_FALSE(region2.IsValid());
-}
-
-// Tests that mapping bytes out of the region limits fails.
-TEST_F(PlatformSharedMemoryRegionTest, MapAtOutOfTheRegionLimitsTest) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- WritableSharedMemoryMapping mapping =
- MapAtForTesting(®ion, 0, region.GetSize() + 1);
- EXPECT_FALSE(mapping.IsValid());
-}
-
-// Tests that mapping with a size and offset causing overflow fails.
-TEST_F(PlatformSharedMemoryRegionTest, MapAtWithOverflowTest) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(
- SysInfo::VMAllocationGranularity() * 2);
- ASSERT_TRUE(region.IsValid());
- size_t size = std::numeric_limits<size_t>::max();
- size_t offset = SysInfo::VMAllocationGranularity();
- // |size| + |offset| should be below the region size due to overflow but
- // mapping a region with these parameters should be invalid.
- EXPECT_LT(size + offset, region.GetSize());
- WritableSharedMemoryMapping mapping = MapAtForTesting(®ion, offset, size);
- EXPECT_FALSE(mapping.IsValid());
-}
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA) && \
- !defined(OS_MACOSX)
-// Tests that the second handle is closed after a conversion to read-only on
-// POSIX.
-TEST_F(PlatformSharedMemoryRegionTest,
- ConvertToReadOnlyInvalidatesSecondHandle) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- ASSERT_TRUE(region.ConvertToReadOnly());
- FDPair fds = region.GetPlatformHandle();
- EXPECT_LT(fds.readonly_fd, 0);
-}
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-// Tests that protection bits are set correctly for read-only region on MacOS.
-TEST_F(PlatformSharedMemoryRegionTest, MapCurrentAndMaxProtectionSetCorrectly) {
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- ASSERT_TRUE(region.ConvertToReadOnly());
- WritableSharedMemoryMapping ro_mapping = MapForTesting(®ion);
- ASSERT_TRUE(ro_mapping.IsValid());
-
- vm_region_basic_info_64 basic_info;
- mach_vm_size_t dummy_size = 0;
- void* temp_addr = ro_mapping.memory();
- MachVMRegionResult result = GetBasicInfo(
- mach_task_self(), &dummy_size,
- reinterpret_cast<mach_vm_address_t*>(&temp_addr), &basic_info);
- EXPECT_EQ(result, MachVMRegionResult::Success);
- EXPECT_EQ(basic_info.protection & VM_PROT_ALL, VM_PROT_READ);
- EXPECT_EQ(basic_info.max_protection & VM_PROT_ALL, VM_PROT_READ);
-}
-#endif
-
-// Tests that platform handle permissions are checked correctly.
-TEST_F(PlatformSharedMemoryRegionTest,
- CheckPlatformHandlePermissionsCorrespondToMode) {
- using Mode = PlatformSharedMemoryRegion::Mode;
- auto check = [](const PlatformSharedMemoryRegion& region,
- PlatformSharedMemoryRegion::Mode mode) {
- return PlatformSharedMemoryRegion::
- CheckPlatformHandlePermissionsCorrespondToMode(
- region.GetPlatformHandle(), mode, region.GetSize());
- };
-
- // Check kWritable region.
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- EXPECT_TRUE(check(region, Mode::kWritable));
- EXPECT_FALSE(check(region, Mode::kReadOnly));
-
- // Check kReadOnly region.
- ASSERT_TRUE(region.ConvertToReadOnly());
- EXPECT_TRUE(check(region, Mode::kReadOnly));
- EXPECT_FALSE(check(region, Mode::kWritable));
- EXPECT_FALSE(check(region, Mode::kUnsafe));
-
- // Check kUnsafe region.
- PlatformSharedMemoryRegion region2 =
- PlatformSharedMemoryRegion::CreateUnsafe(kRegionSize);
- ASSERT_TRUE(region2.IsValid());
- EXPECT_TRUE(check(region2, Mode::kUnsafe));
- EXPECT_FALSE(check(region2, Mode::kReadOnly));
-}
-
-// Tests that it's impossible to create read-only platform shared memory region.
-TEST_F(PlatformSharedMemoryRegionTest, CreateReadOnlyRegionDeathTest) {
-#ifdef OFFICIAL_BUILD
- // The official build does not print the reason a CHECK failed.
- const char kErrorRegex[] = "";
-#else
- const char kErrorRegex[] =
- "Creating a region in read-only mode will lead to this region being "
- "non-modifiable";
-#endif
- EXPECT_DEATH_IF_SUPPORTED(
- PlatformSharedMemoryRegion::Create(
- PlatformSharedMemoryRegion::Mode::kReadOnly, kRegionSize),
- kErrorRegex);
-}
-
-// Tests that it's prohibited to duplicate a writable region.
-TEST_F(PlatformSharedMemoryRegionTest, DuplicateWritableRegionDeathTest) {
-#ifdef OFFICIAL_BUILD
- const char kErrorRegex[] = "";
-#else
- const char kErrorRegex[] =
- "Duplicating a writable shared memory region is prohibited";
-#endif
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- EXPECT_DEATH_IF_SUPPORTED(region.Duplicate(), kErrorRegex);
-}
-
-// Tests that it's prohibited to convert an unsafe region to read-only.
-TEST_F(PlatformSharedMemoryRegionTest, UnsafeRegionConvertToReadOnlyDeathTest) {
-#ifdef OFFICIAL_BUILD
- const char kErrorRegex[] = "";
-#else
- const char kErrorRegex[] =
- "Only writable shared memory region can be converted to read-only";
-#endif
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateUnsafe(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- EXPECT_DEATH_IF_SUPPORTED(region.ConvertToReadOnly(), kErrorRegex);
-}
-
-// Tests that it's prohibited to convert a read-only region to read-only.
-TEST_F(PlatformSharedMemoryRegionTest,
- ReadOnlyRegionConvertToReadOnlyDeathTest) {
-#ifdef OFFICIAL_BUILD
- const char kErrorRegex[] = "";
-#else
- const char kErrorRegex[] =
- "Only writable shared memory region can be converted to read-only";
-#endif
- PlatformSharedMemoryRegion region =
- PlatformSharedMemoryRegion::CreateWritable(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- EXPECT_TRUE(region.ConvertToReadOnly());
- EXPECT_DEATH_IF_SUPPORTED(region.ConvertToReadOnly(), kErrorRegex);
-}
-
-} // namespace subtle
-} // namespace base
diff --git a/base/memory/protected_memory_unittest.cc b/base/memory/protected_memory_unittest.cc
deleted file mode 100644
index b6ec61d..0000000
--- a/base/memory/protected_memory_unittest.cc
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2017 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 "base/memory/protected_memory.h"
-#include "base/memory/protected_memory_cfi.h"
-#include "base/synchronization/lock.h"
-#include "base/test/gtest_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-struct Data {
- Data() = default;
- Data(int foo_) : foo(foo_) {}
- int foo;
-};
-
-} // namespace
-
-class ProtectedMemoryTest : public ::testing::Test {
- protected:
- // Run tests one at a time. Some of the negative tests can not be made thread
- // safe.
- void SetUp() final { lock.Acquire(); }
- void TearDown() final { lock.Release(); }
-
- Lock lock;
-};
-
-PROTECTED_MEMORY_SECTION ProtectedMemory<int> init;
-
-TEST_F(ProtectedMemoryTest, Initializer) {
- static ProtectedMemory<int>::Initializer I(&init, 4);
- EXPECT_EQ(*init, 4);
-}
-
-PROTECTED_MEMORY_SECTION ProtectedMemory<Data> data;
-
-TEST_F(ProtectedMemoryTest, Basic) {
- AutoWritableMemory writer = AutoWritableMemory::Create(data);
- data->foo = 5;
- EXPECT_EQ(data->foo, 5);
-}
-
-#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-
-#if PROTECTED_MEMORY_ENABLED
-TEST_F(ProtectedMemoryTest, ReadOnlyOnStart) {
- EXPECT_DEATH({ data->foo = 6; AutoWritableMemory::Create(data); }, "");
-}
-
-TEST_F(ProtectedMemoryTest, ReadOnlyAfterSetWritable) {
- { AutoWritableMemory writer = AutoWritableMemory::Create(data); }
- EXPECT_DEATH({ data->foo = 7; }, "");
-}
-
-TEST_F(ProtectedMemoryTest, AssertMemoryIsReadOnly) {
- AssertMemoryIsReadOnly(&data->foo);
- { AutoWritableMemory::Create(data); }
- AssertMemoryIsReadOnly(&data->foo);
-
- ProtectedMemory<Data> writable_data;
- EXPECT_DCHECK_DEATH({ AssertMemoryIsReadOnly(&writable_data->foo); });
-}
-
-TEST_F(ProtectedMemoryTest, FailsIfDefinedOutsideOfProtectMemoryRegion) {
- ProtectedMemory<Data> data;
- EXPECT_DCHECK_DEATH({ AutoWritableMemory::Create(data); });
-}
-
-TEST_F(ProtectedMemoryTest, UnsanitizedCfiCallOutsideOfProtectedMemoryRegion) {
- ProtectedMemory<void (*)(void)> data;
- EXPECT_DCHECK_DEATH({ UnsanitizedCfiCall(data)(); });
-}
-#endif // PROTECTED_MEMORY_ENABLED
-
-namespace {
-
-struct BadIcall {
- BadIcall() = default;
- BadIcall(int (*fp_)(int)) : fp(fp_) {}
- int (*fp)(int);
-};
-
-unsigned int bad_icall(int i) {
- return 4 + i;
-}
-
-} // namespace
-
-PROTECTED_MEMORY_SECTION ProtectedMemory<BadIcall> icall_pm1;
-
-TEST_F(ProtectedMemoryTest, BadMemberCall) {
- static ProtectedMemory<BadIcall>::Initializer I(
- &icall_pm1, BadIcall(reinterpret_cast<int (*)(int)>(&bad_icall)));
-
- EXPECT_EQ(UnsanitizedCfiCall(icall_pm1, &BadIcall::fp)(1), 5);
- EXPECT_EQ(icall_pm1->fp(1), 5);
-}
-
-PROTECTED_MEMORY_SECTION ProtectedMemory<int (*)(int)> icall_pm2;
-
-TEST_F(ProtectedMemoryTest, BadFnPtrCall) {
- static ProtectedMemory<int (*)(int)>::Initializer I(
- &icall_pm2, reinterpret_cast<int (*)(int)>(&bad_icall));
-
- EXPECT_EQ(UnsanitizedCfiCall(icall_pm2)(1), 5);
- EXPECT_EQ((*icall_pm2)(1), 5);
-}
-
-#endif // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-
-} // namespace base
diff --git a/base/memory/ptr_util_unittest.cc b/base/memory/ptr_util_unittest.cc
deleted file mode 100644
index 3fa40d8..0000000
--- a/base/memory/ptr_util_unittest.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2015 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 "base/memory/ptr_util.h"
-
-#include <stddef.h>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class DeleteCounter {
- public:
- DeleteCounter() { ++count_; }
- ~DeleteCounter() { --count_; }
-
- static size_t count() { return count_; }
-
- private:
- static size_t count_;
-};
-
-size_t DeleteCounter::count_ = 0;
-
-} // namespace
-
-TEST(PtrUtilTest, WrapUnique) {
- EXPECT_EQ(0u, DeleteCounter::count());
- DeleteCounter* counter = new DeleteCounter;
- EXPECT_EQ(1u, DeleteCounter::count());
- std::unique_ptr<DeleteCounter> owned_counter = WrapUnique(counter);
- EXPECT_EQ(1u, DeleteCounter::count());
- owned_counter.reset();
- EXPECT_EQ(0u, DeleteCounter::count());
-}
-
-} // namespace base
diff --git a/base/memory/ref_counted_memory_unittest.cc b/base/memory/ref_counted_memory_unittest.cc
deleted file mode 100644
index b7498f9..0000000
--- a/base/memory/ref_counted_memory_unittest.cc
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) 2011 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 "base/memory/ref_counted_memory.h"
-
-#include <stdint.h>
-
-#include <utility>
-
-#include "base/memory/read_only_shared_memory_region.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::Each;
-using testing::ElementsAre;
-
-namespace base {
-
-TEST(RefCountedMemoryUnitTest, RefCountedStaticMemory) {
- auto mem = MakeRefCounted<RefCountedStaticMemory>("static mem00", 10);
-
- EXPECT_EQ(10U, mem->size());
- EXPECT_EQ("static mem", std::string(mem->front_as<char>(), mem->size()));
-}
-
-TEST(RefCountedMemoryUnitTest, RefCountedBytes) {
- std::vector<uint8_t> data;
- data.push_back(45);
- data.push_back(99);
- scoped_refptr<RefCountedMemory> mem = RefCountedBytes::TakeVector(&data);
-
- EXPECT_EQ(0U, data.size());
-
- ASSERT_EQ(2U, mem->size());
- EXPECT_EQ(45U, mem->front()[0]);
- EXPECT_EQ(99U, mem->front()[1]);
-
- scoped_refptr<RefCountedMemory> mem2;
- {
- const unsigned char kData[] = {12, 11, 99};
- mem2 = MakeRefCounted<RefCountedBytes>(kData, arraysize(kData));
- }
- ASSERT_EQ(3U, mem2->size());
- EXPECT_EQ(12U, mem2->front()[0]);
- EXPECT_EQ(11U, mem2->front()[1]);
- EXPECT_EQ(99U, mem2->front()[2]);
-}
-
-TEST(RefCountedMemoryUnitTest, RefCountedBytesMutable) {
- auto mem = base::MakeRefCounted<RefCountedBytes>(10);
-
- ASSERT_EQ(10U, mem->size());
- EXPECT_THAT(mem->data(), Each(0U));
-
- // Test non-const versions of data(), front() and front_as<>().
- mem->data()[0] = 1;
- mem->front()[1] = 2;
- mem->front_as<char>()[2] = 3;
-
- EXPECT_THAT(mem->data(), ElementsAre(1, 2, 3, 0, 0, 0, 0, 0, 0, 0));
-}
-
-TEST(RefCountedMemoryUnitTest, RefCountedString) {
- std::string s("destroy me");
- scoped_refptr<RefCountedMemory> mem = RefCountedString::TakeString(&s);
-
- EXPECT_EQ(0U, s.size());
-
- ASSERT_EQ(10U, mem->size());
- EXPECT_EQ('d', mem->front()[0]);
- EXPECT_EQ('e', mem->front()[1]);
- EXPECT_EQ('e', mem->front()[9]);
-}
-
-TEST(RefCountedMemoryUnitTest, RefCountedSharedMemory) {
- static const char kData[] = "shm_dummy_data";
- auto shm = std::make_unique<SharedMemory>();
- ASSERT_TRUE(shm->CreateAndMapAnonymous(sizeof(kData)));
- memcpy(shm->memory(), kData, sizeof(kData));
-
- auto mem =
- MakeRefCounted<RefCountedSharedMemory>(std::move(shm), sizeof(kData));
- ASSERT_EQ(sizeof(kData), mem->size());
- EXPECT_EQ('s', mem->front()[0]);
- EXPECT_EQ('h', mem->front()[1]);
- EXPECT_EQ('_', mem->front()[9]);
-}
-
-TEST(RefCountedMemoryUnitTest, RefCountedSharedMemoryMapping) {
- static const char kData[] = "mem_region_dummy_data";
- scoped_refptr<RefCountedSharedMemoryMapping> mem;
- {
- MappedReadOnlyRegion region =
- ReadOnlySharedMemoryRegion::Create(sizeof(kData));
- ReadOnlySharedMemoryMapping ro_mapping = region.region.Map();
- WritableSharedMemoryMapping rw_mapping = std::move(region.mapping);
- ASSERT_TRUE(rw_mapping.IsValid());
- memcpy(rw_mapping.memory(), kData, sizeof(kData));
- mem = MakeRefCounted<RefCountedSharedMemoryMapping>(std::move(ro_mapping));
- }
-
- ASSERT_LE(sizeof(kData), mem->size());
- EXPECT_EQ('e', mem->front()[1]);
- EXPECT_EQ('m', mem->front()[2]);
- EXPECT_EQ('o', mem->front()[8]);
-
- {
- MappedReadOnlyRegion region =
- ReadOnlySharedMemoryRegion::Create(sizeof(kData));
- WritableSharedMemoryMapping rw_mapping = std::move(region.mapping);
- ASSERT_TRUE(rw_mapping.IsValid());
- memcpy(rw_mapping.memory(), kData, sizeof(kData));
- mem = RefCountedSharedMemoryMapping::CreateFromWholeRegion(region.region);
- }
-
- ASSERT_LE(sizeof(kData), mem->size());
- EXPECT_EQ('_', mem->front()[3]);
- EXPECT_EQ('r', mem->front()[4]);
- EXPECT_EQ('i', mem->front()[7]);
-}
-
-TEST(RefCountedMemoryUnitTest, Equals) {
- std::string s1("same");
- scoped_refptr<RefCountedMemory> mem1 = RefCountedString::TakeString(&s1);
-
- std::vector<unsigned char> d2 = {'s', 'a', 'm', 'e'};
- scoped_refptr<RefCountedMemory> mem2 = RefCountedBytes::TakeVector(&d2);
-
- EXPECT_TRUE(mem1->Equals(mem2));
-
- std::string s3("diff");
- scoped_refptr<RefCountedMemory> mem3 = RefCountedString::TakeString(&s3);
-
- EXPECT_FALSE(mem1->Equals(mem3));
- EXPECT_FALSE(mem2->Equals(mem3));
-}
-
-TEST(RefCountedMemoryUnitTest, EqualsNull) {
- std::string s("str");
- scoped_refptr<RefCountedMemory> mem = RefCountedString::TakeString(&s);
- EXPECT_FALSE(mem->Equals(nullptr));
-}
-
-} // namespace base
diff --git a/base/memory/ref_counted_unittest.cc b/base/memory/ref_counted_unittest.cc
deleted file mode 100644
index d88fc54..0000000
--- a/base/memory/ref_counted_unittest.cc
+++ /dev/null
@@ -1,606 +0,0 @@
-// 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.
-
-#include "base/memory/ref_counted.h"
-
-#include <type_traits>
-#include <utility>
-
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-class SelfAssign : public base::RefCounted<SelfAssign> {
- protected:
- virtual ~SelfAssign() = default;
-
- private:
- friend class base::RefCounted<SelfAssign>;
-};
-
-class Derived : public SelfAssign {
- protected:
- ~Derived() override = default;
-
- private:
- friend class base::RefCounted<Derived>;
-};
-
-class CheckDerivedMemberAccess : public scoped_refptr<SelfAssign> {
- public:
- CheckDerivedMemberAccess() {
- // This shouldn't compile if we don't have access to the member variable.
- SelfAssign** pptr = &ptr_;
- EXPECT_EQ(*pptr, ptr_);
- }
-};
-
-class ScopedRefPtrToSelf : public base::RefCounted<ScopedRefPtrToSelf> {
- public:
- ScopedRefPtrToSelf() : self_ptr_(this) {}
-
- static bool was_destroyed() { return was_destroyed_; }
-
- static void reset_was_destroyed() { was_destroyed_ = false; }
-
- scoped_refptr<ScopedRefPtrToSelf> self_ptr_;
-
- private:
- friend class base::RefCounted<ScopedRefPtrToSelf>;
- ~ScopedRefPtrToSelf() { was_destroyed_ = true; }
-
- static bool was_destroyed_;
-};
-
-bool ScopedRefPtrToSelf::was_destroyed_ = false;
-
-class ScopedRefPtrCountBase : public base::RefCounted<ScopedRefPtrCountBase> {
- public:
- ScopedRefPtrCountBase() { ++constructor_count_; }
-
- static int constructor_count() { return constructor_count_; }
-
- static int destructor_count() { return destructor_count_; }
-
- static void reset_count() {
- constructor_count_ = 0;
- destructor_count_ = 0;
- }
-
- protected:
- virtual ~ScopedRefPtrCountBase() { ++destructor_count_; }
-
- private:
- friend class base::RefCounted<ScopedRefPtrCountBase>;
-
- static int constructor_count_;
- static int destructor_count_;
-};
-
-int ScopedRefPtrCountBase::constructor_count_ = 0;
-int ScopedRefPtrCountBase::destructor_count_ = 0;
-
-class ScopedRefPtrCountDerived : public ScopedRefPtrCountBase {
- public:
- ScopedRefPtrCountDerived() { ++constructor_count_; }
-
- static int constructor_count() { return constructor_count_; }
-
- static int destructor_count() { return destructor_count_; }
-
- static void reset_count() {
- constructor_count_ = 0;
- destructor_count_ = 0;
- }
-
- protected:
- ~ScopedRefPtrCountDerived() override { ++destructor_count_; }
-
- private:
- friend class base::RefCounted<ScopedRefPtrCountDerived>;
-
- static int constructor_count_;
- static int destructor_count_;
-};
-
-int ScopedRefPtrCountDerived::constructor_count_ = 0;
-int ScopedRefPtrCountDerived::destructor_count_ = 0;
-
-class Other : public base::RefCounted<Other> {
- private:
- friend class base::RefCounted<Other>;
-
- ~Other() = default;
-};
-
-class HasPrivateDestructorWithDeleter;
-
-struct Deleter {
- static void Destruct(const HasPrivateDestructorWithDeleter* x);
-};
-
-class HasPrivateDestructorWithDeleter
- : public base::RefCounted<HasPrivateDestructorWithDeleter, Deleter> {
- public:
- HasPrivateDestructorWithDeleter() = default;
-
- private:
- friend struct Deleter;
- ~HasPrivateDestructorWithDeleter() = default;
-};
-
-void Deleter::Destruct(const HasPrivateDestructorWithDeleter* x) {
- delete x;
-}
-
-scoped_refptr<Other> Overloaded(scoped_refptr<Other> other) {
- return other;
-}
-
-scoped_refptr<SelfAssign> Overloaded(scoped_refptr<SelfAssign> self_assign) {
- return self_assign;
-}
-
-class InitialRefCountIsOne : public base::RefCounted<InitialRefCountIsOne> {
- public:
- REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
-
- InitialRefCountIsOne() = default;
-
- private:
- friend class base::RefCounted<InitialRefCountIsOne>;
- ~InitialRefCountIsOne() = default;
-};
-
-} // end namespace
-
-TEST(RefCountedUnitTest, TestSelfAssignment) {
- SelfAssign* p = new SelfAssign;
- scoped_refptr<SelfAssign> var(p);
- var = *&var; // The *& defeats Clang's -Wself-assign warning.
- EXPECT_EQ(var.get(), p);
- var = std::move(var);
- EXPECT_EQ(var.get(), p);
- var.swap(var);
- EXPECT_EQ(var.get(), p);
- swap(var, var);
- EXPECT_EQ(var.get(), p);
-}
-
-TEST(RefCountedUnitTest, ScopedRefPtrMemberAccess) {
- CheckDerivedMemberAccess check;
-}
-
-TEST(RefCountedUnitTest, ScopedRefPtrToSelfPointerAssignment) {
- ScopedRefPtrToSelf::reset_was_destroyed();
-
- ScopedRefPtrToSelf* check = new ScopedRefPtrToSelf();
- EXPECT_FALSE(ScopedRefPtrToSelf::was_destroyed());
- check->self_ptr_ = nullptr;
- EXPECT_TRUE(ScopedRefPtrToSelf::was_destroyed());
-}
-
-TEST(RefCountedUnitTest, ScopedRefPtrToSelfMoveAssignment) {
- ScopedRefPtrToSelf::reset_was_destroyed();
-
- ScopedRefPtrToSelf* check = new ScopedRefPtrToSelf();
- EXPECT_FALSE(ScopedRefPtrToSelf::was_destroyed());
- // Releasing |check->self_ptr_| will delete |check|.
- // The move assignment operator must assign |check->self_ptr_| first then
- // release |check->self_ptr_|.
- check->self_ptr_ = scoped_refptr<ScopedRefPtrToSelf>();
- EXPECT_TRUE(ScopedRefPtrToSelf::was_destroyed());
-}
-
-TEST(RefCountedUnitTest, BooleanTesting) {
- scoped_refptr<SelfAssign> ptr_to_an_instance = new SelfAssign;
- EXPECT_TRUE(ptr_to_an_instance);
- EXPECT_FALSE(!ptr_to_an_instance);
-
- if (ptr_to_an_instance) {
- } else {
- ADD_FAILURE() << "Pointer to an instance should result in true.";
- }
-
- if (!ptr_to_an_instance) { // check for operator!().
- ADD_FAILURE() << "Pointer to an instance should result in !x being false.";
- }
-
- scoped_refptr<SelfAssign> null_ptr;
- EXPECT_FALSE(null_ptr);
- EXPECT_TRUE(!null_ptr);
-
- if (null_ptr) {
- ADD_FAILURE() << "Null pointer should result in false.";
- }
-
- if (!null_ptr) { // check for operator!().
- } else {
- ADD_FAILURE() << "Null pointer should result in !x being true.";
- }
-}
-
-TEST(RefCountedUnitTest, Equality) {
- scoped_refptr<SelfAssign> p1(new SelfAssign);
- scoped_refptr<SelfAssign> p2(new SelfAssign);
-
- EXPECT_EQ(p1, p1);
- EXPECT_EQ(p2, p2);
-
- EXPECT_NE(p1, p2);
- EXPECT_NE(p2, p1);
-}
-
-TEST(RefCountedUnitTest, NullptrEquality) {
- scoped_refptr<SelfAssign> ptr_to_an_instance(new SelfAssign);
- scoped_refptr<SelfAssign> ptr_to_nullptr;
-
- EXPECT_NE(nullptr, ptr_to_an_instance);
- EXPECT_NE(ptr_to_an_instance, nullptr);
- EXPECT_EQ(nullptr, ptr_to_nullptr);
- EXPECT_EQ(ptr_to_nullptr, nullptr);
-}
-
-TEST(RefCountedUnitTest, ConvertibleEquality) {
- scoped_refptr<Derived> p1(new Derived);
- scoped_refptr<SelfAssign> p2;
-
- EXPECT_NE(p1, p2);
- EXPECT_NE(p2, p1);
-
- p2 = p1;
-
- EXPECT_EQ(p1, p2);
- EXPECT_EQ(p2, p1);
-}
-
-TEST(RefCountedUnitTest, MoveAssignment1) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1(raw);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- {
- scoped_refptr<ScopedRefPtrCountBase> p2;
-
- p2 = std::move(p1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(nullptr, p1.get());
- EXPECT_EQ(raw, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveAssignment2) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1;
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- {
- scoped_refptr<ScopedRefPtrCountBase> p2(raw);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- p1 = std::move(p2);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(raw, p1.get());
- EXPECT_EQ(nullptr, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveAssignmentSameInstance1) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1(raw);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- {
- scoped_refptr<ScopedRefPtrCountBase> p2(p1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- p1 = std::move(p2);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(raw, p1.get());
- EXPECT_EQ(nullptr, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveAssignmentSameInstance2) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1(raw);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- {
- scoped_refptr<ScopedRefPtrCountBase> p2(p1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- p2 = std::move(p1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(nullptr, p1.get());
- EXPECT_EQ(raw, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveAssignmentDifferentInstances) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase *raw1 = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1(raw1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- {
- ScopedRefPtrCountBase *raw2 = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p2(raw2);
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- p1 = std::move(p2);
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(raw2, p1.get());
- EXPECT_EQ(nullptr, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(2, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveAssignmentSelfMove) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase* raw = new ScopedRefPtrCountBase;
- scoped_refptr<ScopedRefPtrCountBase> p1(raw);
- scoped_refptr<ScopedRefPtrCountBase>& p1_ref = p1;
-
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- p1 = std::move(p1_ref);
-
- // |p1| is "valid but unspecified", so don't bother inspecting its
- // contents, just ensure that we don't crash.
- }
-
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveAssignmentDerived) {
- ScopedRefPtrCountBase::reset_count();
- ScopedRefPtrCountDerived::reset_count();
-
- {
- ScopedRefPtrCountBase *raw1 = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1(raw1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
-
- {
- ScopedRefPtrCountDerived *raw2 = new ScopedRefPtrCountDerived();
- scoped_refptr<ScopedRefPtrCountDerived> p2(raw2);
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
-
- p1 = std::move(p2);
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
- EXPECT_EQ(raw2, p1.get());
- EXPECT_EQ(nullptr, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(2, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(2, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveConstructor) {
- ScopedRefPtrCountBase::reset_count();
-
- {
- ScopedRefPtrCountBase *raw = new ScopedRefPtrCountBase();
- scoped_refptr<ScopedRefPtrCountBase> p1(raw);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
-
- {
- scoped_refptr<ScopedRefPtrCountBase> p2(std::move(p1));
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(nullptr, p1.get());
- EXPECT_EQ(raw, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
-}
-
-TEST(RefCountedUnitTest, MoveConstructorDerived) {
- ScopedRefPtrCountBase::reset_count();
- ScopedRefPtrCountDerived::reset_count();
-
- {
- ScopedRefPtrCountDerived *raw1 = new ScopedRefPtrCountDerived();
- scoped_refptr<ScopedRefPtrCountDerived> p1(raw1);
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
-
- {
- scoped_refptr<ScopedRefPtrCountBase> p2(std::move(p1));
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(0, ScopedRefPtrCountDerived::destructor_count());
- EXPECT_EQ(nullptr, p1.get());
- EXPECT_EQ(raw1, p2.get());
-
- // p2 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::destructor_count());
-
- // p1 goes out of scope.
- }
- EXPECT_EQ(1, ScopedRefPtrCountBase::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountBase::destructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::constructor_count());
- EXPECT_EQ(1, ScopedRefPtrCountDerived::destructor_count());
-}
-
-TEST(RefCountedUnitTest, TestOverloadResolutionCopy) {
- const scoped_refptr<Derived> derived(new Derived);
- const scoped_refptr<SelfAssign> expected(derived);
- EXPECT_EQ(expected, Overloaded(derived));
-
- const scoped_refptr<Other> other(new Other);
- EXPECT_EQ(other, Overloaded(other));
-}
-
-TEST(RefCountedUnitTest, TestOverloadResolutionMove) {
- scoped_refptr<Derived> derived(new Derived);
- const scoped_refptr<SelfAssign> expected(derived);
- EXPECT_EQ(expected, Overloaded(std::move(derived)));
-
- scoped_refptr<Other> other(new Other);
- const scoped_refptr<Other> other2(other);
- EXPECT_EQ(other2, Overloaded(std::move(other)));
-}
-
-TEST(RefCountedUnitTest, TestMakeRefCounted) {
- scoped_refptr<Derived> derived = new Derived;
- EXPECT_TRUE(derived->HasOneRef());
- derived = nullptr;
-
- scoped_refptr<Derived> derived2 = base::MakeRefCounted<Derived>();
- EXPECT_TRUE(derived2->HasOneRef());
- derived2 = nullptr;
-}
-
-TEST(RefCountedUnitTest, TestInitialRefCountIsOne) {
- scoped_refptr<InitialRefCountIsOne> obj =
- base::MakeRefCounted<InitialRefCountIsOne>();
- EXPECT_TRUE(obj->HasOneRef());
- obj = nullptr;
-
- scoped_refptr<InitialRefCountIsOne> obj2 =
- base::AdoptRef(new InitialRefCountIsOne);
- EXPECT_TRUE(obj2->HasOneRef());
- obj2 = nullptr;
-
- scoped_refptr<Other> obj3 = base::MakeRefCounted<Other>();
- EXPECT_TRUE(obj3->HasOneRef());
- obj3 = nullptr;
-}
-
-TEST(RefCountedDeathTest, TestAdoptRef) {
- // Check that WrapRefCounted() DCHECKs if passed a type that defines
- // REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE.
- EXPECT_DCHECK_DEATH(base::WrapRefCounted(new InitialRefCountIsOne));
-
- // Check that AdoptRef() DCHECKs if passed a nullptr.
- InitialRefCountIsOne* ptr = nullptr;
- EXPECT_DCHECK_DEATH(base::AdoptRef(ptr));
-
- // Check that AdoptRef() DCHECKs if passed an object that doesn't need to be
- // adopted.
- scoped_refptr<InitialRefCountIsOne> obj =
- base::MakeRefCounted<InitialRefCountIsOne>();
- EXPECT_DCHECK_DEATH(base::AdoptRef(obj.get()));
-}
-
-TEST(RefCountedUnitTest, TestPrivateDestructorWithDeleter) {
- // Ensure that RefCounted doesn't need the access to the pointee dtor when
- // a custom deleter is given.
- scoped_refptr<HasPrivateDestructorWithDeleter> obj =
- base::MakeRefCounted<HasPrivateDestructorWithDeleter>();
-}
diff --git a/base/memory/ref_counted_unittest.nc b/base/memory/ref_counted_unittest.nc
deleted file mode 100644
index b8c371f..0000000
--- a/base/memory/ref_counted_unittest.nc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2017 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 "base/memory/ref_counted.h"
-
-namespace base {
-
-class InitialRefCountIsZero : public base::RefCounted<InitialRefCountIsZero> {
- public:
- InitialRefCountIsZero() {}
- private:
- friend class base::RefCounted<InitialRefCountIsZero>;
- ~InitialRefCountIsZero() {}
-};
-
-// TODO(hans): Remove .* and update the static_assert expectations once we roll
-// past Clang r313315. https://crbug.com/765692.
-
-#if defined(NCTEST_ADOPT_REF_TO_ZERO_START) // [r"fatal error: static_assert failed .*\"Use AdoptRef only for the reference count starts from one\.\""]
-
-void WontCompile() {
- AdoptRef(new InitialRefCountIsZero());
-}
-
-#endif
-
-} // namespace base
diff --git a/base/memory/shared_memory_mac_unittest.cc b/base/memory/shared_memory_mac_unittest.cc
deleted file mode 100644
index b17dab7..0000000
--- a/base/memory/shared_memory_mac_unittest.cc
+++ /dev/null
@@ -1,457 +0,0 @@
-// Copyright 2015 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 <mach/mach.h>
-#include <mach/mach_vm.h>
-#include <servers/bootstrap.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/command_line.h"
-#include "base/mac/mac_util.h"
-#include "base/mac/mach_logging.h"
-#include "base/mac/scoped_mach_port.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory.h"
-#include "base/process/process_handle.h"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/sys_info.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "base/unguessable_token.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace base {
-
-namespace {
-
-// Gets the current and maximum protection levels of the memory region.
-// Returns whether the operation was successful.
-// |current| and |max| are output variables only populated on success.
-bool GetProtections(void* address, size_t size, int* current, int* max) {
- vm_region_info_t region_info;
- mach_vm_address_t mem_address = reinterpret_cast<mach_vm_address_t>(address);
- mach_vm_size_t mem_size = size;
- vm_region_basic_info_64 basic_info;
-
- region_info = reinterpret_cast<vm_region_recurse_info_t>(&basic_info);
- vm_region_flavor_t flavor = VM_REGION_BASIC_INFO_64;
- memory_object_name_t memory_object;
- mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
-
- kern_return_t kr =
- mach_vm_region(mach_task_self(), &mem_address, &mem_size, flavor,
- region_info, &count, &memory_object);
- if (kr != KERN_SUCCESS) {
- MACH_LOG(ERROR, kr) << "Failed to get region info.";
- return false;
- }
-
- *current = basic_info.protection;
- *max = basic_info.max_protection;
- return true;
-}
-
-// Creates a new SharedMemory with the given |size|, filled with 'a'.
-std::unique_ptr<SharedMemory> CreateSharedMemory(int size) {
- SharedMemoryHandle shm(size, UnguessableToken::Create());
- if (!shm.IsValid()) {
- LOG(ERROR) << "Failed to make SharedMemoryHandle";
- return nullptr;
- }
- std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
- shared_memory->Map(size);
- memset(shared_memory->memory(), 'a', size);
- return shared_memory;
-}
-
-static const std::string g_service_switch_name = "service_name";
-
-// Structs used to pass a mach port from client to server.
-struct MachSendPortMessage {
- mach_msg_header_t header;
- mach_msg_body_t body;
- mach_msg_port_descriptor_t data;
-};
-struct MachReceivePortMessage {
- mach_msg_header_t header;
- mach_msg_body_t body;
- mach_msg_port_descriptor_t data;
- mach_msg_trailer_t trailer;
-};
-
-// Makes the current process into a Mach Server with the given |service_name|.
-mach_port_t BecomeMachServer(const char* service_name) {
- mach_port_t port;
- kern_return_t kr = bootstrap_check_in(bootstrap_port, service_name, &port);
- MACH_CHECK(kr == KERN_SUCCESS, kr) << "BecomeMachServer";
- return port;
-}
-
-// Returns the mach port for the Mach Server with the given |service_name|.
-mach_port_t LookupServer(const char* service_name) {
- mach_port_t server_port;
- kern_return_t kr =
- bootstrap_look_up(bootstrap_port, service_name, &server_port);
- MACH_CHECK(kr == KERN_SUCCESS, kr) << "LookupServer";
- return server_port;
-}
-
-mach_port_t MakeReceivingPort() {
- mach_port_t client_port;
- kern_return_t kr =
- mach_port_allocate(mach_task_self(), // our task is acquiring
- MACH_PORT_RIGHT_RECEIVE, // a new receive right
- &client_port); // with this name
- MACH_CHECK(kr == KERN_SUCCESS, kr) << "MakeReceivingPort";
- return client_port;
-}
-
-// Blocks until a mach message is sent to |server_port|. This mach message
-// must contain a mach port. Returns that mach port.
-mach_port_t ReceiveMachPort(mach_port_t port_to_listen_on) {
- MachReceivePortMessage recv_msg;
- mach_msg_header_t* recv_hdr = &(recv_msg.header);
- recv_hdr->msgh_local_port = port_to_listen_on;
- recv_hdr->msgh_size = sizeof(recv_msg);
- kern_return_t kr =
- mach_msg(recv_hdr, // message buffer
- MACH_RCV_MSG, // option indicating service
- 0, // send size
- recv_hdr->msgh_size, // size of header + body
- port_to_listen_on, // receive name
- MACH_MSG_TIMEOUT_NONE, // no timeout, wait forever
- MACH_PORT_NULL); // no notification port
- MACH_CHECK(kr == KERN_SUCCESS, kr) << "ReceiveMachPort";
- mach_port_t other_task_port = recv_msg.data.name;
- return other_task_port;
-}
-
-// Passes a copy of the send right of |port_to_send| to |receiving_port|.
-void SendMachPort(mach_port_t receiving_port,
- mach_port_t port_to_send,
- int disposition) {
- MachSendPortMessage send_msg;
- mach_msg_header_t* send_hdr;
- send_hdr = &(send_msg.header);
- send_hdr->msgh_bits =
- MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
- send_hdr->msgh_size = sizeof(send_msg);
- send_hdr->msgh_remote_port = receiving_port;
- send_hdr->msgh_local_port = MACH_PORT_NULL;
- send_hdr->msgh_reserved = 0;
- send_hdr->msgh_id = 0;
- send_msg.body.msgh_descriptor_count = 1;
- send_msg.data.name = port_to_send;
- send_msg.data.disposition = disposition;
- send_msg.data.type = MACH_MSG_PORT_DESCRIPTOR;
- int kr = mach_msg(send_hdr, // message buffer
- MACH_SEND_MSG, // option indicating send
- send_hdr->msgh_size, // size of header + body
- 0, // receive limit
- MACH_PORT_NULL, // receive name
- MACH_MSG_TIMEOUT_NONE, // no timeout, wait forever
- MACH_PORT_NULL); // no notification port
- MACH_CHECK(kr == KERN_SUCCESS, kr) << "SendMachPort";
-}
-
-std::string CreateRandomServiceName() {
- return StringPrintf("SharedMemoryMacMultiProcessTest.%llu", RandUint64());
-}
-
-// Sets up the mach communication ports with the server. Returns a port to which
-// the server will send mach objects.
-mach_port_t CommonChildProcessSetUp() {
- CommandLine cmd_line = *CommandLine::ForCurrentProcess();
- std::string service_name =
- cmd_line.GetSwitchValueASCII(g_service_switch_name);
- mac::ScopedMachSendRight server_port(LookupServer(service_name.c_str()));
- mach_port_t client_port = MakeReceivingPort();
-
- // Send the port that this process is listening on to the server.
- SendMachPort(server_port.get(), client_port, MACH_MSG_TYPE_MAKE_SEND);
- return client_port;
-}
-
-// The number of active names in the current task's port name space.
-mach_msg_type_number_t GetActiveNameCount() {
- mach_port_name_array_t name_array;
- mach_msg_type_number_t names_count;
- mach_port_type_array_t type_array;
- mach_msg_type_number_t types_count;
- kern_return_t kr = mach_port_names(mach_task_self(), &name_array,
- &names_count, &type_array, &types_count);
- MACH_CHECK(kr == KERN_SUCCESS, kr) << "GetActiveNameCount";
- return names_count;
-}
-
-} // namespace
-
-class SharedMemoryMacMultiProcessTest : public MultiProcessTest {
- public:
- SharedMemoryMacMultiProcessTest() {}
-
- CommandLine MakeCmdLine(const std::string& procname) override {
- CommandLine command_line = MultiProcessTest::MakeCmdLine(procname);
- // Pass the service name to the child process.
- command_line.AppendSwitchASCII(g_service_switch_name, service_name_);
- return command_line;
- }
-
- void SetUpChild(const std::string& name) {
- // Make a random service name so that this test doesn't conflict with other
- // similar tests.
- service_name_ = CreateRandomServiceName();
- server_port_.reset(BecomeMachServer(service_name_.c_str()));
- child_process_ = SpawnChild(name);
- client_port_.reset(ReceiveMachPort(server_port_.get()));
- }
-
- static const int s_memory_size = 99999;
-
- protected:
- std::string service_name_;
-
- // A port on which the main process listens for mach messages from the child
- // process.
- mac::ScopedMachReceiveRight server_port_;
-
- // A port on which the child process listens for mach messages from the main
- // process.
- mac::ScopedMachSendRight client_port_;
-
- base::Process child_process_;
- DISALLOW_COPY_AND_ASSIGN(SharedMemoryMacMultiProcessTest);
-};
-
-// Tests that content written to shared memory in the server process can be read
-// by the child process.
-TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemory) {
- SetUpChild("MachBasedSharedMemoryClient");
-
- std::unique_ptr<SharedMemory> shared_memory(
- CreateSharedMemory(s_memory_size));
-
- // Send the underlying memory object to the client process.
- SendMachPort(client_port_.get(), shared_memory->handle().GetMemoryObject(),
- MACH_MSG_TYPE_COPY_SEND);
- int rv = -1;
- ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
- TestTimeouts::action_timeout(), &rv));
- EXPECT_EQ(0, rv);
-}
-
-MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryClient) {
- mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
- // The next mach port should be for a memory object.
- mach_port_t memory_object = ReceiveMachPort(client_port.get());
- SharedMemoryHandle shm(memory_object,
- SharedMemoryMacMultiProcessTest::s_memory_size,
- UnguessableToken::Create());
- SharedMemory shared_memory(shm, false);
- shared_memory.Map(SharedMemoryMacMultiProcessTest::s_memory_size);
- const char* start = static_cast<const char*>(shared_memory.memory());
- for (int i = 0; i < SharedMemoryMacMultiProcessTest::s_memory_size; ++i) {
- DCHECK_EQ(start[i], 'a');
- }
- return 0;
-}
-
-// Tests that mapping shared memory with an offset works correctly.
-TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemoryWithOffset) {
- SetUpChild("MachBasedSharedMemoryWithOffsetClient");
-
- SharedMemoryHandle shm(s_memory_size, UnguessableToken::Create());
- ASSERT_TRUE(shm.IsValid());
- SharedMemory shared_memory(shm, false);
- shared_memory.Map(s_memory_size);
-
- size_t page_size = SysInfo::VMAllocationGranularity();
- char* start = static_cast<char*>(shared_memory.memory());
- memset(start, 'a', page_size);
- memset(start + page_size, 'b', page_size);
- memset(start + 2 * page_size, 'c', page_size);
-
- // Send the underlying memory object to the client process.
- SendMachPort(
- client_port_.get(), shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
- int rv = -1;
- ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
- TestTimeouts::action_timeout(), &rv));
- EXPECT_EQ(0, rv);
-}
-
-MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryWithOffsetClient) {
- mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
- // The next mach port should be for a memory object.
- mach_port_t memory_object = ReceiveMachPort(client_port.get());
- SharedMemoryHandle shm(memory_object,
- SharedMemoryMacMultiProcessTest::s_memory_size,
- UnguessableToken::Create());
- SharedMemory shared_memory(shm, false);
- size_t page_size = SysInfo::VMAllocationGranularity();
- shared_memory.MapAt(page_size, 2 * page_size);
- const char* start = static_cast<const char*>(shared_memory.memory());
- for (size_t i = 0; i < page_size; ++i) {
- DCHECK_EQ(start[i], 'b');
- }
- for (size_t i = page_size; i < 2 * page_size; ++i) {
- DCHECK_EQ(start[i], 'c');
- }
- return 0;
-}
-
-// Tests that duplication and closing has the right effect on Mach reference
-// counts.
-TEST_F(SharedMemoryMacMultiProcessTest, MachDuplicateAndClose) {
- mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
- // Making a new SharedMemoryHandle increments the name count.
- SharedMemoryHandle shm(s_memory_size, UnguessableToken::Create());
- ASSERT_TRUE(shm.IsValid());
- EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
- // Duplicating the SharedMemoryHandle increments the ref count, but doesn't
- // make a new name.
- shm.Duplicate();
- EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
- // Closing the SharedMemoryHandle decrements the ref count. The first time has
- // no effect.
- shm.Close();
- EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
- // Closing the SharedMemoryHandle decrements the ref count. The second time
- // destroys the port.
- shm.Close();
- EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that Mach shared memory can be mapped and unmapped.
-TEST_F(SharedMemoryMacMultiProcessTest, MachUnmapMap) {
- mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
- std::unique_ptr<SharedMemory> shared_memory =
- CreateSharedMemory(s_memory_size);
- ASSERT_TRUE(shared_memory->Unmap());
- ASSERT_TRUE(shared_memory->Map(s_memory_size));
- shared_memory.reset();
- EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that passing a SharedMemoryHandle to a SharedMemory object also passes
-// ownership, and that destroying the SharedMemory closes the SharedMemoryHandle
-// as well.
-TEST_F(SharedMemoryMacMultiProcessTest, MachSharedMemoryTakesOwnership) {
- mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
- // Making a new SharedMemoryHandle increments the name count.
- SharedMemoryHandle shm(s_memory_size, UnguessableToken::Create());
- ASSERT_TRUE(shm.IsValid());
- EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
- // Name count doesn't change when mapping the memory.
- std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
- shared_memory->Map(s_memory_size);
- EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
- // Destroying the SharedMemory object frees the resource.
- shared_memory.reset();
- EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that the read-only flag works.
-TEST_F(SharedMemoryMacMultiProcessTest, MachReadOnly) {
- std::unique_ptr<SharedMemory> shared_memory(
- CreateSharedMemory(s_memory_size));
-
- SharedMemoryHandle shm2 = shared_memory->handle().Duplicate();
- ASSERT_TRUE(shm2.IsValid());
- SharedMemory shared_memory2(shm2, true);
- shared_memory2.Map(s_memory_size);
- ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
-}
-
-// Tests that duplication of the underlying handle works.
-TEST_F(SharedMemoryMacMultiProcessTest, MachDuplicate) {
- mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
- {
- std::unique_ptr<SharedMemory> shared_memory(
- CreateSharedMemory(s_memory_size));
-
- SharedMemoryHandle shm2 = shared_memory->handle().Duplicate();
- ASSERT_TRUE(shm2.IsValid());
- SharedMemory shared_memory2(shm2, true);
- shared_memory2.Map(s_memory_size);
-
- ASSERT_EQ(0, memcmp(shared_memory->memory(), shared_memory2.memory(),
- s_memory_size));
- }
-
- EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that the method GetReadOnlyHandle() creates a memory object that
-// is read only.
-TEST_F(SharedMemoryMacMultiProcessTest, MachReadonly) {
- std::unique_ptr<SharedMemory> shared_memory(
- CreateSharedMemory(s_memory_size));
-
- // Check the protection levels.
- int current_prot, max_prot;
- ASSERT_TRUE(GetProtections(shared_memory->memory(),
- shared_memory->mapped_size(), ¤t_prot,
- &max_prot));
- ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, current_prot);
- ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, max_prot);
-
- // Make a new memory object.
- SharedMemoryHandle shm2 = shared_memory->GetReadOnlyHandle();
- ASSERT_TRUE(shm2.IsValid());
- EXPECT_EQ(shared_memory->handle().GetGUID(), shm2.GetGUID());
-
- // Mapping with |readonly| set to |false| should fail.
- SharedMemory shared_memory2(shm2, false);
- shared_memory2.Map(s_memory_size);
- ASSERT_EQ(nullptr, shared_memory2.memory());
-
- // Now trying mapping with |readonly| set to |true|.
- SharedMemory shared_memory3(shm2.Duplicate(), true);
- shared_memory3.Map(s_memory_size);
- ASSERT_NE(nullptr, shared_memory3.memory());
-
- // Check the protection levels.
- ASSERT_TRUE(GetProtections(shared_memory3.memory(),
- shared_memory3.mapped_size(), ¤t_prot,
- &max_prot));
- ASSERT_EQ(VM_PROT_READ, current_prot);
- ASSERT_EQ(VM_PROT_READ, max_prot);
-
- // The memory should still be readonly, since the underlying memory object
- // is readonly.
- ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
-}
-
-// Tests that the method GetReadOnlyHandle() doesn't leak.
-TEST_F(SharedMemoryMacMultiProcessTest, MachReadonlyLeak) {
- mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
- {
- std::unique_ptr<SharedMemory> shared_memory(
- CreateSharedMemory(s_memory_size));
-
- SharedMemoryHandle shm2 = shared_memory->GetReadOnlyHandle();
- ASSERT_TRUE(shm2.IsValid());
-
- // Intentionally map with |readonly| set to |false|.
- SharedMemory shared_memory2(shm2, false);
- shared_memory2.Map(s_memory_size);
- }
-
- EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-} // namespace base
diff --git a/base/memory/shared_memory_region_unittest.cc b/base/memory/shared_memory_region_unittest.cc
deleted file mode 100644
index e917154..0000000
--- a/base/memory/shared_memory_region_unittest.cc
+++ /dev/null
@@ -1,279 +0,0 @@
-// Copyright 2018 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 <utility>
-
-#include "base/memory/platform_shared_memory_region.h"
-#include "base/memory/read_only_shared_memory_region.h"
-#include "base/memory/unsafe_shared_memory_region.h"
-#include "base/memory/writable_shared_memory_region.h"
-#include "base/sys_info.h"
-#include "base/test/test_shared_memory_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-const size_t kRegionSize = 1024;
-
-bool IsMemoryFilledWithByte(const void* memory, size_t size, char byte) {
- const char* start_ptr = static_cast<const char*>(memory);
- const char* end_ptr = start_ptr + size;
- for (const char* ptr = start_ptr; ptr < end_ptr; ++ptr) {
- if (*ptr != byte)
- return false;
- }
-
- return true;
-}
-
-template <typename SharedMemoryRegionType>
-class SharedMemoryRegionTest : public ::testing::Test {
- public:
- void SetUp() override {
- std::tie(region_, rw_mapping_) =
- CreateMappedRegion<SharedMemoryRegionType>(kRegionSize);
- ASSERT_TRUE(region_.IsValid());
- ASSERT_TRUE(rw_mapping_.IsValid());
- memset(rw_mapping_.memory(), 'G', kRegionSize);
- EXPECT_TRUE(IsMemoryFilledWithByte(rw_mapping_.memory(), kRegionSize, 'G'));
- }
-
- protected:
- SharedMemoryRegionType region_;
- WritableSharedMemoryMapping rw_mapping_;
-};
-
-typedef ::testing::Types<WritableSharedMemoryRegion,
- UnsafeSharedMemoryRegion,
- ReadOnlySharedMemoryRegion>
- AllRegionTypes;
-TYPED_TEST_CASE(SharedMemoryRegionTest, AllRegionTypes);
-
-TYPED_TEST(SharedMemoryRegionTest, NonValidRegion) {
- TypeParam region;
- EXPECT_FALSE(region.IsValid());
- // We shouldn't crash on Map but should return an invalid mapping.
- typename TypeParam::MappingType mapping = region.Map();
- EXPECT_FALSE(mapping.IsValid());
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MoveRegion) {
- TypeParam moved_region = std::move(this->region_);
- EXPECT_FALSE(this->region_.IsValid());
- ASSERT_TRUE(moved_region.IsValid());
-
- // Check that moved region maps correctly.
- typename TypeParam::MappingType mapping = moved_region.Map();
- ASSERT_TRUE(mapping.IsValid());
- EXPECT_NE(this->rw_mapping_.memory(), mapping.memory());
- EXPECT_EQ(memcmp(this->rw_mapping_.memory(), mapping.memory(), kRegionSize),
- 0);
-
- // Verify that the second mapping reflects changes in the first.
- memset(this->rw_mapping_.memory(), '#', kRegionSize);
- EXPECT_EQ(memcmp(this->rw_mapping_.memory(), mapping.memory(), kRegionSize),
- 0);
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MappingValidAfterClose) {
- // Check the mapping is still valid after the region is closed.
- this->region_ = TypeParam();
- EXPECT_FALSE(this->region_.IsValid());
- ASSERT_TRUE(this->rw_mapping_.IsValid());
- EXPECT_TRUE(
- IsMemoryFilledWithByte(this->rw_mapping_.memory(), kRegionSize, 'G'));
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapTwice) {
- // The second mapping is either writable or read-only.
- typename TypeParam::MappingType mapping = this->region_.Map();
- ASSERT_TRUE(mapping.IsValid());
- EXPECT_NE(this->rw_mapping_.memory(), mapping.memory());
- EXPECT_EQ(memcmp(this->rw_mapping_.memory(), mapping.memory(), kRegionSize),
- 0);
-
- // Verify that the second mapping reflects changes in the first.
- memset(this->rw_mapping_.memory(), '#', kRegionSize);
- EXPECT_EQ(memcmp(this->rw_mapping_.memory(), mapping.memory(), kRegionSize),
- 0);
-
- // Close the region and unmap the first memory segment, verify the second
- // still has the right data.
- this->region_ = TypeParam();
- this->rw_mapping_ = WritableSharedMemoryMapping();
- EXPECT_TRUE(IsMemoryFilledWithByte(mapping.memory(), kRegionSize, '#'));
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapUnmapMap) {
- this->rw_mapping_ = WritableSharedMemoryMapping();
-
- typename TypeParam::MappingType mapping = this->region_.Map();
- ASSERT_TRUE(mapping.IsValid());
- EXPECT_TRUE(IsMemoryFilledWithByte(mapping.memory(), kRegionSize, 'G'));
-}
-
-TYPED_TEST(SharedMemoryRegionTest, SerializeAndDeserialize) {
- subtle::PlatformSharedMemoryRegion platform_region =
- TypeParam::TakeHandleForSerialization(std::move(this->region_));
- EXPECT_EQ(platform_region.GetGUID(), this->rw_mapping_.guid());
- TypeParam region = TypeParam::Deserialize(std::move(platform_region));
- EXPECT_TRUE(region.IsValid());
- EXPECT_FALSE(this->region_.IsValid());
- typename TypeParam::MappingType mapping = region.Map();
- ASSERT_TRUE(mapping.IsValid());
- EXPECT_TRUE(IsMemoryFilledWithByte(mapping.memory(), kRegionSize, 'G'));
-
- // Verify that the second mapping reflects changes in the first.
- memset(this->rw_mapping_.memory(), '#', kRegionSize);
- EXPECT_EQ(memcmp(this->rw_mapping_.memory(), mapping.memory(), kRegionSize),
- 0);
-}
-
-// Map() will return addresses which are aligned to the platform page size, this
-// varies from platform to platform though. Since we'd like to advertise a
-// minimum alignment that callers can count on, test for it here.
-TYPED_TEST(SharedMemoryRegionTest, MapMinimumAlignment) {
- EXPECT_EQ(0U,
- reinterpret_cast<uintptr_t>(this->rw_mapping_.memory()) &
- (subtle::PlatformSharedMemoryRegion::kMapMinimumAlignment - 1));
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapSize) {
- EXPECT_EQ(this->rw_mapping_.size(), kRegionSize);
- EXPECT_GE(this->rw_mapping_.mapped_size(), kRegionSize);
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapGranularity) {
- EXPECT_LT(this->rw_mapping_.mapped_size(),
- kRegionSize + SysInfo::VMAllocationGranularity());
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapAt) {
- const size_t kPageSize = SysInfo::VMAllocationGranularity();
- ASSERT_TRUE(kPageSize >= sizeof(uint32_t));
- ASSERT_EQ(kPageSize % sizeof(uint32_t), 0U);
- const size_t kDataSize = kPageSize * 2;
- const size_t kCount = kDataSize / sizeof(uint32_t);
-
- TypeParam region;
- WritableSharedMemoryMapping rw_mapping;
- std::tie(region, rw_mapping) = CreateMappedRegion<TypeParam>(kDataSize);
- ASSERT_TRUE(region.IsValid());
- ASSERT_TRUE(rw_mapping.IsValid());
- uint32_t* ptr = static_cast<uint32_t*>(rw_mapping.memory());
-
- for (size_t i = 0; i < kCount; ++i)
- ptr[i] = i;
-
- rw_mapping = WritableSharedMemoryMapping();
- off_t bytes_offset = kPageSize;
- typename TypeParam::MappingType mapping =
- region.MapAt(bytes_offset, kDataSize - bytes_offset);
- ASSERT_TRUE(mapping.IsValid());
-
- off_t int_offset = bytes_offset / sizeof(uint32_t);
- const uint32_t* ptr2 = static_cast<const uint32_t*>(mapping.memory());
- for (size_t i = int_offset; i < kCount; ++i) {
- EXPECT_EQ(ptr2[i - int_offset], i);
- }
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapAtNotAlignedOffsetFails) {
- const size_t kDataSize = SysInfo::VMAllocationGranularity();
-
- TypeParam region;
- WritableSharedMemoryMapping rw_mapping;
- std::tie(region, rw_mapping) = CreateMappedRegion<TypeParam>(kDataSize);
- ASSERT_TRUE(region.IsValid());
- ASSERT_TRUE(rw_mapping.IsValid());
- off_t offset = kDataSize / 2;
- typename TypeParam::MappingType mapping =
- region.MapAt(offset, kDataSize - offset);
- EXPECT_FALSE(mapping.IsValid());
-}
-
-TYPED_TEST(SharedMemoryRegionTest, MapMoreBytesThanRegionSizeFails) {
- size_t region_real_size = this->region_.GetSize();
- typename TypeParam::MappingType mapping =
- this->region_.MapAt(0, region_real_size + 1);
- EXPECT_FALSE(mapping.IsValid());
-}
-
-template <typename DuplicatableSharedMemoryRegion>
-class DuplicatableSharedMemoryRegionTest
- : public SharedMemoryRegionTest<DuplicatableSharedMemoryRegion> {};
-
-typedef ::testing::Types<UnsafeSharedMemoryRegion, ReadOnlySharedMemoryRegion>
- DuplicatableRegionTypes;
-TYPED_TEST_CASE(DuplicatableSharedMemoryRegionTest, DuplicatableRegionTypes);
-
-TYPED_TEST(DuplicatableSharedMemoryRegionTest, Duplicate) {
- TypeParam dup_region = this->region_.Duplicate();
- typename TypeParam::MappingType mapping = dup_region.Map();
- ASSERT_TRUE(mapping.IsValid());
- EXPECT_NE(this->rw_mapping_.memory(), mapping.memory());
- EXPECT_EQ(this->rw_mapping_.guid(), mapping.guid());
- EXPECT_TRUE(IsMemoryFilledWithByte(mapping.memory(), kRegionSize, 'G'));
-}
-
-class ReadOnlySharedMemoryRegionTest : public ::testing::Test {
- public:
- ReadOnlySharedMemoryRegion GetInitiallyReadOnlyRegion(size_t size) {
- MappedReadOnlyRegion mapped_region =
- ReadOnlySharedMemoryRegion::Create(size);
- ReadOnlySharedMemoryRegion region = std::move(mapped_region.region);
- return region;
- }
-
- ReadOnlySharedMemoryRegion GetConvertedToReadOnlyRegion(size_t size) {
- WritableSharedMemoryRegion region =
- WritableSharedMemoryRegion::Create(kRegionSize);
- ReadOnlySharedMemoryRegion ro_region =
- WritableSharedMemoryRegion::ConvertToReadOnly(std::move(region));
- return ro_region;
- }
-};
-
-TEST_F(ReadOnlySharedMemoryRegionTest,
- InitiallyReadOnlyRegionCannotBeMappedAsWritable) {
- ReadOnlySharedMemoryRegion region = GetInitiallyReadOnlyRegion(kRegionSize);
- ASSERT_TRUE(region.IsValid());
-
- EXPECT_TRUE(CheckReadOnlyPlatformSharedMemoryRegionForTesting(
- ReadOnlySharedMemoryRegion::TakeHandleForSerialization(
- std::move(region))));
-}
-
-TEST_F(ReadOnlySharedMemoryRegionTest,
- ConvertedToReadOnlyRegionCannotBeMappedAsWritable) {
- ReadOnlySharedMemoryRegion region = GetConvertedToReadOnlyRegion(kRegionSize);
- ASSERT_TRUE(region.IsValid());
-
- EXPECT_TRUE(CheckReadOnlyPlatformSharedMemoryRegionForTesting(
- ReadOnlySharedMemoryRegion::TakeHandleForSerialization(
- std::move(region))));
-}
-
-TEST_F(ReadOnlySharedMemoryRegionTest,
- InitiallyReadOnlyRegionProducedMappingWriteDeathTest) {
- ReadOnlySharedMemoryRegion region = GetInitiallyReadOnlyRegion(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- ReadOnlySharedMemoryMapping mapping = region.Map();
- ASSERT_TRUE(mapping.IsValid());
- void* memory_ptr = const_cast<void*>(mapping.memory());
- EXPECT_DEATH_IF_SUPPORTED(memset(memory_ptr, 'G', kRegionSize), "");
-}
-
-TEST_F(ReadOnlySharedMemoryRegionTest,
- ConvertedToReadOnlyRegionProducedMappingWriteDeathTest) {
- ReadOnlySharedMemoryRegion region = GetConvertedToReadOnlyRegion(kRegionSize);
- ASSERT_TRUE(region.IsValid());
- ReadOnlySharedMemoryMapping mapping = region.Map();
- ASSERT_TRUE(mapping.IsValid());
- void* memory_ptr = const_cast<void*>(mapping.memory());
- EXPECT_DEATH_IF_SUPPORTED(memset(memory_ptr, 'G', kRegionSize), "");
-}
-
-} // namespace base
diff --git a/base/memory/shared_memory_unittest.cc b/base/memory/shared_memory_unittest.cc
deleted file mode 100644
index c4c21c4..0000000
--- a/base/memory/shared_memory_unittest.cc
+++ /dev/null
@@ -1,965 +0,0 @@
-// 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.
-
-#include "base/memory/shared_memory.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/base_switches.h"
-#include "base/bind.h"
-#include "base/command_line.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory_handle.h"
-#include "base/process/kill.h"
-#include "base/rand_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/sys_info.h"
-#include "base/test/multiprocess_test.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "base/unguessable_token.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-#if defined(OS_ANDROID)
-#include "base/callback.h"
-#endif
-
-#if defined(OS_POSIX)
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-
-#if defined(OS_LINUX)
-#include <sys/syscall.h>
-#endif
-
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
-
-#if defined(OS_FUCHSIA)
-#include <zircon/process.h>
-#include <zircon/syscalls.h>
-#include "base/fuchsia/scoped_zx_handle.h"
-#endif
-
-namespace base {
-
-namespace {
-
-#if !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-// Each thread will open the shared memory. Each thread will take a different 4
-// byte int pointer, and keep changing it, with some small pauses in between.
-// Verify that each thread's value in the shared memory is always correct.
-class MultipleThreadMain : public PlatformThread::Delegate {
- public:
- explicit MultipleThreadMain(int16_t id) : id_(id) {}
- ~MultipleThreadMain() override = default;
-
- static void CleanUp() {
- SharedMemory memory;
- memory.Delete(s_test_name_);
- }
-
- // PlatformThread::Delegate interface.
- void ThreadMain() override {
- const uint32_t kDataSize = 1024;
- SharedMemory memory;
- bool rv = memory.CreateNamedDeprecated(s_test_name_, true, kDataSize);
- EXPECT_TRUE(rv);
- rv = memory.Map(kDataSize);
- EXPECT_TRUE(rv);
- int* ptr = static_cast<int*>(memory.memory()) + id_;
- EXPECT_EQ(0, *ptr);
-
- for (int idx = 0; idx < 100; idx++) {
- *ptr = idx;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
- EXPECT_EQ(*ptr, idx);
- }
- // Reset back to 0 for the next test that uses the same name.
- *ptr = 0;
-
- memory.Close();
- }
-
- private:
- int16_t id_;
-
- static const char s_test_name_[];
-
- DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
-};
-
-const char MultipleThreadMain::s_test_name_[] =
- "SharedMemoryOpenThreadTest";
-#endif // !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-
-enum class Mode {
- Default,
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
- DisableDevShm = 1,
-#endif
-};
-
-class SharedMemoryTest : public ::testing::TestWithParam<Mode> {
- public:
- void SetUp() override {
- switch (GetParam()) {
- case Mode::Default:
- break;
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
- case Mode::DisableDevShm:
- CommandLine* cmdline = CommandLine::ForCurrentProcess();
- cmdline->AppendSwitch(switches::kDisableDevShmUsage);
- break;
-#endif // defined(OS_LINUX) && !defined(OS_CHROMEOS)
- }
- }
-};
-
-} // namespace
-
-// Android/Mac/Fuchsia doesn't support SharedMemory::Open/Delete/
-// CreateNamedDeprecated(openExisting=true)
-#if !defined(OS_ANDROID) && !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-
-TEST_P(SharedMemoryTest, OpenClose) {
- const uint32_t kDataSize = 1024;
- std::string test_name = "SharedMemoryOpenCloseTest";
-
- // Open two handles to a memory segment, confirm that they are mapped
- // separately yet point to the same space.
- SharedMemory memory1;
- bool rv = memory1.Delete(test_name);
- EXPECT_TRUE(rv);
- rv = memory1.Delete(test_name);
- EXPECT_TRUE(rv);
- rv = memory1.Open(test_name, false);
- EXPECT_FALSE(rv);
- rv = memory1.CreateNamedDeprecated(test_name, false, kDataSize);
- EXPECT_TRUE(rv);
- rv = memory1.Map(kDataSize);
- EXPECT_TRUE(rv);
- SharedMemory memory2;
- rv = memory2.Open(test_name, false);
- EXPECT_TRUE(rv);
- rv = memory2.Map(kDataSize);
- EXPECT_TRUE(rv);
- EXPECT_NE(memory1.memory(), memory2.memory()); // Compare the pointers.
-
- // Make sure we don't segfault. (it actually happened!)
- ASSERT_NE(memory1.memory(), static_cast<void*>(nullptr));
- ASSERT_NE(memory2.memory(), static_cast<void*>(nullptr));
-
- // Write data to the first memory segment, verify contents of second.
- memset(memory1.memory(), '1', kDataSize);
- EXPECT_EQ(memcmp(memory1.memory(), memory2.memory(), kDataSize), 0);
-
- // Close the first memory segment, and verify the second has the right data.
- memory1.Close();
- char* start_ptr = static_cast<char*>(memory2.memory());
- char* end_ptr = start_ptr + kDataSize;
- for (char* ptr = start_ptr; ptr < end_ptr; ptr++)
- EXPECT_EQ(*ptr, '1');
-
- // Close the second memory segment.
- memory2.Close();
-
- rv = memory1.Delete(test_name);
- EXPECT_TRUE(rv);
- rv = memory2.Delete(test_name);
- EXPECT_TRUE(rv);
-}
-
-TEST_P(SharedMemoryTest, OpenExclusive) {
- const uint32_t kDataSize = 1024;
- const uint32_t kDataSize2 = 2048;
- std::ostringstream test_name_stream;
- test_name_stream << "SharedMemoryOpenExclusiveTest."
- << Time::Now().ToDoubleT();
- std::string test_name = test_name_stream.str();
-
- // Open two handles to a memory segment and check that
- // open_existing_deprecated works as expected.
- SharedMemory memory1;
- bool rv = memory1.CreateNamedDeprecated(test_name, false, kDataSize);
- EXPECT_TRUE(rv);
-
- // Memory1 knows it's size because it created it.
- EXPECT_EQ(memory1.requested_size(), kDataSize);
-
- rv = memory1.Map(kDataSize);
- EXPECT_TRUE(rv);
-
- // The mapped memory1 must be at least the size we asked for.
- EXPECT_GE(memory1.mapped_size(), kDataSize);
-
- // The mapped memory1 shouldn't exceed rounding for allocation granularity.
- EXPECT_LT(memory1.mapped_size(),
- kDataSize + SysInfo::VMAllocationGranularity());
-
- memset(memory1.memory(), 'G', kDataSize);
-
- SharedMemory memory2;
- // Should not be able to create if openExisting is false.
- rv = memory2.CreateNamedDeprecated(test_name, false, kDataSize2);
- EXPECT_FALSE(rv);
-
- // Should be able to create with openExisting true.
- rv = memory2.CreateNamedDeprecated(test_name, true, kDataSize2);
- EXPECT_TRUE(rv);
-
- // Memory2 shouldn't know the size because we didn't create it.
- EXPECT_EQ(memory2.requested_size(), 0U);
-
- // We should be able to map the original size.
- rv = memory2.Map(kDataSize);
- EXPECT_TRUE(rv);
-
- // The mapped memory2 must be at least the size of the original.
- EXPECT_GE(memory2.mapped_size(), kDataSize);
-
- // The mapped memory2 shouldn't exceed rounding for allocation granularity.
- EXPECT_LT(memory2.mapped_size(),
- kDataSize2 + SysInfo::VMAllocationGranularity());
-
- // Verify that opening memory2 didn't truncate or delete memory 1.
- char* start_ptr = static_cast<char*>(memory2.memory());
- char* end_ptr = start_ptr + kDataSize;
- for (char* ptr = start_ptr; ptr < end_ptr; ptr++) {
- EXPECT_EQ(*ptr, 'G');
- }
-
- memory1.Close();
- memory2.Close();
-
- rv = memory1.Delete(test_name);
- EXPECT_TRUE(rv);
-}
-#endif // !defined(OS_ANDROID) && !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-
-// Check that memory is still mapped after its closed.
-TEST_P(SharedMemoryTest, CloseNoUnmap) {
- const size_t kDataSize = 4096;
-
- SharedMemory memory;
- ASSERT_TRUE(memory.CreateAndMapAnonymous(kDataSize));
- char* ptr = static_cast<char*>(memory.memory());
- ASSERT_NE(ptr, static_cast<void*>(nullptr));
- memset(ptr, 'G', kDataSize);
-
- memory.Close();
-
- EXPECT_EQ(ptr, memory.memory());
- EXPECT_TRUE(!memory.handle().IsValid());
-
- for (size_t i = 0; i < kDataSize; i++) {
- EXPECT_EQ('G', ptr[i]);
- }
-
- memory.Unmap();
- EXPECT_EQ(nullptr, memory.memory());
-}
-
-#if !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-// Create a set of N threads to each open a shared memory segment and write to
-// it. Verify that they are always reading/writing consistent data.
-TEST_P(SharedMemoryTest, MultipleThreads) {
- const int kNumThreads = 5;
-
- MultipleThreadMain::CleanUp();
- // On POSIX we have a problem when 2 threads try to create the shmem
- // (a file) at exactly the same time, since create both creates the
- // file and zerofills it. We solve the problem for this unit test
- // (make it not flaky) by starting with 1 thread, then
- // intentionally don't clean up its shmem before running with
- // kNumThreads.
-
- int threadcounts[] = { 1, kNumThreads };
- for (size_t i = 0; i < arraysize(threadcounts); i++) {
- int numthreads = threadcounts[i];
- std::unique_ptr<PlatformThreadHandle[]> thread_handles;
- std::unique_ptr<MultipleThreadMain* []> thread_delegates;
-
- thread_handles.reset(new PlatformThreadHandle[numthreads]);
- thread_delegates.reset(new MultipleThreadMain*[numthreads]);
-
- // Spawn the threads.
- for (int16_t index = 0; index < numthreads; index++) {
- PlatformThreadHandle pth;
- thread_delegates[index] = new MultipleThreadMain(index);
- EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
- thread_handles[index] = pth;
- }
-
- // Wait for the threads to finish.
- for (int index = 0; index < numthreads; index++) {
- PlatformThread::Join(thread_handles[index]);
- delete thread_delegates[index];
- }
- }
- MultipleThreadMain::CleanUp();
-}
-#endif
-
-// Allocate private (unique) shared memory with an empty string for a
-// name. Make sure several of them don't point to the same thing as
-// we might expect if the names are equal.
-TEST_P(SharedMemoryTest, AnonymousPrivate) {
- int i, j;
- int count = 4;
- bool rv;
- const uint32_t kDataSize = 8192;
-
- std::unique_ptr<SharedMemory[]> memories(new SharedMemory[count]);
- std::unique_ptr<int* []> pointers(new int*[count]);
- ASSERT_TRUE(memories.get());
- ASSERT_TRUE(pointers.get());
-
- for (i = 0; i < count; i++) {
- rv = memories[i].CreateAndMapAnonymous(kDataSize);
- EXPECT_TRUE(rv);
- int* ptr = static_cast<int*>(memories[i].memory());
- EXPECT_TRUE(ptr);
- pointers[i] = ptr;
- }
-
- for (i = 0; i < count; i++) {
- // zero out the first int in each except for i; for that one, make it 100.
- for (j = 0; j < count; j++) {
- if (i == j)
- pointers[j][0] = 100;
- else
- pointers[j][0] = 0;
- }
- // make sure there is no bleeding of the 100 into the other pointers
- for (j = 0; j < count; j++) {
- if (i == j)
- EXPECT_EQ(100, pointers[j][0]);
- else
- EXPECT_EQ(0, pointers[j][0]);
- }
- }
-
- for (int i = 0; i < count; i++) {
- memories[i].Close();
- }
-}
-
-TEST_P(SharedMemoryTest, GetReadOnlyHandle) {
- StringPiece contents = "Hello World";
-
- SharedMemory writable_shmem;
- SharedMemoryCreateOptions options;
- options.size = contents.size();
- options.share_read_only = true;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
- // The Mach functionality is tested in shared_memory_mac_unittest.cc.
- options.type = SharedMemoryHandle::POSIX;
-#endif
- ASSERT_TRUE(writable_shmem.Create(options));
- ASSERT_TRUE(writable_shmem.Map(options.size));
- memcpy(writable_shmem.memory(), contents.data(), contents.size());
- EXPECT_TRUE(writable_shmem.Unmap());
-
- SharedMemoryHandle readonly_handle = writable_shmem.GetReadOnlyHandle();
- EXPECT_EQ(writable_shmem.handle().GetGUID(), readonly_handle.GetGUID());
- EXPECT_EQ(writable_shmem.handle().GetSize(), readonly_handle.GetSize());
- ASSERT_TRUE(readonly_handle.IsValid());
- SharedMemory readonly_shmem(readonly_handle, /*readonly=*/true);
-
- ASSERT_TRUE(readonly_shmem.Map(contents.size()));
- EXPECT_EQ(contents,
- StringPiece(static_cast<const char*>(readonly_shmem.memory()),
- contents.size()));
- EXPECT_TRUE(readonly_shmem.Unmap());
-
-#if defined(OS_ANDROID)
- // On Android, mapping a region through a read-only descriptor makes the
- // region read-only. Any writable mapping attempt should fail.
- ASSERT_FALSE(writable_shmem.Map(contents.size()));
-#else
- // Make sure the writable instance is still writable.
- ASSERT_TRUE(writable_shmem.Map(contents.size()));
- StringPiece new_contents = "Goodbye";
- memcpy(writable_shmem.memory(), new_contents.data(), new_contents.size());
- EXPECT_EQ(new_contents,
- StringPiece(static_cast<const char*>(writable_shmem.memory()),
- new_contents.size()));
-#endif
-
- // We'd like to check that if we send the read-only segment to another
- // process, then that other process can't reopen it read/write. (Since that
- // would be a security hole.) Setting up multiple processes is hard in a
- // unittest, so this test checks that the *current* process can't reopen the
- // segment read/write. I think the test here is stronger than we actually
- // care about, but there's a remote possibility that sending a file over a
- // pipe would transform it into read/write.
- SharedMemoryHandle handle = readonly_shmem.handle();
-
-#if defined(OS_ANDROID)
- // The "read-only" handle is still writable on Android:
- // http://crbug.com/320865
- (void)handle;
-#elif defined(OS_FUCHSIA)
- uintptr_t addr;
- EXPECT_NE(ZX_OK, zx_vmar_map(zx_vmar_root_self(), 0, handle.GetHandle(), 0,
- contents.size(), ZX_VM_FLAG_PERM_WRITE, &addr))
- << "Shouldn't be able to map as writable.";
-
- ScopedZxHandle duped_handle;
- EXPECT_NE(ZX_OK, zx_handle_duplicate(handle.GetHandle(), ZX_RIGHT_WRITE,
- duped_handle.receive()))
- << "Shouldn't be able to duplicate the handle into a writable one.";
-
- EXPECT_EQ(ZX_OK, zx_handle_duplicate(handle.GetHandle(), ZX_RIGHT_READ,
- duped_handle.receive()))
- << "Should be able to duplicate the handle into a readable one.";
-#elif defined(OS_POSIX)
- int handle_fd = SharedMemory::GetFdFromSharedMemoryHandle(handle);
- EXPECT_EQ(O_RDONLY, fcntl(handle_fd, F_GETFL) & O_ACCMODE)
- << "The descriptor itself should be read-only.";
-
- errno = 0;
- void* writable = mmap(nullptr, contents.size(), PROT_READ | PROT_WRITE,
- MAP_SHARED, handle_fd, 0);
- int mmap_errno = errno;
- EXPECT_EQ(MAP_FAILED, writable)
- << "It shouldn't be possible to re-mmap the descriptor writable.";
- EXPECT_EQ(EACCES, mmap_errno) << strerror(mmap_errno);
- if (writable != MAP_FAILED)
- EXPECT_EQ(0, munmap(writable, readonly_shmem.mapped_size()));
-
-#elif defined(OS_WIN)
- EXPECT_EQ(NULL, MapViewOfFile(handle.GetHandle(), FILE_MAP_WRITE, 0, 0, 0))
- << "Shouldn't be able to map memory writable.";
-
- HANDLE temp_handle;
- BOOL rv = ::DuplicateHandle(GetCurrentProcess(), handle.GetHandle(),
- GetCurrentProcess(), &temp_handle,
- FILE_MAP_ALL_ACCESS, false, 0);
- EXPECT_EQ(FALSE, rv)
- << "Shouldn't be able to duplicate the handle into a writable one.";
- if (rv)
- win::ScopedHandle writable_handle(temp_handle);
- rv = ::DuplicateHandle(GetCurrentProcess(), handle.GetHandle(),
- GetCurrentProcess(), &temp_handle, FILE_MAP_READ,
- false, 0);
- EXPECT_EQ(TRUE, rv)
- << "Should be able to duplicate the handle into a readable one.";
- if (rv)
- win::ScopedHandle writable_handle(temp_handle);
-#else
-#error Unexpected platform; write a test that tries to make 'handle' writable.
-#endif // defined(OS_POSIX) || defined(OS_WIN)
-}
-
-TEST_P(SharedMemoryTest, ShareToSelf) {
- StringPiece contents = "Hello World";
-
- SharedMemory shmem;
- ASSERT_TRUE(shmem.CreateAndMapAnonymous(contents.size()));
- memcpy(shmem.memory(), contents.data(), contents.size());
- EXPECT_TRUE(shmem.Unmap());
-
- SharedMemoryHandle shared_handle = shmem.handle().Duplicate();
- ASSERT_TRUE(shared_handle.IsValid());
- EXPECT_TRUE(shared_handle.OwnershipPassesToIPC());
- EXPECT_EQ(shared_handle.GetGUID(), shmem.handle().GetGUID());
- EXPECT_EQ(shared_handle.GetSize(), shmem.handle().GetSize());
- SharedMemory shared(shared_handle, /*readonly=*/false);
-
- ASSERT_TRUE(shared.Map(contents.size()));
- EXPECT_EQ(
- contents,
- StringPiece(static_cast<const char*>(shared.memory()), contents.size()));
-
- shared_handle = shmem.handle().Duplicate();
- ASSERT_TRUE(shared_handle.IsValid());
- ASSERT_TRUE(shared_handle.OwnershipPassesToIPC());
- SharedMemory readonly(shared_handle, /*readonly=*/true);
-
- ASSERT_TRUE(readonly.Map(contents.size()));
- EXPECT_EQ(contents,
- StringPiece(static_cast<const char*>(readonly.memory()),
- contents.size()));
-}
-
-TEST_P(SharedMemoryTest, ShareWithMultipleInstances) {
- static const StringPiece kContents = "Hello World";
-
- SharedMemory shmem;
- ASSERT_TRUE(shmem.CreateAndMapAnonymous(kContents.size()));
- // We do not need to unmap |shmem| to let |shared| map.
- const StringPiece shmem_contents(static_cast<const char*>(shmem.memory()),
- shmem.requested_size());
-
- SharedMemoryHandle shared_handle = shmem.handle().Duplicate();
- ASSERT_TRUE(shared_handle.IsValid());
- SharedMemory shared(shared_handle, /*readonly=*/false);
- ASSERT_TRUE(shared.Map(kContents.size()));
- // The underlying shared memory is created by |shmem|, so both
- // |shared|.requested_size() and |readonly|.requested_size() are zero.
- ASSERT_EQ(0U, shared.requested_size());
- const StringPiece shared_contents(static_cast<const char*>(shared.memory()),
- shmem.requested_size());
-
- shared_handle = shmem.handle().Duplicate();
- ASSERT_TRUE(shared_handle.IsValid());
- ASSERT_TRUE(shared_handle.OwnershipPassesToIPC());
- SharedMemory readonly(shared_handle, /*readonly=*/true);
- ASSERT_TRUE(readonly.Map(kContents.size()));
- ASSERT_EQ(0U, readonly.requested_size());
- const StringPiece readonly_contents(
- static_cast<const char*>(readonly.memory()),
- shmem.requested_size());
-
- // |shmem| should be able to update the content.
- memcpy(shmem.memory(), kContents.data(), kContents.size());
-
- ASSERT_EQ(kContents, shmem_contents);
- ASSERT_EQ(kContents, shared_contents);
- ASSERT_EQ(kContents, readonly_contents);
-
- // |shared| should also be able to update the content.
- memcpy(shared.memory(), ToLowerASCII(kContents).c_str(), kContents.size());
-
- ASSERT_EQ(StringPiece(ToLowerASCII(kContents)), shmem_contents);
- ASSERT_EQ(StringPiece(ToLowerASCII(kContents)), shared_contents);
- ASSERT_EQ(StringPiece(ToLowerASCII(kContents)), readonly_contents);
-}
-
-TEST_P(SharedMemoryTest, MapAt) {
- ASSERT_TRUE(SysInfo::VMAllocationGranularity() >= sizeof(uint32_t));
- const size_t kCount = SysInfo::VMAllocationGranularity();
- const size_t kDataSize = kCount * sizeof(uint32_t);
-
- SharedMemory memory;
- ASSERT_TRUE(memory.CreateAndMapAnonymous(kDataSize));
- uint32_t* ptr = static_cast<uint32_t*>(memory.memory());
- ASSERT_NE(ptr, static_cast<void*>(nullptr));
-
- for (size_t i = 0; i < kCount; ++i) {
- ptr[i] = i;
- }
-
- memory.Unmap();
-
- off_t offset = SysInfo::VMAllocationGranularity();
- ASSERT_TRUE(memory.MapAt(offset, kDataSize - offset));
- offset /= sizeof(uint32_t);
- ptr = static_cast<uint32_t*>(memory.memory());
- ASSERT_NE(ptr, static_cast<void*>(nullptr));
- for (size_t i = offset; i < kCount; ++i) {
- EXPECT_EQ(ptr[i - offset], i);
- }
-}
-
-TEST_P(SharedMemoryTest, MapTwice) {
- const uint32_t kDataSize = 1024;
- SharedMemory memory;
- bool rv = memory.CreateAndMapAnonymous(kDataSize);
- EXPECT_TRUE(rv);
-
- void* old_address = memory.memory();
-
- rv = memory.Map(kDataSize);
- EXPECT_FALSE(rv);
- EXPECT_EQ(old_address, memory.memory());
-}
-
-#if defined(OS_POSIX)
-// This test is not applicable for iOS (crbug.com/399384).
-#if !defined(OS_IOS)
-// Create a shared memory object, mmap it, and mprotect it to PROT_EXEC.
-TEST_P(SharedMemoryTest, AnonymousExecutable) {
- const uint32_t kTestSize = 1 << 16;
-
- SharedMemory shared_memory;
- SharedMemoryCreateOptions options;
- options.size = kTestSize;
- options.executable = true;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
- // The Mach functionality is tested in shared_memory_mac_unittest.cc.
- options.type = SharedMemoryHandle::POSIX;
-#endif
-
- EXPECT_TRUE(shared_memory.Create(options));
- EXPECT_TRUE(shared_memory.Map(shared_memory.requested_size()));
-
- EXPECT_EQ(0, mprotect(shared_memory.memory(), shared_memory.requested_size(),
- PROT_READ | PROT_EXEC));
-}
-#endif // !defined(OS_IOS)
-
-#if defined(OS_ANDROID)
-// This test is restricted to Android since there is no way on other platforms
-// to guarantee that a region can never be mapped with PROT_EXEC. E.g. on
-// Linux, anonymous shared regions come from /dev/shm which can be mounted
-// without 'noexec'. In this case, anything can perform an mprotect() to
-// change the protection mask of a given page.
-TEST(SharedMemoryTest, AnonymousIsNotExecutableByDefault) {
- const uint32_t kTestSize = 1 << 16;
-
- SharedMemory shared_memory;
- SharedMemoryCreateOptions options;
- options.size = kTestSize;
-
- EXPECT_TRUE(shared_memory.Create(options));
- EXPECT_TRUE(shared_memory.Map(shared_memory.requested_size()));
-
- errno = 0;
- EXPECT_EQ(-1, mprotect(shared_memory.memory(), shared_memory.requested_size(),
- PROT_READ | PROT_EXEC));
- EXPECT_EQ(EACCES, errno);
-}
-#endif // OS_ANDROID
-
-// Android supports a different permission model than POSIX for its "ashmem"
-// shared memory implementation. So the tests about file permissions are not
-// included on Android. Fuchsia does not use a file-backed shared memory
-// implementation.
-
-#if !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-
-// Set a umask and restore the old mask on destruction.
-class ScopedUmaskSetter {
- public:
- explicit ScopedUmaskSetter(mode_t target_mask) {
- old_umask_ = umask(target_mask);
- }
- ~ScopedUmaskSetter() { umask(old_umask_); }
- private:
- mode_t old_umask_;
- DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedUmaskSetter);
-};
-
-// Create a shared memory object, check its permissions.
-TEST_P(SharedMemoryTest, FilePermissionsAnonymous) {
- const uint32_t kTestSize = 1 << 8;
-
- SharedMemory shared_memory;
- SharedMemoryCreateOptions options;
- options.size = kTestSize;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
- // The Mach functionality is tested in shared_memory_mac_unittest.cc.
- options.type = SharedMemoryHandle::POSIX;
-#endif
- // Set a file mode creation mask that gives all permissions.
- ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
-
- EXPECT_TRUE(shared_memory.Create(options));
-
- int shm_fd =
- SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
- struct stat shm_stat;
- EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
- // Neither the group, nor others should be able to read the shared memory
- // file.
- EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
- EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
-}
-
-// Create a shared memory object, check its permissions.
-TEST_P(SharedMemoryTest, FilePermissionsNamed) {
- const uint32_t kTestSize = 1 << 8;
-
- SharedMemory shared_memory;
- SharedMemoryCreateOptions options;
- options.size = kTestSize;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
- // The Mach functionality is tested in shared_memory_mac_unittest.cc.
- options.type = SharedMemoryHandle::POSIX;
-#endif
-
- // Set a file mode creation mask that gives all permissions.
- ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
-
- EXPECT_TRUE(shared_memory.Create(options));
-
- int fd = SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
- struct stat shm_stat;
- EXPECT_EQ(0, fstat(fd, &shm_stat));
- // Neither the group, nor others should have been able to open the shared
- // memory file while its name existed.
- EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
- EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
-}
-#endif // !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-
-#endif // defined(OS_POSIX)
-
-// Map() will return addresses which are aligned to the platform page size, this
-// varies from platform to platform though. Since we'd like to advertise a
-// minimum alignment that callers can count on, test for it here.
-TEST_P(SharedMemoryTest, MapMinimumAlignment) {
- static const int kDataSize = 8192;
-
- SharedMemory shared_memory;
- ASSERT_TRUE(shared_memory.CreateAndMapAnonymous(kDataSize));
- EXPECT_EQ(0U, reinterpret_cast<uintptr_t>(
- shared_memory.memory()) & (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
- shared_memory.Close();
-}
-
-#if defined(OS_WIN)
-TEST_P(SharedMemoryTest, UnsafeImageSection) {
- const char kTestSectionName[] = "UnsafeImageSection";
- wchar_t path[MAX_PATH];
- EXPECT_GT(::GetModuleFileName(nullptr, path, arraysize(path)), 0U);
-
- // Map the current executable image to save us creating a new PE file on disk.
- base::win::ScopedHandle file_handle(::CreateFile(
- path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr));
- EXPECT_TRUE(file_handle.IsValid());
- base::win::ScopedHandle section_handle(
- ::CreateFileMappingA(file_handle.Get(), nullptr,
- PAGE_READONLY | SEC_IMAGE, 0, 0, kTestSectionName));
- EXPECT_TRUE(section_handle.IsValid());
-
- // Check direct opening by name, from handle and duplicated from handle.
- SharedMemory shared_memory_open;
- EXPECT_TRUE(shared_memory_open.Open(kTestSectionName, true));
- EXPECT_FALSE(shared_memory_open.Map(1));
- EXPECT_EQ(nullptr, shared_memory_open.memory());
-
- SharedMemory shared_memory_handle_local(
- SharedMemoryHandle(section_handle.Take(), 1, UnguessableToken::Create()),
- true);
- EXPECT_FALSE(shared_memory_handle_local.Map(1));
- EXPECT_EQ(nullptr, shared_memory_handle_local.memory());
-
- // Check that a handle without SECTION_QUERY also can't be mapped as it can't
- // be checked.
- SharedMemory shared_memory_handle_dummy;
- SharedMemoryCreateOptions options;
- options.size = 0x1000;
- EXPECT_TRUE(shared_memory_handle_dummy.Create(options));
- HANDLE handle_no_query;
- EXPECT_TRUE(::DuplicateHandle(
- ::GetCurrentProcess(), shared_memory_handle_dummy.handle().GetHandle(),
- ::GetCurrentProcess(), &handle_no_query, FILE_MAP_READ, FALSE, 0));
- SharedMemory shared_memory_handle_no_query(
- SharedMemoryHandle(handle_no_query, options.size,
- UnguessableToken::Create()),
- true);
- EXPECT_FALSE(shared_memory_handle_no_query.Map(1));
- EXPECT_EQ(nullptr, shared_memory_handle_no_query.memory());
-}
-#endif // defined(OS_WIN)
-
-// iOS does not allow multiple processes.
-// Android ashmem does not support named shared memory.
-// Fuchsia SharedMemory does not support named shared memory.
-// Mac SharedMemory does not support named shared memory. crbug.com/345734
-#if !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX) && \
- !defined(OS_FUCHSIA)
-// On POSIX it is especially important we test shmem across processes,
-// not just across threads. But the test is enabled on all platforms.
-class SharedMemoryProcessTest : public MultiProcessTest {
- public:
- static void CleanUp() {
- SharedMemory memory;
- memory.Delete(s_test_name_);
- }
-
- static int TaskTestMain() {
- int errors = 0;
- SharedMemory memory;
- bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
- EXPECT_TRUE(rv);
- if (rv != true)
- errors++;
- rv = memory.Map(s_data_size_);
- EXPECT_TRUE(rv);
- if (rv != true)
- errors++;
- int* ptr = static_cast<int*>(memory.memory());
-
- // This runs concurrently in multiple processes. Writes need to be atomic.
- subtle::Barrier_AtomicIncrement(ptr, 1);
- memory.Close();
- return errors;
- }
-
- static const char s_test_name_[];
- static const uint32_t s_data_size_;
-};
-
-const char SharedMemoryProcessTest::s_test_name_[] = "MPMem";
-const uint32_t SharedMemoryProcessTest::s_data_size_ = 1024;
-
-TEST_F(SharedMemoryProcessTest, SharedMemoryAcrossProcesses) {
- const int kNumTasks = 5;
-
- SharedMemoryProcessTest::CleanUp();
-
- // Create a shared memory region. Set the first word to 0.
- SharedMemory memory;
- bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
- ASSERT_TRUE(rv);
- rv = memory.Map(s_data_size_);
- ASSERT_TRUE(rv);
- int* ptr = static_cast<int*>(memory.memory());
- *ptr = 0;
-
- // Start |kNumTasks| processes, each of which atomically increments the first
- // word by 1.
- Process processes[kNumTasks];
- for (int index = 0; index < kNumTasks; ++index) {
- processes[index] = SpawnChild("SharedMemoryTestMain");
- ASSERT_TRUE(processes[index].IsValid());
- }
-
- // Check that each process exited correctly.
- int exit_code = 0;
- for (int index = 0; index < kNumTasks; ++index) {
- EXPECT_TRUE(processes[index].WaitForExit(&exit_code));
- EXPECT_EQ(0, exit_code);
- }
-
- // Check that the shared memory region reflects |kNumTasks| increments.
- ASSERT_EQ(kNumTasks, *ptr);
-
- memory.Close();
- SharedMemoryProcessTest::CleanUp();
-}
-
-MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
- return SharedMemoryProcessTest::TaskTestMain();
-}
-#endif // !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX) &&
- // !defined(OS_FUCHSIA)
-
-TEST_P(SharedMemoryTest, MappedId) {
- const uint32_t kDataSize = 1024;
- SharedMemory memory;
- SharedMemoryCreateOptions options;
- options.size = kDataSize;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
- // The Mach functionality is tested in shared_memory_mac_unittest.cc.
- options.type = SharedMemoryHandle::POSIX;
-#endif
-
- EXPECT_TRUE(memory.Create(options));
- base::UnguessableToken id = memory.handle().GetGUID();
- EXPECT_FALSE(id.is_empty());
- EXPECT_TRUE(memory.mapped_id().is_empty());
-
- EXPECT_TRUE(memory.Map(kDataSize));
- EXPECT_EQ(id, memory.mapped_id());
-
- memory.Close();
- EXPECT_EQ(id, memory.mapped_id());
-
- memory.Unmap();
- EXPECT_TRUE(memory.mapped_id().is_empty());
-}
-
-INSTANTIATE_TEST_CASE_P(Default,
- SharedMemoryTest,
- ::testing::Values(Mode::Default));
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-INSTANTIATE_TEST_CASE_P(SkipDevShm,
- SharedMemoryTest,
- ::testing::Values(Mode::DisableDevShm));
-#endif // defined(OS_LINUX) && !defined(OS_CHROMEOS)
-
-#if defined(OS_ANDROID)
-TEST(SharedMemoryTest, ReadOnlyRegions) {
- const uint32_t kDataSize = 1024;
- SharedMemory memory;
- SharedMemoryCreateOptions options;
- options.size = kDataSize;
- EXPECT_TRUE(memory.Create(options));
-
- EXPECT_FALSE(memory.handle().IsRegionReadOnly());
-
- // Check that it is possible to map the region directly from the fd.
- int region_fd = memory.handle().GetHandle();
- EXPECT_GE(region_fd, 0);
- void* address = mmap(nullptr, kDataSize, PROT_READ | PROT_WRITE, MAP_SHARED,
- region_fd, 0);
- bool success = address && address != MAP_FAILED;
- ASSERT_TRUE(address);
- ASSERT_NE(address, MAP_FAILED);
- if (success) {
- EXPECT_EQ(0, munmap(address, kDataSize));
- }
-
- ASSERT_TRUE(memory.handle().SetRegionReadOnly());
- EXPECT_TRUE(memory.handle().IsRegionReadOnly());
-
- // Check that it is no longer possible to map the region read/write.
- errno = 0;
- address = mmap(nullptr, kDataSize, PROT_READ | PROT_WRITE, MAP_SHARED,
- region_fd, 0);
- success = address && address != MAP_FAILED;
- ASSERT_FALSE(success);
- ASSERT_EQ(EPERM, errno);
- if (success) {
- EXPECT_EQ(0, munmap(address, kDataSize));
- }
-}
-
-TEST(SharedMemoryTest, ReadOnlyDescriptors) {
- const uint32_t kDataSize = 1024;
- SharedMemory memory;
- SharedMemoryCreateOptions options;
- options.size = kDataSize;
- EXPECT_TRUE(memory.Create(options));
-
- EXPECT_FALSE(memory.handle().IsRegionReadOnly());
-
- // Getting a read-only descriptor should not make the region read-only itself.
- SharedMemoryHandle ro_handle = memory.GetReadOnlyHandle();
- EXPECT_FALSE(memory.handle().IsRegionReadOnly());
-
- // Mapping a writable region from a read-only descriptor should not
- // be possible, it will DCHECK() in debug builds (see test below),
- // while returning false on release ones.
- {
- bool dcheck_fired = false;
- logging::ScopedLogAssertHandler log_assert(
- base::BindRepeating([](bool* flag, const char*, int, base::StringPiece,
- base::StringPiece) { *flag = true; },
- base::Unretained(&dcheck_fired)));
-
- SharedMemory rw_region(ro_handle.Duplicate(), /* read_only */ false);
- EXPECT_FALSE(rw_region.Map(kDataSize));
- EXPECT_EQ(DCHECK_IS_ON() ? true : false, dcheck_fired);
- }
-
- // Nor shall it turn the region read-only itself.
- EXPECT_FALSE(ro_handle.IsRegionReadOnly());
-
- // Mapping a read-only region from a read-only descriptor should work.
- SharedMemory ro_region(ro_handle.Duplicate(), /* read_only */ true);
- EXPECT_TRUE(ro_region.Map(kDataSize));
-
- // And it should turn the region read-only too.
- EXPECT_TRUE(ro_handle.IsRegionReadOnly());
- EXPECT_TRUE(memory.handle().IsRegionReadOnly());
- EXPECT_FALSE(memory.Map(kDataSize));
-
- ro_handle.Close();
-}
-
-#endif // OS_ANDROID
-
-} // namespace base
diff --git a/base/memory/shared_memory_win_unittest.cc b/base/memory/shared_memory_win_unittest.cc
deleted file mode 100644
index 5fc132d..0000000
--- a/base/memory/shared_memory_win_unittest.cc
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright 2016 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 <windows.h>
-#include <sddl.h>
-
-#include <memory>
-
-#include "base/command_line.h"
-#include "base/memory/free_deleter.h"
-#include "base/memory/shared_memory.h"
-#include "base/process/process.h"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/win_util.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace base {
-namespace {
-const char* kHandleSwitchName = "shared_memory_win_test_switch";
-
-// Creates a process token with a low integrity SID.
-win::ScopedHandle CreateLowIntegritySID() {
- HANDLE process_token_raw = nullptr;
- BOOL success = ::OpenProcessToken(GetCurrentProcess(),
- TOKEN_DUPLICATE | TOKEN_ADJUST_DEFAULT |
- TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY,
- &process_token_raw);
- if (!success)
- return base::win::ScopedHandle();
- win::ScopedHandle process_token(process_token_raw);
-
- HANDLE lowered_process_token_raw = nullptr;
- success =
- ::DuplicateTokenEx(process_token.Get(), 0, NULL, SecurityImpersonation,
- TokenPrimary, &lowered_process_token_raw);
- if (!success)
- return base::win::ScopedHandle();
- win::ScopedHandle lowered_process_token(lowered_process_token_raw);
-
- // Low integrity SID
- WCHAR integrity_sid_string[20] = L"S-1-16-4096";
- PSID integrity_sid = nullptr;
- success = ::ConvertStringSidToSid(integrity_sid_string, &integrity_sid);
- if (!success)
- return base::win::ScopedHandle();
-
- TOKEN_MANDATORY_LABEL TIL = {};
- TIL.Label.Attributes = SE_GROUP_INTEGRITY;
- TIL.Label.Sid = integrity_sid;
- success = ::SetTokenInformation(
- lowered_process_token.Get(), TokenIntegrityLevel, &TIL,
- sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(integrity_sid));
- if (!success)
- return base::win::ScopedHandle();
- return lowered_process_token;
-}
-
-// Reads a HANDLE from the pipe as a raw int, least significant digit first.
-win::ScopedHandle ReadHandleFromPipe(HANDLE pipe) {
- // Read from parent pipe.
- const size_t buf_size = 1000;
- char buffer[buf_size];
- memset(buffer, 0, buf_size);
- DWORD bytes_read;
- BOOL success = ReadFile(pipe, buffer, buf_size, &bytes_read, NULL);
-
- if (!success || bytes_read == 0) {
- LOG(ERROR) << "Failed to read handle from pipe.";
- return win::ScopedHandle();
- }
-
- int handle_as_int = 0;
- int power_of_ten = 1;
- for (unsigned int i = 0; i < bytes_read; ++i) {
- handle_as_int += buffer[i] * power_of_ten;
- power_of_ten *= 10;
- }
-
- return win::ScopedHandle(reinterpret_cast<HANDLE>(handle_as_int));
-}
-
-// Writes a HANDLE to a pipe as a raw int, least significant digit first.
-void WriteHandleToPipe(HANDLE pipe, HANDLE handle) {
- uint32_t handle_as_int = base::win::HandleToUint32(handle);
-
- std::unique_ptr<char, base::FreeDeleter> buffer(
- static_cast<char*>(malloc(1000)));
- size_t index = 0;
- while (handle_as_int > 0) {
- buffer.get()[index] = handle_as_int % 10;
- handle_as_int /= 10;
- ++index;
- }
-
- ::ConnectNamedPipe(pipe, nullptr);
- DWORD written;
- ASSERT_TRUE(::WriteFile(pipe, buffer.get(), index, &written, NULL));
-}
-
-// Creates a communication pipe with the given name.
-win::ScopedHandle CreateCommunicationPipe(const std::wstring& name) {
- return win::ScopedHandle(CreateNamedPipe(name.c_str(), // pipe name
- PIPE_ACCESS_DUPLEX, PIPE_WAIT, 255,
- 1000, 1000, 0, NULL));
-}
-
-// Generates a random name for a communication pipe.
-std::wstring CreateCommunicationPipeName() {
- uint64_t rand_values[4];
- RandBytes(&rand_values, sizeof(rand_values));
- std::wstring child_pipe_name = StringPrintf(
- L"\\\\.\\pipe\\SharedMemoryWinTest_%016llx%016llx%016llx%016llx",
- rand_values[0], rand_values[1], rand_values[2], rand_values[3]);
- return child_pipe_name;
-}
-
-class SharedMemoryWinTest : public base::MultiProcessTest {
- protected:
- CommandLine MakeCmdLine(const std::string& procname) override {
- CommandLine line = base::MultiProcessTest::MakeCmdLine(procname);
- line.AppendSwitchASCII(kHandleSwitchName, communication_pipe_name_);
- return line;
- }
-
- std::string communication_pipe_name_;
-};
-
-MULTIPROCESS_TEST_MAIN(LowerPermissions) {
- std::string handle_name =
- CommandLine::ForCurrentProcess()->GetSwitchValueASCII(kHandleSwitchName);
- std::wstring handle_name16 = SysUTF8ToWide(handle_name);
- win::ScopedHandle parent_pipe(
- ::CreateFile(handle_name16.c_str(), // pipe name
- GENERIC_READ,
- 0, // no sharing
- NULL, // default security attributes
- OPEN_EXISTING, // opens existing pipe
- 0, // default attributes
- NULL)); // no template file
- if (parent_pipe.Get() == INVALID_HANDLE_VALUE) {
- LOG(ERROR) << "Failed to open communication pipe.";
- return 1;
- }
-
- win::ScopedHandle received_handle = ReadHandleFromPipe(parent_pipe.Get());
- if (!received_handle.Get()) {
- LOG(ERROR) << "Failed to read handle from pipe.";
- return 1;
- }
-
- // Attempting to add the WRITE_DAC permission should fail.
- HANDLE duped_handle;
- BOOL success = ::DuplicateHandle(GetCurrentProcess(), received_handle.Get(),
- GetCurrentProcess(), &duped_handle,
- FILE_MAP_READ | WRITE_DAC, FALSE, 0);
- if (success) {
- LOG(ERROR) << "Should not have been able to add WRITE_DAC permission.";
- return 1;
- }
-
- // Attempting to add the FILE_MAP_WRITE permission should fail.
- success = ::DuplicateHandle(GetCurrentProcess(), received_handle.Get(),
- GetCurrentProcess(), &duped_handle,
- FILE_MAP_READ | FILE_MAP_WRITE, FALSE, 0);
- if (success) {
- LOG(ERROR) << "Should not have been able to add FILE_MAP_WRITE permission.";
- return 1;
- }
-
- // Attempting to duplicate the HANDLE with the same permissions should
- // succeed.
- success = ::DuplicateHandle(GetCurrentProcess(), received_handle.Get(),
- GetCurrentProcess(), &duped_handle, FILE_MAP_READ,
- FALSE, 0);
- if (!success) {
- LOG(ERROR) << "Failed to duplicate handle.";
- return 4;
- }
- ::CloseHandle(duped_handle);
- return 0;
-}
-
-TEST_F(SharedMemoryWinTest, LowerPermissions) {
- std::wstring communication_pipe_name = CreateCommunicationPipeName();
- communication_pipe_name_ = SysWideToUTF8(communication_pipe_name);
-
- win::ScopedHandle communication_pipe =
- CreateCommunicationPipe(communication_pipe_name);
- ASSERT_TRUE(communication_pipe.Get());
-
- win::ScopedHandle lowered_process_token = CreateLowIntegritySID();
- ASSERT_TRUE(lowered_process_token.Get());
-
- base::LaunchOptions options;
- options.as_user = lowered_process_token.Get();
- base::Process process = SpawnChildWithOptions("LowerPermissions", options);
- ASSERT_TRUE(process.IsValid());
-
- SharedMemory memory;
- memory.CreateAndMapAnonymous(1001);
-
- // Duplicate into child process, giving only FILE_MAP_READ permissions.
- HANDLE raw_handle = nullptr;
- ::DuplicateHandle(::GetCurrentProcess(), memory.handle().GetHandle(),
- process.Handle(), &raw_handle,
- FILE_MAP_READ | SECTION_QUERY, FALSE, 0);
- ASSERT_TRUE(raw_handle);
-
- WriteHandleToPipe(communication_pipe.Get(), raw_handle);
-
- int exit_code;
- EXPECT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
- &exit_code));
- EXPECT_EQ(0, exit_code);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/memory/singleton_unittest.cc b/base/memory/singleton_unittest.cc
deleted file mode 100644
index 06e53b2..0000000
--- a/base/memory/singleton_unittest.cc
+++ /dev/null
@@ -1,299 +0,0 @@
-// 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.
-
-#include <stdint.h>
-
-#include "base/at_exit.h"
-#include "base/memory/singleton.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-static_assert(DefaultSingletonTraits<int>::kRegisterAtExit == true,
- "object must be deleted on process exit");
-
-typedef void (*CallbackFunc)();
-
-template <size_t alignment>
-class AlignedData {
- public:
- AlignedData() = default;
- ~AlignedData() = default;
- alignas(alignment) char data_[alignment];
-};
-
-class IntSingleton {
- public:
- static IntSingleton* GetInstance() {
- return Singleton<IntSingleton>::get();
- }
-
- int value_;
-};
-
-class Init5Singleton {
- public:
- struct Trait;
-
- static Init5Singleton* GetInstance() {
- return Singleton<Init5Singleton, Trait>::get();
- }
-
- int value_;
-};
-
-struct Init5Singleton::Trait : public DefaultSingletonTraits<Init5Singleton> {
- static Init5Singleton* New() {
- Init5Singleton* instance = new Init5Singleton();
- instance->value_ = 5;
- return instance;
- }
-};
-
-int* SingletonInt() {
- return &IntSingleton::GetInstance()->value_;
-}
-
-int* SingletonInt5() {
- return &Init5Singleton::GetInstance()->value_;
-}
-
-template <typename Type>
-struct CallbackTrait : public DefaultSingletonTraits<Type> {
- static void Delete(Type* instance) {
- if (instance->callback_)
- (instance->callback_)();
- DefaultSingletonTraits<Type>::Delete(instance);
- }
-};
-
-class CallbackSingleton {
- public:
- CallbackSingleton() : callback_(nullptr) {}
- CallbackFunc callback_;
-};
-
-class CallbackSingletonWithNoLeakTrait : public CallbackSingleton {
- public:
- struct Trait : public CallbackTrait<CallbackSingletonWithNoLeakTrait> { };
-
- CallbackSingletonWithNoLeakTrait() : CallbackSingleton() { }
-
- static CallbackSingletonWithNoLeakTrait* GetInstance() {
- return Singleton<CallbackSingletonWithNoLeakTrait, Trait>::get();
- }
-};
-
-class CallbackSingletonWithLeakTrait : public CallbackSingleton {
- public:
- struct Trait : public CallbackTrait<CallbackSingletonWithLeakTrait> {
- static const bool kRegisterAtExit = false;
- };
-
- CallbackSingletonWithLeakTrait() : CallbackSingleton() { }
-
- static CallbackSingletonWithLeakTrait* GetInstance() {
- return Singleton<CallbackSingletonWithLeakTrait, Trait>::get();
- }
-};
-
-class CallbackSingletonWithStaticTrait : public CallbackSingleton {
- public:
- struct Trait;
-
- CallbackSingletonWithStaticTrait() : CallbackSingleton() { }
-
- static CallbackSingletonWithStaticTrait* GetInstance() {
- return Singleton<CallbackSingletonWithStaticTrait, Trait>::get();
- }
-};
-
-struct CallbackSingletonWithStaticTrait::Trait
- : public StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait> {
- static void Delete(CallbackSingletonWithStaticTrait* instance) {
- if (instance->callback_)
- (instance->callback_)();
- StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete(
- instance);
- }
-};
-
-template <class Type>
-class AlignedTestSingleton {
- public:
- AlignedTestSingleton() = default;
- ~AlignedTestSingleton() = default;
- static AlignedTestSingleton* GetInstance() {
- return Singleton<AlignedTestSingleton,
- StaticMemorySingletonTraits<AlignedTestSingleton>>::get();
- }
-
- Type type_;
-};
-
-
-void SingletonNoLeak(CallbackFunc CallOnQuit) {
- CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit;
-}
-
-void SingletonLeak(CallbackFunc CallOnQuit) {
- CallbackSingletonWithLeakTrait::GetInstance()->callback_ = CallOnQuit;
-}
-
-CallbackFunc* GetLeakySingleton() {
- return &CallbackSingletonWithLeakTrait::GetInstance()->callback_;
-}
-
-void DeleteLeakySingleton() {
- DefaultSingletonTraits<CallbackSingletonWithLeakTrait>::Delete(
- CallbackSingletonWithLeakTrait::GetInstance());
-}
-
-void SingletonStatic(CallbackFunc CallOnQuit) {
- CallbackSingletonWithStaticTrait::GetInstance()->callback_ = CallOnQuit;
-}
-
-CallbackFunc* GetStaticSingleton() {
- return &CallbackSingletonWithStaticTrait::GetInstance()->callback_;
-}
-
-
-class SingletonTest : public testing::Test {
- public:
- SingletonTest() = default;
-
- void SetUp() override {
- non_leak_called_ = false;
- leaky_called_ = false;
- static_called_ = false;
- }
-
- protected:
- void VerifiesCallbacks() {
- EXPECT_TRUE(non_leak_called_);
- EXPECT_FALSE(leaky_called_);
- EXPECT_TRUE(static_called_);
- non_leak_called_ = false;
- leaky_called_ = false;
- static_called_ = false;
- }
-
- void VerifiesCallbacksNotCalled() {
- EXPECT_FALSE(non_leak_called_);
- EXPECT_FALSE(leaky_called_);
- EXPECT_FALSE(static_called_);
- non_leak_called_ = false;
- leaky_called_ = false;
- static_called_ = false;
- }
-
- static void CallbackNoLeak() {
- non_leak_called_ = true;
- }
-
- static void CallbackLeak() {
- leaky_called_ = true;
- }
-
- static void CallbackStatic() {
- static_called_ = true;
- }
-
- private:
- static bool non_leak_called_;
- static bool leaky_called_;
- static bool static_called_;
-};
-
-bool SingletonTest::non_leak_called_ = false;
-bool SingletonTest::leaky_called_ = false;
-bool SingletonTest::static_called_ = false;
-
-TEST_F(SingletonTest, Basic) {
- int* singleton_int;
- int* singleton_int_5;
- CallbackFunc* leaky_singleton;
- CallbackFunc* static_singleton;
-
- {
- ShadowingAtExitManager sem;
- {
- singleton_int = SingletonInt();
- }
- // Ensure POD type initialization.
- EXPECT_EQ(*singleton_int, 0);
- *singleton_int = 1;
-
- EXPECT_EQ(singleton_int, SingletonInt());
- EXPECT_EQ(*singleton_int, 1);
-
- {
- singleton_int_5 = SingletonInt5();
- }
- // Is default initialized to 5.
- EXPECT_EQ(*singleton_int_5, 5);
-
- SingletonNoLeak(&CallbackNoLeak);
- SingletonLeak(&CallbackLeak);
- SingletonStatic(&CallbackStatic);
- static_singleton = GetStaticSingleton();
- leaky_singleton = GetLeakySingleton();
- EXPECT_TRUE(leaky_singleton);
- }
-
- // Verify that only the expected callback has been called.
- VerifiesCallbacks();
- // Delete the leaky singleton.
- DeleteLeakySingleton();
-
- // The static singleton can't be acquired post-atexit.
- EXPECT_EQ(nullptr, GetStaticSingleton());
-
- {
- ShadowingAtExitManager sem;
- // Verifiy that the variables were reset.
- {
- singleton_int = SingletonInt();
- EXPECT_EQ(*singleton_int, 0);
- }
- {
- singleton_int_5 = SingletonInt5();
- EXPECT_EQ(*singleton_int_5, 5);
- }
- {
- // Resurrect the static singleton, and assert that it
- // still points to the same (static) memory.
- CallbackSingletonWithStaticTrait::Trait::ResurrectForTesting();
- EXPECT_EQ(GetStaticSingleton(), static_singleton);
- }
- }
- // The leaky singleton shouldn't leak since SingletonLeak has not been called.
- VerifiesCallbacksNotCalled();
-}
-
-#define EXPECT_ALIGNED(ptr, align) \
- EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
-
-TEST_F(SingletonTest, Alignment) {
- // Create some static singletons with increasing sizes and alignment
- // requirements. By ordering this way, the linker will need to do some work to
- // ensure proper alignment of the static data.
- AlignedTestSingleton<int32_t>* align4 =
- AlignedTestSingleton<int32_t>::GetInstance();
- AlignedTestSingleton<AlignedData<32>>* align32 =
- AlignedTestSingleton<AlignedData<32>>::GetInstance();
- AlignedTestSingleton<AlignedData<128>>* align128 =
- AlignedTestSingleton<AlignedData<128>>::GetInstance();
- AlignedTestSingleton<AlignedData<4096>>* align4096 =
- AlignedTestSingleton<AlignedData<4096>>::GetInstance();
-
- EXPECT_ALIGNED(align4, 4);
- EXPECT_ALIGNED(align32, 32);
- EXPECT_ALIGNED(align128, 128);
- EXPECT_ALIGNED(align4096, 4096);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/memory/weak_ptr_unittest.cc b/base/memory/weak_ptr_unittest.cc
deleted file mode 100644
index f8dfb7c..0000000
--- a/base/memory/weak_ptr_unittest.cc
+++ /dev/null
@@ -1,716 +0,0 @@
-// 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.
-
-#include "base/memory/weak_ptr.h"
-
-#include <memory>
-#include <string>
-
-#include "base/bind.h"
-#include "base/debug/leak_annotations.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-WeakPtr<int> PassThru(WeakPtr<int> ptr) {
- return ptr;
-}
-
-template <class T>
-class OffThreadObjectCreator {
- public:
- static T* NewObject() {
- T* result;
- {
- Thread creator_thread("creator_thread");
- creator_thread.Start();
- creator_thread.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(OffThreadObjectCreator::CreateObject, &result));
- }
- DCHECK(result); // We synchronized on thread destruction above.
- return result;
- }
- private:
- static void CreateObject(T** result) {
- *result = new T;
- }
-};
-
-struct Base {
- std::string member;
-};
-struct Derived : public Base {};
-
-struct TargetBase {};
-struct Target : public TargetBase, public SupportsWeakPtr<Target> {
- virtual ~Target() = default;
-};
-
-struct DerivedTarget : public Target {};
-
-// A class inheriting from Target and defining a nested type called 'Base'.
-// To guard against strange compilation errors.
-struct DerivedTargetWithNestedBase : public Target {
- using Base = void;
-};
-
-// A struct with a virtual destructor.
-struct VirtualDestructor {
- virtual ~VirtualDestructor() = default;
-};
-
-// A class inheriting from Target where Target is not the first base, and where
-// the first base has a virtual method table. This creates a structure where the
-// Target base is not positioned at the beginning of
-// DerivedTargetMultipleInheritance.
-struct DerivedTargetMultipleInheritance : public VirtualDestructor,
- public Target {};
-
-struct Arrow {
- WeakPtr<Target> target;
-};
-struct TargetWithFactory : public Target {
- TargetWithFactory() : factory(this) {}
- WeakPtrFactory<Target> factory;
-};
-
-// Helper class to create and destroy weak pointer copies
-// and delete objects on a background thread.
-class BackgroundThread : public Thread {
- public:
- BackgroundThread() : Thread("owner_thread") {}
-
- ~BackgroundThread() override { Stop(); }
-
- void CreateArrowFromTarget(Arrow** arrow, Target* target) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&BackgroundThread::DoCreateArrowFromTarget,
- arrow, target, &completion));
- completion.Wait();
- }
-
- void CreateArrowFromArrow(Arrow** arrow, const Arrow* other) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&BackgroundThread::DoCreateArrowFromArrow,
- arrow, other, &completion));
- completion.Wait();
- }
-
- void DeleteTarget(Target* object) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&BackgroundThread::DoDeleteTarget, object, &completion));
- completion.Wait();
- }
-
- void CopyAndAssignArrow(Arrow* object) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&BackgroundThread::DoCopyAndAssignArrow,
- object, &completion));
- completion.Wait();
- }
-
- void CopyAndAssignArrowBase(Arrow* object) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&BackgroundThread::DoCopyAndAssignArrowBase,
- object, &completion));
- completion.Wait();
- }
-
- void DeleteArrow(Arrow* object) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&BackgroundThread::DoDeleteArrow, object, &completion));
- completion.Wait();
- }
-
- Target* DeRef(const Arrow* arrow) {
- WaitableEvent completion(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- Target* result = nullptr;
- task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&BackgroundThread::DoDeRef, arrow, &result,
- &completion));
- completion.Wait();
- return result;
- }
-
- protected:
- static void DoCreateArrowFromArrow(Arrow** arrow,
- const Arrow* other,
- WaitableEvent* completion) {
- *arrow = new Arrow;
- **arrow = *other;
- completion->Signal();
- }
-
- static void DoCreateArrowFromTarget(Arrow** arrow,
- Target* target,
- WaitableEvent* completion) {
- *arrow = new Arrow;
- (*arrow)->target = target->AsWeakPtr();
- completion->Signal();
- }
-
- static void DoDeRef(const Arrow* arrow,
- Target** result,
- WaitableEvent* completion) {
- *result = arrow->target.get();
- completion->Signal();
- }
-
- static void DoDeleteTarget(Target* object, WaitableEvent* completion) {
- delete object;
- completion->Signal();
- }
-
- static void DoCopyAndAssignArrow(Arrow* object, WaitableEvent* completion) {
- // Copy constructor.
- Arrow a = *object;
- // Assignment operator.
- *object = a;
- completion->Signal();
- }
-
- static void DoCopyAndAssignArrowBase(
- Arrow* object,
- WaitableEvent* completion) {
- // Copy constructor.
- WeakPtr<TargetBase> b = object->target;
- // Assignment operator.
- WeakPtr<TargetBase> c;
- c = object->target;
- completion->Signal();
- }
-
- static void DoDeleteArrow(Arrow* object, WaitableEvent* completion) {
- delete object;
- completion->Signal();
- }
-};
-
-} // namespace
-
-TEST(WeakPtrFactoryTest, Basic) {
- int data;
- WeakPtrFactory<int> factory(&data);
- WeakPtr<int> ptr = factory.GetWeakPtr();
- EXPECT_EQ(&data, ptr.get());
-}
-
-TEST(WeakPtrFactoryTest, Comparison) {
- int data;
- WeakPtrFactory<int> factory(&data);
- WeakPtr<int> ptr = factory.GetWeakPtr();
- WeakPtr<int> ptr2 = ptr;
- EXPECT_EQ(ptr.get(), ptr2.get());
-}
-
-TEST(WeakPtrFactoryTest, Move) {
- int data;
- WeakPtrFactory<int> factory(&data);
- WeakPtr<int> ptr = factory.GetWeakPtr();
- WeakPtr<int> ptr2 = factory.GetWeakPtr();
- WeakPtr<int> ptr3 = std::move(ptr2);
- EXPECT_NE(ptr.get(), ptr2.get());
- EXPECT_EQ(ptr.get(), ptr3.get());
-}
-
-TEST(WeakPtrFactoryTest, OutOfScope) {
- WeakPtr<int> ptr;
- EXPECT_EQ(nullptr, ptr.get());
- {
- int data;
- WeakPtrFactory<int> factory(&data);
- ptr = factory.GetWeakPtr();
- }
- EXPECT_EQ(nullptr, ptr.get());
-}
-
-TEST(WeakPtrFactoryTest, Multiple) {
- WeakPtr<int> a, b;
- {
- int data;
- WeakPtrFactory<int> factory(&data);
- a = factory.GetWeakPtr();
- b = factory.GetWeakPtr();
- EXPECT_EQ(&data, a.get());
- EXPECT_EQ(&data, b.get());
- }
- EXPECT_EQ(nullptr, a.get());
- EXPECT_EQ(nullptr, b.get());
-}
-
-TEST(WeakPtrFactoryTest, MultipleStaged) {
- WeakPtr<int> a;
- {
- int data;
- WeakPtrFactory<int> factory(&data);
- a = factory.GetWeakPtr();
- {
- WeakPtr<int> b = factory.GetWeakPtr();
- }
- EXPECT_NE(nullptr, a.get());
- }
- EXPECT_EQ(nullptr, a.get());
-}
-
-TEST(WeakPtrFactoryTest, Dereference) {
- Base data;
- data.member = "123456";
- WeakPtrFactory<Base> factory(&data);
- WeakPtr<Base> ptr = factory.GetWeakPtr();
- EXPECT_EQ(&data, ptr.get());
- EXPECT_EQ(data.member, (*ptr).member);
- EXPECT_EQ(data.member, ptr->member);
-}
-
-TEST(WeakPtrFactoryTest, UpCast) {
- Derived data;
- WeakPtrFactory<Derived> factory(&data);
- WeakPtr<Base> ptr = factory.GetWeakPtr();
- ptr = factory.GetWeakPtr();
- EXPECT_EQ(ptr.get(), &data);
-}
-
-TEST(WeakPtrTest, ConstructFromNullptr) {
- WeakPtr<int> ptr = PassThru(nullptr);
- EXPECT_EQ(nullptr, ptr.get());
-}
-
-TEST(WeakPtrTest, SupportsWeakPtr) {
- Target target;
- WeakPtr<Target> ptr = target.AsWeakPtr();
- EXPECT_EQ(&target, ptr.get());
-}
-
-TEST(WeakPtrTest, DerivedTarget) {
- DerivedTarget target;
- WeakPtr<DerivedTarget> ptr = AsWeakPtr(&target);
- EXPECT_EQ(&target, ptr.get());
-}
-
-TEST(WeakPtrTest, DerivedTargetWithNestedBase) {
- DerivedTargetWithNestedBase target;
- WeakPtr<DerivedTargetWithNestedBase> ptr = AsWeakPtr(&target);
- EXPECT_EQ(&target, ptr.get());
-}
-
-TEST(WeakPtrTest, DerivedTargetMultipleInheritance) {
- DerivedTargetMultipleInheritance d;
- Target& b = d;
- EXPECT_NE(static_cast<void*>(&d), static_cast<void*>(&b));
- const WeakPtr<Target> pb = AsWeakPtr(&b);
- EXPECT_EQ(pb.get(), &b);
- const WeakPtr<DerivedTargetMultipleInheritance> pd = AsWeakPtr(&d);
- EXPECT_EQ(pd.get(), &d);
-}
-
-TEST(WeakPtrFactoryTest, BooleanTesting) {
- int data;
- WeakPtrFactory<int> factory(&data);
-
- WeakPtr<int> ptr_to_an_instance = factory.GetWeakPtr();
- EXPECT_TRUE(ptr_to_an_instance);
- EXPECT_FALSE(!ptr_to_an_instance);
-
- if (ptr_to_an_instance) {
- } else {
- ADD_FAILURE() << "Pointer to an instance should result in true.";
- }
-
- if (!ptr_to_an_instance) { // check for operator!().
- ADD_FAILURE() << "Pointer to an instance should result in !x being false.";
- }
-
- WeakPtr<int> null_ptr;
- EXPECT_FALSE(null_ptr);
- EXPECT_TRUE(!null_ptr);
-
- if (null_ptr) {
- ADD_FAILURE() << "Null pointer should result in false.";
- }
-
- if (!null_ptr) { // check for operator!().
- } else {
- ADD_FAILURE() << "Null pointer should result in !x being true.";
- }
-}
-
-TEST(WeakPtrFactoryTest, ComparisonToNull) {
- int data;
- WeakPtrFactory<int> factory(&data);
-
- WeakPtr<int> ptr_to_an_instance = factory.GetWeakPtr();
- EXPECT_NE(nullptr, ptr_to_an_instance);
- EXPECT_NE(ptr_to_an_instance, nullptr);
-
- WeakPtr<int> null_ptr;
- EXPECT_EQ(null_ptr, nullptr);
- EXPECT_EQ(nullptr, null_ptr);
-}
-
-TEST(WeakPtrTest, InvalidateWeakPtrs) {
- int data;
- WeakPtrFactory<int> factory(&data);
- WeakPtr<int> ptr = factory.GetWeakPtr();
- EXPECT_EQ(&data, ptr.get());
- EXPECT_TRUE(factory.HasWeakPtrs());
- factory.InvalidateWeakPtrs();
- EXPECT_EQ(nullptr, ptr.get());
- EXPECT_FALSE(factory.HasWeakPtrs());
-
- // Test that the factory can create new weak pointers after a
- // InvalidateWeakPtrs call, and they remain valid until the next
- // InvalidateWeakPtrs call.
- WeakPtr<int> ptr2 = factory.GetWeakPtr();
- EXPECT_EQ(&data, ptr2.get());
- EXPECT_TRUE(factory.HasWeakPtrs());
- factory.InvalidateWeakPtrs();
- EXPECT_EQ(nullptr, ptr2.get());
- EXPECT_FALSE(factory.HasWeakPtrs());
-}
-
-TEST(WeakPtrTest, HasWeakPtrs) {
- int data;
- WeakPtrFactory<int> factory(&data);
- {
- WeakPtr<int> ptr = factory.GetWeakPtr();
- EXPECT_TRUE(factory.HasWeakPtrs());
- }
- EXPECT_FALSE(factory.HasWeakPtrs());
-}
-
-TEST(WeakPtrTest, ObjectAndWeakPtrOnDifferentThreads) {
- // Test that it is OK to create an object that supports WeakPtr on one thread,
- // but use it on another. This tests that we do not trip runtime checks that
- // ensure that a WeakPtr is not used by multiple threads.
- std::unique_ptr<Target> target(OffThreadObjectCreator<Target>::NewObject());
- WeakPtr<Target> weak_ptr = target->AsWeakPtr();
- EXPECT_EQ(target.get(), weak_ptr.get());
-}
-
-TEST(WeakPtrTest, WeakPtrInitiateAndUseOnDifferentThreads) {
- // Test that it is OK to create an object that has a WeakPtr member on one
- // thread, but use it on another. This tests that we do not trip runtime
- // checks that ensure that a WeakPtr is not used by multiple threads.
- std::unique_ptr<Arrow> arrow(OffThreadObjectCreator<Arrow>::NewObject());
- Target target;
- arrow->target = target.AsWeakPtr();
- EXPECT_EQ(&target, arrow->target.get());
-}
-
-TEST(WeakPtrTest, MoveOwnershipImplicitly) {
- // Move object ownership to another thread by releasing all weak pointers
- // on the original thread first, and then establish WeakPtr on a different
- // thread.
- BackgroundThread background;
- background.Start();
-
- Target* target = new Target();
- {
- WeakPtr<Target> weak_ptr = target->AsWeakPtr();
- // Main thread deletes the WeakPtr, then the thread ownership of the
- // object can be implicitly moved.
- }
- Arrow* arrow;
-
- // Background thread creates WeakPtr(and implicitly owns the object).
- background.CreateArrowFromTarget(&arrow, target);
- EXPECT_EQ(background.DeRef(arrow), target);
-
- {
- // Main thread creates another WeakPtr, but this does not trigger implicitly
- // thread ownership move.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
-
- // The new WeakPtr is owned by background thread.
- EXPECT_EQ(target, background.DeRef(&arrow));
- }
-
- // Target can only be deleted on background thread.
- background.DeleteTarget(target);
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrTest, MoveOwnershipOfUnreferencedObject) {
- BackgroundThread background;
- background.Start();
-
- Arrow* arrow;
- {
- Target target;
- // Background thread creates WeakPtr.
- background.CreateArrowFromTarget(&arrow, &target);
-
- // Bind to background thread.
- EXPECT_EQ(&target, background.DeRef(arrow));
-
- // Release the only WeakPtr.
- arrow->target.reset();
-
- // Now we should be able to create a new reference from this thread.
- arrow->target = target.AsWeakPtr();
-
- // Re-bind to main thread.
- EXPECT_EQ(&target, arrow->target.get());
-
- // And the main thread can now delete the target.
- }
-
- delete arrow;
-}
-
-TEST(WeakPtrTest, MoveOwnershipAfterInvalidate) {
- BackgroundThread background;
- background.Start();
-
- Arrow arrow;
- std::unique_ptr<TargetWithFactory> target(new TargetWithFactory);
-
- // Bind to main thread.
- arrow.target = target->factory.GetWeakPtr();
- EXPECT_EQ(target.get(), arrow.target.get());
-
- target->factory.InvalidateWeakPtrs();
- EXPECT_EQ(nullptr, arrow.target.get());
-
- arrow.target = target->factory.GetWeakPtr();
- // Re-bind to background thread.
- EXPECT_EQ(target.get(), background.DeRef(&arrow));
-
- // And the background thread can now delete the target.
- background.DeleteTarget(target.release());
-}
-
-TEST(WeakPtrTest, MainThreadRefOutlivesBackgroundThreadRef) {
- // Originating thread has a WeakPtr that outlives others.
- // - Main thread creates a WeakPtr
- // - Background thread creates a WeakPtr copy from the one in main thread
- // - Destruct the WeakPtr on background thread
- // - Destruct the WeakPtr on main thread
- BackgroundThread background;
- background.Start();
-
- Target target;
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
-
- Arrow* arrow_copy;
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
- EXPECT_EQ(arrow_copy->target.get(), &target);
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrTest, BackgroundThreadRefOutlivesMainThreadRef) {
- // Originating thread drops all references before another thread.
- // - Main thread creates a WeakPtr and passes copy to background thread
- // - Destruct the pointer on main thread
- // - Destruct the pointer on background thread
- BackgroundThread background;
- background.Start();
-
- Target target;
- Arrow* arrow_copy;
- {
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
- }
- EXPECT_EQ(arrow_copy->target.get(), &target);
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrTest, OwnerThreadDeletesObject) {
- // Originating thread invalidates WeakPtrs while its held by other thread.
- // - Main thread creates WeakPtr and passes Copy to background thread
- // - Object gets destroyed on main thread
- // (invalidates WeakPtr on background thread)
- // - WeakPtr gets destroyed on Thread B
- BackgroundThread background;
- background.Start();
- Arrow* arrow_copy;
- {
- Target target;
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
- }
- EXPECT_EQ(nullptr, arrow_copy->target.get());
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrTest, NonOwnerThreadCanCopyAndAssignWeakPtr) {
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow *arrow = new Arrow();
- arrow->target = target.AsWeakPtr();
-
- // Background can copy and assign arrow (as well as the WeakPtr inside).
- BackgroundThread background;
- background.Start();
- background.CopyAndAssignArrow(arrow);
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrTest, NonOwnerThreadCanCopyAndAssignWeakPtrBase) {
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow *arrow = new Arrow();
- arrow->target = target.AsWeakPtr();
-
- // Background can copy and assign arrow's WeakPtr to a base class WeakPtr.
- BackgroundThread background;
- background.Start();
- background.CopyAndAssignArrowBase(arrow);
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrTest, NonOwnerThreadCanDeleteWeakPtr) {
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow* arrow = new Arrow();
- arrow->target = target.AsWeakPtr();
-
- // Background can delete arrow (as well as the WeakPtr inside).
- BackgroundThread background;
- background.Start();
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrDeathTest, WeakPtrCopyDoesNotChangeThreadBinding) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- BackgroundThread background;
- background.Start();
-
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
-
- // Background copies the WeakPtr.
- Arrow* arrow_copy;
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
-
- // The copy is still bound to main thread so I can deref.
- EXPECT_EQ(arrow.target.get(), arrow_copy->target.get());
-
- // Although background thread created the copy, it can not deref the copied
- // WeakPtr.
- ASSERT_DCHECK_DEATH(background.DeRef(arrow_copy));
-
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadDereferencesWeakPtrAfterReference) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- // Main thread creates a Target object.
- Target target;
-
- // Main thread creates an arrow referencing the Target (so target's
- // thread ownership can not be implicitly moved).
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
- arrow.target.get();
-
- // Background thread tries to deref target, which violates thread ownership.
- BackgroundThread background;
- background.Start();
- ASSERT_DCHECK_DEATH(background.DeRef(&arrow));
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadDeletesWeakPtrAfterReference) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- std::unique_ptr<Target> target(new Target());
-
- // Main thread creates an arrow referencing the Target.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
-
- // Background thread tries to deref target, binding it to the thread.
- BackgroundThread background;
- background.Start();
- background.DeRef(&arrow);
-
- // Main thread deletes Target, violating thread binding.
- ASSERT_DCHECK_DEATH(target.reset());
-
- // |target.reset()| died so |target| still holds the object, so we
- // must pass it to the background thread to teardown.
- background.DeleteTarget(target.release());
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadDeletesObjectAfterReference) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- std::unique_ptr<Target> target(new Target());
-
- // Main thread creates an arrow referencing the Target, and references it, so
- // that it becomes bound to the thread.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
- arrow.target.get();
-
- // Background thread tries to delete target, volating thread binding.
- BackgroundThread background;
- background.Start();
- ASSERT_DCHECK_DEATH(background.DeleteTarget(target.release()));
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadReferencesObjectAfterDeletion) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- std::unique_ptr<Target> target(new Target());
-
- // Main thread creates an arrow referencing the Target.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
-
- // Background thread tries to delete target, binding the object to the thread.
- BackgroundThread background;
- background.Start();
- background.DeleteTarget(target.release());
-
- // Main thread attempts to dereference the target, violating thread binding.
- ASSERT_DCHECK_DEATH(arrow.target.get());
-}
-
-} // namespace base
diff --git a/base/memory/weak_ptr_unittest.nc b/base/memory/weak_ptr_unittest.nc
deleted file mode 100644
index b96b033..0000000
--- a/base/memory/weak_ptr_unittest.nc
+++ /dev/null
@@ -1,144 +0,0 @@
-// 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/memory/weak_ptr.h"
-
-namespace base {
-
-struct Producer : SupportsWeakPtr<Producer> {};
-struct DerivedProducer : Producer {};
-struct OtherDerivedProducer : Producer {};
-struct MultiplyDerivedProducer : Producer,
- SupportsWeakPtr<MultiplyDerivedProducer> {};
-struct Unrelated {};
-struct DerivedUnrelated : Unrelated {};
-
-#if defined(NCTEST_AUTO_DOWNCAST) // [r"cannot initialize a variable of type 'base::DerivedProducer \*' with an rvalue of type 'base::Producer \*'"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<Producer> ptr = f.AsWeakPtr();
- WeakPtr<DerivedProducer> derived_ptr = ptr;
-}
-
-#elif defined(NCTEST_STATIC_DOWNCAST) // [r"cannot initialize a variable of type 'base::DerivedProducer \*' with an rvalue of type 'base::Producer \*'"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<Producer> ptr = f.AsWeakPtr();
- WeakPtr<DerivedProducer> derived_ptr =
- static_cast<WeakPtr<DerivedProducer> >(ptr);
-}
-
-#elif defined(NCTEST_AUTO_REF_DOWNCAST) // [r"fatal error: non-const lvalue reference to type 'WeakPtr<base::DerivedProducer>' cannot bind to a value of unrelated type 'WeakPtr<base::Producer>'"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<Producer> ptr = f.AsWeakPtr();
- WeakPtr<DerivedProducer>& derived_ptr = ptr;
-}
-
-#elif defined(NCTEST_STATIC_REF_DOWNCAST) // [r"fatal error: non-const lvalue reference to type 'WeakPtr<base::DerivedProducer>' cannot bind to a value of unrelated type 'WeakPtr<base::Producer>'"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<Producer> ptr = f.AsWeakPtr();
- WeakPtr<DerivedProducer>& derived_ptr =
- static_cast<WeakPtr<DerivedProducer>&>(ptr);
-}
-
-#elif defined(NCTEST_STATIC_ASWEAKPTR_DOWNCAST) // [r"no matching function"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<DerivedProducer> ptr =
- SupportsWeakPtr<Producer>::StaticAsWeakPtr<DerivedProducer>(&f);
-}
-
-#elif defined(NCTEST_UNSAFE_HELPER_DOWNCAST) // [r"cannot initialize a variable of type 'base::DerivedProducer \*' with an rvalue of type 'base::Producer \*'"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<DerivedProducer> ptr = AsWeakPtr(&f);
-}
-
-#elif defined(NCTEST_UNSAFE_INSTANTIATED_HELPER_DOWNCAST) // [r"no matching function"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<DerivedProducer> ptr = AsWeakPtr<DerivedProducer>(&f);
-}
-
-#elif defined(NCTEST_UNSAFE_WRONG_INSANTIATED_HELPER_DOWNCAST) // [r"cannot initialize a variable of type 'base::DerivedProducer \*' with an rvalue of type 'base::Producer \*'"]
-
-void WontCompile() {
- Producer f;
- WeakPtr<DerivedProducer> ptr = AsWeakPtr<Producer>(&f);
-}
-
-#elif defined(NCTEST_UNSAFE_HELPER_CAST) // [r"cannot initialize a variable of type 'base::OtherDerivedProducer \*' with an rvalue of type 'base::DerivedProducer \*'"]
-
-void WontCompile() {
- DerivedProducer f;
- WeakPtr<OtherDerivedProducer> ptr = AsWeakPtr(&f);
-}
-
-#elif defined(NCTEST_UNSAFE_INSTANTIATED_HELPER_SIDECAST) // [r"fatal error: no matching function for call to 'AsWeakPtr'"]
-
-void WontCompile() {
- DerivedProducer f;
- WeakPtr<OtherDerivedProducer> ptr = AsWeakPtr<OtherDerivedProducer>(&f);
-}
-
-#elif defined(NCTEST_UNSAFE_WRONG_INSTANTIATED_HELPER_SIDECAST) // [r"cannot initialize a variable of type 'base::OtherDerivedProducer \*' with an rvalue of type 'base::DerivedProducer \*'"]
-
-void WontCompile() {
- DerivedProducer f;
- WeakPtr<OtherDerivedProducer> ptr = AsWeakPtr<DerivedProducer>(&f);
-}
-
-#elif defined(NCTEST_UNRELATED_HELPER) // [r"cannot initialize a variable of type 'base::Unrelated \*' with an rvalue of type 'base::DerivedProducer \*'"]
-
-void WontCompile() {
- DerivedProducer f;
- WeakPtr<Unrelated> ptr = AsWeakPtr(&f);
-}
-
-#elif defined(NCTEST_UNRELATED_INSTANTIATED_HELPER) // [r"no matching function"]
-
-void WontCompile() {
- DerivedProducer f;
- WeakPtr<Unrelated> ptr = AsWeakPtr<Unrelated>(&f);
-}
-
-// TODO(hans): Remove .* and update the static_assert expectations once we roll
-// past Clang r313315. https://crbug.com/765692.
-
-#elif defined(NCTEST_COMPLETELY_UNRELATED_HELPER) // [r"fatal error: static_assert failed .*\"AsWeakPtr argument must inherit from SupportsWeakPtr\""]
-
-void WontCompile() {
- Unrelated f;
- WeakPtr<Unrelated> ptr = AsWeakPtr(&f);
-}
-
-#elif defined(NCTEST_DERIVED_COMPLETELY_UNRELATED_HELPER) // [r"fatal error: static_assert failed .*\"AsWeakPtr argument must inherit from SupportsWeakPtr\""]
-
-void WontCompile() {
- DerivedUnrelated f;
- WeakPtr<Unrelated> ptr = AsWeakPtr(&f);
-}
-
-#elif defined(NCTEST_AMBIGUOUS_ANCESTORS) // [r"fatal error: use of undeclared identifier 'AsWeakPtrImpl'"]
-
-void WontCompile() {
- MultiplyDerivedProducer f;
- WeakPtr<MultiplyDerivedProducer> ptr = AsWeakPtr(&f);
-}
-
-#endif
-
-}
diff --git a/base/message_loop/message_loop_io_posix_unittest.cc b/base/message_loop/message_loop_io_posix_unittest.cc
deleted file mode 100644
index 9ecd606..0000000
--- a/base/message_loop/message_loop_io_posix_unittest.cc
+++ /dev/null
@@ -1,418 +0,0 @@
-// Copyright 2017 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 "base/message_loop/message_loop.h"
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop_current.h"
-#include "base/message_loop/message_pump_for_io.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/run_loop.h"
-#include "base/test/gtest_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-#if !defined(OS_NACL)
-
-namespace {
-
-class MessageLoopForIoPosixTest : public testing::Test {
- public:
- MessageLoopForIoPosixTest() = default;
-
- // testing::Test interface.
- void SetUp() override {
- // Create a file descriptor. Doesn't need to be readable or writable,
- // as we don't need to actually get any notifications.
- // pipe() is just the easiest way to do it.
- int pipefds[2];
- int err = pipe(pipefds);
- ASSERT_EQ(0, err);
- read_fd_ = ScopedFD(pipefds[0]);
- write_fd_ = ScopedFD(pipefds[1]);
- }
-
- void TriggerReadEvent() {
- // Write from the other end of the pipe to trigger the event.
- char c = '\0';
- EXPECT_EQ(1, HANDLE_EINTR(write(write_fd_.get(), &c, 1)));
- }
-
- protected:
- ScopedFD read_fd_;
- ScopedFD write_fd_;
-
- DISALLOW_COPY_AND_ASSIGN(MessageLoopForIoPosixTest);
-};
-
-class TestHandler : public MessagePumpForIO::FdWatcher {
- public:
- void OnFileCanReadWithoutBlocking(int fd) override {
- watcher_to_delete_ = nullptr;
- is_readable_ = true;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
- void OnFileCanWriteWithoutBlocking(int fd) override {
- watcher_to_delete_ = nullptr;
- is_writable_ = true;
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- bool is_readable_ = false;
- bool is_writable_ = false;
-
- // If set then the contained watcher will be deleted on notification.
- std::unique_ptr<MessagePumpForIO::FdWatchController> watcher_to_delete_;
-};
-
-// Watcher that calls specified closures when read/write events occur. Verifies
-// that each non-null closure passed to this class is called once and only once.
-// Also resets the read event by reading from the FD.
-class CallClosureHandler : public MessagePumpForIO::FdWatcher {
- public:
- CallClosureHandler(OnceClosure read_closure, OnceClosure write_closure)
- : read_closure_(std::move(read_closure)),
- write_closure_(std::move(write_closure)) {}
-
- ~CallClosureHandler() override {
- EXPECT_TRUE(read_closure_.is_null());
- EXPECT_TRUE(write_closure_.is_null());
- }
-
- void SetReadClosure(OnceClosure read_closure) {
- EXPECT_TRUE(read_closure_.is_null());
- read_closure_ = std::move(read_closure);
- }
-
- void SetWriteClosure(OnceClosure write_closure) {
- EXPECT_TRUE(write_closure_.is_null());
- write_closure_ = std::move(write_closure);
- }
-
- // base:MessagePumpFuchsia::Watcher interface.
- void OnFileCanReadWithoutBlocking(int fd) override {
- // Empty the pipe buffer to reset the event. Otherwise libevent
- // implementation of MessageLoop may call the event handler again even if
- // |read_closure_| below quits the RunLoop.
- char c;
- int result = HANDLE_EINTR(read(fd, &c, 1));
- if (result == -1) {
- PLOG(ERROR) << "read";
- FAIL();
- }
- EXPECT_EQ(result, 1);
-
- ASSERT_FALSE(read_closure_.is_null());
- std::move(read_closure_).Run();
- }
-
- void OnFileCanWriteWithoutBlocking(int fd) override {
- ASSERT_FALSE(write_closure_.is_null());
- std::move(write_closure_).Run();
- }
-
- private:
- OnceClosure read_closure_;
- OnceClosure write_closure_;
-};
-
-TEST_F(MessageLoopForIoPosixTest, FileDescriptorWatcherOutlivesMessageLoop) {
- // Simulate a MessageLoop that dies before an FileDescriptorWatcher.
- // This could happen when people use the Singleton pattern or atexit.
-
- // Arrange for watcher to live longer than message loop.
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
- TestHandler handler;
- {
- MessageLoopForIO message_loop;
-
- MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- write_fd_.get(), true, MessagePumpForIO::WATCH_WRITE, &watcher,
- &handler);
- // Don't run the message loop, just destroy it.
- }
-
- ASSERT_FALSE(handler.is_readable_);
- ASSERT_FALSE(handler.is_writable_);
-}
-
-TEST_F(MessageLoopForIoPosixTest, FileDescriptorWatcherDoubleStop) {
- // Verify that it's ok to call StopWatchingFileDescriptor().
-
- // Arrange for message loop to live longer than watcher.
- MessageLoopForIO message_loop;
- {
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
-
- TestHandler handler;
- MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- write_fd_.get(), true, MessagePumpForIO::WATCH_WRITE, &watcher,
- &handler);
- ASSERT_TRUE(watcher.StopWatchingFileDescriptor());
- ASSERT_TRUE(watcher.StopWatchingFileDescriptor());
- }
-}
-
-TEST_F(MessageLoopForIoPosixTest, FileDescriptorWatcherDeleteInCallback) {
- // Verify that it is OK to delete the FileDescriptorWatcher from within a
- // callback.
- MessageLoopForIO message_loop;
-
- TestHandler handler;
- handler.watcher_to_delete_ =
- std::make_unique<MessagePumpForIO::FdWatchController>(FROM_HERE);
-
- MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- write_fd_.get(), true, MessagePumpForIO::WATCH_WRITE,
- handler.watcher_to_delete_.get(), &handler);
- RunLoop().Run();
-}
-
-// Verify that basic readable notification works.
-TEST_F(MessageLoopForIoPosixTest, WatchReadable) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
- TestHandler handler;
-
- // Watch the pipe for readability.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/false, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- // The pipe should not be readable when first created.
- RunLoop().RunUntilIdle();
- ASSERT_FALSE(handler.is_readable_);
- ASSERT_FALSE(handler.is_writable_);
-
- TriggerReadEvent();
-
- // We don't want to assume that the read fd becomes readable the
- // instant a bytes is written, so Run until quit by an event.
- RunLoop().Run();
-
- ASSERT_TRUE(handler.is_readable_);
- ASSERT_FALSE(handler.is_writable_);
-}
-
-// Verify that watching a file descriptor for writability succeeds.
-TEST_F(MessageLoopForIoPosixTest, WatchWritable) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
- TestHandler handler;
-
- // Watch the pipe for writability.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- write_fd_.get(), /*persistent=*/false, MessagePumpForIO::WATCH_WRITE,
- &watcher, &handler));
-
- // We should not receive a writable notification until we process events.
- ASSERT_FALSE(handler.is_readable_);
- ASSERT_FALSE(handler.is_writable_);
-
- // The pipe should be writable immediately, but wait for the quit closure
- // anyway, to be sure.
- RunLoop().Run();
-
- ASSERT_FALSE(handler.is_readable_);
- ASSERT_TRUE(handler.is_writable_);
-}
-
-// Verify that RunUntilIdle() receives IO notifications.
-TEST_F(MessageLoopForIoPosixTest, RunUntilIdle) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
- TestHandler handler;
-
- // Watch the pipe for readability.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/false, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- // The pipe should not be readable when first created.
- RunLoop().RunUntilIdle();
- ASSERT_FALSE(handler.is_readable_);
-
- TriggerReadEvent();
-
- while (!handler.is_readable_)
- RunLoop().RunUntilIdle();
-}
-
-void StopWatching(MessagePumpForIO::FdWatchController* controller,
- RunLoop* run_loop) {
- controller->StopWatchingFileDescriptor();
- run_loop->Quit();
-}
-
-// Verify that StopWatchingFileDescriptor() works from an event handler.
-TEST_F(MessageLoopForIoPosixTest, StopFromHandler) {
- MessageLoopForIO message_loop;
- RunLoop run_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
- CallClosureHandler handler(BindOnce(&StopWatching, &watcher, &run_loop),
- OnceClosure());
-
- // Create persistent watcher.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/true, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- TriggerReadEvent();
- run_loop.Run();
-
- // Trigger the event again. The event handler should not be called again.
- TriggerReadEvent();
- RunLoop().RunUntilIdle();
-}
-
-// Verify that non-persistent watcher is called only once.
-TEST_F(MessageLoopForIoPosixTest, NonPersistentWatcher) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
-
- RunLoop run_loop;
- CallClosureHandler handler(run_loop.QuitClosure(), OnceClosure());
-
- // Create a non-persistent watcher.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/false, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- TriggerReadEvent();
- run_loop.Run();
-
- // Trigger the event again. handler should not be called again.
- TriggerReadEvent();
- RunLoop().RunUntilIdle();
-}
-
-// Verify that persistent watcher is called every time the event is triggered.
-TEST_F(MessageLoopForIoPosixTest, PersistentWatcher) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
-
- RunLoop run_loop1;
- CallClosureHandler handler(run_loop1.QuitClosure(), OnceClosure());
-
- // Create persistent watcher.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/true, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- TriggerReadEvent();
- run_loop1.Run();
-
- RunLoop run_loop2;
- handler.SetReadClosure(run_loop2.QuitClosure());
-
- // Trigger the event again. handler should be called now, which will quit
- // run_loop2.
- TriggerReadEvent();
- run_loop2.Run();
-}
-
-void StopWatchingAndWatchAgain(MessagePumpForIO::FdWatchController* controller,
- int fd,
- MessagePumpForIO::FdWatcher* new_handler,
- RunLoop* run_loop) {
- controller->StopWatchingFileDescriptor();
-
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- fd, /*persistent=*/true, MessagePumpForIO::WATCH_READ, controller,
- new_handler));
-
- run_loop->Quit();
-}
-
-// Verify that a watcher can be stopped and reused from an event handler.
-TEST_F(MessageLoopForIoPosixTest, StopAndRestartFromHandler) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
-
- RunLoop run_loop1;
- RunLoop run_loop2;
- CallClosureHandler handler2(run_loop2.QuitClosure(), OnceClosure());
- CallClosureHandler handler1(BindOnce(&StopWatchingAndWatchAgain, &watcher,
- read_fd_.get(), &handler2, &run_loop1),
- OnceClosure());
-
- // Create persistent watcher.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/true, MessagePumpForIO::WATCH_READ,
- &watcher, &handler1));
-
- TriggerReadEvent();
- run_loop1.Run();
-
- // Trigger the event again. handler2 should be called now, which will quit
- // run_loop2
- TriggerReadEvent();
- run_loop2.Run();
-}
-
-// Verify that the pump properly handles a delayed task after an IO event.
-TEST_F(MessageLoopForIoPosixTest, IoEventThenTimer) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
-
- RunLoop timer_run_loop;
- message_loop.task_runner()->PostDelayedTask(
- FROM_HERE, timer_run_loop.QuitClosure(),
- base::TimeDelta::FromMilliseconds(10));
-
- RunLoop watcher_run_loop;
- CallClosureHandler handler(watcher_run_loop.QuitClosure(), OnceClosure());
-
- // Create a non-persistent watcher.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/false, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- TriggerReadEvent();
-
- // Normally the IO event will be received before the delayed task is
- // executed, so this run loop will first handle the IO event and then quit on
- // the timer.
- timer_run_loop.Run();
-
- // Run watcher_run_loop in case the IO event wasn't received before the
- // delayed task.
- watcher_run_loop.Run();
-}
-
-// Verify that the pipe can handle an IO event after a delayed task.
-TEST_F(MessageLoopForIoPosixTest, TimerThenIoEvent) {
- MessageLoopForIO message_loop;
- MessagePumpForIO::FdWatchController watcher(FROM_HERE);
-
- // Trigger read event from a delayed task.
- message_loop.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(&MessageLoopForIoPosixTest::TriggerReadEvent, Unretained(this)),
- TimeDelta::FromMilliseconds(1));
-
- RunLoop run_loop;
- CallClosureHandler handler(run_loop.QuitClosure(), OnceClosure());
-
- // Create a non-persistent watcher.
- ASSERT_TRUE(MessageLoopCurrentForIO::Get()->WatchFileDescriptor(
- read_fd_.get(), /*persistent=*/false, MessagePumpForIO::WATCH_READ,
- &watcher, &handler));
-
- run_loop.Run();
-}
-
-} // namespace
-
-#endif // !defined(OS_NACL)
-
-} // namespace base
diff --git a/base/message_loop/message_loop_task_runner_unittest.cc b/base/message_loop/message_loop_task_runner_unittest.cc
deleted file mode 100644
index c7e9aa0..0000000
--- a/base/message_loop/message_loop_task_runner_unittest.cc
+++ /dev/null
@@ -1,365 +0,0 @@
-// 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.
-
-#include "base/message_loop/message_loop_task_runner.h"
-
-#include <memory>
-
-#include "base/atomic_sequence_num.h"
-#include "base/bind.h"
-#include "base/debug/leak_annotations.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_task_runner.h"
-#include "base/run_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-namespace base {
-
-class MessageLoopTaskRunnerTest : public testing::Test {
- public:
- MessageLoopTaskRunnerTest()
- : current_loop_(new MessageLoop()),
- task_thread_("task_thread"),
- thread_sync_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- void DeleteCurrentMessageLoop() { current_loop_.reset(); }
-
- protected:
- void SetUp() override {
- // Use SetUp() instead of the constructor to avoid posting a task to a
- // partially constructed object.
- task_thread_.Start();
-
- // Allow us to pause the |task_thread_|'s MessageLoop.
- task_thread_.task_runner()->PostTask(
- FROM_HERE, BindOnce(&MessageLoopTaskRunnerTest::BlockTaskThreadHelper,
- Unretained(this)));
- }
-
- void TearDown() override {
- // Make sure the |task_thread_| is not blocked, and stop the thread
- // fully before destruction because its tasks may still depend on the
- // |thread_sync_| event.
- thread_sync_.Signal();
- task_thread_.Stop();
- DeleteCurrentMessageLoop();
- }
-
- // Make LoopRecorder threadsafe so that there is defined behavior even if a
- // threading mistake sneaks into the PostTaskAndReplyRelay implementation.
- class LoopRecorder : public RefCountedThreadSafe<LoopRecorder> {
- public:
- LoopRecorder(MessageLoop** run_on,
- MessageLoop** deleted_on,
- int* destruct_order)
- : run_on_(run_on),
- deleted_on_(deleted_on),
- destruct_order_(destruct_order) {}
-
- void RecordRun() { *run_on_ = MessageLoop::current(); }
-
- private:
- friend class RefCountedThreadSafe<LoopRecorder>;
- ~LoopRecorder() {
- *deleted_on_ = MessageLoop::current();
- *destruct_order_ = g_order.GetNext();
- }
-
- MessageLoop** run_on_;
- MessageLoop** deleted_on_;
- int* destruct_order_;
- };
-
- static void RecordLoop(scoped_refptr<LoopRecorder> recorder) {
- recorder->RecordRun();
- }
-
- static void RecordLoopAndQuit(scoped_refptr<LoopRecorder> recorder) {
- recorder->RecordRun();
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-
- void UnblockTaskThread() { thread_sync_.Signal(); }
-
- void BlockTaskThreadHelper() { thread_sync_.Wait(); }
-
- static AtomicSequenceNumber g_order;
-
- std::unique_ptr<MessageLoop> current_loop_;
- Thread task_thread_;
-
- private:
- base::WaitableEvent thread_sync_;
-};
-
-AtomicSequenceNumber MessageLoopTaskRunnerTest::g_order;
-
-TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReply_Basic) {
- MessageLoop* task_run_on = nullptr;
- MessageLoop* task_deleted_on = nullptr;
- int task_delete_order = -1;
- MessageLoop* reply_run_on = nullptr;
- MessageLoop* reply_deleted_on = nullptr;
- int reply_delete_order = -1;
-
- scoped_refptr<LoopRecorder> task_recorder =
- new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
- scoped_refptr<LoopRecorder> reply_recorder =
- new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
-
- ASSERT_TRUE(task_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE, BindOnce(&RecordLoop, task_recorder),
- BindOnce(&RecordLoopAndQuit, reply_recorder)));
-
- // Die if base::Bind doesn't retain a reference to the recorders.
- task_recorder = nullptr;
- reply_recorder = nullptr;
- ASSERT_FALSE(task_deleted_on);
- ASSERT_FALSE(reply_deleted_on);
-
- UnblockTaskThread();
- RunLoop().Run();
-
- EXPECT_EQ(task_thread_.message_loop(), task_run_on);
- EXPECT_EQ(task_thread_.message_loop(), task_deleted_on);
- EXPECT_EQ(current_loop_.get(), reply_run_on);
- EXPECT_EQ(current_loop_.get(), reply_deleted_on);
- EXPECT_LT(task_delete_order, reply_delete_order);
-}
-
-TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReplyOnDeletedThreadDoesNotLeak) {
- MessageLoop* task_run_on = nullptr;
- MessageLoop* task_deleted_on = nullptr;
- int task_delete_order = -1;
- MessageLoop* reply_run_on = nullptr;
- MessageLoop* reply_deleted_on = nullptr;
- int reply_delete_order = -1;
-
- scoped_refptr<LoopRecorder> task_recorder =
- new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
- scoped_refptr<LoopRecorder> reply_recorder =
- new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
-
- // Grab a task runner to a dead MessageLoop.
- scoped_refptr<SingleThreadTaskRunner> task_runner =
- task_thread_.task_runner();
- UnblockTaskThread();
- task_thread_.Stop();
-
- ASSERT_FALSE(task_runner->PostTaskAndReply(
- FROM_HERE, BindOnce(&RecordLoop, task_recorder),
- BindOnce(&RecordLoopAndQuit, reply_recorder)));
-
- // The relay should have properly deleted its resources leaving us as the only
- // reference.
- EXPECT_EQ(task_delete_order, reply_delete_order);
- ASSERT_TRUE(task_recorder->HasOneRef());
- ASSERT_TRUE(reply_recorder->HasOneRef());
-
- // Nothing should have run though.
- EXPECT_FALSE(task_run_on);
- EXPECT_FALSE(reply_run_on);
-}
-
-TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReply_SameLoop) {
- MessageLoop* task_run_on = nullptr;
- MessageLoop* task_deleted_on = nullptr;
- int task_delete_order = -1;
- MessageLoop* reply_run_on = nullptr;
- MessageLoop* reply_deleted_on = nullptr;
- int reply_delete_order = -1;
-
- scoped_refptr<LoopRecorder> task_recorder =
- new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
- scoped_refptr<LoopRecorder> reply_recorder =
- new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
-
- // Enqueue the relay.
- ASSERT_TRUE(current_loop_->task_runner()->PostTaskAndReply(
- FROM_HERE, BindOnce(&RecordLoop, task_recorder),
- BindOnce(&RecordLoopAndQuit, reply_recorder)));
-
- // Die if base::Bind doesn't retain a reference to the recorders.
- task_recorder = nullptr;
- reply_recorder = nullptr;
- ASSERT_FALSE(task_deleted_on);
- ASSERT_FALSE(reply_deleted_on);
-
- RunLoop().Run();
-
- EXPECT_EQ(current_loop_.get(), task_run_on);
- EXPECT_EQ(current_loop_.get(), task_deleted_on);
- EXPECT_EQ(current_loop_.get(), reply_run_on);
- EXPECT_EQ(current_loop_.get(), reply_deleted_on);
- EXPECT_LT(task_delete_order, reply_delete_order);
-}
-
-TEST_F(MessageLoopTaskRunnerTest,
- PostTaskAndReply_DeadReplyTaskRunnerBehavior) {
- // Annotate the scope as having memory leaks to suppress heapchecker reports.
- ANNOTATE_SCOPED_MEMORY_LEAK;
- MessageLoop* task_run_on = nullptr;
- MessageLoop* task_deleted_on = nullptr;
- int task_delete_order = -1;
- MessageLoop* reply_run_on = nullptr;
- MessageLoop* reply_deleted_on = nullptr;
- int reply_delete_order = -1;
-
- scoped_refptr<LoopRecorder> task_recorder =
- new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
- scoped_refptr<LoopRecorder> reply_recorder =
- new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
-
- // Enqueue the relay.
- task_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE, BindOnce(&RecordLoop, task_recorder),
- BindOnce(&RecordLoopAndQuit, reply_recorder));
-
- // Die if base::Bind doesn't retain a reference to the recorders.
- task_recorder = nullptr;
- reply_recorder = nullptr;
- ASSERT_FALSE(task_deleted_on);
- ASSERT_FALSE(reply_deleted_on);
-
- UnblockTaskThread();
-
- // Mercilessly whack the current loop before |reply| gets to run.
- current_loop_.reset();
-
- // This should ensure the relay has been run. We need to record the
- // MessageLoop pointer before stopping the thread because Thread::Stop() will
- // NULL out its own pointer.
- MessageLoop* task_loop = task_thread_.message_loop();
- task_thread_.Stop();
-
- // Even if the reply task runner is already gone, the original task should
- // already be deleted. However, the reply which hasn't executed yet should
- // leak to avoid thread-safety issues.
- EXPECT_EQ(task_loop, task_run_on);
- EXPECT_EQ(task_loop, task_deleted_on);
- EXPECT_FALSE(reply_run_on);
- ASSERT_FALSE(reply_deleted_on);
-
- // The PostTaskAndReplyRelay is leaked here. Even if we had a reference to
- // it, we cannot just delete it because PostTaskAndReplyRelay's destructor
- // checks that MessageLoop::current() is the the same as when the
- // PostTaskAndReplyRelay object was constructed. However, this loop must have
- // already been deleted in order to perform this test. See
- // http://crbug.com/86301.
-}
-
-class MessageLoopTaskRunnerThreadingTest : public testing::Test {
- public:
- void Release() const {
- AssertOnIOThread();
- Quit();
- }
-
- void Quit() const {
- loop_.task_runner()->PostTask(
- FROM_HERE, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- }
-
- void AssertOnIOThread() const {
- ASSERT_TRUE(io_thread_->task_runner()->BelongsToCurrentThread());
- ASSERT_EQ(io_thread_->task_runner(), ThreadTaskRunnerHandle::Get());
- }
-
- void AssertOnFileThread() const {
- ASSERT_TRUE(file_thread_->task_runner()->BelongsToCurrentThread());
- ASSERT_EQ(file_thread_->task_runner(), ThreadTaskRunnerHandle::Get());
- }
-
- protected:
- void SetUp() override {
- io_thread_.reset(new Thread("MessageLoopTaskRunnerThreadingTest_IO"));
- file_thread_.reset(new Thread("MessageLoopTaskRunnerThreadingTest_File"));
- io_thread_->Start();
- file_thread_->Start();
- }
-
- void TearDown() override {
- io_thread_->Stop();
- file_thread_->Stop();
- }
-
- static void BasicFunction(MessageLoopTaskRunnerThreadingTest* test) {
- test->AssertOnFileThread();
- test->Quit();
- }
-
- static void AssertNotRun() { FAIL() << "Callback Should not get executed."; }
-
- class DeletedOnFile {
- public:
- explicit DeletedOnFile(MessageLoopTaskRunnerThreadingTest* test)
- : test_(test) {}
-
- ~DeletedOnFile() {
- test_->AssertOnFileThread();
- test_->Quit();
- }
-
- private:
- MessageLoopTaskRunnerThreadingTest* test_;
- };
-
- std::unique_ptr<Thread> io_thread_;
- std::unique_ptr<Thread> file_thread_;
-
- private:
- mutable MessageLoop loop_;
-};
-
-TEST_F(MessageLoopTaskRunnerThreadingTest, Release) {
- EXPECT_TRUE(io_thread_->task_runner()->ReleaseSoon(FROM_HERE, this));
- RunLoop().Run();
-}
-
-TEST_F(MessageLoopTaskRunnerThreadingTest, Delete) {
- DeletedOnFile* deleted_on_file = new DeletedOnFile(this);
- EXPECT_TRUE(
- file_thread_->task_runner()->DeleteSoon(FROM_HERE, deleted_on_file));
- RunLoop().Run();
-}
-
-TEST_F(MessageLoopTaskRunnerThreadingTest, PostTask) {
- EXPECT_TRUE(file_thread_->task_runner()->PostTask(
- FROM_HERE, BindOnce(&MessageLoopTaskRunnerThreadingTest::BasicFunction,
- Unretained(this))));
- RunLoop().Run();
-}
-
-TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadExits) {
- std::unique_ptr<Thread> test_thread(
- new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
- test_thread->Start();
- scoped_refptr<SingleThreadTaskRunner> task_runner =
- test_thread->task_runner();
- test_thread->Stop();
-
- bool ret = task_runner->PostTask(
- FROM_HERE, BindOnce(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
- EXPECT_FALSE(ret);
-}
-
-TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadIsDeleted) {
- scoped_refptr<SingleThreadTaskRunner> task_runner;
- {
- std::unique_ptr<Thread> test_thread(
- new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
- test_thread->Start();
- task_runner = test_thread->task_runner();
- }
- bool ret = task_runner->PostTask(
- FROM_HERE, BindOnce(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
- EXPECT_FALSE(ret);
-}
-
-} // namespace base
diff --git a/base/message_loop/message_loop_unittest.cc b/base/message_loop/message_loop_unittest.cc
deleted file mode 100644
index 970f6d1..0000000
--- a/base/message_loop/message_loop_unittest.cc
+++ /dev/null
@@ -1,2184 +0,0 @@
-// Copyright 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 <stddef.h>
-#include <stdint.h>
-
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_current.h"
-#include "base/message_loop/message_pump_for_io.h"
-#include "base/pending_task.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/task_scheduler.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequence_local_storage_slot.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_ANDROID)
-#include "base/android/java_handler_thread.h"
-#include "base/android/jni_android.h"
-#include "base/test/android/java_handler_thread_helpers.h"
-#endif
-
-#if defined(OS_WIN)
-#include "base/message_loop/message_pump_win.h"
-#include "base/process/memory.h"
-#include "base/strings/string16.h"
-#include "base/win/current_module.h"
-#include "base/win/scoped_handle.h"
-#endif
-
-namespace base {
-
-// TODO(darin): Platform-specific MessageLoop tests should be grouped together
-// to avoid chopping this file up with so many #ifdefs.
-
-namespace {
-
-class Foo : public RefCounted<Foo> {
- public:
- Foo() : test_count_(0) {
- }
-
- void Test0() { ++test_count_; }
-
- void Test1ConstRef(const std::string& a) {
- ++test_count_;
- result_.append(a);
- }
-
- void Test1Ptr(std::string* a) {
- ++test_count_;
- result_.append(*a);
- }
-
- void Test1Int(int a) { test_count_ += a; }
-
- void Test2Ptr(std::string* a, std::string* b) {
- ++test_count_;
- result_.append(*a);
- result_.append(*b);
- }
-
- void Test2Mixed(const std::string& a, std::string* b) {
- ++test_count_;
- result_.append(a);
- result_.append(*b);
- }
-
- int test_count() const { return test_count_; }
- const std::string& result() const { return result_; }
-
- private:
- friend class RefCounted<Foo>;
-
- ~Foo() = default;
-
- int test_count_;
- std::string result_;
-
- DISALLOW_COPY_AND_ASSIGN(Foo);
-};
-
-// This function runs slowly to simulate a large amount of work being done.
-static void SlowFunc(TimeDelta pause, int* quit_counter) {
- PlatformThread::Sleep(pause);
- if (--(*quit_counter) == 0)
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-// This function records the time when Run was called in a Time object, which is
-// useful for building a variety of MessageLoop tests.
-static void RecordRunTimeFunc(TimeTicks* run_time, int* quit_counter) {
- *run_time = TimeTicks::Now();
-
- // Cause our Run function to take some time to execute. As a result we can
- // count on subsequent RecordRunTimeFunc()s running at a future time,
- // without worry about the resolution of our system clock being an issue.
- SlowFunc(TimeDelta::FromMilliseconds(10), quit_counter);
-}
-
-enum TaskType {
- MESSAGEBOX,
- ENDDIALOG,
- RECURSIVE,
- TIMEDMESSAGELOOP,
- QUITMESSAGELOOP,
- ORDERED,
- PUMPS,
- SLEEP,
- RUNS,
-};
-
-// Saves the order in which the tasks executed.
-struct TaskItem {
- TaskItem(TaskType t, int c, bool s)
- : type(t),
- cookie(c),
- start(s) {
- }
-
- TaskType type;
- int cookie;
- bool start;
-
- bool operator == (const TaskItem& other) const {
- return type == other.type && cookie == other.cookie && start == other.start;
- }
-};
-
-std::ostream& operator <<(std::ostream& os, TaskType type) {
- switch (type) {
- case MESSAGEBOX: os << "MESSAGEBOX"; break;
- case ENDDIALOG: os << "ENDDIALOG"; break;
- case RECURSIVE: os << "RECURSIVE"; break;
- case TIMEDMESSAGELOOP: os << "TIMEDMESSAGELOOP"; break;
- case QUITMESSAGELOOP: os << "QUITMESSAGELOOP"; break;
- case ORDERED: os << "ORDERED"; break;
- case PUMPS: os << "PUMPS"; break;
- case SLEEP: os << "SLEEP"; break;
- default:
- NOTREACHED();
- os << "Unknown TaskType";
- break;
- }
- return os;
-}
-
-std::ostream& operator <<(std::ostream& os, const TaskItem& item) {
- if (item.start)
- return os << item.type << " " << item.cookie << " starts";
- else
- return os << item.type << " " << item.cookie << " ends";
-}
-
-class TaskList {
- public:
- void RecordStart(TaskType type, int cookie) {
- TaskItem item(type, cookie, true);
- DVLOG(1) << item;
- task_list_.push_back(item);
- }
-
- void RecordEnd(TaskType type, int cookie) {
- TaskItem item(type, cookie, false);
- DVLOG(1) << item;
- task_list_.push_back(item);
- }
-
- size_t Size() {
- return task_list_.size();
- }
-
- TaskItem Get(int n) {
- return task_list_[n];
- }
-
- private:
- std::vector<TaskItem> task_list_;
-};
-
-class DummyTaskObserver : public MessageLoop::TaskObserver {
- public:
- explicit DummyTaskObserver(int num_tasks)
- : num_tasks_started_(0), num_tasks_processed_(0), num_tasks_(num_tasks) {}
-
- DummyTaskObserver(int num_tasks, int num_tasks_started)
- : num_tasks_started_(num_tasks_started),
- num_tasks_processed_(0),
- num_tasks_(num_tasks) {}
-
- ~DummyTaskObserver() override = default;
-
- void WillProcessTask(const PendingTask& pending_task) override {
- num_tasks_started_++;
- EXPECT_LE(num_tasks_started_, num_tasks_);
- EXPECT_EQ(num_tasks_started_, num_tasks_processed_ + 1);
- }
-
- void DidProcessTask(const PendingTask& pending_task) override {
- num_tasks_processed_++;
- EXPECT_LE(num_tasks_started_, num_tasks_);
- EXPECT_EQ(num_tasks_started_, num_tasks_processed_);
- }
-
- int num_tasks_started() const { return num_tasks_started_; }
- int num_tasks_processed() const { return num_tasks_processed_; }
-
- private:
- int num_tasks_started_;
- int num_tasks_processed_;
- const int num_tasks_;
-
- DISALLOW_COPY_AND_ASSIGN(DummyTaskObserver);
-};
-
-void RecursiveFunc(TaskList* order, int cookie, int depth,
- bool is_reentrant) {
- order->RecordStart(RECURSIVE, cookie);
- if (depth > 0) {
- if (is_reentrant)
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
- }
- order->RecordEnd(RECURSIVE, cookie);
-}
-
-void QuitFunc(TaskList* order, int cookie) {
- order->RecordStart(QUITMESSAGELOOP, cookie);
- RunLoop::QuitCurrentWhenIdleDeprecated();
- order->RecordEnd(QUITMESSAGELOOP, cookie);
-}
-
-void PostNTasks(int posts_remaining) {
- if (posts_remaining > 1) {
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&PostNTasks, posts_remaining - 1));
- }
-}
-
-enum class TaskSchedulerAvailability {
- NO_TASK_SCHEDULER,
- WITH_TASK_SCHEDULER,
-};
-
-std::string TaskSchedulerAvailabilityToString(
- TaskSchedulerAvailability availability) {
- switch (availability) {
- case TaskSchedulerAvailability::NO_TASK_SCHEDULER:
- return "NoTaskScheduler";
- case TaskSchedulerAvailability::WITH_TASK_SCHEDULER:
- return "WithTaskScheduler";
- }
- NOTREACHED();
- return "Unknown";
-}
-
-class MessageLoopTest
- : public ::testing::TestWithParam<TaskSchedulerAvailability> {
- public:
- MessageLoopTest() = default;
- ~MessageLoopTest() override = default;
-
- void SetUp() override {
- if (GetParam() == TaskSchedulerAvailability::WITH_TASK_SCHEDULER)
- TaskScheduler::CreateAndStartWithDefaultParams("MessageLoopTest");
- }
-
- void TearDown() override {
- if (GetParam() == TaskSchedulerAvailability::WITH_TASK_SCHEDULER) {
- // Failure to call FlushForTesting() could result in task leaks as tasks
- // are skipped on shutdown.
- base::TaskScheduler::GetInstance()->FlushForTesting();
- base::TaskScheduler::GetInstance()->Shutdown();
- base::TaskScheduler::GetInstance()->JoinForTesting();
- base::TaskScheduler::SetInstance(nullptr);
- }
- }
-
- static std::string ParamInfoToString(
- ::testing::TestParamInfo<TaskSchedulerAvailability> param_info) {
- return TaskSchedulerAvailabilityToString(param_info.param);
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MessageLoopTest);
-};
-
-#if defined(OS_ANDROID)
-void DoNotRun() {
- ASSERT_TRUE(false);
-}
-
-void RunTest_AbortDontRunMoreTasks(bool delayed, bool init_java_first) {
- WaitableEvent test_done_event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- std::unique_ptr<android::JavaHandlerThread> java_thread;
- if (init_java_first) {
- java_thread = android::JavaHandlerThreadHelpers::CreateJavaFirst();
- } else {
- java_thread = std::make_unique<android::JavaHandlerThread>(
- "JavaHandlerThreadForTesting from AbortDontRunMoreTasks");
- }
- java_thread->Start();
- java_thread->ListenForUncaughtExceptionsForTesting();
-
- auto target =
- BindOnce(&android::JavaHandlerThreadHelpers::ThrowExceptionAndAbort,
- &test_done_event);
- if (delayed) {
- java_thread->message_loop()->task_runner()->PostDelayedTask(
- FROM_HERE, std::move(target), TimeDelta::FromMilliseconds(10));
- } else {
- java_thread->message_loop()->task_runner()->PostTask(FROM_HERE,
- std::move(target));
- java_thread->message_loop()->task_runner()->PostTask(FROM_HERE,
- BindOnce(&DoNotRun));
- }
- test_done_event.Wait();
- java_thread->Stop();
- android::ScopedJavaLocalRef<jthrowable> exception =
- java_thread->GetUncaughtExceptionIfAny();
- ASSERT_TRUE(
- android::JavaHandlerThreadHelpers::IsExceptionTestException(exception));
-}
-
-TEST_P(MessageLoopTest, JavaExceptionAbort) {
- constexpr bool delayed = false;
- constexpr bool init_java_first = false;
- RunTest_AbortDontRunMoreTasks(delayed, init_java_first);
-}
-TEST_P(MessageLoopTest, DelayedJavaExceptionAbort) {
- constexpr bool delayed = true;
- constexpr bool init_java_first = false;
- RunTest_AbortDontRunMoreTasks(delayed, init_java_first);
-}
-TEST_P(MessageLoopTest, JavaExceptionAbortInitJavaFirst) {
- constexpr bool delayed = false;
- constexpr bool init_java_first = true;
- RunTest_AbortDontRunMoreTasks(delayed, init_java_first);
-}
-
-TEST_P(MessageLoopTest, RunTasksWhileShuttingDownJavaThread) {
- const int kNumPosts = 6;
- DummyTaskObserver observer(kNumPosts, 1);
-
- auto java_thread = std::make_unique<android::JavaHandlerThread>("test");
- java_thread->Start();
-
- java_thread->message_loop()->task_runner()->PostTask(
- FROM_HERE,
- BindOnce(
- [](android::JavaHandlerThread* java_thread,
- DummyTaskObserver* observer, int num_posts) {
- java_thread->message_loop()->AddTaskObserver(observer);
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce([]() { ADD_FAILURE(); }),
- TimeDelta::FromDays(1));
- java_thread->StopMessageLoopForTesting();
- PostNTasks(num_posts);
- },
- Unretained(java_thread.get()), Unretained(&observer), kNumPosts));
-
- java_thread->JoinForTesting();
- java_thread.reset();
-
- EXPECT_EQ(kNumPosts, observer.num_tasks_started());
- EXPECT_EQ(kNumPosts, observer.num_tasks_processed());
-}
-#endif // defined(OS_ANDROID)
-
-#if defined(OS_WIN)
-
-void SubPumpFunc() {
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- MSG msg;
- while (GetMessage(&msg, NULL, 0, 0)) {
- TranslateMessage(&msg);
- DispatchMessage(&msg);
- }
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-void RunTest_PostDelayedTask_SharedTimer_SubPump() {
- MessageLoop message_loop(MessageLoop::TYPE_UI);
-
- // Test that the interval of the timer, used to run the next delayed task, is
- // set to a value corresponding to when the next delayed task should run.
-
- // By setting num_tasks to 1, we ensure that the first task to run causes the
- // run loop to exit.
- int num_tasks = 1;
- TimeTicks run_time;
-
- message_loop.task_runner()->PostTask(FROM_HERE, BindOnce(&SubPumpFunc));
-
- // This very delayed task should never run.
- message_loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time, &num_tasks),
- TimeDelta::FromSeconds(1000));
-
- // This slightly delayed task should run from within SubPumpFunc.
- message_loop.task_runner()->PostDelayedTask(FROM_HERE,
- BindOnce(&PostQuitMessage, 0),
- TimeDelta::FromMilliseconds(10));
-
- Time start_time = Time::Now();
-
- RunLoop().Run();
- EXPECT_EQ(1, num_tasks);
-
- // Ensure that we ran in far less time than the slower timer.
- TimeDelta total_time = Time::Now() - start_time;
- EXPECT_GT(5000, total_time.InMilliseconds());
-
- // In case both timers somehow run at nearly the same time, sleep a little
- // and then run all pending to force them both to have run. This is just
- // encouraging flakiness if there is any.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- RunLoop().RunUntilIdle();
-
- EXPECT_TRUE(run_time.is_null());
-}
-
-const wchar_t kMessageBoxTitle[] = L"MessageLoop Unit Test";
-
-// MessageLoop implicitly start a "modal message loop". Modal dialog boxes,
-// common controls (like OpenFile) and StartDoc printing function can cause
-// implicit message loops.
-void MessageBoxFunc(TaskList* order, int cookie, bool is_reentrant) {
- order->RecordStart(MESSAGEBOX, cookie);
- if (is_reentrant)
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- MessageBox(NULL, L"Please wait...", kMessageBoxTitle, MB_OK);
- order->RecordEnd(MESSAGEBOX, cookie);
-}
-
-// Will end the MessageBox.
-void EndDialogFunc(TaskList* order, int cookie) {
- order->RecordStart(ENDDIALOG, cookie);
- HWND window = GetActiveWindow();
- if (window != NULL) {
- EXPECT_NE(EndDialog(window, IDCONTINUE), 0);
- // Cheap way to signal that the window wasn't found if RunEnd() isn't
- // called.
- order->RecordEnd(ENDDIALOG, cookie);
- }
-}
-
-void RecursiveFuncWin(scoped_refptr<SingleThreadTaskRunner> task_runner,
- HANDLE event,
- bool expect_window,
- TaskList* order,
- bool is_reentrant) {
- task_runner->PostTask(FROM_HERE,
- BindOnce(&RecursiveFunc, order, 1, 2, is_reentrant));
- task_runner->PostTask(FROM_HERE,
- BindOnce(&MessageBoxFunc, order, 2, is_reentrant));
- task_runner->PostTask(FROM_HERE,
- BindOnce(&RecursiveFunc, order, 3, 2, is_reentrant));
- // The trick here is that for recursive task processing, this task will be
- // ran _inside_ the MessageBox message loop, dismissing the MessageBox
- // without a chance.
- // For non-recursive task processing, this will be executed _after_ the
- // MessageBox will have been dismissed by the code below, where
- // expect_window_ is true.
- task_runner->PostTask(FROM_HERE, BindOnce(&EndDialogFunc, order, 4));
- task_runner->PostTask(FROM_HERE, BindOnce(&QuitFunc, order, 5));
-
- // Enforce that every tasks are sent before starting to run the main thread
- // message loop.
- ASSERT_TRUE(SetEvent(event));
-
- // Poll for the MessageBox. Don't do this at home! At the speed we do it,
- // you will never realize one MessageBox was shown.
- for (; expect_window;) {
- HWND window = FindWindow(L"#32770", kMessageBoxTitle);
- if (window) {
- // Dismiss it.
- for (;;) {
- HWND button = FindWindowEx(window, NULL, L"Button", NULL);
- if (button != NULL) {
- EXPECT_EQ(0, SendMessage(button, WM_LBUTTONDOWN, 0, 0));
- EXPECT_EQ(0, SendMessage(button, WM_LBUTTONUP, 0, 0));
- break;
- }
- }
- break;
- }
- }
-}
-
-// TODO(darin): These tests need to be ported since they test critical
-// message loop functionality.
-
-// A side effect of this test is the generation a beep. Sorry.
-void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- Thread worker("RecursiveDenial2_worker");
- Thread::Options options;
- options.message_loop_type = message_loop_type;
- ASSERT_EQ(true, worker.StartWithOptions(options));
- TaskList order;
- win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
- worker.task_runner()->PostTask(
- FROM_HERE, BindOnce(&RecursiveFuncWin, ThreadTaskRunnerHandle::Get(),
- event.Get(), true, &order, false));
- // Let the other thread execute.
- WaitForSingleObject(event.Get(), INFINITE);
- RunLoop().Run();
-
- ASSERT_EQ(17u, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
- EXPECT_EQ(order.Get(3), TaskItem(MESSAGEBOX, 2, false));
- EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, true));
- EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 3, false));
- // When EndDialogFunc is processed, the window is already dismissed, hence no
- // "end" entry.
- EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, true));
- EXPECT_EQ(order.Get(7), TaskItem(QUITMESSAGELOOP, 5, true));
- EXPECT_EQ(order.Get(8), TaskItem(QUITMESSAGELOOP, 5, false));
- EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 3, true));
- EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, false));
- EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 3, true));
- EXPECT_EQ(order.Get(16), TaskItem(RECURSIVE, 3, false));
-}
-
-// A side effect of this test is the generation a beep. Sorry. This test also
-// needs to process windows messages on the current thread.
-void RunTest_RecursiveSupport2(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- Thread worker("RecursiveSupport2_worker");
- Thread::Options options;
- options.message_loop_type = message_loop_type;
- ASSERT_EQ(true, worker.StartWithOptions(options));
- TaskList order;
- win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
- worker.task_runner()->PostTask(
- FROM_HERE, BindOnce(&RecursiveFuncWin, ThreadTaskRunnerHandle::Get(),
- event.Get(), false, &order, true));
- // Let the other thread execute.
- WaitForSingleObject(event.Get(), INFINITE);
- RunLoop().Run();
-
- ASSERT_EQ(18u, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
- // Note that this executes in the MessageBox modal loop.
- EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 3, true));
- EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, false));
- EXPECT_EQ(order.Get(5), TaskItem(ENDDIALOG, 4, true));
- EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, false));
- EXPECT_EQ(order.Get(7), TaskItem(MESSAGEBOX, 2, false));
- /* The order can subtly change here. The reason is that when RecursiveFunc(1)
- is called in the main thread, if it is faster than getting to the
- PostTask(FROM_HERE, BindOnce(&QuitFunc) execution, the order of task
- execution can change. We don't care anyway that the order isn't correct.
- EXPECT_EQ(order.Get(8), TaskItem(QUITMESSAGELOOP, 5, true));
- EXPECT_EQ(order.Get(9), TaskItem(QUITMESSAGELOOP, 5, false));
- EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
- */
- EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, true));
- EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 3, false));
- EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(16), TaskItem(RECURSIVE, 3, true));
- EXPECT_EQ(order.Get(17), TaskItem(RECURSIVE, 3, false));
-}
-
-#endif // defined(OS_WIN)
-
-void PostNTasksThenQuit(int posts_remaining) {
- if (posts_remaining > 1) {
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&PostNTasksThenQuit, posts_remaining - 1));
- } else {
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-}
-
-#if defined(OS_WIN)
-
-class TestIOHandler : public MessagePumpForIO::IOHandler {
- public:
- TestIOHandler(const wchar_t* name, HANDLE signal, bool wait);
-
- void OnIOCompleted(MessagePumpForIO::IOContext* context,
- DWORD bytes_transfered,
- DWORD error) override;
-
- void Init();
- void WaitForIO();
- OVERLAPPED* context() { return &context_.overlapped; }
- DWORD size() { return sizeof(buffer_); }
-
- private:
- char buffer_[48];
- MessagePumpForIO::IOContext context_;
- HANDLE signal_;
- win::ScopedHandle file_;
- bool wait_;
-};
-
-TestIOHandler::TestIOHandler(const wchar_t* name, HANDLE signal, bool wait)
- : signal_(signal), wait_(wait) {
- memset(buffer_, 0, sizeof(buffer_));
-
- file_.Set(CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING,
- FILE_FLAG_OVERLAPPED, NULL));
- EXPECT_TRUE(file_.IsValid());
-}
-
-void TestIOHandler::Init() {
- MessageLoopCurrentForIO::Get()->RegisterIOHandler(file_.Get(), this);
-
- DWORD read;
- EXPECT_FALSE(ReadFile(file_.Get(), buffer_, size(), &read, context()));
- EXPECT_EQ(static_cast<DWORD>(ERROR_IO_PENDING), GetLastError());
- if (wait_)
- WaitForIO();
-}
-
-void TestIOHandler::OnIOCompleted(MessagePumpForIO::IOContext* context,
- DWORD bytes_transfered,
- DWORD error) {
- ASSERT_TRUE(context == &context_);
- ASSERT_TRUE(SetEvent(signal_));
-}
-
-void TestIOHandler::WaitForIO() {
- EXPECT_TRUE(MessageLoopCurrentForIO::Get()->WaitForIOCompletion(300, this));
- EXPECT_TRUE(MessageLoopCurrentForIO::Get()->WaitForIOCompletion(400, this));
-}
-
-void RunTest_IOHandler() {
- win::ScopedHandle callback_called(CreateEvent(NULL, TRUE, FALSE, NULL));
- ASSERT_TRUE(callback_called.IsValid());
-
- const wchar_t* kPipeName = L"\\\\.\\pipe\\iohandler_pipe";
- win::ScopedHandle server(
- CreateNamedPipe(kPipeName, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
- ASSERT_TRUE(server.IsValid());
-
- Thread thread("IOHandler test");
- Thread::Options options;
- options.message_loop_type = MessageLoop::TYPE_IO;
- ASSERT_TRUE(thread.StartWithOptions(options));
-
- TestIOHandler handler(kPipeName, callback_called.Get(), false);
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TestIOHandler::Init, Unretained(&handler)));
- // Make sure the thread runs and sleeps for lack of work.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
-
- const char buffer[] = "Hello there!";
- DWORD written;
- EXPECT_TRUE(WriteFile(server.Get(), buffer, sizeof(buffer), &written, NULL));
-
- DWORD result = WaitForSingleObject(callback_called.Get(), 1000);
- EXPECT_EQ(WAIT_OBJECT_0, result);
-
- thread.Stop();
-}
-
-void RunTest_WaitForIO() {
- win::ScopedHandle callback1_called(
- CreateEvent(NULL, TRUE, FALSE, NULL));
- win::ScopedHandle callback2_called(
- CreateEvent(NULL, TRUE, FALSE, NULL));
- ASSERT_TRUE(callback1_called.IsValid());
- ASSERT_TRUE(callback2_called.IsValid());
-
- const wchar_t* kPipeName1 = L"\\\\.\\pipe\\iohandler_pipe1";
- const wchar_t* kPipeName2 = L"\\\\.\\pipe\\iohandler_pipe2";
- win::ScopedHandle server1(
- CreateNamedPipe(kPipeName1, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
- win::ScopedHandle server2(
- CreateNamedPipe(kPipeName2, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
- ASSERT_TRUE(server1.IsValid());
- ASSERT_TRUE(server2.IsValid());
-
- Thread thread("IOHandler test");
- Thread::Options options;
- options.message_loop_type = MessageLoop::TYPE_IO;
- ASSERT_TRUE(thread.StartWithOptions(options));
-
- TestIOHandler handler1(kPipeName1, callback1_called.Get(), false);
- TestIOHandler handler2(kPipeName2, callback2_called.Get(), true);
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TestIOHandler::Init, Unretained(&handler1)));
- // TODO(ajwong): Do we really need such long Sleeps in this function?
- // Make sure the thread runs and sleeps for lack of work.
- TimeDelta delay = TimeDelta::FromMilliseconds(100);
- PlatformThread::Sleep(delay);
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TestIOHandler::Init, Unretained(&handler2)));
- PlatformThread::Sleep(delay);
-
- // At this time handler1 is waiting to be called, and the thread is waiting
- // on the Init method of handler2, filtering only handler2 callbacks.
-
- const char buffer[] = "Hello there!";
- DWORD written;
- EXPECT_TRUE(WriteFile(server1.Get(), buffer, sizeof(buffer), &written, NULL));
- PlatformThread::Sleep(2 * delay);
- EXPECT_EQ(static_cast<DWORD>(WAIT_TIMEOUT),
- WaitForSingleObject(callback1_called.Get(), 0))
- << "handler1 has not been called";
-
- EXPECT_TRUE(WriteFile(server2.Get(), buffer, sizeof(buffer), &written, NULL));
-
- HANDLE objects[2] = { callback1_called.Get(), callback2_called.Get() };
- DWORD result = WaitForMultipleObjects(2, objects, TRUE, 1000);
- EXPECT_EQ(WAIT_OBJECT_0, result);
-
- thread.Stop();
-}
-
-#endif // defined(OS_WIN)
-
-} // namespace
-
-//-----------------------------------------------------------------------------
-// Each test is run against each type of MessageLoop. That way we are sure
-// that message loops work properly in all configurations. Of course, in some
-// cases, a unit test may only be for a particular type of loop.
-
-namespace {
-
-struct MessageLoopTypedTestParams {
- MessageLoopTypedTestParams(
- MessageLoop::Type type_in,
- TaskSchedulerAvailability task_scheduler_availability_in) {
- type = type_in;
- task_scheduler_availability = task_scheduler_availability_in;
- }
-
- MessageLoop::Type type;
- TaskSchedulerAvailability task_scheduler_availability;
-};
-
-class MessageLoopTypedTest
- : public ::testing::TestWithParam<MessageLoopTypedTestParams> {
- public:
- MessageLoopTypedTest() = default;
- ~MessageLoopTypedTest() = default;
-
- void SetUp() override {
- if (GetTaskSchedulerAvailability() ==
- TaskSchedulerAvailability::WITH_TASK_SCHEDULER) {
- TaskScheduler::CreateAndStartWithDefaultParams("MessageLoopTypedTest");
- }
- }
-
- void TearDown() override {
- if (GetTaskSchedulerAvailability() ==
- TaskSchedulerAvailability::WITH_TASK_SCHEDULER) {
- // Failure to call FlushForTesting() could result in task leaks as tasks
- // are skipped on shutdown.
- base::TaskScheduler::GetInstance()->FlushForTesting();
- base::TaskScheduler::GetInstance()->Shutdown();
- base::TaskScheduler::GetInstance()->JoinForTesting();
- base::TaskScheduler::SetInstance(nullptr);
- }
- }
-
- static std::string ParamInfoToString(
- ::testing::TestParamInfo<MessageLoopTypedTestParams> param_info) {
- return MessageLoopTypeToString(param_info.param.type) + "_" +
- TaskSchedulerAvailabilityToString(
- param_info.param.task_scheduler_availability);
- }
-
- protected:
- MessageLoop::Type GetMessageLoopType() { return GetParam().type; }
-
- private:
- static std::string MessageLoopTypeToString(MessageLoop::Type type) {
- switch (type) {
- case MessageLoop::TYPE_DEFAULT:
- return "Default";
- case MessageLoop::TYPE_IO:
- return "IO";
- case MessageLoop::TYPE_UI:
- return "UI";
- case MessageLoop::TYPE_CUSTOM:
-#if defined(OS_ANDROID)
- case MessageLoop::TYPE_JAVA:
-#endif // defined(OS_ANDROID)
- break;
- }
- NOTREACHED();
- return "NotSupported";
- }
-
- TaskSchedulerAvailability GetTaskSchedulerAvailability() {
- return GetParam().task_scheduler_availability;
- }
-
- DISALLOW_COPY_AND_ASSIGN(MessageLoopTypedTest);
-};
-
-} // namespace
-
-TEST_P(MessageLoopTypedTest, PostTask) {
- MessageLoop loop(GetMessageLoopType());
- // Add tests to message loop
- scoped_refptr<Foo> foo(new Foo());
- std::string a("a"), b("b"), c("c"), d("d");
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&Foo::Test0, foo));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&Foo::Test1ConstRef, foo, a));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&Foo::Test1Ptr, foo, &b));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&Foo::Test1Int, foo, 100));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&Foo::Test2Ptr, foo, &a, &c));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&Foo::Test2Mixed, foo, a, &d));
- // After all tests, post a message that will shut down the message loop
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RunLoop::QuitCurrentWhenIdleDeprecated));
-
- // Now kick things off
- RunLoop().Run();
-
- EXPECT_EQ(foo->test_count(), 105);
- EXPECT_EQ(foo->result(), "abacad");
-}
-
-TEST_P(MessageLoopTypedTest, PostDelayedTask_Basic) {
- MessageLoop loop(GetMessageLoopType());
-
- // Test that PostDelayedTask results in a delayed task.
-
- const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
-
- int num_tasks = 1;
- TimeTicks run_time;
-
- TimeTicks time_before_run = TimeTicks::Now();
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time, &num_tasks), kDelay);
- RunLoop().Run();
- TimeTicks time_after_run = TimeTicks::Now();
-
- EXPECT_EQ(0, num_tasks);
- EXPECT_LT(kDelay, time_after_run - time_before_run);
-}
-
-TEST_P(MessageLoopTypedTest, PostDelayedTask_InDelayOrder) {
- MessageLoop loop(GetMessageLoopType());
-
- // Test that two tasks with different delays run in the right order.
- int num_tasks = 2;
- TimeTicks run_time1, run_time2;
-
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time1, &num_tasks),
- TimeDelta::FromMilliseconds(200));
- // If we get a large pause in execution (due to a context switch) here, this
- // test could fail.
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time2, &num_tasks),
- TimeDelta::FromMilliseconds(10));
-
- RunLoop().Run();
- EXPECT_EQ(0, num_tasks);
-
- EXPECT_TRUE(run_time2 < run_time1);
-}
-
-TEST_P(MessageLoopTypedTest, PostDelayedTask_InPostOrder) {
- MessageLoop loop(GetMessageLoopType());
-
- // Test that two tasks with the same delay run in the order in which they
- // were posted.
- //
- // NOTE: This is actually an approximate test since the API only takes a
- // "delay" parameter, so we are not exactly simulating two tasks that get
- // posted at the exact same time. It would be nice if the API allowed us to
- // specify the desired run time.
-
- const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
-
- int num_tasks = 2;
- TimeTicks run_time1, run_time2;
-
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time1, &num_tasks), kDelay);
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time2, &num_tasks), kDelay);
-
- RunLoop().Run();
- EXPECT_EQ(0, num_tasks);
-
- EXPECT_TRUE(run_time1 < run_time2);
-}
-
-TEST_P(MessageLoopTypedTest, PostDelayedTask_InPostOrder_2) {
- MessageLoop loop(GetMessageLoopType());
-
- // Test that a delayed task still runs after a normal tasks even if the
- // normal tasks take a long time to run.
-
- const TimeDelta kPause = TimeDelta::FromMilliseconds(50);
-
- int num_tasks = 2;
- TimeTicks run_time;
-
- loop.task_runner()->PostTask(FROM_HERE,
- BindOnce(&SlowFunc, kPause, &num_tasks));
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time, &num_tasks),
- TimeDelta::FromMilliseconds(10));
-
- TimeTicks time_before_run = TimeTicks::Now();
- RunLoop().Run();
- TimeTicks time_after_run = TimeTicks::Now();
-
- EXPECT_EQ(0, num_tasks);
-
- EXPECT_LT(kPause, time_after_run - time_before_run);
-}
-
-TEST_P(MessageLoopTypedTest, PostDelayedTask_InPostOrder_3) {
- MessageLoop loop(GetMessageLoopType());
-
- // Test that a delayed task still runs after a pile of normal tasks. The key
- // difference between this test and the previous one is that here we return
- // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
- // to maybe run the delayed task. It should know not to do so until the
- // delayed task's delay has passed.
-
- int num_tasks = 11;
- TimeTicks run_time1, run_time2;
-
- // Clutter the ML with tasks.
- for (int i = 1; i < num_tasks; ++i)
- loop.task_runner()->PostTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time1, &num_tasks));
-
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time2, &num_tasks),
- TimeDelta::FromMilliseconds(1));
-
- RunLoop().Run();
- EXPECT_EQ(0, num_tasks);
-
- EXPECT_TRUE(run_time2 > run_time1);
-}
-
-TEST_P(MessageLoopTypedTest, PostDelayedTask_SharedTimer) {
- MessageLoop loop(GetMessageLoopType());
-
- // Test that the interval of the timer, used to run the next delayed task, is
- // set to a value corresponding to when the next delayed task should run.
-
- // By setting num_tasks to 1, we ensure that the first task to run causes the
- // run loop to exit.
- int num_tasks = 1;
- TimeTicks run_time1, run_time2;
-
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time1, &num_tasks),
- TimeDelta::FromSeconds(1000));
- loop.task_runner()->PostDelayedTask(
- FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time2, &num_tasks),
- TimeDelta::FromMilliseconds(10));
-
- TimeTicks start_time = TimeTicks::Now();
-
- RunLoop().Run();
- EXPECT_EQ(0, num_tasks);
-
- // Ensure that we ran in far less time than the slower timer.
- TimeDelta total_time = TimeTicks::Now() - start_time;
- EXPECT_GT(5000, total_time.InMilliseconds());
-
- // In case both timers somehow run at nearly the same time, sleep a little
- // and then run all pending to force them both to have run. This is just
- // encouraging flakiness if there is any.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- RunLoop().RunUntilIdle();
-
- EXPECT_TRUE(run_time1.is_null());
- EXPECT_FALSE(run_time2.is_null());
-}
-
-namespace {
-
-// This is used to inject a test point for recording the destructor calls for
-// Closure objects send to MessageLoop::PostTask(). It is awkward usage since we
-// are trying to hook the actual destruction, which is not a common operation.
-class RecordDeletionProbe : public RefCounted<RecordDeletionProbe> {
- public:
- RecordDeletionProbe(RecordDeletionProbe* post_on_delete, bool* was_deleted)
- : post_on_delete_(post_on_delete), was_deleted_(was_deleted) {}
- void Run() {}
-
- private:
- friend class RefCounted<RecordDeletionProbe>;
-
- ~RecordDeletionProbe() {
- *was_deleted_ = true;
- if (post_on_delete_.get())
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecordDeletionProbe::Run, post_on_delete_));
- }
-
- scoped_refptr<RecordDeletionProbe> post_on_delete_;
- bool* was_deleted_;
-};
-
-} // namespace
-
-/* TODO(darin): MessageLoop does not support deleting all tasks in the */
-/* destructor. */
-/* Fails, http://crbug.com/50272. */
-TEST_P(MessageLoopTypedTest, DISABLED_EnsureDeletion) {
- bool a_was_deleted = false;
- bool b_was_deleted = false;
- {
- MessageLoop loop(GetMessageLoopType());
- loop.task_runner()->PostTask(
- FROM_HERE, BindOnce(&RecordDeletionProbe::Run,
- new RecordDeletionProbe(nullptr, &a_was_deleted)));
- // TODO(ajwong): Do we really need 1000ms here?
- loop.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(&RecordDeletionProbe::Run,
- new RecordDeletionProbe(nullptr, &b_was_deleted)),
- TimeDelta::FromMilliseconds(1000));
- }
- EXPECT_TRUE(a_was_deleted);
- EXPECT_TRUE(b_was_deleted);
-}
-
-/* TODO(darin): MessageLoop does not support deleting all tasks in the */
-/* destructor. */
-/* Fails, http://crbug.com/50272. */
-TEST_P(MessageLoopTypedTest, DISABLED_EnsureDeletion_Chain) {
- bool a_was_deleted = false;
- bool b_was_deleted = false;
- bool c_was_deleted = false;
- {
- MessageLoop loop(GetMessageLoopType());
- // The scoped_refptr for each of the below is held either by the chained
- // RecordDeletionProbe, or the bound RecordDeletionProbe::Run() callback.
- RecordDeletionProbe* a = new RecordDeletionProbe(nullptr, &a_was_deleted);
- RecordDeletionProbe* b = new RecordDeletionProbe(a, &b_was_deleted);
- RecordDeletionProbe* c = new RecordDeletionProbe(b, &c_was_deleted);
- loop.task_runner()->PostTask(FROM_HERE,
- BindOnce(&RecordDeletionProbe::Run, c));
- }
- EXPECT_TRUE(a_was_deleted);
- EXPECT_TRUE(b_was_deleted);
- EXPECT_TRUE(c_was_deleted);
-}
-
-namespace {
-
-void NestingFunc(int* depth) {
- if (*depth > 0) {
- *depth -= 1;
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&NestingFunc, depth));
-
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- RunLoop().Run();
- }
- base::RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-} // namespace
-
-TEST_P(MessageLoopTypedTest, Nesting) {
- MessageLoop loop(GetMessageLoopType());
-
- int depth = 50;
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&NestingFunc, &depth));
- RunLoop().Run();
- EXPECT_EQ(depth, 0);
-}
-
-TEST_P(MessageLoopTypedTest, RecursiveDenial1) {
- MessageLoop loop(GetMessageLoopType());
-
- EXPECT_TRUE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- TaskList order;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecursiveFunc, &order, 1, 2, false));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecursiveFunc, &order, 2, 2, false));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&QuitFunc, &order, 3));
-
- RunLoop().Run();
-
- // FIFO order.
- ASSERT_EQ(14U, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
- EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
- EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
- EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
- EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
-}
-
-namespace {
-
-void RecursiveSlowFunc(TaskList* order,
- int cookie,
- int depth,
- bool is_reentrant) {
- RecursiveFunc(order, cookie, depth, is_reentrant);
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
-}
-
-void OrderedFunc(TaskList* order, int cookie) {
- order->RecordStart(ORDERED, cookie);
- order->RecordEnd(ORDERED, cookie);
-}
-
-} // namespace
-
-TEST_P(MessageLoopTypedTest, RecursiveDenial3) {
- MessageLoop loop(GetMessageLoopType());
-
- EXPECT_TRUE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- TaskList order;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecursiveSlowFunc, &order, 1, 2, false));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecursiveSlowFunc, &order, 2, 2, false));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&OrderedFunc, &order, 3),
- TimeDelta::FromMilliseconds(5));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&QuitFunc, &order, 4),
- TimeDelta::FromMilliseconds(5));
-
- RunLoop().Run();
-
- // FIFO order.
- ASSERT_EQ(16U, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
- EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true));
- EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false));
- EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
- EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
- EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false));
- EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false));
-}
-
-TEST_P(MessageLoopTypedTest, RecursiveSupport1) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecursiveFunc, &order, 1, 2, true));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RecursiveFunc, &order, 2, 2, true));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&QuitFunc, &order, 3));
-
- RunLoop().Run();
-
- // FIFO order.
- ASSERT_EQ(14U, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
- EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
- EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
- EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
- EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
- EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
- EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
- EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
-}
-
-// Tests that non nestable tasks run in FIFO if there are no nested loops.
-TEST_P(MessageLoopTypedTest, NonNestableWithNoNesting) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
- FROM_HERE, BindOnce(&OrderedFunc, &order, 1));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&QuitFunc, &order, 3));
- RunLoop().Run();
-
- // FIFO order.
- ASSERT_EQ(6U, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false));
- EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
- EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
-}
-
-namespace {
-
-void FuncThatPumps(TaskList* order, int cookie) {
- order->RecordStart(PUMPS, cookie);
- RunLoop(RunLoop::Type::kNestableTasksAllowed).RunUntilIdle();
- order->RecordEnd(PUMPS, cookie);
-}
-
-void SleepFunc(TaskList* order, int cookie, TimeDelta delay) {
- order->RecordStart(SLEEP, cookie);
- PlatformThread::Sleep(delay);
- order->RecordEnd(SLEEP, cookie);
-}
-
-} // namespace
-
-// Tests that non nestable tasks don't run when there's code in the call stack.
-TEST_P(MessageLoopTypedTest, NonNestableDelayedInNestedLoop) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&FuncThatPumps, &order, 1));
- ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
- FROM_HERE, BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 3));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 5));
- ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
- FROM_HERE, BindOnce(&QuitFunc, &order, 6));
-
- RunLoop().Run();
-
- // FIFO order.
- ASSERT_EQ(12U, order.Size());
- EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true));
- EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true));
- EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false));
- EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true));
- EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false));
- EXPECT_EQ(order.Get(5), TaskItem(ORDERED, 5, true));
- EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 5, false));
- EXPECT_EQ(order.Get(7), TaskItem(PUMPS, 1, false));
- EXPECT_EQ(order.Get(8), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(9), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 6, true));
- EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false));
-}
-
-namespace {
-
-void FuncThatRuns(TaskList* order, int cookie, RunLoop* run_loop) {
- order->RecordStart(RUNS, cookie);
- {
- MessageLoopCurrent::ScopedNestableTaskAllower allow;
- run_loop->Run();
- }
- order->RecordEnd(RUNS, cookie);
-}
-
-void FuncThatQuitsNow() {
- base::RunLoop::QuitCurrentDeprecated();
-}
-
-} // namespace
-
-// Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
-TEST_P(MessageLoopTypedTest, QuitNow) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&FuncThatQuitsNow));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 3));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&FuncThatQuitsNow));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&OrderedFunc, &order, 4)); // never runs
-
- RunLoop().Run();
-
- ASSERT_EQ(6U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
-TEST_P(MessageLoopTypedTest, RunLoopQuitTop) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop outer_run_loop;
- RunLoop nested_run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- outer_run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_run_loop.QuitClosure());
-
- outer_run_loop.Run();
-
- ASSERT_EQ(4U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
-TEST_P(MessageLoopTypedTest, RunLoopQuitNested) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop outer_run_loop;
- RunLoop nested_run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- outer_run_loop.QuitClosure());
-
- outer_run_loop.Run();
-
- ASSERT_EQ(4U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Quits current loop and immediately runs a nested loop.
-void QuitAndRunNestedLoop(TaskList* order,
- int cookie,
- RunLoop* outer_run_loop,
- RunLoop* nested_run_loop) {
- order->RecordStart(RUNS, cookie);
- outer_run_loop->Quit();
- nested_run_loop->Run();
- order->RecordEnd(RUNS, cookie);
-}
-
-// Test that we can run nested loop after quitting the current one.
-TEST_P(MessageLoopTypedTest, RunLoopNestedAfterQuit) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop outer_run_loop;
- RunLoop nested_run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&QuitAndRunNestedLoop, &order, 1, &outer_run_loop,
- &nested_run_loop));
-
- outer_run_loop.Run();
-
- ASSERT_EQ(2U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
-TEST_P(MessageLoopTypedTest, RunLoopQuitBogus) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop outer_run_loop;
- RunLoop nested_run_loop;
- RunLoop bogus_run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- bogus_run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- outer_run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_run_loop.QuitClosure());
-
- outer_run_loop.Run();
-
- ASSERT_EQ(4U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
-TEST_P(MessageLoopTypedTest, RunLoopQuitDeep) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop outer_run_loop;
- RunLoop nested_loop1;
- RunLoop nested_loop2;
- RunLoop nested_loop3;
- RunLoop nested_loop4;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatRuns, &order, 1, Unretained(&nested_loop1)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatRuns, &order, 2, Unretained(&nested_loop2)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatRuns, &order, 3, Unretained(&nested_loop3)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatRuns, &order, 4, Unretained(&nested_loop4)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 5));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- outer_run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 6));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_loop1.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 7));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_loop2.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 8));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_loop3.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 9));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_loop4.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 10));
-
- outer_run_loop.Run();
-
- ASSERT_EQ(18U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Tests RunLoopQuit works before RunWithID.
-TEST_P(MessageLoopTypedTest, RunLoopQuitOrderBefore) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop run_loop;
-
- run_loop.Quit();
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&OrderedFunc, &order, 1)); // never runs
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatQuitsNow)); // never runs
-
- run_loop.Run();
-
- ASSERT_EQ(0U, order.Size());
-}
-
-// Tests RunLoopQuit works during RunWithID.
-TEST_P(MessageLoopTypedTest, RunLoopQuitOrderDuring) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 1));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop.QuitClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&OrderedFunc, &order, 2)); // never runs
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatQuitsNow)); // never runs
-
- run_loop.Run();
-
- ASSERT_EQ(2U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// Tests RunLoopQuit works after RunWithID.
-TEST_P(MessageLoopTypedTest, RunLoopQuitOrderAfter) {
- MessageLoop loop(GetMessageLoopType());
-
- TaskList order;
-
- RunLoop run_loop;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 2));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&FuncThatQuitsNow));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 3));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, run_loop.QuitClosure()); // has no affect
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&OrderedFunc, &order, 4));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&FuncThatQuitsNow));
-
- RunLoop outer_run_loop;
- outer_run_loop.Run();
-
- ASSERT_EQ(8U, order.Size());
- int task_index = 0;
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true));
- EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false));
- EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
-}
-
-// There was a bug in the MessagePumpGLib where posting tasks recursively
-// caused the message loop to hang, due to the buffer of the internal pipe
-// becoming full. Test all MessageLoop types to ensure this issue does not
-// exist in other MessagePumps.
-//
-// On Linux, the pipe buffer size is 64KiB by default. The bug caused one
-// byte accumulated in the pipe per two posts, so we should repeat 128K
-// times to reproduce the bug.
-TEST_P(MessageLoopTypedTest, RecursivePosts) {
- const int kNumTimes = 1 << 17;
- MessageLoop loop(GetMessageLoopType());
- loop.task_runner()->PostTask(FROM_HERE,
- BindOnce(&PostNTasksThenQuit, kNumTimes));
- RunLoop().Run();
-}
-
-TEST_P(MessageLoopTypedTest, NestableTasksAllowedAtTopLevel) {
- MessageLoop loop(GetMessageLoopType());
- EXPECT_TRUE(MessageLoopCurrent::Get()->NestableTasksAllowed());
-}
-
-// Nestable tasks shouldn't be allowed to run reentrantly by default (regression
-// test for https://crbug.com/754112).
-TEST_P(MessageLoopTypedTest, NestableTasksDisallowedByDefault) {
- MessageLoop loop(GetMessageLoopType());
- RunLoop run_loop;
- loop.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* run_loop) {
- EXPECT_FALSE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- run_loop->Quit();
- },
- Unretained(&run_loop)));
- run_loop.Run();
-}
-
-TEST_P(MessageLoopTypedTest, NestableTasksProcessedWhenRunLoopAllows) {
- MessageLoop loop(GetMessageLoopType());
- RunLoop run_loop;
- loop.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* run_loop) {
- // This test would hang if this RunLoop wasn't of type
- // kNestableTasksAllowed (i.e. this is testing that this is
- // processed and doesn't hang).
- RunLoop nested_run_loop(RunLoop::Type::kNestableTasksAllowed);
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* nested_run_loop) {
- // Each additional layer of application task nesting
- // requires its own allowance. The kNestableTasksAllowed
- // RunLoop allowed this task to be processed but further
- // nestable tasks are by default disallowed from this
- // layer.
- EXPECT_FALSE(
- MessageLoopCurrent::Get()->NestableTasksAllowed());
- nested_run_loop->Quit();
- },
- Unretained(&nested_run_loop)));
- nested_run_loop.Run();
-
- run_loop->Quit();
- },
- Unretained(&run_loop)));
- run_loop.Run();
-}
-
-TEST_P(MessageLoopTypedTest, NestableTasksAllowedExplicitlyInScope) {
- MessageLoop loop(GetMessageLoopType());
- RunLoop run_loop;
- loop.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* run_loop) {
- {
- MessageLoopCurrent::ScopedNestableTaskAllower
- allow_nestable_tasks;
- EXPECT_TRUE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- }
- EXPECT_FALSE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- run_loop->Quit();
- },
- Unretained(&run_loop)));
- run_loop.Run();
-}
-
-TEST_P(MessageLoopTypedTest, NestableTasksAllowedManually) {
- MessageLoop loop(GetMessageLoopType());
- RunLoop run_loop;
- loop.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* run_loop) {
- EXPECT_FALSE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- EXPECT_TRUE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(false);
- EXPECT_FALSE(MessageLoopCurrent::Get()->NestableTasksAllowed());
- run_loop->Quit();
- },
- Unretained(&run_loop)));
- run_loop.Run();
-}
-
-INSTANTIATE_TEST_CASE_P(
- ,
- MessageLoopTypedTest,
- ::testing::Values(MessageLoopTypedTestParams(
- MessageLoop::TYPE_DEFAULT,
- TaskSchedulerAvailability::NO_TASK_SCHEDULER),
- MessageLoopTypedTestParams(
- MessageLoop::TYPE_IO,
- TaskSchedulerAvailability::NO_TASK_SCHEDULER),
- MessageLoopTypedTestParams(
- MessageLoop::TYPE_UI,
- TaskSchedulerAvailability::NO_TASK_SCHEDULER),
- MessageLoopTypedTestParams(
- MessageLoop::TYPE_DEFAULT,
- TaskSchedulerAvailability::WITH_TASK_SCHEDULER),
- MessageLoopTypedTestParams(
- MessageLoop::TYPE_IO,
- TaskSchedulerAvailability::WITH_TASK_SCHEDULER),
- MessageLoopTypedTestParams(
- MessageLoop::TYPE_UI,
- TaskSchedulerAvailability::WITH_TASK_SCHEDULER)),
- MessageLoopTypedTest::ParamInfoToString);
-
-#if defined(OS_WIN)
-// Verifies that the MessageLoop ignores WM_QUIT, rather than quitting.
-// Users of MessageLoop typically expect to control when their RunLoops stop
-// Run()ning explicitly, via QuitClosure() etc (see https://crbug.com/720078)
-TEST_P(MessageLoopTest, WmQuitIsIgnored) {
- MessageLoop loop(MessageLoop::TYPE_UI);
- RunLoop run_loop;
- // Post a WM_QUIT message to the current thread.
- ::PostQuitMessage(0);
-
- // Post a task to the current thread, with a small delay to make it less
- // likely that we process the posted task before looking for WM_* messages.
- bool task_was_run = false;
- loop.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(
- [](bool* flag, OnceClosure closure) {
- *flag = true;
- std::move(closure).Run();
- },
- &task_was_run, run_loop.QuitClosure()),
- TestTimeouts::tiny_timeout());
-
- // Run the loop, and ensure that the posted task is processed before we quit.
- run_loop.Run();
- EXPECT_TRUE(task_was_run);
-}
-
-TEST_P(MessageLoopTest, PostDelayedTask_SharedTimer_SubPump) {
- RunTest_PostDelayedTask_SharedTimer_SubPump();
-}
-
-// This test occasionally hangs. See http://crbug.com/44567.
-TEST_P(MessageLoopTest, DISABLED_RecursiveDenial2) {
- RunTest_RecursiveDenial2(MessageLoop::TYPE_DEFAULT);
- RunTest_RecursiveDenial2(MessageLoop::TYPE_UI);
- RunTest_RecursiveDenial2(MessageLoop::TYPE_IO);
-}
-
-TEST_P(MessageLoopTest, RecursiveSupport2) {
- // This test requires a UI loop.
- RunTest_RecursiveSupport2(MessageLoop::TYPE_UI);
-}
-#endif // defined(OS_WIN)
-
-TEST_P(MessageLoopTest, TaskObserver) {
- const int kNumPosts = 6;
- DummyTaskObserver observer(kNumPosts);
-
- MessageLoop loop;
- loop.AddTaskObserver(&observer);
- loop.task_runner()->PostTask(FROM_HERE,
- BindOnce(&PostNTasksThenQuit, kNumPosts));
- RunLoop().Run();
- loop.RemoveTaskObserver(&observer);
-
- EXPECT_EQ(kNumPosts, observer.num_tasks_started());
- EXPECT_EQ(kNumPosts, observer.num_tasks_processed());
-}
-
-#if defined(OS_WIN)
-TEST_P(MessageLoopTest, IOHandler) {
- RunTest_IOHandler();
-}
-
-TEST_P(MessageLoopTest, WaitForIO) {
- RunTest_WaitForIO();
-}
-
-TEST_P(MessageLoopTest, HighResolutionTimer) {
- MessageLoop message_loop;
- Time::EnableHighResolutionTimer(true);
-
- constexpr TimeDelta kFastTimer = TimeDelta::FromMilliseconds(5);
- constexpr TimeDelta kSlowTimer = TimeDelta::FromMilliseconds(100);
-
- {
- // Post a fast task to enable the high resolution timers.
- RunLoop run_loop;
- message_loop.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* run_loop) {
- EXPECT_TRUE(Time::IsHighResolutionTimerInUse());
- run_loop->QuitWhenIdle();
- },
- &run_loop),
- kFastTimer);
- run_loop.Run();
- }
- EXPECT_FALSE(Time::IsHighResolutionTimerInUse());
- {
- // Check that a slow task does not trigger the high resolution logic.
- RunLoop run_loop;
- message_loop.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(
- [](RunLoop* run_loop) {
- EXPECT_FALSE(Time::IsHighResolutionTimerInUse());
- run_loop->QuitWhenIdle();
- },
- &run_loop),
- kSlowTimer);
- run_loop.Run();
- }
- Time::EnableHighResolutionTimer(false);
- Time::ResetHighResolutionTimerUsage();
-}
-
-#endif // defined(OS_WIN)
-
-namespace {
-// Inject a test point for recording the destructor calls for Closure objects
-// send to MessageLoop::PostTask(). It is awkward usage since we are trying to
-// hook the actual destruction, which is not a common operation.
-class DestructionObserverProbe :
- public RefCounted<DestructionObserverProbe> {
- public:
- DestructionObserverProbe(bool* task_destroyed,
- bool* destruction_observer_called)
- : task_destroyed_(task_destroyed),
- destruction_observer_called_(destruction_observer_called) {
- }
- virtual void Run() {
- // This task should never run.
- ADD_FAILURE();
- }
- private:
- friend class RefCounted<DestructionObserverProbe>;
-
- virtual ~DestructionObserverProbe() {
- EXPECT_FALSE(*destruction_observer_called_);
- *task_destroyed_ = true;
- }
-
- bool* task_destroyed_;
- bool* destruction_observer_called_;
-};
-
-class MLDestructionObserver : public MessageLoopCurrent::DestructionObserver {
- public:
- MLDestructionObserver(bool* task_destroyed, bool* destruction_observer_called)
- : task_destroyed_(task_destroyed),
- destruction_observer_called_(destruction_observer_called),
- task_destroyed_before_message_loop_(false) {
- }
- void WillDestroyCurrentMessageLoop() override {
- task_destroyed_before_message_loop_ = *task_destroyed_;
- *destruction_observer_called_ = true;
- }
- bool task_destroyed_before_message_loop() const {
- return task_destroyed_before_message_loop_;
- }
- private:
- bool* task_destroyed_;
- bool* destruction_observer_called_;
- bool task_destroyed_before_message_loop_;
-};
-
-} // namespace
-
-TEST_P(MessageLoopTest, DestructionObserverTest) {
- // Verify that the destruction observer gets called at the very end (after
- // all the pending tasks have been destroyed).
- MessageLoop* loop = new MessageLoop;
- const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
-
- bool task_destroyed = false;
- bool destruction_observer_called = false;
-
- MLDestructionObserver observer(&task_destroyed, &destruction_observer_called);
- loop->AddDestructionObserver(&observer);
- loop->task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(&DestructionObserverProbe::Run,
- new DestructionObserverProbe(&task_destroyed,
- &destruction_observer_called)),
- kDelay);
- delete loop;
- EXPECT_TRUE(observer.task_destroyed_before_message_loop());
- // The task should have been destroyed when we deleted the loop.
- EXPECT_TRUE(task_destroyed);
- EXPECT_TRUE(destruction_observer_called);
-}
-
-
-// Verify that MessageLoop sets ThreadMainTaskRunner::current() and it
-// posts tasks on that message loop.
-TEST_P(MessageLoopTest, ThreadMainTaskRunner) {
- MessageLoop loop;
-
- scoped_refptr<Foo> foo(new Foo());
- std::string a("a");
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&Foo::Test1ConstRef, foo, a));
-
- // Post quit task;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RunLoop::QuitCurrentWhenIdleDeprecated));
-
- // Now kick things off
- RunLoop().Run();
-
- EXPECT_EQ(foo->test_count(), 1);
- EXPECT_EQ(foo->result(), "a");
-}
-
-TEST_P(MessageLoopTest, IsType) {
- MessageLoop loop(MessageLoop::TYPE_UI);
- EXPECT_TRUE(loop.IsType(MessageLoop::TYPE_UI));
- EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_IO));
- EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_DEFAULT));
-}
-
-#if defined(OS_WIN)
-void EmptyFunction() {}
-
-void PostMultipleTasks() {
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::BindOnce(&EmptyFunction));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::BindOnce(&EmptyFunction));
-}
-
-static const int kSignalMsg = WM_USER + 2;
-
-void PostWindowsMessage(HWND message_hwnd) {
- PostMessage(message_hwnd, kSignalMsg, 0, 2);
-}
-
-void EndTest(bool* did_run, HWND hwnd) {
- *did_run = true;
- PostMessage(hwnd, WM_CLOSE, 0, 0);
-}
-
-int kMyMessageFilterCode = 0x5002;
-
-LRESULT CALLBACK TestWndProcThunk(HWND hwnd, UINT message,
- WPARAM wparam, LPARAM lparam) {
- if (message == WM_CLOSE)
- EXPECT_TRUE(DestroyWindow(hwnd));
- if (message != kSignalMsg)
- return DefWindowProc(hwnd, message, wparam, lparam);
-
- switch (lparam) {
- case 1:
- // First, we post a task that will post multiple no-op tasks to make sure
- // that the pump's incoming task queue does not become empty during the
- // test.
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::BindOnce(&PostMultipleTasks));
- // Next, we post a task that posts a windows message to trigger the second
- // stage of the test.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&PostWindowsMessage, hwnd));
- break;
- case 2:
- // Since we're about to enter a modal loop, tell the message loop that we
- // intend to nest tasks.
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- bool did_run = false;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&EndTest, &did_run, hwnd));
- // Run a nested windows-style message loop and verify that our task runs. If
- // it doesn't, then we'll loop here until the test times out.
- MSG msg;
- while (GetMessage(&msg, 0, 0, 0)) {
- if (!CallMsgFilter(&msg, kMyMessageFilterCode))
- DispatchMessage(&msg);
- // If this message is a WM_CLOSE, explicitly exit the modal loop. Posting
- // a WM_QUIT should handle this, but unfortunately MessagePumpWin eats
- // WM_QUIT messages even when running inside a modal loop.
- if (msg.message == WM_CLOSE)
- break;
- }
- EXPECT_TRUE(did_run);
- RunLoop::QuitCurrentWhenIdleDeprecated();
- break;
- }
- return 0;
-}
-
-TEST_P(MessageLoopTest, AlwaysHaveUserMessageWhenNesting) {
- MessageLoop loop(MessageLoop::TYPE_UI);
- HINSTANCE instance = CURRENT_MODULE();
- WNDCLASSEX wc = {0};
- wc.cbSize = sizeof(wc);
- wc.lpfnWndProc = TestWndProcThunk;
- wc.hInstance = instance;
- wc.lpszClassName = L"MessageLoopTest_HWND";
- ATOM atom = RegisterClassEx(&wc);
- ASSERT_TRUE(atom);
-
- HWND message_hwnd = CreateWindow(MAKEINTATOM(atom), 0, 0, 0, 0, 0, 0,
- HWND_MESSAGE, 0, instance, 0);
- ASSERT_TRUE(message_hwnd) << GetLastError();
-
- ASSERT_TRUE(PostMessage(message_hwnd, kSignalMsg, 0, 1));
-
- RunLoop().Run();
-
- ASSERT_TRUE(UnregisterClass(MAKEINTATOM(atom), instance));
-}
-#endif // defined(OS_WIN)
-
-TEST_P(MessageLoopTest, SetTaskRunner) {
- MessageLoop loop;
- scoped_refptr<SingleThreadTaskRunner> new_runner(new TestSimpleTaskRunner());
-
- loop.SetTaskRunner(new_runner);
- EXPECT_EQ(new_runner, loop.task_runner());
- EXPECT_EQ(new_runner, ThreadTaskRunnerHandle::Get());
-}
-
-TEST_P(MessageLoopTest, OriginalRunnerWorks) {
- MessageLoop loop;
- scoped_refptr<SingleThreadTaskRunner> new_runner(new TestSimpleTaskRunner());
- scoped_refptr<SingleThreadTaskRunner> original_runner(loop.task_runner());
- loop.SetTaskRunner(new_runner);
-
- scoped_refptr<Foo> foo(new Foo());
- original_runner->PostTask(FROM_HERE, BindOnce(&Foo::Test1ConstRef, foo, "a"));
- RunLoop().RunUntilIdle();
- EXPECT_EQ(1, foo->test_count());
-}
-
-TEST_P(MessageLoopTest, DeleteUnboundLoop) {
- // It should be possible to delete an unbound message loop on a thread which
- // already has another active loop. This happens when thread creation fails.
- MessageLoop loop;
- std::unique_ptr<MessageLoop> unbound_loop(MessageLoop::CreateUnbound(
- MessageLoop::TYPE_DEFAULT, MessageLoop::MessagePumpFactoryCallback()));
- unbound_loop.reset();
- EXPECT_EQ(&loop, MessageLoop::current());
- EXPECT_EQ(loop.task_runner(), ThreadTaskRunnerHandle::Get());
-}
-
-TEST_P(MessageLoopTest, ThreadName) {
- {
- std::string kThreadName("foo");
- MessageLoop loop;
- PlatformThread::SetName(kThreadName);
- EXPECT_EQ(kThreadName, loop.GetThreadName());
- }
-
- {
- std::string kThreadName("bar");
- base::Thread thread(kThreadName);
- ASSERT_TRUE(thread.StartAndWaitForTesting());
- EXPECT_EQ(kThreadName, thread.message_loop()->GetThreadName());
- }
-}
-
-// Verify that tasks posted to and code running in the scope of the same
-// MessageLoop access the same SequenceLocalStorage values.
-TEST_P(MessageLoopTest, SequenceLocalStorageSetGet) {
- MessageLoop loop;
-
- SequenceLocalStorageSlot<int> slot;
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&SequenceLocalStorageSlot<int>::Set, Unretained(&slot), 11));
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(
- [](SequenceLocalStorageSlot<int>* slot) {
- EXPECT_EQ(slot->Get(), 11);
- },
- &slot));
-
- RunLoop().RunUntilIdle();
- EXPECT_EQ(slot.Get(), 11);
-}
-
-// Verify that tasks posted to and code running in different MessageLoops access
-// different SequenceLocalStorage values.
-TEST_P(MessageLoopTest, SequenceLocalStorageDifferentMessageLoops) {
- SequenceLocalStorageSlot<int> slot;
-
- {
- MessageLoop loop;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce(&SequenceLocalStorageSlot<int>::Set, Unretained(&slot), 11));
-
- RunLoop().RunUntilIdle();
- EXPECT_EQ(slot.Get(), 11);
- }
-
- MessageLoop loop;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(
- [](SequenceLocalStorageSlot<int>* slot) {
- EXPECT_NE(slot->Get(), 11);
- },
- &slot));
-
- RunLoop().RunUntilIdle();
- EXPECT_NE(slot.Get(), 11);
-}
-
-INSTANTIATE_TEST_CASE_P(
- ,
- MessageLoopTest,
- ::testing::Values(TaskSchedulerAvailability::NO_TASK_SCHEDULER,
- TaskSchedulerAvailability::WITH_TASK_SCHEDULER),
- MessageLoopTest::ParamInfoToString);
-
-} // namespace base
diff --git a/base/message_loop/message_pump_glib_unittest.cc b/base/message_loop/message_pump_glib_unittest.cc
deleted file mode 100644
index 70be2a4..0000000
--- a/base/message_loop/message_pump_glib_unittest.cc
+++ /dev/null
@@ -1,523 +0,0 @@
-// 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.
-
-#include "base/message_loop/message_pump_glib.h"
-
-#include <glib.h>
-#include <math.h>
-
-#include <algorithm>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_current.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-// This class injects dummy "events" into the GLib loop. When "handled" these
-// events can run tasks. This is intended to mock gtk events (the corresponding
-// GLib source runs at the same priority).
-class EventInjector {
- public:
- EventInjector() : processed_events_(0) {
- source_ = static_cast<Source*>(g_source_new(&SourceFuncs, sizeof(Source)));
- source_->injector = this;
- g_source_attach(source_, nullptr);
- g_source_set_can_recurse(source_, TRUE);
- }
-
- ~EventInjector() {
- g_source_destroy(source_);
- g_source_unref(source_);
- }
-
- int HandlePrepare() {
- // If the queue is empty, block.
- if (events_.empty())
- return -1;
- TimeDelta delta = events_[0].time - Time::NowFromSystemTime();
- return std::max(0, static_cast<int>(ceil(delta.InMillisecondsF())));
- }
-
- bool HandleCheck() {
- if (events_.empty())
- return false;
- return events_[0].time <= Time::NowFromSystemTime();
- }
-
- void HandleDispatch() {
- if (events_.empty())
- return;
- Event event = std::move(events_[0]);
- events_.erase(events_.begin());
- ++processed_events_;
- if (!event.callback.is_null())
- std::move(event.callback).Run();
- else if (!event.task.is_null())
- std::move(event.task).Run();
- }
-
- // Adds an event to the queue. When "handled", executes |callback|.
- // delay_ms is relative to the last event if any, or to Now() otherwise.
- void AddEvent(int delay_ms, OnceClosure callback) {
- AddEventHelper(delay_ms, std::move(callback), OnceClosure());
- }
-
- void AddDummyEvent(int delay_ms) {
- AddEventHelper(delay_ms, OnceClosure(), OnceClosure());
- }
-
- void AddEventAsTask(int delay_ms, OnceClosure task) {
- AddEventHelper(delay_ms, OnceClosure(), std::move(task));
- }
-
- void Reset() {
- processed_events_ = 0;
- events_.clear();
- }
-
- int processed_events() const { return processed_events_; }
-
- private:
- struct Event {
- Time time;
- OnceClosure callback;
- OnceClosure task;
- };
-
- struct Source : public GSource {
- EventInjector* injector;
- };
-
- void AddEventHelper(int delay_ms, OnceClosure callback, OnceClosure task) {
- Time last_time;
- if (!events_.empty())
- last_time = (events_.end()-1)->time;
- else
- last_time = Time::NowFromSystemTime();
-
- Time future = last_time + TimeDelta::FromMilliseconds(delay_ms);
- EventInjector::Event event = {future, std::move(callback), std::move(task)};
- events_.push_back(std::move(event));
- }
-
- static gboolean Prepare(GSource* source, gint* timeout_ms) {
- *timeout_ms = static_cast<Source*>(source)->injector->HandlePrepare();
- return FALSE;
- }
-
- static gboolean Check(GSource* source) {
- return static_cast<Source*>(source)->injector->HandleCheck();
- }
-
- static gboolean Dispatch(GSource* source,
- GSourceFunc unused_func,
- gpointer unused_data) {
- static_cast<Source*>(source)->injector->HandleDispatch();
- return TRUE;
- }
-
- Source* source_;
- std::vector<Event> events_;
- int processed_events_;
- static GSourceFuncs SourceFuncs;
- DISALLOW_COPY_AND_ASSIGN(EventInjector);
-};
-
-GSourceFuncs EventInjector::SourceFuncs = {EventInjector::Prepare,
- EventInjector::Check,
- EventInjector::Dispatch, nullptr};
-
-void IncrementInt(int *value) {
- ++*value;
-}
-
-// Checks how many events have been processed by the injector.
-void ExpectProcessedEvents(EventInjector* injector, int count) {
- EXPECT_EQ(injector->processed_events(), count);
-}
-
-// Posts a task on the current message loop.
-void PostMessageLoopTask(const Location& from_here, OnceClosure task) {
- ThreadTaskRunnerHandle::Get()->PostTask(from_here, std::move(task));
-}
-
-// Test fixture.
-class MessagePumpGLibTest : public testing::Test {
- public:
- MessagePumpGLibTest() : loop_(nullptr), injector_(nullptr) {}
-
- // Overridden from testing::Test:
- void SetUp() override {
- loop_ = new MessageLoop(MessageLoop::TYPE_UI);
- injector_ = new EventInjector();
- }
- void TearDown() override {
- delete injector_;
- injector_ = nullptr;
- delete loop_;
- loop_ = nullptr;
- }
-
- MessageLoop* loop() const { return loop_; }
- EventInjector* injector() const { return injector_; }
-
- private:
- MessageLoop* loop_;
- EventInjector* injector_;
- DISALLOW_COPY_AND_ASSIGN(MessagePumpGLibTest);
-};
-
-} // namespace
-
-TEST_F(MessagePumpGLibTest, TestQuit) {
- // Checks that Quit works and that the basic infrastructure is working.
-
- // Quit from a task
- RunLoop().RunUntilIdle();
- EXPECT_EQ(0, injector()->processed_events());
-
- injector()->Reset();
- // Quit from an event
- injector()->AddEvent(0, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- RunLoop().Run();
- EXPECT_EQ(1, injector()->processed_events());
-}
-
-TEST_F(MessagePumpGLibTest, TestEventTaskInterleave) {
- // Checks that tasks posted by events are executed before the next event if
- // the posted task queue is empty.
- // MessageLoop doesn't make strong guarantees that it is the case, but the
- // current implementation ensures it and the tests below rely on it.
- // If changes cause this test to fail, it is reasonable to change it, but
- // TestWorkWhileWaitingForEvents and TestEventsWhileWaitingForWork have to be
- // changed accordingly, otherwise they can become flaky.
- injector()->AddEventAsTask(0, DoNothing());
- OnceClosure check_task =
- BindOnce(&ExpectProcessedEvents, Unretained(injector()), 2);
- OnceClosure posted_task =
- BindOnce(&PostMessageLoopTask, FROM_HERE, std::move(check_task));
- injector()->AddEventAsTask(0, std::move(posted_task));
- injector()->AddEventAsTask(0, DoNothing());
- injector()->AddEvent(0, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- RunLoop().Run();
- EXPECT_EQ(4, injector()->processed_events());
-
- injector()->Reset();
- injector()->AddEventAsTask(0, DoNothing());
- check_task = BindOnce(&ExpectProcessedEvents, Unretained(injector()), 2);
- posted_task =
- BindOnce(&PostMessageLoopTask, FROM_HERE, std::move(check_task));
- injector()->AddEventAsTask(0, std::move(posted_task));
- injector()->AddEventAsTask(10, DoNothing());
- injector()->AddEvent(0, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- RunLoop().Run();
- EXPECT_EQ(4, injector()->processed_events());
-}
-
-TEST_F(MessagePumpGLibTest, TestWorkWhileWaitingForEvents) {
- int task_count = 0;
- // Tests that we process tasks while waiting for new events.
- // The event queue is empty at first.
- for (int i = 0; i < 10; ++i) {
- loop()->task_runner()->PostTask(FROM_HERE,
- BindOnce(&IncrementInt, &task_count));
- }
- // After all the previous tasks have executed, enqueue an event that will
- // quit.
- loop()->task_runner()->PostTask(
- FROM_HERE, BindOnce(&EventInjector::AddEvent, Unretained(injector()), 0,
- RunLoop::QuitCurrentWhenIdleClosureDeprecated()));
- RunLoop().Run();
- ASSERT_EQ(10, task_count);
- EXPECT_EQ(1, injector()->processed_events());
-
- // Tests that we process delayed tasks while waiting for new events.
- injector()->Reset();
- task_count = 0;
- for (int i = 0; i < 10; ++i) {
- loop()->task_runner()->PostDelayedTask(FROM_HERE,
- BindOnce(&IncrementInt, &task_count),
- TimeDelta::FromMilliseconds(10 * i));
- }
- // After all the previous tasks have executed, enqueue an event that will
- // quit.
- // This relies on the fact that delayed tasks are executed in delay order.
- // That is verified in message_loop_unittest.cc.
- loop()->task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(&EventInjector::AddEvent, Unretained(injector()), 10,
- RunLoop::QuitCurrentWhenIdleClosureDeprecated()),
- TimeDelta::FromMilliseconds(150));
- RunLoop().Run();
- ASSERT_EQ(10, task_count);
- EXPECT_EQ(1, injector()->processed_events());
-}
-
-TEST_F(MessagePumpGLibTest, TestEventsWhileWaitingForWork) {
- // Tests that we process events while waiting for work.
- // The event queue is empty at first.
- for (int i = 0; i < 10; ++i) {
- injector()->AddDummyEvent(0);
- }
- // After all the events have been processed, post a task that will check that
- // the events have been processed (note: the task executes after the event
- // that posted it has been handled, so we expect 11 at that point).
- OnceClosure check_task =
- BindOnce(&ExpectProcessedEvents, Unretained(injector()), 11);
- OnceClosure posted_task =
- BindOnce(&PostMessageLoopTask, FROM_HERE, std::move(check_task));
- injector()->AddEventAsTask(10, std::move(posted_task));
-
- // And then quit (relies on the condition tested by TestEventTaskInterleave).
- injector()->AddEvent(10, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- RunLoop().Run();
-
- EXPECT_EQ(12, injector()->processed_events());
-}
-
-namespace {
-
-// This class is a helper for the concurrent events / posted tasks test below.
-// It will quit the main loop once enough tasks and events have been processed,
-// while making sure there is always work to do and events in the queue.
-class ConcurrentHelper : public RefCounted<ConcurrentHelper> {
- public:
- explicit ConcurrentHelper(EventInjector* injector)
- : injector_(injector),
- event_count_(kStartingEventCount),
- task_count_(kStartingTaskCount) {
- }
-
- void FromTask() {
- if (task_count_ > 0) {
- --task_count_;
- }
- if (task_count_ == 0 && event_count_ == 0) {
- RunLoop::QuitCurrentWhenIdleDeprecated();
- } else {
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, this));
- }
- }
-
- void FromEvent() {
- if (event_count_ > 0) {
- --event_count_;
- }
- if (task_count_ == 0 && event_count_ == 0) {
- RunLoop::QuitCurrentWhenIdleDeprecated();
- } else {
- injector_->AddEventAsTask(0,
- BindOnce(&ConcurrentHelper::FromEvent, this));
- }
- }
-
- int event_count() const { return event_count_; }
- int task_count() const { return task_count_; }
-
- private:
- friend class RefCounted<ConcurrentHelper>;
-
- ~ConcurrentHelper() {}
-
- static const int kStartingEventCount = 20;
- static const int kStartingTaskCount = 20;
-
- EventInjector* injector_;
- int event_count_;
- int task_count_;
-};
-
-} // namespace
-
-TEST_F(MessagePumpGLibTest, TestConcurrentEventPostedTask) {
- // Tests that posted tasks don't starve events, nor the opposite.
- // We use the helper class above. We keep both event and posted task queues
- // full, the helper verifies that both tasks and events get processed.
- // If that is not the case, either event_count_ or task_count_ will not get
- // to 0, and MessageLoop::QuitWhenIdle() will never be called.
- scoped_refptr<ConcurrentHelper> helper = new ConcurrentHelper(injector());
-
- // Add 2 events to the queue to make sure it is always full (when we remove
- // the event before processing it).
- injector()->AddEventAsTask(0, BindOnce(&ConcurrentHelper::FromEvent, helper));
- injector()->AddEventAsTask(0, BindOnce(&ConcurrentHelper::FromEvent, helper));
-
- // Similarly post 2 tasks.
- loop()->task_runner()->PostTask(
- FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, helper));
- loop()->task_runner()->PostTask(
- FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, helper));
-
- RunLoop().Run();
- EXPECT_EQ(0, helper->event_count());
- EXPECT_EQ(0, helper->task_count());
-}
-
-namespace {
-
-void AddEventsAndDrainGLib(EventInjector* injector) {
- // Add a couple of dummy events
- injector->AddDummyEvent(0);
- injector->AddDummyEvent(0);
- // Then add an event that will quit the main loop.
- injector->AddEvent(0, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
-
- // Post a couple of dummy tasks
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing());
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing());
-
- // Drain the events
- while (g_main_context_pending(nullptr)) {
- g_main_context_iteration(nullptr, FALSE);
- }
-}
-
-} // namespace
-
-TEST_F(MessagePumpGLibTest, TestDrainingGLib) {
- // Tests that draining events using GLib works.
- loop()->task_runner()->PostTask(
- FROM_HERE, BindOnce(&AddEventsAndDrainGLib, Unretained(injector())));
- RunLoop().Run();
-
- EXPECT_EQ(3, injector()->processed_events());
-}
-
-namespace {
-
-// Helper class that lets us run the GLib message loop.
-class GLibLoopRunner : public RefCounted<GLibLoopRunner> {
- public:
- GLibLoopRunner() : quit_(false) { }
-
- void RunGLib() {
- while (!quit_) {
- g_main_context_iteration(nullptr, TRUE);
- }
- }
-
- void RunLoop() {
- while (!quit_) {
- g_main_context_iteration(nullptr, TRUE);
- }
- }
-
- void Quit() {
- quit_ = true;
- }
-
- void Reset() {
- quit_ = false;
- }
-
- private:
- friend class RefCounted<GLibLoopRunner>;
-
- ~GLibLoopRunner() {}
-
- bool quit_;
-};
-
-void TestGLibLoopInternal(EventInjector* injector) {
- // Allow tasks to be processed from 'native' event loops.
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
-
- int task_count = 0;
- // Add a couple of dummy events
- injector->AddDummyEvent(0);
- injector->AddDummyEvent(0);
- // Post a couple of dummy tasks
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&IncrementInt, &task_count));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&IncrementInt, &task_count));
- // Delayed events
- injector->AddDummyEvent(10);
- injector->AddDummyEvent(10);
- // Delayed work
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&IncrementInt, &task_count),
- TimeDelta::FromMilliseconds(30));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&GLibLoopRunner::Quit, runner),
- TimeDelta::FromMilliseconds(40));
-
- // Run a nested, straight GLib message loop.
- runner->RunGLib();
-
- ASSERT_EQ(3, task_count);
- EXPECT_EQ(4, injector->processed_events());
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-void TestGtkLoopInternal(EventInjector* injector) {
- // Allow tasks to be processed from 'native' event loops.
- MessageLoopCurrent::Get()->SetNestableTasksAllowed(true);
- scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
-
- int task_count = 0;
- // Add a couple of dummy events
- injector->AddDummyEvent(0);
- injector->AddDummyEvent(0);
- // Post a couple of dummy tasks
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&IncrementInt, &task_count));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- BindOnce(&IncrementInt, &task_count));
- // Delayed events
- injector->AddDummyEvent(10);
- injector->AddDummyEvent(10);
- // Delayed work
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&IncrementInt, &task_count),
- TimeDelta::FromMilliseconds(30));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&GLibLoopRunner::Quit, runner),
- TimeDelta::FromMilliseconds(40));
-
- // Run a nested, straight Gtk message loop.
- runner->RunLoop();
-
- ASSERT_EQ(3, task_count);
- EXPECT_EQ(4, injector->processed_events());
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-} // namespace
-
-TEST_F(MessagePumpGLibTest, TestGLibLoop) {
- // Tests that events and posted tasks are correctly executed if the message
- // loop is not run by MessageLoop::Run() but by a straight GLib loop.
- // Note that in this case we don't make strong guarantees about niceness
- // between events and posted tasks.
- loop()->task_runner()->PostTask(
- FROM_HERE, BindOnce(&TestGLibLoopInternal, Unretained(injector())));
- RunLoop().Run();
-}
-
-TEST_F(MessagePumpGLibTest, TestGtkLoop) {
- // Tests that events and posted tasks are correctly executed if the message
- // loop is not run by MessageLoop::Run() but by a straight Gtk loop.
- // Note that in this case we don't make strong guarantees about niceness
- // between events and posted tasks.
- loop()->task_runner()->PostTask(
- FROM_HERE, BindOnce(&TestGtkLoopInternal, Unretained(injector())));
- RunLoop().Run();
-}
-
-} // namespace base
diff --git a/base/message_loop/message_pump_io_ios_unittest.cc b/base/message_loop/message_pump_io_ios_unittest.cc
deleted file mode 100644
index 4d15d44..0000000
--- a/base/message_loop/message_pump_io_ios_unittest.cc
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright 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.
-
-#include "base/message_loop/message_pump_io_ios.h"
-
-#include <unistd.h>
-
-#include "base/macros.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class MessagePumpIOSForIOTest : public testing::Test {
- protected:
- MessagePumpIOSForIOTest() = default;
- ~MessagePumpIOSForIOTest() override = default;
-
- void SetUp() override {
- int ret = pipe(pipefds_);
- ASSERT_EQ(0, ret);
- ret = pipe(alternate_pipefds_);
- ASSERT_EQ(0, ret);
- }
-
- void TearDown() override {
- if (IGNORE_EINTR(close(pipefds_[0])) < 0)
- PLOG(ERROR) << "close";
- if (IGNORE_EINTR(close(pipefds_[1])) < 0)
- PLOG(ERROR) << "close";
- }
-
- void HandleFdIOEvent(MessagePumpForIO::FdWatchController* watcher) {
- MessagePumpIOSForIO::HandleFdIOEvent(watcher->fdref_.get(),
- kCFFileDescriptorReadCallBack | kCFFileDescriptorWriteCallBack,
- watcher);
- }
-
- int pipefds_[2];
- int alternate_pipefds_[2];
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MessagePumpIOSForIOTest);
-};
-
-namespace {
-
-// Concrete implementation of MessagePumpIOSForIO::FdWatcher that does
-// nothing useful.
-class StupidWatcher : public MessagePumpIOSForIO::FdWatcher {
- public:
- ~StupidWatcher() override {}
-
- // base:MessagePumpIOSForIO::FdWatcher interface
- void OnFileCanReadWithoutBlocking(int fd) override {}
- void OnFileCanWriteWithoutBlocking(int fd) override {}
-};
-
-class BaseWatcher : public MessagePumpIOSForIO::FdWatcher {
- public:
- BaseWatcher(MessagePumpIOSForIO::FdWatchController* controller)
- : controller_(controller) {
- DCHECK(controller_);
- }
- ~BaseWatcher() override {}
-
- // MessagePumpIOSForIO::FdWatcher interface
- void OnFileCanReadWithoutBlocking(int /* fd */) override { NOTREACHED(); }
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override { NOTREACHED(); }
-
- protected:
- MessagePumpIOSForIO::FdWatchController* controller_;
-};
-
-class DeleteWatcher : public BaseWatcher {
- public:
- explicit DeleteWatcher(MessagePumpIOSForIO::FdWatchController* controller)
- : BaseWatcher(controller) {}
-
- ~DeleteWatcher() override { DCHECK(!controller_); }
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override {
- DCHECK(controller_);
- delete controller_;
- controller_ = NULL;
- }
-};
-
-TEST_F(MessagePumpIOSForIOTest, DeleteWatcher) {
- std::unique_ptr<MessagePumpIOSForIO> pump(new MessagePumpIOSForIO);
- MessagePumpIOSForIO::FdWatchController* watcher =
- new MessagePumpIOSForIO::FdWatchController(FROM_HERE);
- DeleteWatcher delegate(watcher);
- pump->WatchFileDescriptor(pipefds_[1],
- false, MessagePumpIOSForIO::WATCH_READ_WRITE, watcher, &delegate);
-
- // Spoof a callback.
- HandleFdIOEvent(watcher);
-}
-
-class StopWatcher : public BaseWatcher {
- public:
- StopWatcher(MessagePumpIOSForIO::FdWatchController* controller,
- MessagePumpIOSForIO* pump,
- int fd_to_start_watching = -1)
- : BaseWatcher(controller),
- pump_(pump),
- fd_to_start_watching_(fd_to_start_watching) {}
-
- ~StopWatcher() override {}
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override {
- controller_->StopWatchingFileDescriptor();
- if (fd_to_start_watching_ >= 0) {
- pump_->WatchFileDescriptor(fd_to_start_watching_,
- false, MessagePumpIOSForIO::WATCH_READ_WRITE, controller_, this);
- }
- }
-
- private:
- MessagePumpIOSForIO* pump_;
- int fd_to_start_watching_;
-};
-
-TEST_F(MessagePumpIOSForIOTest, StopWatcher) {
- std::unique_ptr<MessagePumpIOSForIO> pump(new MessagePumpIOSForIO);
- MessagePumpIOSForIO::FdWatchController watcher(FROM_HERE);
- StopWatcher delegate(&watcher, pump.get());
- pump->WatchFileDescriptor(pipefds_[1],
- false, MessagePumpIOSForIO::WATCH_READ_WRITE, &watcher, &delegate);
-
- // Spoof a callback.
- HandleFdIOEvent(&watcher);
-}
-
-TEST_F(MessagePumpIOSForIOTest, StopWatcherAndWatchSomethingElse) {
- std::unique_ptr<MessagePumpIOSForIO> pump(new MessagePumpIOSForIO);
- MessagePumpIOSForIO::FdWatchController watcher(FROM_HERE);
- StopWatcher delegate(&watcher, pump.get(), alternate_pipefds_[1]);
- pump->WatchFileDescriptor(pipefds_[1],
- false, MessagePumpIOSForIO::WATCH_READ_WRITE, &watcher, &delegate);
-
- // Spoof a callback.
- HandleFdIOEvent(&watcher);
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/message_loop/message_pump_libevent_unittest.cc b/base/message_loop/message_pump_libevent_unittest.cc
deleted file mode 100644
index bb26c29..0000000
--- a/base/message_loop/message_pump_libevent_unittest.cc
+++ /dev/null
@@ -1,263 +0,0 @@
-// 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.
-
-#include "base/message_loop/message_pump_libevent.h"
-
-#include <unistd.h>
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/files/file_util.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/synchronization/waitable_event_watcher.h"
-#include "base/test/gtest_util.h"
-#include "base/third_party/libevent/event.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class MessagePumpLibeventTest : public testing::Test {
- protected:
- MessagePumpLibeventTest()
- : ui_loop_(new MessageLoop(MessageLoop::TYPE_UI)),
- io_thread_("MessagePumpLibeventTestIOThread") {}
- ~MessagePumpLibeventTest() override = default;
-
- void SetUp() override {
- Thread::Options options(MessageLoop::TYPE_IO, 0);
- ASSERT_TRUE(io_thread_.StartWithOptions(options));
- ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type());
- int ret = pipe(pipefds_);
- ASSERT_EQ(0, ret);
- }
-
- void TearDown() override {
- if (IGNORE_EINTR(close(pipefds_[0])) < 0)
- PLOG(ERROR) << "close";
- if (IGNORE_EINTR(close(pipefds_[1])) < 0)
- PLOG(ERROR) << "close";
- }
-
- void WaitUntilIoThreadStarted() {
- ASSERT_TRUE(io_thread_.WaitUntilThreadStarted());
- }
-
- scoped_refptr<SingleThreadTaskRunner> io_runner() const {
- return io_thread_.task_runner();
- }
-
- void OnLibeventNotification(
- MessagePumpLibevent* pump,
- MessagePumpLibevent::FdWatchController* controller) {
- pump->OnLibeventNotification(0, EV_WRITE | EV_READ, controller);
- }
-
- int pipefds_[2];
- std::unique_ptr<MessageLoop> ui_loop_;
-
- private:
- Thread io_thread_;
-};
-
-namespace {
-
-// Concrete implementation of MessagePumpLibevent::FdWatcher that does
-// nothing useful.
-class StupidWatcher : public MessagePumpLibevent::FdWatcher {
- public:
- ~StupidWatcher() override = default;
-
- // base:MessagePumpLibevent::FdWatcher interface
- void OnFileCanReadWithoutBlocking(int fd) override {}
- void OnFileCanWriteWithoutBlocking(int fd) override {}
-};
-
-TEST_F(MessagePumpLibeventTest, QuitOutsideOfRun) {
- std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
- ASSERT_DCHECK_DEATH(pump->Quit());
-}
-
-class BaseWatcher : public MessagePumpLibevent::FdWatcher {
- public:
- explicit BaseWatcher(MessagePumpLibevent::FdWatchController* controller)
- : controller_(controller) {
- DCHECK(controller_);
- }
- ~BaseWatcher() override = default;
-
- // base:MessagePumpLibevent::FdWatcher interface
- void OnFileCanReadWithoutBlocking(int /* fd */) override { NOTREACHED(); }
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override { NOTREACHED(); }
-
- protected:
- MessagePumpLibevent::FdWatchController* controller_;
-};
-
-class DeleteWatcher : public BaseWatcher {
- public:
- explicit DeleteWatcher(MessagePumpLibevent::FdWatchController* controller)
- : BaseWatcher(controller) {}
-
- ~DeleteWatcher() override { DCHECK(!controller_); }
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override {
- DCHECK(controller_);
- delete controller_;
- controller_ = nullptr;
- }
-};
-
-TEST_F(MessagePumpLibeventTest, DeleteWatcher) {
- std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
- MessagePumpLibevent::FdWatchController* watcher =
- new MessagePumpLibevent::FdWatchController(FROM_HERE);
- DeleteWatcher delegate(watcher);
- pump->WatchFileDescriptor(pipefds_[1],
- false, MessagePumpLibevent::WATCH_READ_WRITE, watcher, &delegate);
-
- // Spoof a libevent notification.
- OnLibeventNotification(pump.get(), watcher);
-}
-
-class StopWatcher : public BaseWatcher {
- public:
- explicit StopWatcher(MessagePumpLibevent::FdWatchController* controller)
- : BaseWatcher(controller) {}
-
- ~StopWatcher() override = default;
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override {
- controller_->StopWatchingFileDescriptor();
- }
-};
-
-TEST_F(MessagePumpLibeventTest, StopWatcher) {
- std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
- MessagePumpLibevent::FdWatchController watcher(FROM_HERE);
- StopWatcher delegate(&watcher);
- pump->WatchFileDescriptor(pipefds_[1],
- false, MessagePumpLibevent::WATCH_READ_WRITE, &watcher, &delegate);
-
- // Spoof a libevent notification.
- OnLibeventNotification(pump.get(), &watcher);
-}
-
-void QuitMessageLoopAndStart(const Closure& quit_closure) {
- quit_closure.Run();
-
- RunLoop runloop(RunLoop::Type::kNestableTasksAllowed);
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, runloop.QuitClosure());
- runloop.Run();
-}
-
-class NestedPumpWatcher : public MessagePumpLibevent::FdWatcher {
- public:
- NestedPumpWatcher() = default;
- ~NestedPumpWatcher() override = default;
-
- void OnFileCanReadWithoutBlocking(int /* fd */) override {
- RunLoop runloop;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&QuitMessageLoopAndStart, runloop.QuitClosure()));
- runloop.Run();
- }
-
- void OnFileCanWriteWithoutBlocking(int /* fd */) override {}
-};
-
-TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) {
- std::unique_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent);
- MessagePumpLibevent::FdWatchController watcher(FROM_HERE);
- NestedPumpWatcher delegate;
- pump->WatchFileDescriptor(pipefds_[1],
- false, MessagePumpLibevent::WATCH_READ, &watcher, &delegate);
-
- // Spoof a libevent notification.
- OnLibeventNotification(pump.get(), &watcher);
-}
-
-void FatalClosure() {
- FAIL() << "Reached fatal closure.";
-}
-
-class QuitWatcher : public BaseWatcher {
- public:
- QuitWatcher(MessagePumpLibevent::FdWatchController* controller,
- base::Closure quit_closure)
- : BaseWatcher(controller), quit_closure_(std::move(quit_closure)) {}
-
- void OnFileCanReadWithoutBlocking(int /* fd */) override {
- // Post a fatal closure to the MessageLoop before we quit it.
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, BindOnce(&FatalClosure));
-
- quit_closure_.Run();
- }
-
- private:
- base::Closure quit_closure_;
-};
-
-void WriteFDWrapper(const int fd,
- const char* buf,
- int size,
- WaitableEvent* event) {
- ASSERT_TRUE(WriteFileDescriptor(fd, buf, size));
-}
-
-// Tests that MessagePumpLibevent quits immediately when it is quit from
-// libevent's event_base_loop().
-TEST_F(MessagePumpLibeventTest, QuitWatcher) {
- // Delete the old MessageLoop so that we can manage our own one here.
- ui_loop_.reset();
-
- MessagePumpLibevent* pump = new MessagePumpLibevent; // owned by |loop|.
- MessageLoop loop(WrapUnique(pump));
- RunLoop run_loop;
- MessagePumpLibevent::FdWatchController controller(FROM_HERE);
- QuitWatcher delegate(&controller, run_loop.QuitClosure());
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- std::unique_ptr<WaitableEventWatcher> watcher(new WaitableEventWatcher);
-
- // Tell the pump to watch the pipe.
- pump->WatchFileDescriptor(pipefds_[0], false, MessagePumpLibevent::WATCH_READ,
- &controller, &delegate);
-
- // Make the IO thread wait for |event| before writing to pipefds[1].
- const char buf = 0;
- WaitableEventWatcher::EventCallback write_fd_task =
- BindOnce(&WriteFDWrapper, pipefds_[1], &buf, 1);
- io_runner()->PostTask(
- FROM_HERE, BindOnce(IgnoreResult(&WaitableEventWatcher::StartWatching),
- Unretained(watcher.get()), &event,
- std::move(write_fd_task), io_runner()));
-
- // Queue |event| to signal on |loop|.
- loop.task_runner()->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&event)));
-
- // Now run the MessageLoop.
- run_loop.Run();
-
- // StartWatching can move |watcher| to IO thread. Release on IO thread.
- io_runner()->PostTask(FROM_HERE, BindOnce(&WaitableEventWatcher::StopWatching,
- Owned(watcher.release())));
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/metrics/bucket_ranges_unittest.cc b/base/metrics/bucket_ranges_unittest.cc
deleted file mode 100644
index 481054c..0000000
--- a/base/metrics/bucket_ranges_unittest.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-// 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.
-
-#include "base/metrics/bucket_ranges.h"
-
-#include <stdint.h>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-TEST(BucketRangesTest, NormalSetup) {
- BucketRanges ranges(5);
- ASSERT_EQ(5u, ranges.size());
- ASSERT_EQ(4u, ranges.bucket_count());
-
- for (int i = 0; i < 5; ++i) {
- EXPECT_EQ(0, ranges.range(i));
- }
- EXPECT_EQ(0u, ranges.checksum());
-
- ranges.set_range(3, 100);
- EXPECT_EQ(100, ranges.range(3));
-}
-
-TEST(BucketRangesTest, Equals) {
- // Compare empty ranges.
- BucketRanges ranges1(3);
- BucketRanges ranges2(3);
- BucketRanges ranges3(5);
-
- EXPECT_TRUE(ranges1.Equals(&ranges2));
- EXPECT_FALSE(ranges1.Equals(&ranges3));
- EXPECT_FALSE(ranges2.Equals(&ranges3));
-
- // Compare full filled ranges.
- ranges1.set_range(0, 0);
- ranges1.set_range(1, 1);
- ranges1.set_range(2, 2);
- ranges1.set_checksum(100);
- ranges2.set_range(0, 0);
- ranges2.set_range(1, 1);
- ranges2.set_range(2, 2);
- ranges2.set_checksum(100);
-
- EXPECT_TRUE(ranges1.Equals(&ranges2));
-
- // Checksum does not match.
- ranges1.set_checksum(99);
- EXPECT_FALSE(ranges1.Equals(&ranges2));
- ranges1.set_checksum(100);
-
- // Range does not match.
- ranges1.set_range(1, 3);
- EXPECT_FALSE(ranges1.Equals(&ranges2));
-}
-
-TEST(BucketRangesTest, Checksum) {
- BucketRanges ranges(3);
- ranges.set_range(0, 0);
- ranges.set_range(1, 1);
- ranges.set_range(2, 2);
-
- ranges.ResetChecksum();
- EXPECT_EQ(289217253u, ranges.checksum());
-
- ranges.set_range(2, 3);
- EXPECT_FALSE(ranges.HasValidChecksum());
-
- ranges.ResetChecksum();
- EXPECT_EQ(2843835776u, ranges.checksum());
- EXPECT_TRUE(ranges.HasValidChecksum());
-}
-
-// Table was generated similarly to sample code for CRC-32 given on:
-// http://www.w3.org/TR/PNG/#D-CRCAppendix.
-TEST(BucketRangesTest, Crc32TableTest) {
- for (int i = 0; i < 256; ++i) {
- uint32_t checksum = i;
- for (int j = 0; j < 8; ++j) {
- const uint32_t kReversedPolynomial = 0xedb88320L;
- if (checksum & 1)
- checksum = kReversedPolynomial ^ (checksum >> 1);
- else
- checksum >>= 1;
- }
- EXPECT_EQ(kCrcTable[i], checksum);
- }
-}
-
-} // namespace
-} // namespace base
diff --git a/base/metrics/field_trial_params_unittest.cc b/base/metrics/field_trial_params_unittest.cc
deleted file mode 100644
index d310c0d..0000000
--- a/base/metrics/field_trial_params_unittest.cc
+++ /dev/null
@@ -1,458 +0,0 @@
-// Copyright 2017 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 "base/metrics/field_trial_params.h"
-
-#include "base/feature_list.h"
-#include "base/macros.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/field_trial_param_associator.h"
-#include "base/test/scoped_feature_list.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Call FieldTrialList::FactoryGetFieldTrial() with a future expiry date.
-scoped_refptr<FieldTrial> CreateFieldTrial(
- const std::string& trial_name,
- int total_probability,
- const std::string& default_group_name,
- int* default_group_number) {
- return FieldTrialList::FactoryGetFieldTrial(
- trial_name, total_probability, default_group_name,
- FieldTrialList::kNoExpirationYear, 1, 1, FieldTrial::SESSION_RANDOMIZED,
- default_group_number);
-}
-
-} // namespace
-
-class FieldTrialParamsTest : public ::testing::Test {
- public:
- FieldTrialParamsTest() : field_trial_list_(nullptr) {}
-
- ~FieldTrialParamsTest() override {
- // Ensure that the maps are cleared between tests, since they are stored as
- // process singletons.
- FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
- }
-
- void CreateFeatureWithTrial(const Feature& feature,
- FeatureList::OverrideState override_state,
- FieldTrial* trial) {
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->RegisterFieldTrialOverride(feature.name, override_state,
- trial);
- scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
- }
-
- private:
- FieldTrialList field_trial_list_;
- test::ScopedFeatureList scoped_feature_list_;
-
- DISALLOW_COPY_AND_ASSIGN(FieldTrialParamsTest);
-};
-
-TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams) {
- const std::string kTrialName = "AssociateFieldTrialParams";
-
- {
- std::map<std::string, std::string> params;
- params["a"] = "10";
- params["b"] = "test";
- ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params));
- }
- {
- std::map<std::string, std::string> params;
- params["a"] = "5";
- ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "B", params));
- }
-
- FieldTrialList::CreateFieldTrial(kTrialName, "B");
- EXPECT_EQ("5", GetFieldTrialParamValue(kTrialName, "a"));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b"));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
-
- std::map<std::string, std::string> params;
- EXPECT_TRUE(GetFieldTrialParams(kTrialName, ¶ms));
- EXPECT_EQ(1U, params.size());
- EXPECT_EQ("5", params["a"]);
-}
-
-TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_Fail) {
- const std::string kTrialName = "AssociateFieldTrialParams_Fail";
- const std::string kGroupName = "A";
-
- std::map<std::string, std::string> params;
- params["a"] = "10";
- ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, kGroupName, params));
- params["a"] = "1";
- params["b"] = "2";
- ASSERT_FALSE(AssociateFieldTrialParams(kTrialName, kGroupName, params));
-
- FieldTrialList::CreateFieldTrial(kTrialName, kGroupName);
- EXPECT_EQ("10", GetFieldTrialParamValue(kTrialName, "a"));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b"));
-}
-
-TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_TrialActiveFail) {
- const std::string kTrialName = "AssociateFieldTrialParams_TrialActiveFail";
- FieldTrialList::CreateFieldTrial(kTrialName, "A");
- ASSERT_EQ("A", FieldTrialList::FindFullName(kTrialName));
-
- std::map<std::string, std::string> params;
- params["a"] = "10";
- EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "B", params));
- EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "A", params));
-}
-
-TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_DoesntActivateTrial) {
- const std::string kTrialName =
- "AssociateFieldTrialParams_DoesntActivateTrial";
-
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
-
- std::map<std::string, std::string> params;
- params["a"] = "10";
- EXPECT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params));
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoTrial) {
- const std::string kTrialName = "GetFieldTrialParams_NoParams";
-
- std::map<std::string, std::string> params;
- EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y"));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoParams) {
- const std::string kTrialName = "GetFieldTrialParams_NoParams";
-
- FieldTrialList::CreateFieldTrial(kTrialName, "A");
-
- std::map<std::string, std::string> params;
- EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y"));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParams_ActivatesTrial) {
- const std::string kTrialName = "GetFieldTrialParams_ActivatesTrial";
-
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
-
- std::map<std::string, std::string> params;
- EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms));
- ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamValue_ActivatesTrial) {
- const std::string kTrialName = "GetFieldTrialParamValue_ActivatesTrial";
-
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
- ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
-
- std::map<std::string, std::string> params;
- EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
- ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
- const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
-
- std::map<std::string, std::string> params;
- params["x"] = "1";
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- std::map<std::string, std::string> actualParams;
- EXPECT_TRUE(GetFieldTrialParamsByFeature(kFeature, &actualParams));
- EXPECT_EQ(params, actualParams);
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
- const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
-
- std::map<std::string, std::string> params;
- params["x"] = "1";
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- std::map<std::string, std::string> actualParams;
- EXPECT_EQ(params["x"], GetFieldTrialParamValueByFeature(kFeature, "x"));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature_Disable) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
- const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
-
- std::map<std::string, std::string> params;
- params["x"] = "1";
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
- trial.get());
-
- std::map<std::string, std::string> actualParams;
- EXPECT_FALSE(GetFieldTrialParamsByFeature(kFeature, &actualParams));
-}
-
-TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature_Disable) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
- const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
-
- std::map<std::string, std::string> params;
- params["x"] = "1";
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
- trial.get());
-
- std::map<std::string, std::string> actualParams;
- EXPECT_EQ(std::string(), GetFieldTrialParamValueByFeature(kFeature, "x"));
-}
-
-TEST_F(FieldTrialParamsTest, FeatureParamString) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
-
- static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
- static const FeatureParam<std::string> a{&kFeature, "a", "default"};
- static const FeatureParam<std::string> b{&kFeature, "b", ""};
- static const FeatureParam<std::string> c{&kFeature, "c", "default"};
- static const FeatureParam<std::string> d{&kFeature, "d", ""};
- static const FeatureParam<std::string> e{&kFeature, "e", "default"};
- static const FeatureParam<std::string> f{&kFeature, "f", ""};
-
- std::map<std::string, std::string> params;
- params["a"] = "";
- params["b"] = "non-default";
- params["c"] = "non-default";
- params["d"] = "";
- // "e" is not registered
- // "f" is not registered
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- EXPECT_EQ("default", a.Get()); // empty
- EXPECT_EQ("non-default", b.Get());
- EXPECT_EQ("non-default", c.Get());
- EXPECT_EQ("", d.Get()); // empty
- EXPECT_EQ("default", e.Get()); // not registered
- EXPECT_EQ("", f.Get()); // not registered
-}
-
-TEST_F(FieldTrialParamsTest, FeatureParamInt) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
-
- static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
- static const FeatureParam<int> a{&kFeature, "a", 0};
- static const FeatureParam<int> b{&kFeature, "b", 0};
- static const FeatureParam<int> c{&kFeature, "c", 0};
- static const FeatureParam<int> d{&kFeature, "d", 0};
- static const FeatureParam<int> e{&kFeature, "e", 0};
-
- std::map<std::string, std::string> params;
- params["a"] = "1";
- params["b"] = "1.5";
- params["c"] = "foo";
- params["d"] = "";
- // "e" is not registered
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- EXPECT_EQ(1, GetFieldTrialParamByFeatureAsInt(kFeature, "a", 0));
- EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "b", 0)); // invalid
- EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "c", 0)); // invalid
- EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "d", 0)); // empty
- EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "e", 0)); // empty
-
- EXPECT_EQ(1, a.Get());
- EXPECT_EQ(0, b.Get()); // invalid
- EXPECT_EQ(0, c.Get()); // invalid
- EXPECT_EQ(0, d.Get()); // empty
- EXPECT_EQ(0, e.Get()); // empty
-}
-
-TEST_F(FieldTrialParamsTest, FeatureParamDouble) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
-
- static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
- static const FeatureParam<double> a{&kFeature, "a", 0.0};
- static const FeatureParam<double> b{&kFeature, "b", 0.0};
- static const FeatureParam<double> c{&kFeature, "c", 0.0};
- static const FeatureParam<double> d{&kFeature, "d", 0.0};
- static const FeatureParam<double> e{&kFeature, "e", 0.0};
- static const FeatureParam<double> f{&kFeature, "f", 0.0};
-
- std::map<std::string, std::string> params;
- params["a"] = "1";
- params["b"] = "1.5";
- params["c"] = "1.0e-10";
- params["d"] = "foo";
- params["e"] = "";
- // "f" is not registered
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- EXPECT_EQ(1, GetFieldTrialParamByFeatureAsDouble(kFeature, "a", 0));
- EXPECT_EQ(1.5, GetFieldTrialParamByFeatureAsDouble(kFeature, "b", 0));
- EXPECT_EQ(1.0e-10, GetFieldTrialParamByFeatureAsDouble(kFeature, "c", 0));
- EXPECT_EQ(0,
- GetFieldTrialParamByFeatureAsDouble(kFeature, "d", 0)); // invalid
- EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "e", 0)); // empty
- EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "f", 0)); // empty
-
- EXPECT_EQ(1, a.Get());
- EXPECT_EQ(1.5, b.Get());
- EXPECT_EQ(1.0e-10, c.Get());
- EXPECT_EQ(0, d.Get()); // invalid
- EXPECT_EQ(0, e.Get()); // empty
- EXPECT_EQ(0, f.Get()); // empty
-}
-
-TEST_F(FieldTrialParamsTest, FeatureParamBool) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
-
- static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
- static const FeatureParam<bool> a{&kFeature, "a", false};
- static const FeatureParam<bool> b{&kFeature, "b", true};
- static const FeatureParam<bool> c{&kFeature, "c", false};
- static const FeatureParam<bool> d{&kFeature, "d", true};
- static const FeatureParam<bool> e{&kFeature, "e", true};
- static const FeatureParam<bool> f{&kFeature, "f", true};
-
- std::map<std::string, std::string> params;
- params["a"] = "true";
- params["b"] = "false";
- params["c"] = "1";
- params["d"] = "False";
- params["e"] = "";
- // "f" is not registered
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- EXPECT_TRUE(a.Get());
- EXPECT_FALSE(b.Get());
- EXPECT_FALSE(c.Get()); // invalid
- EXPECT_TRUE(d.Get()); // invalid
- EXPECT_TRUE(e.Get()); // empty
- EXPECT_TRUE(f.Get()); // empty
-}
-
-enum Hand { ROCK, PAPER, SCISSORS };
-
-TEST_F(FieldTrialParamsTest, FeatureParamEnum) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
-
- static const FeatureParam<Hand>::Option hands[] = {
- {ROCK, "rock"}, {PAPER, "paper"}, {SCISSORS, "scissors"}};
- static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
- static const FeatureParam<Hand> a{&kFeature, "a", ROCK, &hands};
- static const FeatureParam<Hand> b{&kFeature, "b", ROCK, &hands};
- static const FeatureParam<Hand> c{&kFeature, "c", ROCK, &hands};
- static const FeatureParam<Hand> d{&kFeature, "d", ROCK, &hands};
- static const FeatureParam<Hand> e{&kFeature, "e", PAPER, &hands};
- static const FeatureParam<Hand> f{&kFeature, "f", SCISSORS, &hands};
-
- std::map<std::string, std::string> params;
- params["a"] = "rock";
- params["b"] = "paper";
- params["c"] = "scissors";
- params["d"] = "lizard";
- params["e"] = "";
- // "f" is not registered
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- EXPECT_EQ(ROCK, a.Get());
- EXPECT_EQ(PAPER, b.Get());
- EXPECT_EQ(SCISSORS, c.Get());
- EXPECT_EQ(ROCK, d.Get()); // invalid
- EXPECT_EQ(PAPER, e.Get()); // invalid/empty
- EXPECT_EQ(SCISSORS, f.Get()); // not registered
-}
-
-enum class UI { ONE_D, TWO_D, THREE_D };
-
-TEST_F(FieldTrialParamsTest, FeatureParamEnumClass) {
- const std::string kTrialName = "GetFieldTrialParamsByFeature";
-
- static const FeatureParam<UI>::Option uis[] = {
- {UI::ONE_D, "1d"}, {UI::TWO_D, "2d"}, {UI::THREE_D, "3d"}};
- static const Feature kFeature{"TestFeature", FEATURE_DISABLED_BY_DEFAULT};
- static const FeatureParam<UI> a{&kFeature, "a", UI::ONE_D, &uis};
- static const FeatureParam<UI> b{&kFeature, "b", UI::ONE_D, &uis};
- static const FeatureParam<UI> c{&kFeature, "c", UI::ONE_D, &uis};
- static const FeatureParam<UI> d{&kFeature, "d", UI::ONE_D, &uis};
- static const FeatureParam<UI> e{&kFeature, "e", UI::TWO_D, &uis};
- static const FeatureParam<UI> f{&kFeature, "f", UI::THREE_D, &uis};
-
- std::map<std::string, std::string> params;
- params["a"] = "1d";
- params["b"] = "2d";
- params["c"] = "3d";
- params["d"] = "4d";
- params["e"] = "";
- // "f" is not registered
- AssociateFieldTrialParams(kTrialName, "A", params);
- scoped_refptr<FieldTrial> trial(
- CreateFieldTrial(kTrialName, 100, "A", nullptr));
-
- CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
- trial.get());
-
- EXPECT_EQ(UI::ONE_D, a.Get());
- EXPECT_EQ(UI::TWO_D, b.Get());
- EXPECT_EQ(UI::THREE_D, c.Get());
- EXPECT_EQ(UI::ONE_D, d.Get()); // invalid
- EXPECT_EQ(UI::TWO_D, e.Get()); // invalid/empty
- EXPECT_EQ(UI::THREE_D, f.Get()); // not registered
-}
-
-} // namespace base
diff --git a/base/metrics/field_trial_params_unittest.nc b/base/metrics/field_trial_params_unittest.nc
deleted file mode 100644
index 4c6005e..0000000
--- a/base/metrics/field_trial_params_unittest.nc
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2017 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/feature_list.h"
-#include "base/metrics/field_trial_params.h"
-
-constexpr base::Feature kFeature{"NoCompileFeature"};
-
-enum Param { FOO, BAR };
-
-#if defined(NCTEST_NO_PARAM_TYPE) // [r"too few template arguments"]
-
-constexpr base::FeatureParam<> kParam{
- &kFeature, "Param"};
-
-#elif defined(NCTEST_VOID_PARAM_TYPE) // [r"unsupported FeatureParam<> type"]
-
-constexpr base::FeatureParam<void> kParam{
- &kFeature, "Param"};
-
-#elif defined(NCTEST_INVALID_PARAM_TYPE) // [r"unsupported FeatureParam<> type"]
-
-constexpr base::FeatureParam<size_t> kParam{
- &kFeature, "Param", 1u};
-
-#elif defined(NCTEST_ENUM_NULL_OPTIONS) // [r"candidate template ignored: could not match"]
-
-constexpr base::FeatureParam<Param> kParam{
- &kFeature, "Param", FOO, nullptr};
-
-#elif defined(NCTEST_ENUM_EMPTY_OPTIONS) // [r"zero-length arrays are not permitted"]
-
-constexpr base::FeatureParam<Param>::Option kParamOptions[] = {};
-constexpr base::FeatureParam<Param> kParam{
- &kFeature, "Param", FOO, &kParamOptions};
-
-#else
-
-void suppress_unused_variable_warning() {
- (void)kFeature;
-}
-
-#endif
diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc
deleted file mode 100644
index 4d55697..0000000
--- a/base/metrics/field_trial_unittest.cc
+++ /dev/null
@@ -1,1400 +0,0 @@
-// 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.
-
-#include "base/metrics/field_trial.h"
-
-#include <stddef.h>
-
-#include "base/base_switches.h"
-#include "base/feature_list.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/metrics/field_trial_param_associator.h"
-#include "base/rand_util.h"
-#include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/stringprintf.h"
-#include "base/test/gtest_util.h"
-#include "base/test/mock_entropy_provider.h"
-#include "base/test/scoped_feature_list.h"
-#include "base/test/test_shared_memory_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Default group name used by several tests.
-const char kDefaultGroupName[] = "DefaultGroup";
-
-// Call FieldTrialList::FactoryGetFieldTrial() with a future expiry date.
-scoped_refptr<FieldTrial> CreateFieldTrial(
- const std::string& trial_name,
- int total_probability,
- const std::string& default_group_name,
- int* default_group_number) {
- return FieldTrialList::FactoryGetFieldTrial(
- trial_name, total_probability, default_group_name,
- FieldTrialList::kNoExpirationYear, 1, 1, FieldTrial::SESSION_RANDOMIZED,
- default_group_number);
-}
-
-// FieldTrialList::Observer implementation for testing.
-class TestFieldTrialObserver : public FieldTrialList::Observer {
- public:
- enum Type {
- ASYNCHRONOUS,
- SYNCHRONOUS,
- };
-
- TestFieldTrialObserver(Type type) : type_(type) {
- if (type == SYNCHRONOUS)
- FieldTrialList::SetSynchronousObserver(this);
- else
- FieldTrialList::AddObserver(this);
- }
-
- ~TestFieldTrialObserver() override {
- if (type_ == SYNCHRONOUS)
- FieldTrialList::RemoveSynchronousObserver(this);
- else
- FieldTrialList::RemoveObserver(this);
- }
-
- void OnFieldTrialGroupFinalized(const std::string& trial,
- const std::string& group) override {
- trial_name_ = trial;
- group_name_ = group;
- }
-
- const std::string& trial_name() const { return trial_name_; }
- const std::string& group_name() const { return group_name_; }
-
- private:
- const Type type_;
- std::string trial_name_;
- std::string group_name_;
-
- DISALLOW_COPY_AND_ASSIGN(TestFieldTrialObserver);
-};
-
-std::string MockEscapeQueryParamValue(const std::string& input) {
- return input;
-}
-
-} // namespace
-
-class FieldTrialTest : public ::testing::Test {
- public:
- FieldTrialTest() : trial_list_(nullptr) {}
-
- private:
- MessageLoop message_loop_;
- FieldTrialList trial_list_;
-
- DISALLOW_COPY_AND_ASSIGN(FieldTrialTest);
-};
-
-// Test registration, and also check that destructors are called for trials.
-TEST_F(FieldTrialTest, Registration) {
- const char name1[] = "name 1 test";
- const char name2[] = "name 2 test";
- EXPECT_FALSE(FieldTrialList::Find(name1));
- EXPECT_FALSE(FieldTrialList::Find(name2));
-
- scoped_refptr<FieldTrial> trial1 =
- CreateFieldTrial(name1, 10, "default name 1 test", nullptr);
- EXPECT_EQ(FieldTrial::kNotFinalized, trial1->group_);
- EXPECT_EQ(name1, trial1->trial_name());
- EXPECT_EQ("", trial1->group_name_internal());
-
- trial1->AppendGroup(std::string(), 7);
-
- EXPECT_EQ(trial1.get(), FieldTrialList::Find(name1));
- EXPECT_FALSE(FieldTrialList::Find(name2));
-
- scoped_refptr<FieldTrial> trial2 =
- CreateFieldTrial(name2, 10, "default name 2 test", nullptr);
- EXPECT_EQ(FieldTrial::kNotFinalized, trial2->group_);
- EXPECT_EQ(name2, trial2->trial_name());
- EXPECT_EQ("", trial2->group_name_internal());
-
- trial2->AppendGroup("a first group", 7);
-
- EXPECT_EQ(trial1.get(), FieldTrialList::Find(name1));
- EXPECT_EQ(trial2.get(), FieldTrialList::Find(name2));
- // Note: FieldTrialList should delete the objects at shutdown.
-}
-
-TEST_F(FieldTrialTest, AbsoluteProbabilities) {
- char always_true[] = " always true";
- char default_always_true[] = " default always true";
- char always_false[] = " always false";
- char default_always_false[] = " default always false";
- for (int i = 1; i < 250; ++i) {
- // Try lots of names, by changing the first character of the name.
- char c = static_cast<char>(i);
- always_true[0] = c;
- default_always_true[0] = c;
- always_false[0] = c;
- default_always_false[0] = c;
-
- scoped_refptr<FieldTrial> trial_true =
- CreateFieldTrial(always_true, 10, default_always_true, nullptr);
- const std::string winner = "TheWinner";
- int winner_group = trial_true->AppendGroup(winner, 10);
-
- EXPECT_EQ(winner_group, trial_true->group());
- EXPECT_EQ(winner, trial_true->group_name());
-
- scoped_refptr<FieldTrial> trial_false =
- CreateFieldTrial(always_false, 10, default_always_false, nullptr);
- int loser_group = trial_false->AppendGroup("ALoser", 0);
-
- EXPECT_NE(loser_group, trial_false->group());
- }
-}
-
-TEST_F(FieldTrialTest, RemainingProbability) {
- // First create a test that hasn't had a winner yet.
- const std::string winner = "Winner";
- const std::string loser = "Loser";
- scoped_refptr<FieldTrial> trial;
- int counter = 0;
- int default_group_number = -1;
- do {
- std::string name = StringPrintf("trial%d", ++counter);
- trial = CreateFieldTrial(name, 10, winner, &default_group_number);
- trial->AppendGroup(loser, 5); // 50% chance of not being chosen.
- // If a group is not assigned, group_ will be kNotFinalized.
- } while (trial->group_ != FieldTrial::kNotFinalized);
-
- // And that 'default' group (winner) should always win.
- EXPECT_EQ(default_group_number, trial->group());
-
- // And that winner should ALWAYS win.
- EXPECT_EQ(winner, trial->group_name());
-}
-
-TEST_F(FieldTrialTest, FiftyFiftyProbability) {
- // Check that even with small divisors, we have the proper probabilities, and
- // all outcomes are possible. Since this is a 50-50 test, it should get both
- // outcomes in a few tries, but we'll try no more than 100 times (and be flaky
- // with probability around 1 in 2^99).
- bool first_winner = false;
- bool second_winner = false;
- int counter = 0;
- do {
- std::string name = StringPrintf("FiftyFifty%d", ++counter);
- std::string default_group_name =
- StringPrintf("Default FiftyFifty%d", ++counter);
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(name, 2, default_group_name, nullptr);
- trial->AppendGroup("first", 1); // 50% chance of being chosen.
- // If group_ is kNotFinalized, then a group assignement hasn't been done.
- if (trial->group_ != FieldTrial::kNotFinalized) {
- first_winner = true;
- continue;
- }
- trial->AppendGroup("second", 1); // Always chosen at this point.
- EXPECT_NE(FieldTrial::kNotFinalized, trial->group());
- second_winner = true;
- } while ((!second_winner || !first_winner) && counter < 100);
- EXPECT_TRUE(second_winner);
- EXPECT_TRUE(first_winner);
-}
-
-TEST_F(FieldTrialTest, MiddleProbabilities) {
- char name[] = " same name";
- char default_group_name[] = " default same name";
- bool false_event_seen = false;
- bool true_event_seen = false;
- for (int i = 1; i < 250; ++i) {
- char c = static_cast<char>(i);
- name[0] = c;
- default_group_name[0] = c;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(name, 10, default_group_name, nullptr);
- int might_win = trial->AppendGroup("MightWin", 5);
-
- if (trial->group() == might_win) {
- true_event_seen = true;
- } else {
- false_event_seen = true;
- }
- if (false_event_seen && true_event_seen)
- return; // Successful test!!!
- }
- // Very surprising to get here. Probability should be around 1 in 2 ** 250.
- // One of the following will fail.
- EXPECT_TRUE(false_event_seen);
- EXPECT_TRUE(true_event_seen);
-}
-
-TEST_F(FieldTrialTest, OneWinner) {
- char name[] = "Some name";
- char default_group_name[] = "Default some name";
- int group_count(10);
-
- int default_group_number = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(name, group_count, default_group_name, nullptr);
- int winner_index(-2);
- std::string winner_name;
-
- for (int i = 1; i <= group_count; ++i) {
- int might_win = trial->AppendGroup(std::string(), 1);
-
- // Because we keep appending groups, we want to see if the last group that
- // was added has been assigned or not.
- if (trial->group_ == might_win) {
- EXPECT_EQ(-2, winner_index);
- winner_index = might_win;
- StringAppendF(&winner_name, "%d", might_win);
- EXPECT_EQ(winner_name, trial->group_name());
- }
- }
- EXPECT_GE(winner_index, 0);
- // Since all groups cover the total probability, we should not have
- // chosen the default group.
- EXPECT_NE(trial->group(), default_group_number);
- EXPECT_EQ(trial->group(), winner_index);
- EXPECT_EQ(trial->group_name(), winner_name);
-}
-
-TEST_F(FieldTrialTest, ActiveGroups) {
- std::string no_group("No Group");
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(no_group, 10, "Default", nullptr);
-
- // There is no winner yet, so no NameGroupId should be returned.
- FieldTrial::ActiveGroup active_group;
- EXPECT_FALSE(trial->GetActiveGroup(&active_group));
-
- // Create a single winning group.
- std::string one_winner("One Winner");
- trial = CreateFieldTrial(one_winner, 10, "Default", nullptr);
- std::string winner("Winner");
- trial->AppendGroup(winner, 10);
- EXPECT_FALSE(trial->GetActiveGroup(&active_group));
- // Finalize the group selection by accessing the selected group.
- trial->group();
- EXPECT_TRUE(trial->GetActiveGroup(&active_group));
- EXPECT_EQ(one_winner, active_group.trial_name);
- EXPECT_EQ(winner, active_group.group_name);
-
- std::string multi_group("MultiGroup");
- scoped_refptr<FieldTrial> multi_group_trial =
- CreateFieldTrial(multi_group, 9, "Default", nullptr);
-
- multi_group_trial->AppendGroup("Me", 3);
- multi_group_trial->AppendGroup("You", 3);
- multi_group_trial->AppendGroup("Them", 3);
- EXPECT_FALSE(multi_group_trial->GetActiveGroup(&active_group));
- // Finalize the group selection by accessing the selected group.
- multi_group_trial->group();
- EXPECT_TRUE(multi_group_trial->GetActiveGroup(&active_group));
- EXPECT_EQ(multi_group, active_group.trial_name);
- EXPECT_EQ(multi_group_trial->group_name(), active_group.group_name);
-
- // Now check if the list is built properly...
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_EQ(2U, active_groups.size());
- for (size_t i = 0; i < active_groups.size(); ++i) {
- // Order is not guaranteed, so check all values.
- EXPECT_NE(no_group, active_groups[i].trial_name);
- EXPECT_TRUE(one_winner != active_groups[i].trial_name ||
- winner == active_groups[i].group_name);
- EXPECT_TRUE(multi_group != active_groups[i].trial_name ||
- multi_group_trial->group_name() == active_groups[i].group_name);
- }
-}
-
-TEST_F(FieldTrialTest, GetActiveFieldTrialGroupsFromString) {
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroupsFromString("*A/X/B/Y/*C/Z",
- &active_groups);
- ASSERT_EQ(2U, active_groups.size());
- EXPECT_EQ("A", active_groups[0].trial_name);
- EXPECT_EQ("X", active_groups[0].group_name);
- EXPECT_EQ("C", active_groups[1].trial_name);
- EXPECT_EQ("Z", active_groups[1].group_name);
-}
-
-TEST_F(FieldTrialTest, ActiveGroupsNotFinalized) {
- const char kTrialName[] = "TestTrial";
- const char kSecondaryGroupName[] = "SecondaryGroup";
-
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
-
- // Before |group()| is called, |GetActiveGroup()| should return false.
- FieldTrial::ActiveGroup active_group;
- EXPECT_FALSE(trial->GetActiveGroup(&active_group));
-
- // |GetActiveFieldTrialGroups()| should also not include the trial.
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_TRUE(active_groups.empty());
-
- // After |group()| has been called, both APIs should succeed.
- const int chosen_group = trial->group();
- EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
-
- EXPECT_TRUE(trial->GetActiveGroup(&active_group));
- EXPECT_EQ(kTrialName, active_group.trial_name);
- if (chosen_group == default_group)
- EXPECT_EQ(kDefaultGroupName, active_group.group_name);
- else
- EXPECT_EQ(kSecondaryGroupName, active_group.group_name);
-
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- ASSERT_EQ(1U, active_groups.size());
- EXPECT_EQ(kTrialName, active_groups[0].trial_name);
- EXPECT_EQ(active_group.group_name, active_groups[0].group_name);
-}
-
-TEST_F(FieldTrialTest, GetGroupNameWithoutActivation) {
- const char kTrialName[] = "TestTrial";
- const char kSecondaryGroupName[] = "SecondaryGroup";
-
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- trial->AppendGroup(kSecondaryGroupName, 50);
-
- // The trial should start inactive.
- EXPECT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
-
- // Calling |GetGroupNameWithoutActivation()| should not activate the trial.
- std::string group_name = trial->GetGroupNameWithoutActivation();
- EXPECT_FALSE(group_name.empty());
- EXPECT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
-
- // Calling |group_name()| should activate it and return the same group name.
- EXPECT_EQ(group_name, trial->group_name());
- EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
-}
-
-TEST_F(FieldTrialTest, Save) {
- std::string save_string;
-
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial("Some name", 10, "Default some name", nullptr);
- // There is no winner yet, so no textual group name is associated with trial.
- // In this case, the trial should not be included.
- EXPECT_EQ("", trial->group_name_internal());
- FieldTrialList::StatesToString(&save_string);
- EXPECT_EQ("", save_string);
- save_string.clear();
-
- // Create a winning group.
- trial->AppendGroup("Winner", 10);
- // Finalize the group selection by accessing the selected group.
- trial->group();
- FieldTrialList::StatesToString(&save_string);
- EXPECT_EQ("Some name/Winner/", save_string);
- save_string.clear();
-
- // Create a second trial and winning group.
- scoped_refptr<FieldTrial> trial2 =
- CreateFieldTrial("xxx", 10, "Default xxx", nullptr);
- trial2->AppendGroup("yyyy", 10);
- // Finalize the group selection by accessing the selected group.
- trial2->group();
-
- FieldTrialList::StatesToString(&save_string);
- // We assume names are alphabetized... though this is not critical.
- EXPECT_EQ("Some name/Winner/xxx/yyyy/", save_string);
- save_string.clear();
-
- // Create a third trial with only the default group.
- scoped_refptr<FieldTrial> trial3 =
- CreateFieldTrial("zzz", 10, "default", nullptr);
- // Finalize the group selection by accessing the selected group.
- trial3->group();
-
- FieldTrialList::StatesToString(&save_string);
- EXPECT_EQ("Some name/Winner/xxx/yyyy/zzz/default/", save_string);
-}
-
-TEST_F(FieldTrialTest, Restore) {
- ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
- ASSERT_FALSE(FieldTrialList::TrialExists("xxx"));
-
- FieldTrialList::CreateTrialsFromString("Some_name/Winner/xxx/yyyy/",
- std::set<std::string>());
-
- FieldTrial* trial = FieldTrialList::Find("Some_name");
- ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
- EXPECT_EQ("Winner", trial->group_name());
- EXPECT_EQ("Some_name", trial->trial_name());
-
- trial = FieldTrialList::Find("xxx");
- ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
- EXPECT_EQ("yyyy", trial->group_name());
- EXPECT_EQ("xxx", trial->trial_name());
-}
-
-TEST_F(FieldTrialTest, RestoreNotEndingWithSlash) {
- EXPECT_TRUE(FieldTrialList::CreateTrialsFromString("tname/gname",
- std::set<std::string>()));
-
- FieldTrial* trial = FieldTrialList::Find("tname");
- ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
- EXPECT_EQ("gname", trial->group_name());
- EXPECT_EQ("tname", trial->trial_name());
-}
-
-TEST_F(FieldTrialTest, BogusRestore) {
- EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("MissingSlash",
- std::set<std::string>()));
- EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("MissingGroupName/",
- std::set<std::string>()));
- EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("noname, only group/",
- std::set<std::string>()));
- EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("/emptyname",
- std::set<std::string>()));
- EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("*/emptyname",
- std::set<std::string>()));
-}
-
-TEST_F(FieldTrialTest, DuplicateRestore) {
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial("Some name", 10, "Default", nullptr);
- trial->AppendGroup("Winner", 10);
- // Finalize the group selection by accessing the selected group.
- trial->group();
- std::string save_string;
- FieldTrialList::StatesToString(&save_string);
- EXPECT_EQ("Some name/Winner/", save_string);
-
- // It is OK if we redundantly specify a winner.
- EXPECT_TRUE(FieldTrialList::CreateTrialsFromString(save_string,
- std::set<std::string>()));
-
- // But it is an error to try to change to a different winner.
- EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("Some name/Loser/",
- std::set<std::string>()));
-}
-
-TEST_F(FieldTrialTest, CreateTrialsFromStringNotActive) {
- ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
- ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
- ASSERT_TRUE(FieldTrialList::CreateTrialsFromString("Abc/def/Xyz/zyx/",
- std::set<std::string>()));
-
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- ASSERT_TRUE(active_groups.empty());
-
- // Check that the values still get returned and querying them activates them.
- EXPECT_EQ("def", FieldTrialList::FindFullName("Abc"));
- EXPECT_EQ("zyx", FieldTrialList::FindFullName("Xyz"));
-
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- ASSERT_EQ(2U, active_groups.size());
- EXPECT_EQ("Abc", active_groups[0].trial_name);
- EXPECT_EQ("def", active_groups[0].group_name);
- EXPECT_EQ("Xyz", active_groups[1].trial_name);
- EXPECT_EQ("zyx", active_groups[1].group_name);
-}
-
-TEST_F(FieldTrialTest, CreateTrialsFromStringForceActivation) {
- ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
- ASSERT_FALSE(FieldTrialList::TrialExists("def"));
- ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
- ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
- "*Abc/cba/def/fed/*Xyz/zyx/", std::set<std::string>()));
-
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- ASSERT_EQ(2U, active_groups.size());
- EXPECT_EQ("Abc", active_groups[0].trial_name);
- EXPECT_EQ("cba", active_groups[0].group_name);
- EXPECT_EQ("Xyz", active_groups[1].trial_name);
- EXPECT_EQ("zyx", active_groups[1].group_name);
-}
-
-TEST_F(FieldTrialTest, CreateTrialsFromStringNotActiveObserver) {
- ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
-
- TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
- ASSERT_TRUE(FieldTrialList::CreateTrialsFromString("Abc/def/",
- std::set<std::string>()));
- RunLoop().RunUntilIdle();
- // Observer shouldn't be notified.
- EXPECT_TRUE(observer.trial_name().empty());
-
- // Check that the values still get returned and querying them activates them.
- EXPECT_EQ("def", FieldTrialList::FindFullName("Abc"));
-
- RunLoop().RunUntilIdle();
- EXPECT_EQ("Abc", observer.trial_name());
- EXPECT_EQ("def", observer.group_name());
-}
-
-TEST_F(FieldTrialTest, CreateTrialsFromStringWithIgnoredFieldTrials) {
- ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
- ASSERT_FALSE(FieldTrialList::TrialExists("Foo"));
- ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
- ASSERT_FALSE(FieldTrialList::TrialExists("Bar"));
- ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
-
- std::set<std::string> ignored_trial_names;
- ignored_trial_names.insert("Unaccepted1");
- ignored_trial_names.insert("Unaccepted2");
- ignored_trial_names.insert("Unaccepted3");
-
- FieldTrialList::CreateTrialsFromString(
- "Unaccepted1/Unaccepted1_name/"
- "Foo/Foo_name/"
- "Unaccepted2/Unaccepted2_name/"
- "Bar/Bar_name/"
- "Unaccepted3/Unaccepted3_name/",
- ignored_trial_names);
-
- EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
- EXPECT_TRUE(FieldTrialList::TrialExists("Foo"));
- EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
- EXPECT_TRUE(FieldTrialList::TrialExists("Bar"));
- EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
-
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_TRUE(active_groups.empty());
-
- FieldTrial* trial = FieldTrialList::Find("Foo");
- ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
- EXPECT_EQ("Foo", trial->trial_name());
- EXPECT_EQ("Foo_name", trial->group_name());
-
- trial = FieldTrialList::Find("Bar");
- ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
- EXPECT_EQ("Bar", trial->trial_name());
- EXPECT_EQ("Bar_name", trial->group_name());
-}
-
-TEST_F(FieldTrialTest, CreateFieldTrial) {
- ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
-
- FieldTrialList::CreateFieldTrial("Some_name", "Winner");
-
- FieldTrial* trial = FieldTrialList::Find("Some_name");
- ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
- EXPECT_EQ("Winner", trial->group_name());
- EXPECT_EQ("Some_name", trial->trial_name());
-}
-
-TEST_F(FieldTrialTest, CreateFieldTrialIsNotActive) {
- const char kTrialName[] = "CreateFieldTrialIsActiveTrial";
- const char kWinnerGroup[] = "Winner";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
- FieldTrialList::CreateFieldTrial(kTrialName, kWinnerGroup);
-
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_TRUE(active_groups.empty());
-}
-
-TEST_F(FieldTrialTest, DuplicateFieldTrial) {
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial("Some_name", 10, "Default", nullptr);
- trial->AppendGroup("Winner", 10);
-
- // It is OK if we redundantly specify a winner.
- FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("Some_name", "Winner");
- EXPECT_TRUE(trial1 != nullptr);
-
- // But it is an error to try to change to a different winner.
- FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("Some_name", "Loser");
- EXPECT_TRUE(trial2 == nullptr);
-}
-
-TEST_F(FieldTrialTest, DisableImmediately) {
- int default_group_number = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial("trial", 100, "default", &default_group_number);
- trial->Disable();
- ASSERT_EQ("default", trial->group_name());
- ASSERT_EQ(default_group_number, trial->group());
-}
-
-TEST_F(FieldTrialTest, DisableAfterInitialization) {
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial("trial", 100, "default", nullptr);
- trial->AppendGroup("non_default", 100);
- trial->Disable();
- ASSERT_EQ("default", trial->group_name());
-}
-
-TEST_F(FieldTrialTest, ForcedFieldTrials) {
- // Validate we keep the forced choice.
- FieldTrial* forced_trial = FieldTrialList::CreateFieldTrial("Use the",
- "Force");
- EXPECT_STREQ("Force", forced_trial->group_name().c_str());
-
- int default_group_number = -1;
- scoped_refptr<FieldTrial> factory_trial =
- CreateFieldTrial("Use the", 1000, "default", &default_group_number);
- EXPECT_EQ(factory_trial.get(), forced_trial);
-
- int chosen_group = factory_trial->AppendGroup("Force", 100);
- EXPECT_EQ(chosen_group, factory_trial->group());
- int not_chosen_group = factory_trial->AppendGroup("Dark Side", 100);
- EXPECT_NE(chosen_group, not_chosen_group);
-
- // Since we didn't force the default group, we should not be returned the
- // chosen group as the default group.
- EXPECT_NE(default_group_number, chosen_group);
- int new_group = factory_trial->AppendGroup("Duck Tape", 800);
- EXPECT_NE(chosen_group, new_group);
- // The new group should not be the default group either.
- EXPECT_NE(default_group_number, new_group);
-}
-
-TEST_F(FieldTrialTest, ForcedFieldTrialsDefaultGroup) {
- // Forcing the default should use the proper group ID.
- FieldTrial* forced_trial = FieldTrialList::CreateFieldTrial("Trial Name",
- "Default");
- int default_group_number = -1;
- scoped_refptr<FieldTrial> factory_trial =
- CreateFieldTrial("Trial Name", 1000, "Default", &default_group_number);
- EXPECT_EQ(forced_trial, factory_trial.get());
-
- int other_group = factory_trial->AppendGroup("Not Default", 100);
- EXPECT_STREQ("Default", factory_trial->group_name().c_str());
- EXPECT_EQ(default_group_number, factory_trial->group());
- EXPECT_NE(other_group, factory_trial->group());
-
- int new_other_group = factory_trial->AppendGroup("Not Default Either", 800);
- EXPECT_NE(new_other_group, factory_trial->group());
-}
-
-TEST_F(FieldTrialTest, SetForced) {
- // Start by setting a trial for which we ensure a winner...
- int default_group_number = -1;
- scoped_refptr<FieldTrial> forced_trial =
- CreateFieldTrial("Use the", 1, "default", &default_group_number);
- EXPECT_EQ(forced_trial, forced_trial);
-
- int forced_group = forced_trial->AppendGroup("Force", 1);
- EXPECT_EQ(forced_group, forced_trial->group());
-
- // Now force it.
- forced_trial->SetForced();
-
- // Now try to set it up differently as a hard coded registration would.
- scoped_refptr<FieldTrial> hard_coded_trial =
- CreateFieldTrial("Use the", 1, "default", &default_group_number);
- EXPECT_EQ(hard_coded_trial, forced_trial);
-
- int would_lose_group = hard_coded_trial->AppendGroup("Force", 0);
- EXPECT_EQ(forced_group, hard_coded_trial->group());
- EXPECT_EQ(forced_group, would_lose_group);
-
- // Same thing if we would have done it to win again.
- scoped_refptr<FieldTrial> other_hard_coded_trial =
- CreateFieldTrial("Use the", 1, "default", &default_group_number);
- EXPECT_EQ(other_hard_coded_trial, forced_trial);
-
- int would_win_group = other_hard_coded_trial->AppendGroup("Force", 1);
- EXPECT_EQ(forced_group, other_hard_coded_trial->group());
- EXPECT_EQ(forced_group, would_win_group);
-}
-
-TEST_F(FieldTrialTest, SetForcedDefaultOnly) {
- const char kTrialName[] = "SetForcedDefaultOnly";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- trial->SetForced();
-
- trial = CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
- EXPECT_EQ(default_group, trial->group());
- EXPECT_EQ(kDefaultGroupName, trial->group_name());
-}
-
-TEST_F(FieldTrialTest, SetForcedDefaultWithExtraGroup) {
- const char kTrialName[] = "SetForcedDefaultWithExtraGroup";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- trial->SetForced();
-
- trial = CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
- const int extra_group = trial->AppendGroup("Extra", 100);
- EXPECT_EQ(default_group, trial->group());
- EXPECT_NE(extra_group, trial->group());
- EXPECT_EQ(kDefaultGroupName, trial->group_name());
-}
-
-TEST_F(FieldTrialTest, SetForcedTurnFeatureOn) {
- const char kTrialName[] = "SetForcedTurnFeatureOn";
- const char kExtraGroupName[] = "Extra";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- // Simulate a server-side (forced) config that turns the feature on when the
- // original hard-coded config had it disabled.
- scoped_refptr<FieldTrial> forced_trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
- forced_trial->AppendGroup(kExtraGroupName, 100);
- forced_trial->SetForced();
-
- int default_group = -1;
- scoped_refptr<FieldTrial> client_trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- const int extra_group = client_trial->AppendGroup(kExtraGroupName, 0);
- EXPECT_NE(default_group, extra_group);
-
- EXPECT_FALSE(client_trial->group_reported_);
- EXPECT_EQ(extra_group, client_trial->group());
- EXPECT_TRUE(client_trial->group_reported_);
- EXPECT_EQ(kExtraGroupName, client_trial->group_name());
-}
-
-TEST_F(FieldTrialTest, SetForcedTurnFeatureOff) {
- const char kTrialName[] = "SetForcedTurnFeatureOff";
- const char kExtraGroupName[] = "Extra";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- // Simulate a server-side (forced) config that turns the feature off when the
- // original hard-coded config had it enabled.
- scoped_refptr<FieldTrial> forced_trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
- forced_trial->AppendGroup(kExtraGroupName, 0);
- forced_trial->SetForced();
-
- int default_group = -1;
- scoped_refptr<FieldTrial> client_trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- const int extra_group = client_trial->AppendGroup(kExtraGroupName, 100);
- EXPECT_NE(default_group, extra_group);
-
- EXPECT_FALSE(client_trial->group_reported_);
- EXPECT_EQ(default_group, client_trial->group());
- EXPECT_TRUE(client_trial->group_reported_);
- EXPECT_EQ(kDefaultGroupName, client_trial->group_name());
-}
-
-TEST_F(FieldTrialTest, SetForcedChangeDefault_Default) {
- const char kTrialName[] = "SetForcedDefaultGroupChange";
- const char kGroupAName[] = "A";
- const char kGroupBName[] = "B";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- // Simulate a server-side (forced) config that switches which group is default
- // and ensures that the non-forced code receives the correct group numbers.
- scoped_refptr<FieldTrial> forced_trial =
- CreateFieldTrial(kTrialName, 100, kGroupAName, nullptr);
- forced_trial->AppendGroup(kGroupBName, 100);
- forced_trial->SetForced();
-
- int default_group = -1;
- scoped_refptr<FieldTrial> client_trial =
- CreateFieldTrial(kTrialName, 100, kGroupBName, &default_group);
- const int extra_group = client_trial->AppendGroup(kGroupAName, 50);
- EXPECT_NE(default_group, extra_group);
-
- EXPECT_FALSE(client_trial->group_reported_);
- EXPECT_EQ(default_group, client_trial->group());
- EXPECT_TRUE(client_trial->group_reported_);
- EXPECT_EQ(kGroupBName, client_trial->group_name());
-}
-
-TEST_F(FieldTrialTest, SetForcedChangeDefault_NonDefault) {
- const char kTrialName[] = "SetForcedDefaultGroupChange";
- const char kGroupAName[] = "A";
- const char kGroupBName[] = "B";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- // Simulate a server-side (forced) config that switches which group is default
- // and ensures that the non-forced code receives the correct group numbers.
- scoped_refptr<FieldTrial> forced_trial =
- CreateFieldTrial(kTrialName, 100, kGroupAName, nullptr);
- forced_trial->AppendGroup(kGroupBName, 0);
- forced_trial->SetForced();
-
- int default_group = -1;
- scoped_refptr<FieldTrial> client_trial =
- CreateFieldTrial(kTrialName, 100, kGroupBName, &default_group);
- const int extra_group = client_trial->AppendGroup(kGroupAName, 50);
- EXPECT_NE(default_group, extra_group);
-
- EXPECT_FALSE(client_trial->group_reported_);
- EXPECT_EQ(extra_group, client_trial->group());
- EXPECT_TRUE(client_trial->group_reported_);
- EXPECT_EQ(kGroupAName, client_trial->group_name());
-}
-
-TEST_F(FieldTrialTest, Observe) {
- const char kTrialName[] = "TrialToObserve1";
- const char kSecondaryGroupName[] = "SecondaryGroup";
-
- TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
- const int chosen_group = trial->group();
- EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
-
- // Observers are called asynchronously.
- EXPECT_TRUE(observer.trial_name().empty());
- EXPECT_TRUE(observer.group_name().empty());
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(kTrialName, observer.trial_name());
- if (chosen_group == default_group)
- EXPECT_EQ(kDefaultGroupName, observer.group_name());
- else
- EXPECT_EQ(kSecondaryGroupName, observer.group_name());
-}
-
-TEST_F(FieldTrialTest, SynchronousObserver) {
- const char kTrialName[] = "TrialToObserve1";
- const char kSecondaryGroupName[] = "SecondaryGroup";
-
- TestFieldTrialObserver observer(TestFieldTrialObserver::SYNCHRONOUS);
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
- const int chosen_group = trial->group();
- EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
-
- // The observer should be notified synchronously by the group() call.
- EXPECT_EQ(kTrialName, observer.trial_name());
- if (chosen_group == default_group)
- EXPECT_EQ(kDefaultGroupName, observer.group_name());
- else
- EXPECT_EQ(kSecondaryGroupName, observer.group_name());
-}
-
-TEST_F(FieldTrialTest, ObserveDisabled) {
- const char kTrialName[] = "TrialToObserve2";
-
- TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- trial->AppendGroup("A", 25);
- trial->AppendGroup("B", 25);
- trial->AppendGroup("C", 25);
- trial->Disable();
-
- // Observer shouldn't be notified of a disabled trial.
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(observer.trial_name().empty());
- EXPECT_TRUE(observer.group_name().empty());
-
- // Observer shouldn't be notified even after a |group()| call.
- EXPECT_EQ(default_group, trial->group());
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(observer.trial_name().empty());
- EXPECT_TRUE(observer.group_name().empty());
-}
-
-TEST_F(FieldTrialTest, ObserveForcedDisabled) {
- const char kTrialName[] = "TrialToObserve3";
-
- TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
- int default_group = -1;
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
- trial->AppendGroup("A", 25);
- trial->AppendGroup("B", 25);
- trial->AppendGroup("C", 25);
- trial->SetForced();
- trial->Disable();
-
- // Observer shouldn't be notified of a disabled trial, even when forced.
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(observer.trial_name().empty());
- EXPECT_TRUE(observer.group_name().empty());
-
- // Observer shouldn't be notified even after a |group()| call.
- EXPECT_EQ(default_group, trial->group());
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(observer.trial_name().empty());
- EXPECT_TRUE(observer.group_name().empty());
-}
-
-TEST_F(FieldTrialTest, DisabledTrialNotActive) {
- const char kTrialName[] = "DisabledTrial";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
- trial->AppendGroup("X", 50);
- trial->Disable();
-
- // Ensure the trial is not listed as active.
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_TRUE(active_groups.empty());
-
- // Ensure the trial is not listed in the |StatesToString()| result.
- std::string states;
- FieldTrialList::StatesToString(&states);
- EXPECT_TRUE(states.empty());
-}
-
-TEST_F(FieldTrialTest, ExpirationYearNotExpired) {
- const char kTrialName[] = "NotExpired";
- const char kGroupName[] = "Group2";
- const int kProbability = 100;
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial(kTrialName, kProbability, kDefaultGroupName, nullptr);
- trial->AppendGroup(kGroupName, kProbability);
- EXPECT_EQ(kGroupName, trial->group_name());
-}
-
-TEST_F(FieldTrialTest, FloatBoundariesGiveEqualGroupSizes) {
- const int kBucketCount = 100;
-
- // Try each boundary value |i / 100.0| as the entropy value.
- for (int i = 0; i < kBucketCount; ++i) {
- const double entropy = i / static_cast<double>(kBucketCount);
-
- scoped_refptr<FieldTrial> trial(
- new FieldTrial("test", kBucketCount, "default", entropy));
- for (int j = 0; j < kBucketCount; ++j)
- trial->AppendGroup(IntToString(j), 1);
-
- EXPECT_EQ(IntToString(i), trial->group_name());
- }
-}
-
-TEST_F(FieldTrialTest, DoesNotSurpassTotalProbability) {
- const double kEntropyValue = 1.0 - 1e-9;
- ASSERT_LT(kEntropyValue, 1.0);
-
- scoped_refptr<FieldTrial> trial(
- new FieldTrial("test", 2, "default", kEntropyValue));
- trial->AppendGroup("1", 1);
- trial->AppendGroup("2", 1);
-
- EXPECT_EQ("2", trial->group_name());
-}
-
-TEST_F(FieldTrialTest, CreateSimulatedFieldTrial) {
- const char kTrialName[] = "CreateSimulatedFieldTrial";
- ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
-
- // Different cases to test, e.g. default vs. non default group being chosen.
- struct {
- double entropy_value;
- const char* expected_group;
- } test_cases[] = {
- { 0.4, "A" },
- { 0.85, "B" },
- { 0.95, kDefaultGroupName },
- };
-
- for (size_t i = 0; i < arraysize(test_cases); ++i) {
- TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
- scoped_refptr<FieldTrial> trial(
- FieldTrial::CreateSimulatedFieldTrial(kTrialName, 100, kDefaultGroupName,
- test_cases[i].entropy_value));
- trial->AppendGroup("A", 80);
- trial->AppendGroup("B", 10);
- EXPECT_EQ(test_cases[i].expected_group, trial->group_name());
-
- // Field trial shouldn't have been registered with the list.
- EXPECT_FALSE(FieldTrialList::TrialExists(kTrialName));
- EXPECT_EQ(0u, FieldTrialList::GetFieldTrialCount());
-
- // Observer shouldn't have been notified.
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(observer.trial_name().empty());
-
- // The trial shouldn't be in the active set of trials.
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_TRUE(active_groups.empty());
-
- // The trial shouldn't be listed in the |StatesToString()| result.
- std::string states;
- FieldTrialList::StatesToString(&states);
- EXPECT_TRUE(states.empty());
- }
-}
-
-TEST(FieldTrialTestWithoutList, StatesStringFormat) {
- std::string save_string;
-
- // Scoping the first FieldTrialList, as we need another one to test the
- // importing function.
- {
- FieldTrialList field_trial_list(nullptr);
- scoped_refptr<FieldTrial> trial =
- CreateFieldTrial("Abc", 10, "Default some name", nullptr);
- trial->AppendGroup("cba", 10);
- trial->group();
- scoped_refptr<FieldTrial> trial2 =
- CreateFieldTrial("Xyz", 10, "Default xxx", nullptr);
- trial2->AppendGroup("zyx", 10);
- trial2->group();
- scoped_refptr<FieldTrial> trial3 =
- CreateFieldTrial("zzz", 10, "default", nullptr);
-
- FieldTrialList::AllStatesToString(&save_string, false);
- }
-
- // Starting with a new blank FieldTrialList.
- FieldTrialList field_trial_list(nullptr);
- ASSERT_TRUE(field_trial_list.CreateTrialsFromString(save_string,
- std::set<std::string>()));
-
- FieldTrial::ActiveGroups active_groups;
- field_trial_list.GetActiveFieldTrialGroups(&active_groups);
- ASSERT_EQ(2U, active_groups.size());
- EXPECT_EQ("Abc", active_groups[0].trial_name);
- EXPECT_EQ("cba", active_groups[0].group_name);
- EXPECT_EQ("Xyz", active_groups[1].trial_name);
- EXPECT_EQ("zyx", active_groups[1].group_name);
- EXPECT_TRUE(field_trial_list.TrialExists("zzz"));
-}
-
-TEST(FieldTrialDeathTest, OneTimeRandomizedTrialWithoutFieldTrialList) {
- // Trying to instantiate a one-time randomized field trial before the
- // FieldTrialList is created should crash.
- EXPECT_DEATH_IF_SUPPORTED(
- FieldTrialList::FactoryGetFieldTrial(
- "OneTimeRandomizedTrialWithoutFieldTrialList", 100, kDefaultGroupName,
- FieldTrialList::kNoExpirationYear, 1, 1,
- FieldTrial::ONE_TIME_RANDOMIZED, nullptr),
- "");
-}
-
-TEST(FieldTrialListTest, TestCopyFieldTrialStateToFlags) {
- constexpr char kFieldTrialHandleSwitch[] = "test-field-trial-handle";
- constexpr char kEnableFeaturesSwitch[] = "test-enable-features";
- constexpr char kDisableFeaturesSwitch[] = "test-disable-features";
-
- FieldTrialList field_trial_list(std::make_unique<MockEntropyProvider>());
-
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine("A,B", "C");
-
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial1", "Group1");
- feature_list->RegisterFieldTrialOverride(
- "MyFeature", FeatureList::OVERRIDE_ENABLE_FEATURE, trial);
-
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.InitWithFeatureList(std::move(feature_list));
-
- FilePath test_file_path = FilePath(FILE_PATH_LITERAL("Program"));
- CommandLine command_line = CommandLine(test_file_path);
-
- FieldTrialList::CopyFieldTrialStateToFlags(
- kFieldTrialHandleSwitch, kEnableFeaturesSwitch, kDisableFeaturesSwitch,
- &command_line);
- EXPECT_TRUE(command_line.HasSwitch(kFieldTrialHandleSwitch));
-
- // Explictly specified enabled/disabled features should be specified.
- EXPECT_EQ("A,B", command_line.GetSwitchValueASCII(kEnableFeaturesSwitch));
- EXPECT_EQ("C", command_line.GetSwitchValueASCII(kDisableFeaturesSwitch));
-}
-
-TEST(FieldTrialListTest, InstantiateAllocator) {
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.Init();
-
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial("Trial1", "Group1");
-
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
- void* memory = field_trial_list.field_trial_allocator_->shared_memory();
- size_t used = field_trial_list.field_trial_allocator_->used();
-
- // Ensure that the function is idempotent.
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
- void* new_memory = field_trial_list.field_trial_allocator_->shared_memory();
- size_t new_used = field_trial_list.field_trial_allocator_->used();
- EXPECT_EQ(memory, new_memory);
- EXPECT_EQ(used, new_used);
-}
-
-TEST(FieldTrialListTest, AddTrialsToAllocator) {
- std::string save_string;
- SharedMemoryHandle handle;
-
- // Scoping the first FieldTrialList, as we need another one to test that it
- // matches.
- {
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.Init();
-
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial("Trial1", "Group1");
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
- FieldTrialList::AllStatesToString(&save_string, false);
- handle = SharedMemory::DuplicateHandle(
- field_trial_list.field_trial_allocator_->shared_memory()->handle());
- }
-
- FieldTrialList field_trial_list2(nullptr);
- std::unique_ptr<SharedMemory> shm(new SharedMemory(handle, true));
- // 4 KiB is enough to hold the trials only created for this test.
- shm.get()->Map(4 << 10);
- FieldTrialList::CreateTrialsFromSharedMemory(std::move(shm));
- std::string check_string;
- FieldTrialList::AllStatesToString(&check_string, false);
- EXPECT_EQ(save_string, check_string);
-}
-
-TEST(FieldTrialListTest, DoNotAddSimulatedFieldTrialsToAllocator) {
- constexpr char kTrialName[] = "trial";
- SharedMemoryHandle handle;
- {
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.Init();
-
- // Create a simulated trial and a real trial and call group() on them, which
- // should only add the real trial to the field trial allocator.
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
-
- // This shouldn't add to the allocator.
- scoped_refptr<FieldTrial> simulated_trial =
- FieldTrial::CreateSimulatedFieldTrial(kTrialName, 100, "Simulated",
- 0.95);
- simulated_trial->group();
-
- // This should add to the allocator.
- FieldTrial* real_trial =
- FieldTrialList::CreateFieldTrial(kTrialName, "Real");
- real_trial->group();
-
- handle = SharedMemory::DuplicateHandle(
- field_trial_list.field_trial_allocator_->shared_memory()->handle());
- }
-
- // Check that there's only one entry in the allocator.
- FieldTrialList field_trial_list2(nullptr);
- std::unique_ptr<SharedMemory> shm(new SharedMemory(handle, true));
- // 4 KiB is enough to hold the trials only created for this test.
- shm.get()->Map(4 << 10);
- FieldTrialList::CreateTrialsFromSharedMemory(std::move(shm));
- std::string check_string;
- FieldTrialList::AllStatesToString(&check_string, false);
- ASSERT_EQ(check_string.find("Simulated"), std::string::npos);
-}
-
-TEST(FieldTrialListTest, AssociateFieldTrialParams) {
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.Init();
-
- std::string trial_name("Trial1");
- std::string group_name("Group1");
-
- // Create a field trial with some params.
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial(trial_name, group_name);
- std::map<std::string, std::string> params;
- params["key1"] = "value1";
- params["key2"] = "value2";
- FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
- trial_name, group_name, params);
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
-
- // Clear all cached params from the associator.
- FieldTrialParamAssociator::GetInstance()->ClearAllCachedParamsForTesting();
- // Check that the params have been cleared from the cache.
- std::map<std::string, std::string> cached_params;
- FieldTrialParamAssociator::GetInstance()->GetFieldTrialParamsWithoutFallback(
- trial_name, group_name, &cached_params);
- EXPECT_EQ(0U, cached_params.size());
-
- // Check that we fetch the param from shared memory properly.
- std::map<std::string, std::string> new_params;
- FieldTrialParamAssociator::GetInstance()->GetFieldTrialParams(trial_name,
- &new_params);
- EXPECT_EQ("value1", new_params["key1"]);
- EXPECT_EQ("value2", new_params["key2"]);
- EXPECT_EQ(2U, new_params.size());
-}
-
-TEST(FieldTrialListTest, ClearParamsFromSharedMemory) {
- std::string trial_name("Trial1");
- std::string group_name("Group1");
-
- SharedMemoryHandle handle;
- {
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.Init();
-
- // Create a field trial with some params.
- FieldTrialList field_trial_list(nullptr);
- FieldTrial* trial =
- FieldTrialList::CreateFieldTrial(trial_name, group_name);
- std::map<std::string, std::string> params;
- params["key1"] = "value1";
- params["key2"] = "value2";
- FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
- trial_name, group_name, params);
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
-
- // Clear all params from the associator AND shared memory. The allocated
- // segments should be different.
- FieldTrial::FieldTrialRef old_ref = trial->ref_;
- FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
- FieldTrial::FieldTrialRef new_ref = trial->ref_;
- EXPECT_NE(old_ref, new_ref);
-
- // Check that there are no params associated with the field trial anymore.
- std::map<std::string, std::string> new_params;
- FieldTrialParamAssociator::GetInstance()->GetFieldTrialParams(trial_name,
- &new_params);
- EXPECT_EQ(0U, new_params.size());
-
- // Now duplicate the handle so we can easily check that the trial is still
- // in shared memory via AllStatesToString.
- handle = SharedMemory::DuplicateHandle(
- field_trial_list.field_trial_allocator_->shared_memory()->handle());
- }
-
- // Check that we have the trial.
- FieldTrialList field_trial_list2(nullptr);
- std::unique_ptr<SharedMemory> shm(new SharedMemory(handle, true));
- // 4 KiB is enough to hold the trials only created for this test.
- shm.get()->Map(4 << 10);
- FieldTrialList::CreateTrialsFromSharedMemory(std::move(shm));
- std::string check_string;
- FieldTrialList::AllStatesToString(&check_string, false);
- EXPECT_EQ("*Trial1/Group1/", check_string);
-}
-
-TEST(FieldTrialListTest, DumpAndFetchFromSharedMemory) {
- std::string trial_name("Trial1");
- std::string group_name("Group1");
-
- // Create a field trial with some params.
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial(trial_name, group_name);
- std::map<std::string, std::string> params;
- params["key1"] = "value1";
- params["key2"] = "value2";
- FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
- trial_name, group_name, params);
-
- std::unique_ptr<SharedMemory> shm(new SharedMemory());
- // 4 KiB is enough to hold the trials only created for this test.
- shm.get()->CreateAndMapAnonymous(4 << 10);
- // We _could_ use PersistentMemoryAllocator, this just has less params.
- SharedPersistentMemoryAllocator allocator(std::move(shm), 1, "", false);
-
- // Dump and subsequently retrieve the field trial to |allocator|.
- FieldTrialList::DumpAllFieldTrialsToPersistentAllocator(&allocator);
- std::vector<const FieldTrial::FieldTrialEntry*> entries =
- FieldTrialList::GetAllFieldTrialsFromPersistentAllocator(allocator);
-
- // Check that we have the entry we put in.
- EXPECT_EQ(1u, entries.size());
- const FieldTrial::FieldTrialEntry* entry = entries[0];
-
- // Check that the trial and group names match.
- StringPiece shm_trial_name;
- StringPiece shm_group_name;
- entry->GetTrialAndGroupName(&shm_trial_name, &shm_group_name);
- EXPECT_EQ(trial_name, shm_trial_name);
- EXPECT_EQ(group_name, shm_group_name);
-
- // Check that the params match.
- std::map<std::string, std::string> shm_params;
- entry->GetParams(&shm_params);
- EXPECT_EQ(2u, shm_params.size());
- EXPECT_EQ("value1", shm_params["key1"]);
- EXPECT_EQ("value2", shm_params["key2"]);
-}
-
-#if !defined(OS_NACL)
-TEST(FieldTrialListTest, SerializeSharedMemoryHandleMetadata) {
- std::unique_ptr<SharedMemory> shm(new SharedMemory());
- shm->CreateAndMapAnonymous(4 << 10);
-
- std::string serialized =
- FieldTrialList::SerializeSharedMemoryHandleMetadata(shm->handle());
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
- SharedMemoryHandle deserialized =
- FieldTrialList::DeserializeSharedMemoryHandleMetadata(serialized);
-#else
- // Use a valid-looking arbitrary number for the file descriptor. It's not
- // being used in this unittest, but needs to pass sanity checks in the
- // handle's constructor.
- SharedMemoryHandle deserialized =
- FieldTrialList::DeserializeSharedMemoryHandleMetadata(42, serialized);
-#endif
- EXPECT_EQ(deserialized.GetGUID(), shm->handle().GetGUID());
- EXPECT_FALSE(deserialized.GetGUID().is_empty());
-}
-#endif // !defined(OS_NACL)
-
-// Verify that the field trial shared memory handle is really read-only, and
-// does not allow writable mappings. Test disabled on NaCl, Windows and Fuchsia
-// which don't support/implement GetFieldTrialHandle(). For Fuchsia, see
-// crbug.com/752368
-#if !defined(OS_NACL) && !defined(OS_WIN) && !defined(OS_FUCHSIA)
-TEST(FieldTrialListTest, CheckReadOnlySharedMemoryHandle) {
- FieldTrialList field_trial_list(nullptr);
- FieldTrialList::CreateFieldTrial("Trial1", "Group1");
-
- test::ScopedFeatureList scoped_feature_list;
- scoped_feature_list.Init();
-
- FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
-
- SharedMemoryHandle handle = FieldTrialList::GetFieldTrialHandle();
- ASSERT_TRUE(handle.IsValid());
-
- ASSERT_TRUE(CheckReadOnlySharedMemoryHandleForTesting(handle));
-}
-#endif // !OS_NACL && !OS_WIN && !OS_FUCHSIA
-
-TEST_F(FieldTrialTest, TestAllParamsToString) {
- std::string exptected_output = "t1.g1:p1/v1/p2/v2";
-
- // Create study with one group and two params.
- std::map<std::string, std::string> params;
- params["p1"] = "v1";
- params["p2"] = "v2";
- FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
- "t1", "g1", params);
- EXPECT_EQ(
- "", FieldTrialList::AllParamsToString(false, &MockEscapeQueryParamValue));
-
- scoped_refptr<FieldTrial> trial1 =
- CreateFieldTrial("t1", 100, "Default", nullptr);
- trial1->AppendGroup("g1", 100);
- trial1->group();
- EXPECT_EQ(exptected_output, FieldTrialList::AllParamsToString(
- false, &MockEscapeQueryParamValue));
-
- // Create study with two groups and params that don't belog to the assigned
- // group. This should be in the output.
- FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
- "t2", "g2", params);
- scoped_refptr<FieldTrial> trial2 =
- CreateFieldTrial("t2", 100, "Default", nullptr);
- trial2->AppendGroup("g1", 100);
- trial2->AppendGroup("g2", 0);
- trial2->group();
- EXPECT_EQ(exptected_output, FieldTrialList::AllParamsToString(
- false, &MockEscapeQueryParamValue));
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_base_unittest.cc b/base/metrics/histogram_base_unittest.cc
deleted file mode 100644
index e539e5c..0000000
--- a/base/metrics/histogram_base_unittest.cc
+++ /dev/null
@@ -1,189 +0,0 @@
-// 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.
-
-#include <vector>
-
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/sample_vector.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/pickle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class HistogramBaseTest : public testing::Test {
- protected:
- HistogramBaseTest() {
- // Each test will have a clean state (no Histogram / BucketRanges
- // registered).
- ResetStatisticsRecorder();
- }
-
- ~HistogramBaseTest() override = default;
-
- void ResetStatisticsRecorder() {
- // It is necessary to fully destruct any existing StatisticsRecorder
- // before creating a new one.
- statistics_recorder_.reset();
- statistics_recorder_ = StatisticsRecorder::CreateTemporaryForTesting();
- }
-
- private:
- std::unique_ptr<StatisticsRecorder> statistics_recorder_;
-
- DISALLOW_COPY_AND_ASSIGN(HistogramBaseTest);
-};
-
-TEST_F(HistogramBaseTest, DeserializeHistogram) {
- HistogramBase* histogram = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10,
- (HistogramBase::kUmaTargetedHistogramFlag |
- HistogramBase::kIPCSerializationSourceFlag));
-
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
- HistogramBase* deserialized = DeserializeHistogramInfo(&iter);
- EXPECT_EQ(histogram, deserialized);
-
- ResetStatisticsRecorder();
-
- PickleIterator iter2(pickle);
- deserialized = DeserializeHistogramInfo(&iter2);
- EXPECT_TRUE(deserialized);
- EXPECT_NE(histogram, deserialized);
- EXPECT_EQ("TestHistogram", StringPiece(deserialized->histogram_name()));
- EXPECT_TRUE(deserialized->HasConstructionArguments(1, 1000, 10));
-
- // kIPCSerializationSourceFlag will be cleared.
- EXPECT_EQ(HistogramBase::kUmaTargetedHistogramFlag, deserialized->flags());
-}
-
-TEST_F(HistogramBaseTest, DeserializeLinearHistogram) {
- HistogramBase* histogram = LinearHistogram::FactoryGet(
- "TestHistogram", 1, 1000, 10,
- HistogramBase::kIPCSerializationSourceFlag);
-
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
- HistogramBase* deserialized = DeserializeHistogramInfo(&iter);
- EXPECT_EQ(histogram, deserialized);
-
- ResetStatisticsRecorder();
-
- PickleIterator iter2(pickle);
- deserialized = DeserializeHistogramInfo(&iter2);
- EXPECT_TRUE(deserialized);
- EXPECT_NE(histogram, deserialized);
- EXPECT_EQ("TestHistogram", StringPiece(deserialized->histogram_name()));
- EXPECT_TRUE(deserialized->HasConstructionArguments(1, 1000, 10));
- EXPECT_EQ(0, deserialized->flags());
-}
-
-TEST_F(HistogramBaseTest, DeserializeBooleanHistogram) {
- HistogramBase* histogram = BooleanHistogram::FactoryGet(
- "TestHistogram", HistogramBase::kIPCSerializationSourceFlag);
-
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
- HistogramBase* deserialized = DeserializeHistogramInfo(&iter);
- EXPECT_EQ(histogram, deserialized);
-
- ResetStatisticsRecorder();
-
- PickleIterator iter2(pickle);
- deserialized = DeserializeHistogramInfo(&iter2);
- EXPECT_TRUE(deserialized);
- EXPECT_NE(histogram, deserialized);
- EXPECT_EQ("TestHistogram", StringPiece(deserialized->histogram_name()));
- EXPECT_TRUE(deserialized->HasConstructionArguments(1, 2, 3));
- EXPECT_EQ(0, deserialized->flags());
-}
-
-TEST_F(HistogramBaseTest, DeserializeCustomHistogram) {
- std::vector<HistogramBase::Sample> ranges;
- ranges.push_back(13);
- ranges.push_back(5);
- ranges.push_back(9);
-
- HistogramBase* histogram = CustomHistogram::FactoryGet(
- "TestHistogram", ranges, HistogramBase::kIPCSerializationSourceFlag);
-
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
- HistogramBase* deserialized = DeserializeHistogramInfo(&iter);
- EXPECT_EQ(histogram, deserialized);
-
- ResetStatisticsRecorder();
-
- PickleIterator iter2(pickle);
- deserialized = DeserializeHistogramInfo(&iter2);
- EXPECT_TRUE(deserialized);
- EXPECT_NE(histogram, deserialized);
- EXPECT_EQ("TestHistogram", StringPiece(deserialized->histogram_name()));
- EXPECT_TRUE(deserialized->HasConstructionArguments(5, 13, 4));
- EXPECT_EQ(0, deserialized->flags());
-}
-
-TEST_F(HistogramBaseTest, DeserializeSparseHistogram) {
- HistogramBase* histogram = SparseHistogram::FactoryGet(
- "TestHistogram", HistogramBase::kIPCSerializationSourceFlag);
-
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
- HistogramBase* deserialized = DeserializeHistogramInfo(&iter);
- EXPECT_EQ(histogram, deserialized);
-
- ResetStatisticsRecorder();
-
- PickleIterator iter2(pickle);
- deserialized = DeserializeHistogramInfo(&iter2);
- EXPECT_TRUE(deserialized);
- EXPECT_NE(histogram, deserialized);
- EXPECT_EQ("TestHistogram", StringPiece(deserialized->histogram_name()));
- EXPECT_EQ(0, deserialized->flags());
-}
-
-TEST_F(HistogramBaseTest, AddKilo) {
- HistogramBase* histogram =
- LinearHistogram::FactoryGet("TestAddKiloHistogram", 1, 1000, 100, 0);
-
- histogram->AddKilo(100, 1000);
- histogram->AddKilo(200, 2000);
- histogram->AddKilo(300, 1500);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
- EXPECT_EQ(1, samples->GetCount(100));
- EXPECT_EQ(2, samples->GetCount(200));
- EXPECT_LE(1, samples->GetCount(300));
- EXPECT_GE(2, samples->GetCount(300));
-}
-
-TEST_F(HistogramBaseTest, AddKiB) {
- HistogramBase* histogram =
- LinearHistogram::FactoryGet("TestAddKiBHistogram", 1, 1000, 100, 0);
-
- histogram->AddKiB(100, 1024);
- histogram->AddKiB(200, 2048);
- histogram->AddKiB(300, 1536);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
- EXPECT_EQ(1, samples->GetCount(100));
- EXPECT_EQ(2, samples->GetCount(200));
- EXPECT_LE(1, samples->GetCount(300));
- EXPECT_GE(2, samples->GetCount(300));
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_delta_serialization_unittest.cc b/base/metrics/histogram_delta_serialization_unittest.cc
deleted file mode 100644
index 719bc70..0000000
--- a/base/metrics/histogram_delta_serialization_unittest.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 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 "base/metrics/histogram_delta_serialization.h"
-
-#include <vector>
-
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/statistics_recorder.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(HistogramDeltaSerializationTest, DeserializeHistogramAndAddSamples) {
- std::unique_ptr<StatisticsRecorder> statistic_recorder(
- StatisticsRecorder::CreateTemporaryForTesting());
- HistogramDeltaSerialization serializer("HistogramDeltaSerializationTest");
- std::vector<std::string> deltas;
- // Nothing was changed yet.
- serializer.PrepareAndSerializeDeltas(&deltas, true);
- EXPECT_TRUE(deltas.empty());
-
- HistogramBase* histogram = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10, HistogramBase::kIPCSerializationSourceFlag);
- histogram->Add(1);
- histogram->Add(10);
- histogram->Add(100);
- histogram->Add(1000);
-
- serializer.PrepareAndSerializeDeltas(&deltas, true);
- EXPECT_FALSE(deltas.empty());
-
- HistogramDeltaSerialization::DeserializeAndAddSamples(deltas);
-
- // The histogram has kIPCSerializationSourceFlag. So samples will be ignored.
- std::unique_ptr<HistogramSamples> snapshot(histogram->SnapshotSamples());
- EXPECT_EQ(1, snapshot->GetCount(1));
- EXPECT_EQ(1, snapshot->GetCount(10));
- EXPECT_EQ(1, snapshot->GetCount(100));
- EXPECT_EQ(1, snapshot->GetCount(1000));
-
- // Clear kIPCSerializationSourceFlag to emulate multi-process usage.
- histogram->ClearFlags(HistogramBase::kIPCSerializationSourceFlag);
- HistogramDeltaSerialization::DeserializeAndAddSamples(deltas);
-
- std::unique_ptr<HistogramSamples> snapshot2(histogram->SnapshotSamples());
- EXPECT_EQ(2, snapshot2->GetCount(1));
- EXPECT_EQ(2, snapshot2->GetCount(10));
- EXPECT_EQ(2, snapshot2->GetCount(100));
- EXPECT_EQ(2, snapshot2->GetCount(1000));
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_functions_unittest.cc b/base/metrics/histogram_functions_unittest.cc
deleted file mode 100644
index 3720674..0000000
--- a/base/metrics/histogram_functions_unittest.cc
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2016 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 "base/metrics/histogram_functions.h"
-
-#include "base/metrics/histogram_macros.h"
-#include "base/test/histogram_tester.h"
-#include "base/time/time.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-enum UmaHistogramTestingEnum {
- UMA_HISTOGRAM_TESTING_ENUM_FIRST,
- UMA_HISTOGRAM_TESTING_ENUM_SECOND,
- UMA_HISTOGRAM_TESTING_ENUM_THIRD
-};
-
-TEST(HistogramFunctionsTest, ExactLinear) {
- std::string histogram("Testing.UMA.HistogramExactLinear");
- HistogramTester tester;
- UmaHistogramExactLinear(histogram, 10, 100);
- tester.ExpectUniqueSample(histogram, 10, 1);
- UmaHistogramExactLinear(histogram, 20, 100);
- UmaHistogramExactLinear(histogram, 10, 100);
- tester.ExpectBucketCount(histogram, 10, 2);
- tester.ExpectBucketCount(histogram, 20, 1);
- tester.ExpectTotalCount(histogram, 3);
- // Test linear buckets overflow.
- UmaHistogramExactLinear(histogram, 200, 100);
- tester.ExpectBucketCount(histogram, 101, 1);
- tester.ExpectTotalCount(histogram, 4);
- // Test linear buckets underflow.
- UmaHistogramExactLinear(histogram, 0, 100);
- tester.ExpectBucketCount(histogram, 0, 1);
- tester.ExpectTotalCount(histogram, 5);
-}
-
-TEST(HistogramFunctionsTest, Enumeration) {
- std::string histogram("Testing.UMA.HistogramEnumeration");
- HistogramTester tester;
- UmaHistogramEnumeration(histogram, UMA_HISTOGRAM_TESTING_ENUM_FIRST,
- UMA_HISTOGRAM_TESTING_ENUM_THIRD);
- tester.ExpectUniqueSample(histogram, UMA_HISTOGRAM_TESTING_ENUM_FIRST, 1);
-
- // Verify the overflow & underflow bucket exists.
- UMA_HISTOGRAM_ENUMERATION(
- histogram, static_cast<int>(UMA_HISTOGRAM_TESTING_ENUM_THIRD) + 10,
- static_cast<int>(UMA_HISTOGRAM_TESTING_ENUM_THIRD));
- tester.ExpectBucketCount(
- histogram, static_cast<int>(UMA_HISTOGRAM_TESTING_ENUM_THIRD) + 1, 1);
- tester.ExpectTotalCount(histogram, 2);
-}
-
-TEST(HistogramFunctionsTest, Boolean) {
- std::string histogram("Testing.UMA.HistogramBoolean");
- HistogramTester tester;
- UmaHistogramBoolean(histogram, true);
- tester.ExpectUniqueSample(histogram, 1, 1);
- UmaHistogramBoolean(histogram, false);
- tester.ExpectBucketCount(histogram, 0, 1);
- tester.ExpectTotalCount(histogram, 2);
-}
-
-TEST(HistogramFunctionsTest, Percentage) {
- std::string histogram("Testing.UMA.HistogramPercentage");
- HistogramTester tester;
- UmaHistogramPercentage(histogram, 50);
- tester.ExpectUniqueSample(histogram, 50, 1);
- // Test overflows.
- UmaHistogramPercentage(histogram, 110);
- tester.ExpectBucketCount(histogram, 101, 1);
- tester.ExpectTotalCount(histogram, 2);
-}
-
-TEST(HistogramFunctionsTest, Counts) {
- std::string histogram("Testing.UMA.HistogramCount.Custom");
- HistogramTester tester;
- UmaHistogramCustomCounts(histogram, 10, 1, 100, 10);
- tester.ExpectUniqueSample(histogram, 10, 1);
- UmaHistogramCustomCounts(histogram, 20, 1, 100, 10);
- UmaHistogramCustomCounts(histogram, 20, 1, 100, 10);
- UmaHistogramCustomCounts(histogram, 20, 1, 100, 10);
- tester.ExpectBucketCount(histogram, 20, 3);
- tester.ExpectTotalCount(histogram, 4);
- UmaHistogramCustomCounts(histogram, 110, 1, 100, 10);
- tester.ExpectBucketCount(histogram, 101, 1);
- tester.ExpectTotalCount(histogram, 5);
-}
-
-TEST(HistogramFunctionsTest, Times) {
- std::string histogram("Testing.UMA.HistogramTimes");
- HistogramTester tester;
- UmaHistogramTimes(histogram, TimeDelta::FromSeconds(1));
- tester.ExpectTimeBucketCount(histogram, TimeDelta::FromSeconds(1), 1);
- tester.ExpectTotalCount(histogram, 1);
- UmaHistogramTimes(histogram, TimeDelta::FromSeconds(9));
- tester.ExpectTimeBucketCount(histogram, TimeDelta::FromSeconds(9), 1);
- tester.ExpectTotalCount(histogram, 2);
- UmaHistogramTimes(histogram, TimeDelta::FromSeconds(10)); // Overflows
- tester.ExpectTimeBucketCount(histogram, TimeDelta::FromSeconds(10), 1);
- UmaHistogramTimes(histogram, TimeDelta::FromSeconds(20)); // Overflows.
- // Check the value by picking any overflow time.
- tester.ExpectTimeBucketCount(histogram, TimeDelta::FromSeconds(11), 2);
- tester.ExpectTotalCount(histogram, 4);
-}
-
-TEST(HistogramFunctionsTest, Sparse_SupportsLargeRange) {
- std::string histogram("Testing.UMA.HistogramSparse");
- HistogramTester tester;
- UmaHistogramSparse(histogram, 0);
- UmaHistogramSparse(histogram, 123456789);
- UmaHistogramSparse(histogram, 123456789);
- EXPECT_THAT(tester.GetAllSamples(histogram),
- testing::ElementsAre(Bucket(0, 1), Bucket(123456789, 2)));
-}
-
-TEST(HistogramFunctionsTest, Sparse_SupportsNegativeValues) {
- std::string histogram("Testing.UMA.HistogramSparse");
- HistogramTester tester;
- UmaHistogramSparse(histogram, -1);
- tester.ExpectUniqueSample(histogram, -1, 1);
-}
-
-} // namespace base.
diff --git a/base/metrics/histogram_macros_unittest.cc b/base/metrics/histogram_macros_unittest.cc
deleted file mode 100644
index 3c592b0..0000000
--- a/base/metrics/histogram_macros_unittest.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 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 "base/metrics/histogram_macros.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(ScopedHistogramTimer, TwoTimersOneScope) {
- SCOPED_UMA_HISTOGRAM_TIMER("TestTimer0");
- SCOPED_UMA_HISTOGRAM_TIMER("TestTimer1");
- SCOPED_UMA_HISTOGRAM_LONG_TIMER("TestLongTimer0");
- SCOPED_UMA_HISTOGRAM_LONG_TIMER("TestLongTimer1");
-}
-
-// Compile tests for UMA_HISTOGRAM_ENUMERATION with the three different types it
-// accepts:
-// - integral types
-// - unscoped enums
-// - scoped enums
-TEST(HistogramMacro, IntegralPsuedoEnumeration) {
- UMA_HISTOGRAM_ENUMERATION("Test.FauxEnumeration", 1, 10000);
-}
-
-TEST(HistogramMacro, UnscopedEnumeration) {
- enum TestEnum : char {
- FIRST_VALUE,
- SECOND_VALUE,
- THIRD_VALUE,
- MAX_ENTRIES,
- };
- UMA_HISTOGRAM_ENUMERATION("Test.UnscopedEnumeration", SECOND_VALUE,
- MAX_ENTRIES);
-}
-
-TEST(HistogramMacro, ScopedEnumeration) {
- enum class TestEnum {
- FIRST_VALUE,
- SECOND_VALUE,
- THIRD_VALUE,
- kMaxValue = THIRD_VALUE,
- };
- UMA_HISTOGRAM_ENUMERATION("Test.ScopedEnumeration", TestEnum::FIRST_VALUE);
-
- enum class TestEnum2 {
- FIRST_VALUE,
- SECOND_VALUE,
- THIRD_VALUE,
- MAX_ENTRIES,
- };
- UMA_HISTOGRAM_ENUMERATION("Test.ScopedEnumeration2", TestEnum2::SECOND_VALUE,
- TestEnum2::MAX_ENTRIES);
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_samples_unittest.cc b/base/metrics/histogram_samples_unittest.cc
deleted file mode 100644
index 74c743b..0000000
--- a/base/metrics/histogram_samples_unittest.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) 2017 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 "base/metrics/histogram_samples.h"
-
-#include <limits>
-
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-using SingleSample = HistogramSamples::SingleSample;
-using AtomicSingleSample = HistogramSamples::AtomicSingleSample;
-
-TEST(SingleSampleTest, Load) {
- AtomicSingleSample sample;
- ASSERT_TRUE(sample.Accumulate(9, 1));
-
- SingleSample s = sample.Load();
- EXPECT_EQ(9U, s.bucket);
- EXPECT_EQ(1U, s.count);
-
- s = sample.Load();
- EXPECT_EQ(9U, s.bucket);
- EXPECT_EQ(1U, s.count);
-}
-
-TEST(SingleSampleTest, Extract) {
- AtomicSingleSample sample;
- ASSERT_TRUE(sample.Accumulate(9, 1));
-
- SingleSample s = sample.Extract(/*disable=*/false);
- EXPECT_EQ(9U, s.bucket);
- EXPECT_EQ(1U, s.count);
-
- s = sample.Extract(/*disable=*/false);
- EXPECT_EQ(0U, s.bucket);
- EXPECT_EQ(0U, s.count);
-}
-
-TEST(SingleSampleTest, Disable) {
- AtomicSingleSample sample;
- EXPECT_EQ(0U, sample.Extract(/*disable=*/false).count);
- EXPECT_FALSE(sample.IsDisabled());
-
- ASSERT_TRUE(sample.Accumulate(9, 1));
- EXPECT_EQ(1U, sample.Extract(/*disable=*/true).count);
- EXPECT_TRUE(sample.IsDisabled());
-
- ASSERT_FALSE(sample.Accumulate(9, 1));
- EXPECT_EQ(0U, sample.Extract(/*disable=*/false).count);
- EXPECT_FALSE(sample.IsDisabled());
-}
-
-TEST(SingleSampleTest, Accumulate) {
- AtomicSingleSample sample;
-
- ASSERT_TRUE(sample.Accumulate(9, 1));
- ASSERT_TRUE(sample.Accumulate(9, 2));
- ASSERT_TRUE(sample.Accumulate(9, 4));
- EXPECT_EQ(7U, sample.Extract(/*disable=*/false).count);
-
- ASSERT_TRUE(sample.Accumulate(9, 4));
- ASSERT_TRUE(sample.Accumulate(9, -2));
- ASSERT_TRUE(sample.Accumulate(9, 1));
- EXPECT_EQ(3U, sample.Extract(/*disable=*/false).count);
-}
-
-TEST(SingleSampleTest, Overflow) {
- AtomicSingleSample sample;
-
- ASSERT_TRUE(sample.Accumulate(9, 1));
- ASSERT_FALSE(sample.Accumulate(9, -2));
- EXPECT_EQ(1U, sample.Extract(/*disable=*/false).count);
-
- ASSERT_TRUE(sample.Accumulate(9, std::numeric_limits<uint16_t>::max()));
- ASSERT_FALSE(sample.Accumulate(9, 1));
- EXPECT_EQ(std::numeric_limits<uint16_t>::max(),
- sample.Extract(/*disable=*/false).count);
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_snapshot_manager_unittest.cc b/base/metrics/histogram_snapshot_manager_unittest.cc
deleted file mode 100644
index 1e2c599..0000000
--- a/base/metrics/histogram_snapshot_manager_unittest.cc
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2014 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 "base/metrics/histogram_snapshot_manager.h"
-
-#include <string>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/metrics/histogram_delta_serialization.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/sample_vector.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/stl_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class HistogramFlattenerDeltaRecorder : public HistogramFlattener {
- public:
- HistogramFlattenerDeltaRecorder() = default;
-
- void RecordDelta(const HistogramBase& histogram,
- const HistogramSamples& snapshot) override {
- recorded_delta_histogram_names_.push_back(histogram.histogram_name());
- // Use CHECK instead of ASSERT to get full stack-trace and thus origin.
- CHECK(!ContainsKey(recorded_delta_histogram_sum_,
- histogram.histogram_name()));
- // Keep pointer to snapshot for testing. This really isn't ideal but the
- // snapshot-manager keeps the snapshot alive until it's "forgotten".
- recorded_delta_histogram_sum_[histogram.histogram_name()] = snapshot.sum();
- }
-
- void Reset() {
- recorded_delta_histogram_names_.clear();
- recorded_delta_histogram_sum_.clear();
- }
-
- std::vector<std::string> GetRecordedDeltaHistogramNames() {
- return recorded_delta_histogram_names_;
- }
-
- int64_t GetRecordedDeltaHistogramSum(const std::string& name) {
- EXPECT_TRUE(ContainsKey(recorded_delta_histogram_sum_, name));
- return recorded_delta_histogram_sum_[name];
- }
-
- private:
- std::vector<std::string> recorded_delta_histogram_names_;
- std::map<std::string, int64_t> recorded_delta_histogram_sum_;
-
- DISALLOW_COPY_AND_ASSIGN(HistogramFlattenerDeltaRecorder);
-};
-
-class HistogramSnapshotManagerTest : public testing::Test {
- protected:
- HistogramSnapshotManagerTest()
- : statistics_recorder_(StatisticsRecorder::CreateTemporaryForTesting()),
- histogram_snapshot_manager_(&histogram_flattener_delta_recorder_) {}
-
- ~HistogramSnapshotManagerTest() override = default;
-
- std::unique_ptr<StatisticsRecorder> statistics_recorder_;
- HistogramFlattenerDeltaRecorder histogram_flattener_delta_recorder_;
- HistogramSnapshotManager histogram_snapshot_manager_;
-};
-
-TEST_F(HistogramSnapshotManagerTest, PrepareDeltasNoFlagsFilter) {
- // kNoFlags filter should record all histograms.
- UMA_HISTOGRAM_ENUMERATION("UmaHistogram", 1, 4);
- UMA_STABILITY_HISTOGRAM_ENUMERATION("UmaStabilityHistogram", 1, 2);
-
- StatisticsRecorder::PrepareDeltas(false, HistogramBase::kNoFlags,
- HistogramBase::kNoFlags,
- &histogram_snapshot_manager_);
-
- const std::vector<std::string>& histograms =
- histogram_flattener_delta_recorder_.GetRecordedDeltaHistogramNames();
- EXPECT_EQ(2U, histograms.size());
- EXPECT_EQ("UmaHistogram", histograms[0]);
- EXPECT_EQ("UmaStabilityHistogram", histograms[1]);
-}
-
-TEST_F(HistogramSnapshotManagerTest, PrepareDeltasUmaHistogramFlagFilter) {
- // Note that kUmaStabilityHistogramFlag includes kUmaTargetedHistogramFlag.
- UMA_HISTOGRAM_ENUMERATION("UmaHistogram", 1, 4);
- UMA_STABILITY_HISTOGRAM_ENUMERATION("UmaStabilityHistogram", 1, 2);
-
- StatisticsRecorder::PrepareDeltas(false, HistogramBase::kNoFlags,
- HistogramBase::kUmaTargetedHistogramFlag,
- &histogram_snapshot_manager_);
-
- const std::vector<std::string>& histograms =
- histogram_flattener_delta_recorder_.GetRecordedDeltaHistogramNames();
- EXPECT_EQ(2U, histograms.size());
- EXPECT_EQ("UmaHistogram", histograms[0]);
- EXPECT_EQ("UmaStabilityHistogram", histograms[1]);
-}
-
-TEST_F(HistogramSnapshotManagerTest,
- PrepareDeltasUmaStabilityHistogramFlagFilter) {
- UMA_HISTOGRAM_ENUMERATION("UmaHistogram", 1, 4);
- UMA_STABILITY_HISTOGRAM_ENUMERATION("UmaStabilityHistogram", 1, 2);
-
- StatisticsRecorder::PrepareDeltas(false, HistogramBase::kNoFlags,
- HistogramBase::kUmaStabilityHistogramFlag,
- &histogram_snapshot_manager_);
-
- const std::vector<std::string>& histograms =
- histogram_flattener_delta_recorder_.GetRecordedDeltaHistogramNames();
- EXPECT_EQ(1U, histograms.size());
- EXPECT_EQ("UmaStabilityHistogram", histograms[0]);
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_unittest.cc b/base/metrics/histogram_unittest.cc
deleted file mode 100644
index b819393..0000000
--- a/base/metrics/histogram_unittest.cc
+++ /dev/null
@@ -1,841 +0,0 @@
-// 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.
-
-#include "base/metrics/histogram.h"
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <climits>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/metrics/bucket_ranges.h"
-#include "base/metrics/dummy_histogram.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/metrics/record_histogram_checker.h"
-#include "base/metrics/sample_vector.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/pickle.h"
-#include "base/strings/stringprintf.h"
-#include "base/test/gtest_util.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-const char kExpiredHistogramName[] = "ExpiredHistogram";
-
-// Test implementation of RecordHistogramChecker interface.
-class TestRecordHistogramChecker : public RecordHistogramChecker {
- public:
- ~TestRecordHistogramChecker() override = default;
-
- // RecordHistogramChecker:
- bool ShouldRecord(uint64_t histogram_hash) const override {
- return histogram_hash != HashMetricName(kExpiredHistogramName);
- }
-};
-
-} // namespace
-
-// Test parameter indicates if a persistent memory allocator should be used
-// for histogram allocation. False will allocate histograms from the process
-// heap.
-class HistogramTest : public testing::TestWithParam<bool> {
- protected:
- const int32_t kAllocatorMemorySize = 8 << 20; // 8 MiB
-
- HistogramTest() : use_persistent_histogram_allocator_(GetParam()) {}
-
- void SetUp() override {
- if (use_persistent_histogram_allocator_)
- CreatePersistentHistogramAllocator();
-
- // Each test will have a clean state (no Histogram / BucketRanges
- // registered).
- InitializeStatisticsRecorder();
- }
-
- void TearDown() override {
- if (allocator_) {
- ASSERT_FALSE(allocator_->IsFull());
- ASSERT_FALSE(allocator_->IsCorrupt());
- }
- UninitializeStatisticsRecorder();
- DestroyPersistentHistogramAllocator();
- }
-
- void InitializeStatisticsRecorder() {
- DCHECK(!statistics_recorder_);
- statistics_recorder_ = StatisticsRecorder::CreateTemporaryForTesting();
- auto record_checker = std::make_unique<TestRecordHistogramChecker>();
- StatisticsRecorder::SetRecordChecker(std::move(record_checker));
- }
-
- void UninitializeStatisticsRecorder() {
- statistics_recorder_.reset();
- }
-
- void CreatePersistentHistogramAllocator() {
- GlobalHistogramAllocator::CreateWithLocalMemory(
- kAllocatorMemorySize, 0, "HistogramAllocatorTest");
- allocator_ = GlobalHistogramAllocator::Get()->memory_allocator();
- }
-
- void DestroyPersistentHistogramAllocator() {
- allocator_ = nullptr;
- GlobalHistogramAllocator::ReleaseForTesting();
- }
-
- const bool use_persistent_histogram_allocator_;
-
- std::unique_ptr<StatisticsRecorder> statistics_recorder_;
- std::unique_ptr<char[]> allocator_memory_;
- PersistentMemoryAllocator* allocator_ = nullptr;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(HistogramTest);
-};
-
-// Run all HistogramTest cases with both heap and persistent memory.
-INSTANTIATE_TEST_CASE_P(HeapAndPersistent, HistogramTest, testing::Bool());
-
-
-// Check for basic syntax and use.
-TEST_P(HistogramTest, BasicTest) {
- // Try basic construction
- HistogramBase* histogram = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- EXPECT_TRUE(histogram);
-
- HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
- "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- EXPECT_TRUE(linear_histogram);
-
- std::vector<int> custom_ranges;
- custom_ranges.push_back(1);
- custom_ranges.push_back(5);
- HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
- "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags);
- EXPECT_TRUE(custom_histogram);
-
- // Macros that create histograms have an internal static variable which will
- // continue to point to those from the very first run of this method even
- // during subsequent runs.
- static bool already_run = false;
- if (already_run)
- return;
- already_run = true;
-
- // Use standard macros (but with fixed samples)
- LOCAL_HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
- LOCAL_HISTOGRAM_COUNTS("Test3Histogram", 30);
-
- LOCAL_HISTOGRAM_ENUMERATION("Test6Histogram", 129, 130);
-}
-
-// Check that the macro correctly matches histograms by name and records their
-// data together.
-TEST_P(HistogramTest, NameMatchTest) {
- // Macros that create histograms have an internal static variable which will
- // continue to point to those from the very first run of this method even
- // during subsequent runs.
- static bool already_run = false;
- if (already_run)
- return;
- already_run = true;
-
- LOCAL_HISTOGRAM_PERCENTAGE("DuplicatedHistogram", 10);
- LOCAL_HISTOGRAM_PERCENTAGE("DuplicatedHistogram", 10);
- HistogramBase* histogram = LinearHistogram::FactoryGet(
- "DuplicatedHistogram", 1, 101, 102, HistogramBase::kNoFlags);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
- EXPECT_EQ(2, samples->TotalCount());
- EXPECT_EQ(2, samples->GetCount(10));
-}
-
-// Check that delta calculations work correctly.
-TEST_P(HistogramTest, DeltaTest) {
- HistogramBase* histogram =
- Histogram::FactoryGet("DeltaHistogram", 1, 64, 8,
- HistogramBase::kNoFlags);
- histogram->Add(1);
- histogram->Add(10);
- histogram->Add(50);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotDelta();
- EXPECT_EQ(3, samples->TotalCount());
- EXPECT_EQ(1, samples->GetCount(1));
- EXPECT_EQ(1, samples->GetCount(10));
- EXPECT_EQ(1, samples->GetCount(50));
- EXPECT_EQ(samples->TotalCount(), samples->redundant_count());
-
- samples = histogram->SnapshotDelta();
- EXPECT_EQ(0, samples->TotalCount());
-
- histogram->Add(10);
- histogram->Add(10);
- samples = histogram->SnapshotDelta();
- EXPECT_EQ(2, samples->TotalCount());
- EXPECT_EQ(2, samples->GetCount(10));
-
- samples = histogram->SnapshotDelta();
- EXPECT_EQ(0, samples->TotalCount());
-}
-
-// Check that final-delta calculations work correctly.
-TEST_P(HistogramTest, FinalDeltaTest) {
- HistogramBase* histogram =
- Histogram::FactoryGet("FinalDeltaHistogram", 1, 64, 8,
- HistogramBase::kNoFlags);
- histogram->Add(1);
- histogram->Add(10);
- histogram->Add(50);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotDelta();
- EXPECT_EQ(3, samples->TotalCount());
- EXPECT_EQ(1, samples->GetCount(1));
- EXPECT_EQ(1, samples->GetCount(10));
- EXPECT_EQ(1, samples->GetCount(50));
- EXPECT_EQ(samples->TotalCount(), samples->redundant_count());
-
- histogram->Add(2);
- histogram->Add(50);
-
- samples = histogram->SnapshotFinalDelta();
- EXPECT_EQ(2, samples->TotalCount());
- EXPECT_EQ(1, samples->GetCount(2));
- EXPECT_EQ(1, samples->GetCount(50));
- EXPECT_EQ(samples->TotalCount(), samples->redundant_count());
-}
-
-TEST_P(HistogramTest, ExponentialRangesTest) {
- // Check that we got a nice exponential when there was enough room.
- BucketRanges ranges(9);
- Histogram::InitializeBucketRanges(1, 64, &ranges);
- EXPECT_EQ(0, ranges.range(0));
- int power_of_2 = 1;
- for (int i = 1; i < 8; i++) {
- EXPECT_EQ(power_of_2, ranges.range(i));
- power_of_2 *= 2;
- }
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges.range(8));
-
- // Check the corresponding Histogram will use the correct ranges.
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
- EXPECT_TRUE(ranges.Equals(histogram->bucket_ranges()));
-
- // When bucket count is limited, exponential ranges will partially look like
- // linear.
- BucketRanges ranges2(16);
- Histogram::InitializeBucketRanges(1, 32, &ranges2);
-
- EXPECT_EQ(0, ranges2.range(0));
- EXPECT_EQ(1, ranges2.range(1));
- EXPECT_EQ(2, ranges2.range(2));
- EXPECT_EQ(3, ranges2.range(3));
- EXPECT_EQ(4, ranges2.range(4));
- EXPECT_EQ(5, ranges2.range(5));
- EXPECT_EQ(6, ranges2.range(6));
- EXPECT_EQ(7, ranges2.range(7));
- EXPECT_EQ(9, ranges2.range(8));
- EXPECT_EQ(11, ranges2.range(9));
- EXPECT_EQ(14, ranges2.range(10));
- EXPECT_EQ(17, ranges2.range(11));
- EXPECT_EQ(21, ranges2.range(12));
- EXPECT_EQ(26, ranges2.range(13));
- EXPECT_EQ(32, ranges2.range(14));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges2.range(15));
-
- // Check the corresponding Histogram will use the correct ranges.
- Histogram* histogram2 = static_cast<Histogram*>(
- Histogram::FactoryGet("Histogram2", 1, 32, 15, HistogramBase::kNoFlags));
- EXPECT_TRUE(ranges2.Equals(histogram2->bucket_ranges()));
-}
-
-TEST_P(HistogramTest, LinearRangesTest) {
- BucketRanges ranges(9);
- LinearHistogram::InitializeBucketRanges(1, 7, &ranges);
- // Gets a nice linear set of bucket ranges.
- for (int i = 0; i < 8; i++)
- EXPECT_EQ(i, ranges.range(i));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges.range(8));
-
- // The correspoding LinearHistogram should use the correct ranges.
- Histogram* histogram = static_cast<Histogram*>(
- LinearHistogram::FactoryGet("Linear", 1, 7, 8, HistogramBase::kNoFlags));
- EXPECT_TRUE(ranges.Equals(histogram->bucket_ranges()));
-
- // Linear ranges are not divisible.
- BucketRanges ranges2(6);
- LinearHistogram::InitializeBucketRanges(1, 6, &ranges2);
- EXPECT_EQ(0, ranges2.range(0));
- EXPECT_EQ(1, ranges2.range(1));
- EXPECT_EQ(3, ranges2.range(2));
- EXPECT_EQ(4, ranges2.range(3));
- EXPECT_EQ(6, ranges2.range(4));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges2.range(5));
- // The correspoding LinearHistogram should use the correct ranges.
- Histogram* histogram2 = static_cast<Histogram*>(
- LinearHistogram::FactoryGet("Linear2", 1, 6, 5, HistogramBase::kNoFlags));
- EXPECT_TRUE(ranges2.Equals(histogram2->bucket_ranges()));
-}
-
-TEST_P(HistogramTest, ArrayToCustomEnumRangesTest) {
- const HistogramBase::Sample ranges[3] = {5, 10, 20};
- std::vector<HistogramBase::Sample> ranges_vec =
- CustomHistogram::ArrayToCustomEnumRanges(ranges);
- ASSERT_EQ(6u, ranges_vec.size());
- EXPECT_EQ(5, ranges_vec[0]);
- EXPECT_EQ(6, ranges_vec[1]);
- EXPECT_EQ(10, ranges_vec[2]);
- EXPECT_EQ(11, ranges_vec[3]);
- EXPECT_EQ(20, ranges_vec[4]);
- EXPECT_EQ(21, ranges_vec[5]);
-}
-
-TEST_P(HistogramTest, CustomHistogramTest) {
- // A well prepared custom ranges.
- std::vector<HistogramBase::Sample> custom_ranges;
- custom_ranges.push_back(1);
- custom_ranges.push_back(2);
-
- Histogram* histogram = static_cast<Histogram*>(
- CustomHistogram::FactoryGet("TestCustomHistogram1", custom_ranges,
- HistogramBase::kNoFlags));
- const BucketRanges* ranges = histogram->bucket_ranges();
- ASSERT_EQ(4u, ranges->size());
- EXPECT_EQ(0, ranges->range(0)); // Auto added.
- EXPECT_EQ(1, ranges->range(1));
- EXPECT_EQ(2, ranges->range(2));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3)); // Auto added.
-
- // A unordered custom ranges.
- custom_ranges.clear();
- custom_ranges.push_back(2);
- custom_ranges.push_back(1);
- histogram = static_cast<Histogram*>(
- CustomHistogram::FactoryGet("TestCustomHistogram2", custom_ranges,
- HistogramBase::kNoFlags));
- ranges = histogram->bucket_ranges();
- ASSERT_EQ(4u, ranges->size());
- EXPECT_EQ(0, ranges->range(0));
- EXPECT_EQ(1, ranges->range(1));
- EXPECT_EQ(2, ranges->range(2));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3));
-
- // A custom ranges with duplicated values.
- custom_ranges.clear();
- custom_ranges.push_back(4);
- custom_ranges.push_back(1);
- custom_ranges.push_back(4);
- histogram = static_cast<Histogram*>(
- CustomHistogram::FactoryGet("TestCustomHistogram3", custom_ranges,
- HistogramBase::kNoFlags));
- ranges = histogram->bucket_ranges();
- ASSERT_EQ(4u, ranges->size());
- EXPECT_EQ(0, ranges->range(0));
- EXPECT_EQ(1, ranges->range(1));
- EXPECT_EQ(4, ranges->range(2));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3));
-}
-
-TEST_P(HistogramTest, CustomHistogramWithOnly2Buckets) {
- // This test exploits the fact that the CustomHistogram can have 2 buckets,
- // while the base class Histogram is *supposed* to have at least 3 buckets.
- // We should probably change the restriction on the base class (or not inherit
- // the base class!).
-
- std::vector<HistogramBase::Sample> custom_ranges;
- custom_ranges.push_back(4);
-
- Histogram* histogram = static_cast<Histogram*>(
- CustomHistogram::FactoryGet("2BucketsCustomHistogram", custom_ranges,
- HistogramBase::kNoFlags));
- const BucketRanges* ranges = histogram->bucket_ranges();
- ASSERT_EQ(3u, ranges->size());
- EXPECT_EQ(0, ranges->range(0));
- EXPECT_EQ(4, ranges->range(1));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(2));
-}
-
-TEST_P(HistogramTest, AddCountTest) {
- const size_t kBucketCount = 50;
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("AddCountHistogram", 10, 100, kBucketCount,
- HistogramBase::kNoFlags));
-
- histogram->AddCount(20, 15);
- histogram->AddCount(30, 14);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
- EXPECT_EQ(29, samples->TotalCount());
- EXPECT_EQ(15, samples->GetCount(20));
- EXPECT_EQ(14, samples->GetCount(30));
-
- histogram->AddCount(20, 25);
- histogram->AddCount(30, 24);
-
- std::unique_ptr<HistogramSamples> samples2 = histogram->SnapshotSamples();
- EXPECT_EQ(78, samples2->TotalCount());
- EXPECT_EQ(40, samples2->GetCount(20));
- EXPECT_EQ(38, samples2->GetCount(30));
-}
-
-TEST_P(HistogramTest, AddCount_LargeValuesDontOverflow) {
- const size_t kBucketCount = 50;
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("AddCountHistogram", 10, 1000000000, kBucketCount,
- HistogramBase::kNoFlags));
-
- histogram->AddCount(200000000, 15);
- histogram->AddCount(300000000, 14);
-
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
- EXPECT_EQ(29, samples->TotalCount());
- EXPECT_EQ(15, samples->GetCount(200000000));
- EXPECT_EQ(14, samples->GetCount(300000000));
-
- histogram->AddCount(200000000, 25);
- histogram->AddCount(300000000, 24);
-
- std::unique_ptr<HistogramSamples> samples2 = histogram->SnapshotSamples();
- EXPECT_EQ(78, samples2->TotalCount());
- EXPECT_EQ(40, samples2->GetCount(200000000));
- EXPECT_EQ(38, samples2->GetCount(300000000));
- EXPECT_EQ(19400000000LL, samples2->sum());
-}
-
-// Some metrics are designed so that they are guaranteed not to overflow between
-// snapshots, but could overflow over a long-running session.
-// Make sure that counts returned by Histogram::SnapshotDelta do not overflow
-// even when a total count (returned by Histogram::SnapshotSample) does.
-TEST_P(HistogramTest, AddCount_LargeCountsDontOverflow) {
- const size_t kBucketCount = 10;
- Histogram* histogram = static_cast<Histogram*>(Histogram::FactoryGet(
- "AddCountHistogram", 10, 50, kBucketCount, HistogramBase::kNoFlags));
-
- const int count = (1 << 30) - 1;
-
- // Repeat N times to make sure that there is no internal value overflow.
- for (int i = 0; i < 10; ++i) {
- histogram->AddCount(42, count);
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotDelta();
- EXPECT_EQ(count, samples->TotalCount());
- EXPECT_EQ(count, samples->GetCount(42));
- }
-}
-
-// Make sure histogram handles out-of-bounds data gracefully.
-TEST_P(HistogramTest, BoundsTest) {
- const size_t kBucketCount = 50;
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("Bounded", 10, 100, kBucketCount,
- HistogramBase::kNoFlags));
-
- // Put two samples "out of bounds" above and below.
- histogram->Add(5);
- histogram->Add(-50);
-
- histogram->Add(100);
- histogram->Add(10000);
-
- // Verify they landed in the underflow, and overflow buckets.
- std::unique_ptr<SampleVector> samples = histogram->SnapshotAllSamples();
- EXPECT_EQ(2, samples->GetCountAtIndex(0));
- EXPECT_EQ(0, samples->GetCountAtIndex(1));
- size_t array_size = histogram->bucket_count();
- EXPECT_EQ(kBucketCount, array_size);
- EXPECT_EQ(0, samples->GetCountAtIndex(array_size - 2));
- EXPECT_EQ(2, samples->GetCountAtIndex(array_size - 1));
-
- std::vector<int> custom_ranges;
- custom_ranges.push_back(10);
- custom_ranges.push_back(50);
- custom_ranges.push_back(100);
- Histogram* test_custom_histogram = static_cast<Histogram*>(
- CustomHistogram::FactoryGet("TestCustomRangeBoundedHistogram",
- custom_ranges, HistogramBase::kNoFlags));
-
- // Put two samples "out of bounds" above and below.
- test_custom_histogram->Add(5);
- test_custom_histogram->Add(-50);
- test_custom_histogram->Add(100);
- test_custom_histogram->Add(1000);
- test_custom_histogram->Add(INT_MAX);
-
- // Verify they landed in the underflow, and overflow buckets.
- std::unique_ptr<SampleVector> custom_samples =
- test_custom_histogram->SnapshotAllSamples();
- EXPECT_EQ(2, custom_samples->GetCountAtIndex(0));
- EXPECT_EQ(0, custom_samples->GetCountAtIndex(1));
- size_t bucket_count = test_custom_histogram->bucket_count();
- EXPECT_EQ(0, custom_samples->GetCountAtIndex(bucket_count - 2));
- EXPECT_EQ(3, custom_samples->GetCountAtIndex(bucket_count - 1));
-}
-
-// Check to be sure samples land as expected is "correct" buckets.
-TEST_P(HistogramTest, BucketPlacementTest) {
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
-
- // Add i+1 samples to the i'th bucket.
- histogram->Add(0);
- int power_of_2 = 1;
- for (int i = 1; i < 8; i++) {
- for (int j = 0; j <= i; j++)
- histogram->Add(power_of_2);
- power_of_2 *= 2;
- }
-
- // Check to see that the bucket counts reflect our additions.
- std::unique_ptr<SampleVector> samples = histogram->SnapshotAllSamples();
- for (int i = 0; i < 8; i++)
- EXPECT_EQ(i + 1, samples->GetCountAtIndex(i));
-}
-
-TEST_P(HistogramTest, CorruptSampleCounts) {
- // The internal code creates histograms via macros and thus keeps static
- // pointers to them. If those pointers are to persistent memory which will
- // be free'd then any following calls to that code will crash with a
- // segmentation violation.
- if (use_persistent_histogram_allocator_)
- return;
-
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
-
- // Add some samples.
- histogram->Add(20);
- histogram->Add(40);
-
- std::unique_ptr<SampleVector> snapshot = histogram->SnapshotAllSamples();
- EXPECT_EQ(HistogramBase::NO_INCONSISTENCIES,
- histogram->FindCorruption(*snapshot));
- EXPECT_EQ(2, snapshot->redundant_count());
- EXPECT_EQ(2, snapshot->TotalCount());
-
- snapshot->counts()[3] += 100; // Sample count won't match redundant count.
- EXPECT_EQ(HistogramBase::COUNT_LOW_ERROR,
- histogram->FindCorruption(*snapshot));
- snapshot->counts()[2] -= 200;
- EXPECT_EQ(HistogramBase::COUNT_HIGH_ERROR,
- histogram->FindCorruption(*snapshot));
-
- // But we can't spot a corruption if it is compensated for.
- snapshot->counts()[1] += 100;
- EXPECT_EQ(HistogramBase::NO_INCONSISTENCIES,
- histogram->FindCorruption(*snapshot));
-}
-
-TEST_P(HistogramTest, CorruptBucketBounds) {
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
-
- std::unique_ptr<HistogramSamples> snapshot = histogram->SnapshotSamples();
- EXPECT_EQ(HistogramBase::NO_INCONSISTENCIES,
- histogram->FindCorruption(*snapshot));
-
- BucketRanges* bucket_ranges =
- const_cast<BucketRanges*>(histogram->bucket_ranges());
- HistogramBase::Sample tmp = bucket_ranges->range(1);
- bucket_ranges->set_range(1, bucket_ranges->range(2));
- bucket_ranges->set_range(2, tmp);
- EXPECT_EQ(
- HistogramBase::BUCKET_ORDER_ERROR | HistogramBase::RANGE_CHECKSUM_ERROR,
- histogram->FindCorruption(*snapshot));
-
- bucket_ranges->set_range(2, bucket_ranges->range(1));
- bucket_ranges->set_range(1, tmp);
- EXPECT_EQ(0U, histogram->FindCorruption(*snapshot));
-
- // Show that two simple changes don't offset each other
- bucket_ranges->set_range(3, bucket_ranges->range(3) + 1);
- EXPECT_EQ(HistogramBase::RANGE_CHECKSUM_ERROR,
- histogram->FindCorruption(*snapshot));
-
- bucket_ranges->set_range(4, bucket_ranges->range(4) - 1);
- EXPECT_EQ(HistogramBase::RANGE_CHECKSUM_ERROR,
- histogram->FindCorruption(*snapshot));
-
- // Repair histogram so that destructor won't DCHECK().
- bucket_ranges->set_range(3, bucket_ranges->range(3) - 1);
- bucket_ranges->set_range(4, bucket_ranges->range(4) + 1);
-}
-
-TEST_P(HistogramTest, HistogramSerializeInfo) {
- Histogram* histogram = static_cast<Histogram*>(
- Histogram::FactoryGet("Histogram", 1, 64, 8,
- HistogramBase::kIPCSerializationSourceFlag));
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
-
- int type;
- EXPECT_TRUE(iter.ReadInt(&type));
- EXPECT_EQ(HISTOGRAM, type);
-
- std::string name;
- EXPECT_TRUE(iter.ReadString(&name));
- EXPECT_EQ("Histogram", name);
-
- int flag;
- EXPECT_TRUE(iter.ReadInt(&flag));
- EXPECT_EQ(HistogramBase::kIPCSerializationSourceFlag,
- flag & ~HistogramBase::kIsPersistent);
-
- int min;
- EXPECT_TRUE(iter.ReadInt(&min));
- EXPECT_EQ(1, min);
-
- int max;
- EXPECT_TRUE(iter.ReadInt(&max));
- EXPECT_EQ(64, max);
-
- uint32_t bucket_count;
- EXPECT_TRUE(iter.ReadUInt32(&bucket_count));
- EXPECT_EQ(8u, bucket_count);
-
- uint32_t checksum;
- EXPECT_TRUE(iter.ReadUInt32(&checksum));
- EXPECT_EQ(histogram->bucket_ranges()->checksum(), checksum);
-
- // No more data in the pickle.
- EXPECT_FALSE(iter.SkipBytes(1));
-}
-
-TEST_P(HistogramTest, CustomHistogramSerializeInfo) {
- std::vector<int> custom_ranges;
- custom_ranges.push_back(10);
- custom_ranges.push_back(100);
-
- HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
- "TestCustomRangeBoundedHistogram",
- custom_ranges,
- HistogramBase::kNoFlags);
- Pickle pickle;
- custom_histogram->SerializeInfo(&pickle);
-
- // Validate the pickle.
- PickleIterator iter(pickle);
-
- int i;
- std::string s;
- uint32_t bucket_count;
- uint32_t ui32;
- EXPECT_TRUE(iter.ReadInt(&i) && iter.ReadString(&s) && iter.ReadInt(&i) &&
- iter.ReadInt(&i) && iter.ReadInt(&i) &&
- iter.ReadUInt32(&bucket_count) && iter.ReadUInt32(&ui32));
- EXPECT_EQ(3u, bucket_count);
-
- int range;
- EXPECT_TRUE(iter.ReadInt(&range));
- EXPECT_EQ(10, range);
- EXPECT_TRUE(iter.ReadInt(&range));
- EXPECT_EQ(100, range);
-
- // No more data in the pickle.
- EXPECT_FALSE(iter.SkipBytes(1));
-}
-
-TEST_P(HistogramTest, BadConstruction) {
- HistogramBase* histogram = Histogram::FactoryGet(
- "BadConstruction", 0, 100, 8, HistogramBase::kNoFlags);
- EXPECT_TRUE(histogram->HasConstructionArguments(1, 100, 8));
-
- // Try to get the same histogram name with different arguments.
- HistogramBase* bad_histogram = Histogram::FactoryGet(
- "BadConstruction", 0, 100, 7, HistogramBase::kNoFlags);
- EXPECT_EQ(DummyHistogram::GetInstance(), bad_histogram);
- bad_histogram = Histogram::FactoryGet(
- "BadConstruction", 0, 99, 8, HistogramBase::kNoFlags);
- EXPECT_EQ(DummyHistogram::GetInstance(), bad_histogram);
-
- HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
- "BadConstructionLinear", 0, 100, 8, HistogramBase::kNoFlags);
- EXPECT_TRUE(linear_histogram->HasConstructionArguments(1, 100, 8));
-
- // Try to get the same histogram name with different arguments.
- bad_histogram = LinearHistogram::FactoryGet(
- "BadConstructionLinear", 0, 100, 7, HistogramBase::kNoFlags);
- EXPECT_EQ(DummyHistogram::GetInstance(), bad_histogram);
- bad_histogram = LinearHistogram::FactoryGet(
- "BadConstructionLinear", 10, 100, 8, HistogramBase::kNoFlags);
- EXPECT_EQ(DummyHistogram::GetInstance(), bad_histogram);
-}
-
-TEST_P(HistogramTest, FactoryTime) {
- const int kTestCreateCount = 1 << 14; // Must be power-of-2.
- const int kTestLookupCount = 100000;
- const int kTestAddCount = 1000000;
-
- // Create all histogram names in advance for accurate timing below.
- std::vector<std::string> histogram_names;
- for (int i = 0; i < kTestCreateCount; ++i) {
- histogram_names.push_back(
- StringPrintf("TestHistogram.%d", i % kTestCreateCount));
- }
-
- // Calculate cost of creating histograms.
- TimeTicks create_start = TimeTicks::Now();
- for (int i = 0; i < kTestCreateCount; ++i) {
- Histogram::FactoryGet(histogram_names[i], 1, 100, 10,
- HistogramBase::kNoFlags);
- }
- TimeDelta create_ticks = TimeTicks::Now() - create_start;
- int64_t create_ms = create_ticks.InMilliseconds();
-
- VLOG(1) << kTestCreateCount << " histogram creations took " << create_ms
- << "ms or about "
- << (create_ms * 1000000) / kTestCreateCount
- << "ns each.";
-
- // Calculate cost of looking up existing histograms.
- TimeTicks lookup_start = TimeTicks::Now();
- for (int i = 0; i < kTestLookupCount; ++i) {
- // 6007 is co-prime with kTestCreateCount and so will do lookups in an
- // order less likely to be cacheable (but still hit them all) should the
- // underlying storage use the exact histogram name as the key.
- const int i_mult = 6007;
- static_assert(i_mult < INT_MAX / kTestCreateCount, "Multiplier too big");
- int index = (i * i_mult) & (kTestCreateCount - 1);
- Histogram::FactoryGet(histogram_names[index], 1, 100, 10,
- HistogramBase::kNoFlags);
- }
- TimeDelta lookup_ticks = TimeTicks::Now() - lookup_start;
- int64_t lookup_ms = lookup_ticks.InMilliseconds();
-
- VLOG(1) << kTestLookupCount << " histogram lookups took " << lookup_ms
- << "ms or about "
- << (lookup_ms * 1000000) / kTestLookupCount
- << "ns each.";
-
- // Calculate cost of accessing histograms.
- HistogramBase* histogram = Histogram::FactoryGet(
- histogram_names[0], 1, 100, 10, HistogramBase::kNoFlags);
- ASSERT_TRUE(histogram);
- TimeTicks add_start = TimeTicks::Now();
- for (int i = 0; i < kTestAddCount; ++i)
- histogram->Add(i & 127);
- TimeDelta add_ticks = TimeTicks::Now() - add_start;
- int64_t add_ms = add_ticks.InMilliseconds();
-
- VLOG(1) << kTestAddCount << " histogram adds took " << add_ms
- << "ms or about "
- << (add_ms * 1000000) / kTestAddCount
- << "ns each.";
-}
-
-// For Histogram, LinearHistogram and CustomHistogram, the minimum for a
-// declared range is 1, while the maximum is (HistogramBase::kSampleType_MAX -
-// 1). But we accept ranges exceeding those limits, and silently clamped to
-// those limits. This is for backwards compatibility.
-TEST(HistogramDeathTest, BadRangesTest) {
- HistogramBase* histogram = Histogram::FactoryGet(
- "BadRanges", 0, HistogramBase::kSampleType_MAX, 8,
- HistogramBase::kNoFlags);
- EXPECT_TRUE(
- histogram->HasConstructionArguments(
- 1, HistogramBase::kSampleType_MAX - 1, 8));
-
- HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
- "BadRangesLinear", 0, HistogramBase::kSampleType_MAX, 8,
- HistogramBase::kNoFlags);
- EXPECT_TRUE(
- linear_histogram->HasConstructionArguments(
- 1, HistogramBase::kSampleType_MAX - 1, 8));
-
- std::vector<int> custom_ranges;
- custom_ranges.push_back(0);
- custom_ranges.push_back(5);
- Histogram* custom_histogram = static_cast<Histogram*>(
- CustomHistogram::FactoryGet(
- "BadRangesCustom", custom_ranges, HistogramBase::kNoFlags));
- const BucketRanges* ranges = custom_histogram->bucket_ranges();
- ASSERT_EQ(3u, ranges->size());
- EXPECT_EQ(0, ranges->range(0));
- EXPECT_EQ(5, ranges->range(1));
- EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(2));
-
- // CustomHistogram does not accepts kSampleType_MAX as range.
- custom_ranges.push_back(HistogramBase::kSampleType_MAX);
- EXPECT_DEATH_IF_SUPPORTED(
- CustomHistogram::FactoryGet("BadRangesCustom2", custom_ranges,
- HistogramBase::kNoFlags),
- "");
-
- // CustomHistogram needs at least 1 valid range.
- custom_ranges.clear();
- custom_ranges.push_back(0);
- EXPECT_DEATH_IF_SUPPORTED(
- CustomHistogram::FactoryGet("BadRangesCustom3", custom_ranges,
- HistogramBase::kNoFlags),
- "");
-}
-
-TEST_P(HistogramTest, ExpiredHistogramTest) {
- HistogramBase* expired = Histogram::FactoryGet(kExpiredHistogramName, 1, 1000,
- 10, HistogramBase::kNoFlags);
- ASSERT_TRUE(expired);
- expired->Add(5);
- expired->Add(500);
- auto samples = expired->SnapshotDelta();
- EXPECT_EQ(0, samples->TotalCount());
-
- HistogramBase* linear_expired = LinearHistogram::FactoryGet(
- kExpiredHistogramName, 1, 1000, 10, HistogramBase::kNoFlags);
- ASSERT_TRUE(linear_expired);
- linear_expired->Add(5);
- linear_expired->Add(500);
- samples = linear_expired->SnapshotDelta();
- EXPECT_EQ(0, samples->TotalCount());
-
- std::vector<int> custom_ranges;
- custom_ranges.push_back(1);
- custom_ranges.push_back(5);
- HistogramBase* custom_expired = CustomHistogram::FactoryGet(
- kExpiredHistogramName, custom_ranges, HistogramBase::kNoFlags);
- ASSERT_TRUE(custom_expired);
- custom_expired->Add(2);
- custom_expired->Add(4);
- samples = custom_expired->SnapshotDelta();
- EXPECT_EQ(0, samples->TotalCount());
-
- HistogramBase* valid = Histogram::FactoryGet("ValidHistogram", 1, 1000, 10,
- HistogramBase::kNoFlags);
- ASSERT_TRUE(valid);
- valid->Add(5);
- valid->Add(500);
- samples = valid->SnapshotDelta();
- EXPECT_EQ(2, samples->TotalCount());
-
- HistogramBase* linear_valid = LinearHistogram::FactoryGet(
- "LinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- ASSERT_TRUE(linear_valid);
- linear_valid->Add(5);
- linear_valid->Add(500);
- samples = linear_valid->SnapshotDelta();
- EXPECT_EQ(2, samples->TotalCount());
-
- HistogramBase* custom_valid = CustomHistogram::FactoryGet(
- "CustomHistogram", custom_ranges, HistogramBase::kNoFlags);
- ASSERT_TRUE(custom_valid);
- custom_valid->Add(2);
- custom_valid->Add(4);
- samples = custom_valid->SnapshotDelta();
- EXPECT_EQ(2, samples->TotalCount());
-}
-
-} // namespace base
diff --git a/base/metrics/histogram_unittest.nc b/base/metrics/histogram_unittest.nc
deleted file mode 100644
index c9c2657..0000000
--- a/base/metrics/histogram_unittest.nc
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2016 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/histogram_macros.h"
-
-namespace base {
-
-#if defined(NCTEST_DIFFERENT_ENUM) // [r"\|sample\| and \|boundary\| shouldn't be of different enums"]
-
-void WontCompile() {
- enum TypeA { A };
- enum TypeB { B };
- UMA_HISTOGRAM_ENUMERATION("", A, B);
-}
-
-#elif defined(NCTEST_DIFFERENT_ENUM_CLASS) // [r"\|sample\| and \|boundary\| shouldn't be of different enums"]
-
-void WontCompile() {
- enum class TypeA { A };
- enum class TypeB { B };
- UMA_HISTOGRAM_ENUMERATION("", TypeA::A, TypeB::B);
-}
-
-#elif defined(NCTEST_DIFFERENT_ENUM_MIXED) // [r"\|sample\| and \|boundary\| shouldn't be of different enums"]
-
-void WontCompile() {
- enum class TypeA { A };
- enum TypeB { B };
- UMA_HISTOGRAM_ENUMERATION("", TypeA::A, B);
-}
-
-#elif defined(NCTEST_NEGATIVE_ENUM_MAX) // [r'static_assert failed "\|boundary\| is out of range of HistogramBase::Sample"']
-
-void WontCompile() {
- // Buckets for enumeration start from 0, so a boundary < 0 is illegal.
- enum class TypeA { A = -1 };
- UMA_HISTOGRAM_ENUMERATION("", TypeA::A, TypeA::A);
-}
-
-#elif defined(NCTEST_ENUM_MAX_OUT_OF_RANGE) // [r'static_assert failed "\|boundary\| is out of range of HistogramBase::Sample"']
-
-void WontCompile() {
- // HistogramBase::Sample is an int and can't hold larger values.
- enum class TypeA : uint32_t { A = 0xffffffff };
- UMA_HISTOGRAM_ENUMERATION("", TypeA::A, TypeA::A);
-}
-
-#elif defined(NCTEST_SAMPLE_NOT_ENUM) // [r'static_assert failed "Unexpected: \|boundary\| is enum, but \|sample\| is not."']
-
-void WontCompile() {
- enum TypeA { A };
- UMA_HISTOGRAM_ENUMERATION("", 0, TypeA::A);
-}
-
-#elif defined(NCTEST_FUNCTION_INT) // [r"Non enum passed to UmaHistogramEnumeration"]
-
-void WontCompile() {
- UmaHistogramEnumeration("", 1, 2);
-}
-
-#elif defined(NCTEST_FUNCTION_DIFFERENT_ENUM) // [r"no matching function for call to 'UmaHistogramEnumeration'"]
-
-void WontCompile() {
- enum TypeA { A };
- enum TypeB { B };
- UmaHistogramEnumeration("", A, B);
-}
-
-#elif defined(NCTEST_FUNCTION_FIRST_NOT_ENUM) // [r"no matching function for call to 'UmaHistogramEnumeration'"]
-
-void WontCompile() {
- enum TypeB { B };
- UmaHistogramEnumeration("", 1, B);
-}
-
-#elif defined(NCTEST_FUNCTION_SECOND_NOT_ENUM) // [r"no matching function for call to 'UmaHistogramEnumeration'"]
-
-void WontCompile() {
- enum TypeA { A };
- UmaHistogramEnumeration("", A, 2);
-}
-
-#endif
-
-} // namespace base
diff --git a/base/metrics/metrics_hashes_unittest.cc b/base/metrics/metrics_hashes_unittest.cc
deleted file mode 100644
index aea254e..0000000
--- a/base/metrics/metrics_hashes_unittest.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2014 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 "base/metrics/metrics_hashes.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/format_macros.h"
-#include "base/macros.h"
-#include "base/strings/stringprintf.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// Make sure our ID hashes are the same as what we see on the server side.
-TEST(MetricsUtilTest, HashMetricName) {
- static const struct {
- std::string input;
- std::string output;
- } cases[] = {
- {"Back", "0x0557fa923dcee4d0"},
- {"Forward", "0x67d2f6740a8eaebf"},
- {"NewTab", "0x290eb683f96572f1"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- uint64_t hash = HashMetricName(cases[i].input);
- std::string hash_hex = base::StringPrintf("0x%016" PRIx64, hash);
- EXPECT_EQ(cases[i].output, hash_hex);
- }
-}
-
-} // namespace metrics
diff --git a/base/metrics/persistent_histogram_allocator_unittest.cc b/base/metrics/persistent_histogram_allocator_unittest.cc
deleted file mode 100644
index 7e07386..0000000
--- a/base/metrics/persistent_histogram_allocator_unittest.cc
+++ /dev/null
@@ -1,375 +0,0 @@
-// Copyright 2016 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 "base/metrics/persistent_histogram_allocator.h"
-
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/bucket_ranges.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/metrics/statistics_recorder.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class PersistentHistogramAllocatorTest : public testing::Test {
- protected:
- const int32_t kAllocatorMemorySize = 64 << 10; // 64 KiB
-
- PersistentHistogramAllocatorTest()
- : statistics_recorder_(StatisticsRecorder::CreateTemporaryForTesting()) {
- CreatePersistentHistogramAllocator();
- }
- ~PersistentHistogramAllocatorTest() override {
- DestroyPersistentHistogramAllocator();
- }
-
- void CreatePersistentHistogramAllocator() {
- allocator_memory_.reset(new char[kAllocatorMemorySize]);
-
- GlobalHistogramAllocator::ReleaseForTesting();
- memset(allocator_memory_.get(), 0, kAllocatorMemorySize);
- GlobalHistogramAllocator::CreateWithPersistentMemory(
- allocator_memory_.get(), kAllocatorMemorySize, 0, 0,
- "PersistentHistogramAllocatorTest");
- allocator_ = GlobalHistogramAllocator::Get()->memory_allocator();
- }
-
- void DestroyPersistentHistogramAllocator() {
- allocator_ = nullptr;
- GlobalHistogramAllocator::ReleaseForTesting();
- }
-
- std::unique_ptr<StatisticsRecorder> statistics_recorder_;
- std::unique_ptr<char[]> allocator_memory_;
- PersistentMemoryAllocator* allocator_ = nullptr;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(PersistentHistogramAllocatorTest);
-};
-
-TEST_F(PersistentHistogramAllocatorTest, CreateAndIterate) {
- PersistentMemoryAllocator::MemoryInfo meminfo0;
- allocator_->GetMemoryInfo(&meminfo0);
-
- // Try basic construction
- HistogramBase* histogram = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10, HistogramBase::kIsPersistent);
- EXPECT_TRUE(histogram);
- histogram->CheckName("TestHistogram");
- PersistentMemoryAllocator::MemoryInfo meminfo1;
- allocator_->GetMemoryInfo(&meminfo1);
- EXPECT_GT(meminfo0.free, meminfo1.free);
-
- HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
- "TestLinearHistogram", 1, 1000, 10, HistogramBase::kIsPersistent);
- EXPECT_TRUE(linear_histogram);
- linear_histogram->CheckName("TestLinearHistogram");
- PersistentMemoryAllocator::MemoryInfo meminfo2;
- allocator_->GetMemoryInfo(&meminfo2);
- EXPECT_GT(meminfo1.free, meminfo2.free);
-
- HistogramBase* boolean_histogram = BooleanHistogram::FactoryGet(
- "TestBooleanHistogram", HistogramBase::kIsPersistent);
- EXPECT_TRUE(boolean_histogram);
- boolean_histogram->CheckName("TestBooleanHistogram");
- PersistentMemoryAllocator::MemoryInfo meminfo3;
- allocator_->GetMemoryInfo(&meminfo3);
- EXPECT_GT(meminfo2.free, meminfo3.free);
-
- std::vector<int> custom_ranges;
- custom_ranges.push_back(1);
- custom_ranges.push_back(5);
- HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
- "TestCustomHistogram", custom_ranges, HistogramBase::kIsPersistent);
- EXPECT_TRUE(custom_histogram);
- custom_histogram->CheckName("TestCustomHistogram");
- PersistentMemoryAllocator::MemoryInfo meminfo4;
- allocator_->GetMemoryInfo(&meminfo4);
- EXPECT_GT(meminfo3.free, meminfo4.free);
-
- PersistentMemoryAllocator::Iterator iter(allocator_);
- uint32_t type;
- EXPECT_NE(0U, iter.GetNext(&type)); // Histogram
- EXPECT_NE(0U, iter.GetNext(&type)); // LinearHistogram
- EXPECT_NE(0U, iter.GetNext(&type)); // BooleanHistogram
- EXPECT_NE(0U, iter.GetNext(&type)); // CustomHistogram
- EXPECT_EQ(0U, iter.GetNext(&type));
-
- // Create a second allocator and have it access the memory of the first.
- std::unique_ptr<HistogramBase> recovered;
- PersistentHistogramAllocator recovery(
- std::make_unique<PersistentMemoryAllocator>(
- allocator_memory_.get(), kAllocatorMemorySize, 0, 0, "", false));
- PersistentHistogramAllocator::Iterator histogram_iter(&recovery);
-
- recovered = histogram_iter.GetNext();
- ASSERT_TRUE(recovered);
- recovered->CheckName("TestHistogram");
-
- recovered = histogram_iter.GetNext();
- ASSERT_TRUE(recovered);
- recovered->CheckName("TestLinearHistogram");
-
- recovered = histogram_iter.GetNext();
- ASSERT_TRUE(recovered);
- recovered->CheckName("TestBooleanHistogram");
-
- recovered = histogram_iter.GetNext();
- ASSERT_TRUE(recovered);
- recovered->CheckName("TestCustomHistogram");
-
- recovered = histogram_iter.GetNext();
- EXPECT_FALSE(recovered);
-}
-
-TEST_F(PersistentHistogramAllocatorTest, ConstructPaths) {
- const FilePath dir_path(FILE_PATH_LITERAL("foo/"));
- const std::string dir_string =
- dir_path.NormalizePathSeparators().AsUTF8Unsafe();
-
- FilePath path = GlobalHistogramAllocator::ConstructFilePath(dir_path, "bar");
- EXPECT_EQ(dir_string + "bar.pma", path.AsUTF8Unsafe());
-
- std::string name;
- Time stamp;
- ProcessId pid;
- EXPECT_FALSE(
- GlobalHistogramAllocator::ParseFilePath(path, &name, nullptr, nullptr));
- EXPECT_FALSE(
- GlobalHistogramAllocator::ParseFilePath(path, nullptr, &stamp, nullptr));
- EXPECT_FALSE(
- GlobalHistogramAllocator::ParseFilePath(path, nullptr, nullptr, &pid));
-
- path = GlobalHistogramAllocator::ConstructFilePathForUploadDir(
- dir_path, "bar", Time::FromTimeT(12345), 6789);
- EXPECT_EQ(dir_string + "bar-3039-1A85.pma", path.AsUTF8Unsafe());
- ASSERT_TRUE(
- GlobalHistogramAllocator::ParseFilePath(path, &name, &stamp, &pid));
- EXPECT_EQ(name, "bar");
- EXPECT_EQ(Time::FromTimeT(12345), stamp);
- EXPECT_EQ(static_cast<ProcessId>(6789), pid);
-}
-
-TEST_F(PersistentHistogramAllocatorTest, CreateWithFile) {
- const char temp_name[] = "CreateWithFileTest";
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath temp_file = temp_dir.GetPath().AppendASCII(temp_name);
- const size_t temp_size = 64 << 10; // 64 KiB
-
- // Test creation of a new file.
- GlobalHistogramAllocator::ReleaseForTesting();
- GlobalHistogramAllocator::CreateWithFile(temp_file, temp_size, 0, temp_name);
- EXPECT_EQ(std::string(temp_name),
- GlobalHistogramAllocator::Get()->memory_allocator()->Name());
-
- // Test re-open of a possibly-existing file.
- GlobalHistogramAllocator::ReleaseForTesting();
- GlobalHistogramAllocator::CreateWithFile(temp_file, temp_size, 0, "");
- EXPECT_EQ(std::string(temp_name),
- GlobalHistogramAllocator::Get()->memory_allocator()->Name());
-
- // Test re-open of an known-existing file.
- GlobalHistogramAllocator::ReleaseForTesting();
- GlobalHistogramAllocator::CreateWithFile(temp_file, 0, 0, "");
- EXPECT_EQ(std::string(temp_name),
- GlobalHistogramAllocator::Get()->memory_allocator()->Name());
-
- // Final release so file and temp-dir can be removed.
- GlobalHistogramAllocator::ReleaseForTesting();
-}
-
-TEST_F(PersistentHistogramAllocatorTest, CreateSpareFile) {
- const char temp_name[] = "CreateSpareFileTest.pma";
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath temp_file = temp_dir.GetPath().AppendASCII(temp_name);
- const size_t temp_size = 64 << 10; // 64 KiB
-
- ASSERT_TRUE(GlobalHistogramAllocator::CreateSpareFile(temp_file, temp_size));
-
- File file(temp_file, File::FLAG_OPEN | File::FLAG_READ);
- ASSERT_TRUE(file.IsValid());
- EXPECT_EQ(static_cast<int64_t>(temp_size), file.GetLength());
-
- char buffer[256];
- for (size_t pos = 0; pos < temp_size; pos += sizeof(buffer)) {
- ASSERT_EQ(static_cast<int>(sizeof(buffer)),
- file.ReadAtCurrentPos(buffer, sizeof(buffer)));
- for (size_t i = 0; i < sizeof(buffer); ++i)
- EXPECT_EQ(0, buffer[i]);
- }
-}
-
-TEST_F(PersistentHistogramAllocatorTest, StatisticsRecorderMerge) {
- const char LinearHistogramName[] = "SRTLinearHistogram";
- const char SparseHistogramName[] = "SRTSparseHistogram";
- const size_t starting_sr_count = StatisticsRecorder::GetHistogramCount();
-
- // Create a local StatisticsRecorder in which the newly created histogram
- // will be recorded. The global allocator must be replaced after because the
- // act of releasing will cause the active SR to forget about all histograms
- // in the relased memory.
- std::unique_ptr<StatisticsRecorder> local_sr =
- StatisticsRecorder::CreateTemporaryForTesting();
- EXPECT_EQ(0U, StatisticsRecorder::GetHistogramCount());
- std::unique_ptr<GlobalHistogramAllocator> old_allocator =
- GlobalHistogramAllocator::ReleaseForTesting();
- GlobalHistogramAllocator::CreateWithLocalMemory(kAllocatorMemorySize, 0, "");
- ASSERT_TRUE(GlobalHistogramAllocator::Get());
-
- // Create a linear histogram for merge testing.
- HistogramBase* histogram1 =
- LinearHistogram::FactoryGet(LinearHistogramName, 1, 10, 10, 0);
- ASSERT_TRUE(histogram1);
- EXPECT_EQ(1U, StatisticsRecorder::GetHistogramCount());
- histogram1->Add(3);
- histogram1->Add(1);
- histogram1->Add(4);
- histogram1->AddCount(1, 4);
- histogram1->Add(6);
-
- // Create a sparse histogram for merge testing.
- HistogramBase* histogram2 =
- SparseHistogram::FactoryGet(SparseHistogramName, 0);
- ASSERT_TRUE(histogram2);
- EXPECT_EQ(2U, StatisticsRecorder::GetHistogramCount());
- histogram2->Add(3);
- histogram2->Add(1);
- histogram2->Add(4);
- histogram2->AddCount(1, 4);
- histogram2->Add(6);
-
- // Destroy the local SR and ensure that we're back to the initial state and
- // restore the global allocator. Histograms created in the local SR will
- // become unmanaged.
- std::unique_ptr<GlobalHistogramAllocator> new_allocator =
- GlobalHistogramAllocator::ReleaseForTesting();
- local_sr.reset();
- EXPECT_EQ(starting_sr_count, StatisticsRecorder::GetHistogramCount());
- GlobalHistogramAllocator::Set(std::move(old_allocator));
-
- // Create a "recovery" allocator using the same memory as the local one.
- PersistentHistogramAllocator recovery1(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(new_allocator->memory_allocator()->data()),
- new_allocator->memory_allocator()->size(), 0, 0, "", false));
- PersistentHistogramAllocator::Iterator histogram_iter1(&recovery1);
-
- // Get the histograms that were created locally (and forgotten) and merge
- // them into the global SR. New objects will be created.
- std::unique_ptr<HistogramBase> recovered;
- while (true) {
- recovered = histogram_iter1.GetNext();
- if (!recovered)
- break;
-
- recovery1.MergeHistogramDeltaToStatisticsRecorder(recovered.get());
- HistogramBase* found =
- StatisticsRecorder::FindHistogram(recovered->histogram_name());
- EXPECT_NE(recovered.get(), found);
- };
- EXPECT_EQ(starting_sr_count + 2, StatisticsRecorder::GetHistogramCount());
-
- // Check the merged histograms for accuracy.
- HistogramBase* found = StatisticsRecorder::FindHistogram(LinearHistogramName);
- ASSERT_TRUE(found);
- std::unique_ptr<HistogramSamples> snapshot = found->SnapshotSamples();
- EXPECT_EQ(found->SnapshotSamples()->TotalCount(), snapshot->TotalCount());
- EXPECT_EQ(1, snapshot->GetCount(3));
- EXPECT_EQ(5, snapshot->GetCount(1));
- EXPECT_EQ(1, snapshot->GetCount(4));
- EXPECT_EQ(1, snapshot->GetCount(6));
-
- found = StatisticsRecorder::FindHistogram(SparseHistogramName);
- ASSERT_TRUE(found);
- snapshot = found->SnapshotSamples();
- EXPECT_EQ(found->SnapshotSamples()->TotalCount(), snapshot->TotalCount());
- EXPECT_EQ(1, snapshot->GetCount(3));
- EXPECT_EQ(5, snapshot->GetCount(1));
- EXPECT_EQ(1, snapshot->GetCount(4));
- EXPECT_EQ(1, snapshot->GetCount(6));
-
- // Perform additional histogram increments.
- histogram1->AddCount(1, 3);
- histogram1->Add(6);
- histogram2->AddCount(1, 3);
- histogram2->Add(7);
-
- // Do another merge.
- PersistentHistogramAllocator recovery2(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(new_allocator->memory_allocator()->data()),
- new_allocator->memory_allocator()->size(), 0, 0, "", false));
- PersistentHistogramAllocator::Iterator histogram_iter2(&recovery2);
- while (true) {
- recovered = histogram_iter2.GetNext();
- if (!recovered)
- break;
- recovery2.MergeHistogramDeltaToStatisticsRecorder(recovered.get());
- };
- EXPECT_EQ(starting_sr_count + 2, StatisticsRecorder::GetHistogramCount());
-
- // And verify.
- found = StatisticsRecorder::FindHistogram(LinearHistogramName);
- snapshot = found->SnapshotSamples();
- EXPECT_EQ(found->SnapshotSamples()->TotalCount(), snapshot->TotalCount());
- EXPECT_EQ(1, snapshot->GetCount(3));
- EXPECT_EQ(8, snapshot->GetCount(1));
- EXPECT_EQ(1, snapshot->GetCount(4));
- EXPECT_EQ(2, snapshot->GetCount(6));
-
- found = StatisticsRecorder::FindHistogram(SparseHistogramName);
- snapshot = found->SnapshotSamples();
- EXPECT_EQ(found->SnapshotSamples()->TotalCount(), snapshot->TotalCount());
- EXPECT_EQ(1, snapshot->GetCount(3));
- EXPECT_EQ(8, snapshot->GetCount(1));
- EXPECT_EQ(1, snapshot->GetCount(4));
- EXPECT_EQ(1, snapshot->GetCount(6));
- EXPECT_EQ(1, snapshot->GetCount(7));
-}
-
-TEST_F(PersistentHistogramAllocatorTest, RangesDeDuplication) {
- // This corresponds to the "ranges_ref" field of the PersistentHistogramData
- // structure defined (privately) inside persistent_histogram_allocator.cc.
- const int kRangesRefIndex = 5;
-
- // Create two histograms with the same ranges.
- HistogramBase* histogram1 =
- Histogram::FactoryGet("TestHistogram1", 1, 1000, 10, 0);
- HistogramBase* histogram2 =
- Histogram::FactoryGet("TestHistogram2", 1, 1000, 10, 0);
- const uint32_t ranges_ref = static_cast<Histogram*>(histogram1)
- ->bucket_ranges()
- ->persistent_reference();
- ASSERT_NE(0U, ranges_ref);
- EXPECT_EQ(ranges_ref, static_cast<Histogram*>(histogram2)
- ->bucket_ranges()
- ->persistent_reference());
-
- // Make sure that the persistent data record is also correct. Two histograms
- // will be fetched; other allocations are not "iterable".
- PersistentMemoryAllocator::Iterator iter(allocator_);
- uint32_t type;
- uint32_t ref1 = iter.GetNext(&type);
- uint32_t ref2 = iter.GetNext(&type);
- EXPECT_EQ(0U, iter.GetNext(&type));
- EXPECT_NE(0U, ref1);
- EXPECT_NE(0U, ref2);
- EXPECT_NE(ref1, ref2);
-
- uint32_t* data1 =
- allocator_->GetAsArray<uint32_t>(ref1, 0, kRangesRefIndex + 1);
- uint32_t* data2 =
- allocator_->GetAsArray<uint32_t>(ref2, 0, kRangesRefIndex + 1);
- EXPECT_EQ(ranges_ref, data1[kRangesRefIndex]);
- EXPECT_EQ(ranges_ref, data2[kRangesRefIndex]);
-}
-
-} // namespace base
diff --git a/base/metrics/persistent_histogram_storage_unittest.cc b/base/metrics/persistent_histogram_storage_unittest.cc
deleted file mode 100644
index ed42068..0000000
--- a/base/metrics/persistent_histogram_storage_unittest.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2018 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 "base/metrics/persistent_histogram_storage.h"
-
-#include <memory>
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Name of the allocator for storing histograms.
-constexpr char kTestHistogramAllocatorName[] = "TestMetrics";
-
-} // namespace
-
-class PersistentHistogramStorageTest : public testing::Test {
- protected:
- PersistentHistogramStorageTest() = default;
- ~PersistentHistogramStorageTest() override = default;
-
- // Creates a unique temporary directory, and sets the test storage directory.
- void SetUp() override {
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- test_storage_dir_ =
- temp_dir_path().AppendASCII(kTestHistogramAllocatorName);
- }
-
- // Gets the path to the temporary directory.
- const FilePath& temp_dir_path() { return temp_dir_.GetPath(); }
-
- const FilePath& test_storage_dir() { return test_storage_dir_; }
-
- private:
- // A temporary directory where all file IO operations take place.
- ScopedTempDir temp_dir_;
-
- // The directory into which metrics files are written.
- FilePath test_storage_dir_;
-
- DISALLOW_COPY_AND_ASSIGN(PersistentHistogramStorageTest);
-};
-
-// TODO(chengx): Re-enable the test on OS_IOS after issue 836789 is fixed.
-// PersistentHistogramStorage is only used on OS_WIN now, so disabling this
-// test on OS_IOS is fine.
-#if !defined(OS_NACL) && !defined(OS_IOS)
-TEST_F(PersistentHistogramStorageTest, HistogramWriteTest) {
- auto persistent_histogram_storage =
- std::make_unique<PersistentHistogramStorage>(
- kTestHistogramAllocatorName,
- PersistentHistogramStorage::StorageDirManagement::kCreate);
-
- persistent_histogram_storage->set_storage_base_dir(temp_dir_path());
-
- // Log some random data.
- UMA_HISTOGRAM_BOOLEAN("Some.Test.Metric", true);
-
- // Deleting the object causes the data to be written to the disk.
- persistent_histogram_storage.reset();
-
- // The storage directory and the histogram file are created during the
- // destruction of the PersistentHistogramStorage instance.
- EXPECT_TRUE(DirectoryExists(test_storage_dir()));
- EXPECT_FALSE(IsDirectoryEmpty(test_storage_dir()));
-}
-#endif // !defined(OS_NACL) && !defined(OS_IOS)
-
-} // namespace base
diff --git a/base/metrics/persistent_memory_allocator_unittest.cc b/base/metrics/persistent_memory_allocator_unittest.cc
deleted file mode 100644
index 75e4faa..0000000
--- a/base/metrics/persistent_memory_allocator_unittest.cc
+++ /dev/null
@@ -1,1001 +0,0 @@
-// Copyright 2015 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 "base/metrics/persistent_memory_allocator.h"
-
-#include <memory>
-
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/memory/shared_memory.h"
-#include "base/metrics/histogram.h"
-#include "base/rand_util.h"
-#include "base/strings/safe_sprintf.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/simple_thread.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace base {
-
-namespace {
-
-const uint32_t TEST_MEMORY_SIZE = 1 << 20; // 1 MiB
-const uint32_t TEST_MEMORY_PAGE = 64 << 10; // 64 KiB
-const uint32_t TEST_ID = 12345;
-const char TEST_NAME[] = "TestAllocator";
-
-void SetFileLength(const base::FilePath& path, size_t length) {
- {
- File file(path, File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE);
- DCHECK(file.IsValid());
- ASSERT_TRUE(file.SetLength(static_cast<int64_t>(length)));
- }
-
- int64_t actual_length;
- DCHECK(GetFileSize(path, &actual_length));
- DCHECK_EQ(length, static_cast<size_t>(actual_length));
-}
-
-} // namespace
-
-typedef PersistentMemoryAllocator::Reference Reference;
-
-class PersistentMemoryAllocatorTest : public testing::Test {
- public:
- // This can't be statically initialized because it's value isn't defined
- // in the PersistentMemoryAllocator header file. Instead, it's simply set
- // in the constructor.
- uint32_t kAllocAlignment;
-
- struct TestObject1 {
- static constexpr uint32_t kPersistentTypeId = 1;
- static constexpr size_t kExpectedInstanceSize = 4 + 1 + 3;
- int32_t onething;
- char oranother;
- };
-
- struct TestObject2 {
- static constexpr uint32_t kPersistentTypeId = 2;
- static constexpr size_t kExpectedInstanceSize = 8 + 4 + 4 + 8 + 8;
- int64_t thiis;
- int32_t that;
- float andthe;
- double other;
- char thing[8];
- };
-
- PersistentMemoryAllocatorTest() {
- kAllocAlignment = GetAllocAlignment();
- mem_segment_.reset(new char[TEST_MEMORY_SIZE]);
- }
-
- void SetUp() override {
- allocator_.reset();
- ::memset(mem_segment_.get(), 0, TEST_MEMORY_SIZE);
- allocator_.reset(new PersistentMemoryAllocator(
- mem_segment_.get(), TEST_MEMORY_SIZE, TEST_MEMORY_PAGE,
- TEST_ID, TEST_NAME, false));
- }
-
- void TearDown() override {
- allocator_.reset();
- }
-
- unsigned CountIterables() {
- PersistentMemoryAllocator::Iterator iter(allocator_.get());
- uint32_t type;
- unsigned count = 0;
- while (iter.GetNext(&type) != 0) {
- ++count;
- }
- return count;
- }
-
- static uint32_t GetAllocAlignment() {
- return PersistentMemoryAllocator::kAllocAlignment;
- }
-
- protected:
- std::unique_ptr<char[]> mem_segment_;
- std::unique_ptr<PersistentMemoryAllocator> allocator_;
-};
-
-TEST_F(PersistentMemoryAllocatorTest, AllocateAndIterate) {
- allocator_->CreateTrackingHistograms(allocator_->Name());
-
- std::string base_name(TEST_NAME);
- EXPECT_EQ(TEST_ID, allocator_->Id());
- EXPECT_TRUE(allocator_->used_histogram_);
- EXPECT_EQ("UMA.PersistentAllocator." + base_name + ".UsedPct",
- allocator_->used_histogram_->histogram_name());
- EXPECT_EQ(PersistentMemoryAllocator::MEMORY_INITIALIZED,
- allocator_->GetMemoryState());
-
- // Get base memory info for later comparison.
- PersistentMemoryAllocator::MemoryInfo meminfo0;
- allocator_->GetMemoryInfo(&meminfo0);
- EXPECT_EQ(TEST_MEMORY_SIZE, meminfo0.total);
- EXPECT_GT(meminfo0.total, meminfo0.free);
-
- // Validate allocation of test object and make sure it can be referenced
- // and all metadata looks correct.
- TestObject1* obj1 = allocator_->New<TestObject1>();
- ASSERT_TRUE(obj1);
- Reference block1 = allocator_->GetAsReference(obj1);
- ASSERT_NE(0U, block1);
- EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject1>(block1));
- EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject2>(block1));
- EXPECT_LE(sizeof(TestObject1), allocator_->GetAllocSize(block1));
- EXPECT_GT(sizeof(TestObject1) + kAllocAlignment,
- allocator_->GetAllocSize(block1));
- PersistentMemoryAllocator::MemoryInfo meminfo1;
- allocator_->GetMemoryInfo(&meminfo1);
- EXPECT_EQ(meminfo0.total, meminfo1.total);
- EXPECT_GT(meminfo0.free, meminfo1.free);
-
- // Verify that pointers can be turned back into references and that invalid
- // addresses return null.
- char* memory1 = allocator_->GetAsArray<char>(block1, 1, 1);
- ASSERT_TRUE(memory1);
- EXPECT_EQ(block1, allocator_->GetAsReference(memory1, 0));
- EXPECT_EQ(block1, allocator_->GetAsReference(memory1, 1));
- EXPECT_EQ(0U, allocator_->GetAsReference(memory1, 2));
- EXPECT_EQ(0U, allocator_->GetAsReference(memory1 + 1, 0));
- EXPECT_EQ(0U, allocator_->GetAsReference(memory1 + 16, 0));
- EXPECT_EQ(0U, allocator_->GetAsReference(nullptr, 0));
- EXPECT_EQ(0U, allocator_->GetAsReference(&base_name, 0));
-
- // Ensure that the test-object can be made iterable.
- PersistentMemoryAllocator::Iterator iter1a(allocator_.get());
- EXPECT_EQ(0U, iter1a.GetLast());
- uint32_t type;
- EXPECT_EQ(0U, iter1a.GetNext(&type));
- allocator_->MakeIterable(block1);
- EXPECT_EQ(block1, iter1a.GetNext(&type));
- EXPECT_EQ(1U, type);
- EXPECT_EQ(block1, iter1a.GetLast());
- EXPECT_EQ(0U, iter1a.GetNext(&type));
- EXPECT_EQ(block1, iter1a.GetLast());
-
- // Create second test-object and ensure everything is good and it cannot
- // be confused with test-object of another type.
- TestObject2* obj2 = allocator_->New<TestObject2>();
- ASSERT_TRUE(obj2);
- Reference block2 = allocator_->GetAsReference(obj2);
- ASSERT_NE(0U, block2);
- EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject2>(block2));
- EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject1>(block2));
- EXPECT_LE(sizeof(TestObject2), allocator_->GetAllocSize(block2));
- EXPECT_GT(sizeof(TestObject2) + kAllocAlignment,
- allocator_->GetAllocSize(block2));
- PersistentMemoryAllocator::MemoryInfo meminfo2;
- allocator_->GetMemoryInfo(&meminfo2);
- EXPECT_EQ(meminfo1.total, meminfo2.total);
- EXPECT_GT(meminfo1.free, meminfo2.free);
-
- // Ensure that second test-object can also be made iterable.
- allocator_->MakeIterable(obj2);
- EXPECT_EQ(block2, iter1a.GetNext(&type));
- EXPECT_EQ(2U, type);
- EXPECT_EQ(block2, iter1a.GetLast());
- EXPECT_EQ(0U, iter1a.GetNext(&type));
- EXPECT_EQ(block2, iter1a.GetLast());
-
- // Check that the iterator can be reset to the beginning.
- iter1a.Reset();
- EXPECT_EQ(0U, iter1a.GetLast());
- EXPECT_EQ(block1, iter1a.GetNext(&type));
- EXPECT_EQ(block1, iter1a.GetLast());
- EXPECT_EQ(block2, iter1a.GetNext(&type));
- EXPECT_EQ(block2, iter1a.GetLast());
- EXPECT_EQ(0U, iter1a.GetNext(&type));
-
- // Check that the iterator can be reset to an arbitrary location.
- iter1a.Reset(block1);
- EXPECT_EQ(block1, iter1a.GetLast());
- EXPECT_EQ(block2, iter1a.GetNext(&type));
- EXPECT_EQ(block2, iter1a.GetLast());
- EXPECT_EQ(0U, iter1a.GetNext(&type));
-
- // Check that iteration can begin after an arbitrary location.
- PersistentMemoryAllocator::Iterator iter1b(allocator_.get(), block1);
- EXPECT_EQ(block2, iter1b.GetNext(&type));
- EXPECT_EQ(0U, iter1b.GetNext(&type));
-
- // Ensure nothing has gone noticably wrong.
- EXPECT_FALSE(allocator_->IsFull());
- EXPECT_FALSE(allocator_->IsCorrupt());
-
- // Check the internal histogram record of used memory.
- allocator_->UpdateTrackingHistograms();
- std::unique_ptr<HistogramSamples> used_samples(
- allocator_->used_histogram_->SnapshotSamples());
- EXPECT_TRUE(used_samples);
- EXPECT_EQ(1, used_samples->TotalCount());
-
- // Check that an object's type can be changed.
- EXPECT_EQ(2U, allocator_->GetType(block2));
- allocator_->ChangeType(block2, 3, 2, false);
- EXPECT_EQ(3U, allocator_->GetType(block2));
- allocator_->New<TestObject2>(block2, 3, false);
- EXPECT_EQ(2U, allocator_->GetType(block2));
-
- // Create second allocator (read/write) using the same memory segment.
- std::unique_ptr<PersistentMemoryAllocator> allocator2(
- new PersistentMemoryAllocator(mem_segment_.get(), TEST_MEMORY_SIZE,
- TEST_MEMORY_PAGE, 0, "", false));
- EXPECT_EQ(TEST_ID, allocator2->Id());
- EXPECT_FALSE(allocator2->used_histogram_);
-
- // Ensure that iteration and access through second allocator works.
- PersistentMemoryAllocator::Iterator iter2(allocator2.get());
- EXPECT_EQ(block1, iter2.GetNext(&type));
- EXPECT_EQ(block2, iter2.GetNext(&type));
- EXPECT_EQ(0U, iter2.GetNext(&type));
- EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject1>(block1));
- EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject2>(block2));
-
- // Create a third allocator (read-only) using the same memory segment.
- std::unique_ptr<const PersistentMemoryAllocator> allocator3(
- new PersistentMemoryAllocator(mem_segment_.get(), TEST_MEMORY_SIZE,
- TEST_MEMORY_PAGE, 0, "", true));
- EXPECT_EQ(TEST_ID, allocator3->Id());
- EXPECT_FALSE(allocator3->used_histogram_);
-
- // Ensure that iteration and access through third allocator works.
- PersistentMemoryAllocator::Iterator iter3(allocator3.get());
- EXPECT_EQ(block1, iter3.GetNext(&type));
- EXPECT_EQ(block2, iter3.GetNext(&type));
- EXPECT_EQ(0U, iter3.GetNext(&type));
- EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject1>(block1));
- EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject2>(block2));
-
- // Ensure that GetNextOfType works.
- PersistentMemoryAllocator::Iterator iter1c(allocator_.get());
- EXPECT_EQ(block2, iter1c.GetNextOfType<TestObject2>());
- EXPECT_EQ(0U, iter1c.GetNextOfType(2));
-
- // Ensure that GetNextOfObject works.
- PersistentMemoryAllocator::Iterator iter1d(allocator_.get());
- EXPECT_EQ(obj2, iter1d.GetNextOfObject<TestObject2>());
- EXPECT_EQ(nullptr, iter1d.GetNextOfObject<TestObject2>());
-
- // Ensure that deleting an object works.
- allocator_->Delete(obj2);
- PersistentMemoryAllocator::Iterator iter1z(allocator_.get());
- EXPECT_EQ(nullptr, iter1z.GetNextOfObject<TestObject2>());
-
- // Ensure that the memory state can be set.
- allocator_->SetMemoryState(PersistentMemoryAllocator::MEMORY_DELETED);
- EXPECT_EQ(PersistentMemoryAllocator::MEMORY_DELETED,
- allocator_->GetMemoryState());
-}
-
-TEST_F(PersistentMemoryAllocatorTest, PageTest) {
- // This allocation will go into the first memory page.
- Reference block1 = allocator_->Allocate(TEST_MEMORY_PAGE / 2, 1);
- EXPECT_LT(0U, block1);
- EXPECT_GT(TEST_MEMORY_PAGE, block1);
-
- // This allocation won't fit in same page as previous block.
- Reference block2 =
- allocator_->Allocate(TEST_MEMORY_PAGE - 2 * kAllocAlignment, 2);
- EXPECT_EQ(TEST_MEMORY_PAGE, block2);
-
- // This allocation will also require a new page.
- Reference block3 = allocator_->Allocate(2 * kAllocAlignment + 99, 3);
- EXPECT_EQ(2U * TEST_MEMORY_PAGE, block3);
-}
-
-// A simple thread that takes an allocator and repeatedly allocates random-
-// sized chunks from it until no more can be done.
-class AllocatorThread : public SimpleThread {
- public:
- AllocatorThread(const std::string& name,
- void* base,
- uint32_t size,
- uint32_t page_size)
- : SimpleThread(name, Options()),
- count_(0),
- iterable_(0),
- allocator_(base, size, page_size, 0, std::string(), false) {}
-
- void Run() override {
- for (;;) {
- uint32_t size = RandInt(1, 99);
- uint32_t type = RandInt(100, 999);
- Reference block = allocator_.Allocate(size, type);
- if (!block)
- break;
-
- count_++;
- if (RandInt(0, 1)) {
- allocator_.MakeIterable(block);
- iterable_++;
- }
- }
- }
-
- unsigned iterable() { return iterable_; }
- unsigned count() { return count_; }
-
- private:
- unsigned count_;
- unsigned iterable_;
- PersistentMemoryAllocator allocator_;
-};
-
-// Test parallel allocation/iteration and ensure consistency across all
-// instances.
-TEST_F(PersistentMemoryAllocatorTest, ParallelismTest) {
- void* memory = mem_segment_.get();
- AllocatorThread t1("t1", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t2("t2", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t3("t3", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t4("t4", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t5("t5", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
-
- t1.Start();
- t2.Start();
- t3.Start();
- t4.Start();
- t5.Start();
-
- unsigned last_count = 0;
- do {
- unsigned count = CountIterables();
- EXPECT_LE(last_count, count);
- } while (!allocator_->IsCorrupt() && !allocator_->IsFull());
-
- t1.Join();
- t2.Join();
- t3.Join();
- t4.Join();
- t5.Join();
-
- EXPECT_FALSE(allocator_->IsCorrupt());
- EXPECT_TRUE(allocator_->IsFull());
- EXPECT_EQ(CountIterables(),
- t1.iterable() + t2.iterable() + t3.iterable() + t4.iterable() +
- t5.iterable());
-}
-
-// A simple thread that counts objects by iterating through an allocator.
-class CounterThread : public SimpleThread {
- public:
- CounterThread(const std::string& name,
- PersistentMemoryAllocator::Iterator* iterator,
- Lock* lock,
- ConditionVariable* condition,
- bool* wake_up)
- : SimpleThread(name, Options()),
- iterator_(iterator),
- lock_(lock),
- condition_(condition),
- count_(0),
- wake_up_(wake_up) {}
-
- void Run() override {
- // Wait so all threads can start at approximately the same time.
- // Best performance comes from releasing a single worker which then
- // releases the next, etc., etc.
- {
- AutoLock autolock(*lock_);
-
- // Before calling Wait(), make sure that the wake up condition
- // has not already passed. Also, since spurious signal events
- // are possible, check the condition in a while loop to make
- // sure that the wake up condition is met when this thread
- // returns from the Wait().
- // See usage comments in src/base/synchronization/condition_variable.h.
- while (!*wake_up_) {
- condition_->Wait();
- condition_->Signal();
- }
- }
-
- uint32_t type;
- while (iterator_->GetNext(&type) != 0) {
- ++count_;
- }
- }
-
- unsigned count() { return count_; }
-
- private:
- PersistentMemoryAllocator::Iterator* iterator_;
- Lock* lock_;
- ConditionVariable* condition_;
- unsigned count_;
- bool* wake_up_;
-
- DISALLOW_COPY_AND_ASSIGN(CounterThread);
-};
-
-// Ensure that parallel iteration returns the same number of objects as
-// single-threaded iteration.
-TEST_F(PersistentMemoryAllocatorTest, IteratorParallelismTest) {
- // Fill the memory segment with random allocations.
- unsigned iterable_count = 0;
- for (;;) {
- uint32_t size = RandInt(1, 99);
- uint32_t type = RandInt(100, 999);
- Reference block = allocator_->Allocate(size, type);
- if (!block)
- break;
- allocator_->MakeIterable(block);
- ++iterable_count;
- }
- EXPECT_FALSE(allocator_->IsCorrupt());
- EXPECT_TRUE(allocator_->IsFull());
- EXPECT_EQ(iterable_count, CountIterables());
-
- PersistentMemoryAllocator::Iterator iter(allocator_.get());
- Lock lock;
- ConditionVariable condition(&lock);
- bool wake_up = false;
-
- CounterThread t1("t1", &iter, &lock, &condition, &wake_up);
- CounterThread t2("t2", &iter, &lock, &condition, &wake_up);
- CounterThread t3("t3", &iter, &lock, &condition, &wake_up);
- CounterThread t4("t4", &iter, &lock, &condition, &wake_up);
- CounterThread t5("t5", &iter, &lock, &condition, &wake_up);
-
- t1.Start();
- t2.Start();
- t3.Start();
- t4.Start();
- t5.Start();
-
- // Take the lock and set the wake up condition to true. This helps to
- // avoid a race condition where the Signal() event is called before
- // all the threads have reached the Wait() and thus never get woken up.
- {
- AutoLock autolock(lock);
- wake_up = true;
- }
-
- // This will release all the waiting threads.
- condition.Signal();
-
- t1.Join();
- t2.Join();
- t3.Join();
- t4.Join();
- t5.Join();
-
- EXPECT_EQ(iterable_count,
- t1.count() + t2.count() + t3.count() + t4.count() + t5.count());
-
-#if 0
- // These ensure that the threads don't run sequentially. It shouldn't be
- // enabled in general because it could lead to a flaky test if it happens
- // simply by chance but it is useful during development to ensure that the
- // test is working correctly.
- EXPECT_NE(iterable_count, t1.count());
- EXPECT_NE(iterable_count, t2.count());
- EXPECT_NE(iterable_count, t3.count());
- EXPECT_NE(iterable_count, t4.count());
- EXPECT_NE(iterable_count, t5.count());
-#endif
-}
-
-TEST_F(PersistentMemoryAllocatorTest, DelayedAllocationTest) {
- std::atomic<Reference> ref1, ref2;
- ref1.store(0, std::memory_order_relaxed);
- ref2.store(0, std::memory_order_relaxed);
- DelayedPersistentAllocation da1(allocator_.get(), &ref1, 1001, 100, true);
- DelayedPersistentAllocation da2a(allocator_.get(), &ref2, 2002, 200, 0, true);
- DelayedPersistentAllocation da2b(allocator_.get(), &ref2, 2002, 200, 5, true);
-
- // Nothing should yet have been allocated.
- uint32_t type;
- PersistentMemoryAllocator::Iterator iter(allocator_.get());
- EXPECT_EQ(0U, iter.GetNext(&type));
-
- // Do first delayed allocation and check that a new persistent object exists.
- EXPECT_EQ(0U, da1.reference());
- void* mem1 = da1.Get();
- ASSERT_TRUE(mem1);
- EXPECT_NE(0U, da1.reference());
- EXPECT_EQ(allocator_->GetAsReference(mem1, 1001),
- ref1.load(std::memory_order_relaxed));
- EXPECT_NE(0U, iter.GetNext(&type));
- EXPECT_EQ(1001U, type);
- EXPECT_EQ(0U, iter.GetNext(&type));
-
- // Do second delayed allocation and check.
- void* mem2a = da2a.Get();
- ASSERT_TRUE(mem2a);
- EXPECT_EQ(allocator_->GetAsReference(mem2a, 2002),
- ref2.load(std::memory_order_relaxed));
- EXPECT_NE(0U, iter.GetNext(&type));
- EXPECT_EQ(2002U, type);
- EXPECT_EQ(0U, iter.GetNext(&type));
-
- // Third allocation should just return offset into second allocation.
- void* mem2b = da2b.Get();
- ASSERT_TRUE(mem2b);
- EXPECT_EQ(0U, iter.GetNext(&type));
- EXPECT_EQ(reinterpret_cast<uintptr_t>(mem2a) + 5,
- reinterpret_cast<uintptr_t>(mem2b));
-}
-
-// This test doesn't verify anything other than it doesn't crash. Its goal
-// is to find coding errors that aren't otherwise tested for, much like a
-// "fuzzer" would.
-// This test is suppsoed to fail on TSAN bot (crbug.com/579867).
-#if defined(THREAD_SANITIZER)
-#define MAYBE_CorruptionTest DISABLED_CorruptionTest
-#else
-#define MAYBE_CorruptionTest CorruptionTest
-#endif
-TEST_F(PersistentMemoryAllocatorTest, MAYBE_CorruptionTest) {
- char* memory = mem_segment_.get();
- AllocatorThread t1("t1", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t2("t2", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t3("t3", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t4("t4", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
- AllocatorThread t5("t5", memory, TEST_MEMORY_SIZE, TEST_MEMORY_PAGE);
-
- t1.Start();
- t2.Start();
- t3.Start();
- t4.Start();
- t5.Start();
-
- do {
- size_t offset = RandInt(0, TEST_MEMORY_SIZE - 1);
- char value = RandInt(0, 255);
- memory[offset] = value;
- } while (!allocator_->IsCorrupt() && !allocator_->IsFull());
-
- t1.Join();
- t2.Join();
- t3.Join();
- t4.Join();
- t5.Join();
-
- CountIterables();
-}
-
-// Attempt to cause crashes or loops by expressly creating dangerous conditions.
-TEST_F(PersistentMemoryAllocatorTest, MaliciousTest) {
- Reference block1 = allocator_->Allocate(sizeof(TestObject1), 1);
- Reference block2 = allocator_->Allocate(sizeof(TestObject1), 2);
- Reference block3 = allocator_->Allocate(sizeof(TestObject1), 3);
- Reference block4 = allocator_->Allocate(sizeof(TestObject1), 3);
- Reference block5 = allocator_->Allocate(sizeof(TestObject1), 3);
- allocator_->MakeIterable(block1);
- allocator_->MakeIterable(block2);
- allocator_->MakeIterable(block3);
- allocator_->MakeIterable(block4);
- allocator_->MakeIterable(block5);
- EXPECT_EQ(5U, CountIterables());
- EXPECT_FALSE(allocator_->IsCorrupt());
-
- // Create loop in iterable list and ensure it doesn't hang. The return value
- // from CountIterables() in these cases is unpredictable. If there is a
- // failure, the call will hang and the test killed for taking too long.
- uint32_t* header4 = (uint32_t*)(mem_segment_.get() + block4);
- EXPECT_EQ(block5, header4[3]);
- header4[3] = block4;
- CountIterables(); // loop: 1-2-3-4-4
- EXPECT_TRUE(allocator_->IsCorrupt());
-
- // Test where loop goes back to previous block.
- header4[3] = block3;
- CountIterables(); // loop: 1-2-3-4-3
-
- // Test where loop goes back to the beginning.
- header4[3] = block1;
- CountIterables(); // loop: 1-2-3-4-1
-}
-
-
-//----- LocalPersistentMemoryAllocator -----------------------------------------
-
-TEST(LocalPersistentMemoryAllocatorTest, CreationTest) {
- LocalPersistentMemoryAllocator allocator(TEST_MEMORY_SIZE, 42, "");
- EXPECT_EQ(42U, allocator.Id());
- EXPECT_NE(0U, allocator.Allocate(24, 1));
- EXPECT_FALSE(allocator.IsFull());
- EXPECT_FALSE(allocator.IsCorrupt());
-}
-
-
-//----- SharedPersistentMemoryAllocator ----------------------------------------
-
-TEST(SharedPersistentMemoryAllocatorTest, CreationTest) {
- SharedMemoryHandle shared_handle_1;
- SharedMemoryHandle shared_handle_2;
-
- PersistentMemoryAllocator::MemoryInfo meminfo1;
- Reference r123, r456, r789;
- {
- std::unique_ptr<SharedMemory> shmem1(new SharedMemory());
- ASSERT_TRUE(shmem1->CreateAndMapAnonymous(TEST_MEMORY_SIZE));
- SharedPersistentMemoryAllocator local(std::move(shmem1), TEST_ID, "",
- false);
- EXPECT_FALSE(local.IsReadonly());
- r123 = local.Allocate(123, 123);
- r456 = local.Allocate(456, 456);
- r789 = local.Allocate(789, 789);
- local.MakeIterable(r123);
- local.ChangeType(r456, 654, 456, false);
- local.MakeIterable(r789);
- local.GetMemoryInfo(&meminfo1);
- EXPECT_FALSE(local.IsFull());
- EXPECT_FALSE(local.IsCorrupt());
-
- shared_handle_1 = local.shared_memory()->handle().Duplicate();
- ASSERT_TRUE(shared_handle_1.IsValid());
- shared_handle_2 = local.shared_memory()->handle().Duplicate();
- ASSERT_TRUE(shared_handle_2.IsValid());
- }
-
- // Read-only test.
- std::unique_ptr<SharedMemory> shmem2(new SharedMemory(shared_handle_1,
- /*readonly=*/true));
- ASSERT_TRUE(shmem2->Map(TEST_MEMORY_SIZE));
-
- SharedPersistentMemoryAllocator shalloc2(std::move(shmem2), 0, "", true);
- EXPECT_TRUE(shalloc2.IsReadonly());
- EXPECT_EQ(TEST_ID, shalloc2.Id());
- EXPECT_FALSE(shalloc2.IsFull());
- EXPECT_FALSE(shalloc2.IsCorrupt());
-
- PersistentMemoryAllocator::Iterator iter2(&shalloc2);
- uint32_t type;
- EXPECT_EQ(r123, iter2.GetNext(&type));
- EXPECT_EQ(r789, iter2.GetNext(&type));
- EXPECT_EQ(0U, iter2.GetNext(&type));
-
- EXPECT_EQ(123U, shalloc2.GetType(r123));
- EXPECT_EQ(654U, shalloc2.GetType(r456));
- EXPECT_EQ(789U, shalloc2.GetType(r789));
-
- PersistentMemoryAllocator::MemoryInfo meminfo2;
- shalloc2.GetMemoryInfo(&meminfo2);
- EXPECT_EQ(meminfo1.total, meminfo2.total);
- EXPECT_EQ(meminfo1.free, meminfo2.free);
-
- // Read/write test.
- std::unique_ptr<SharedMemory> shmem3(new SharedMemory(shared_handle_2,
- /*readonly=*/false));
- ASSERT_TRUE(shmem3->Map(TEST_MEMORY_SIZE));
-
- SharedPersistentMemoryAllocator shalloc3(std::move(shmem3), 0, "", false);
- EXPECT_FALSE(shalloc3.IsReadonly());
- EXPECT_EQ(TEST_ID, shalloc3.Id());
- EXPECT_FALSE(shalloc3.IsFull());
- EXPECT_FALSE(shalloc3.IsCorrupt());
-
- PersistentMemoryAllocator::Iterator iter3(&shalloc3);
- EXPECT_EQ(r123, iter3.GetNext(&type));
- EXPECT_EQ(r789, iter3.GetNext(&type));
- EXPECT_EQ(0U, iter3.GetNext(&type));
-
- EXPECT_EQ(123U, shalloc3.GetType(r123));
- EXPECT_EQ(654U, shalloc3.GetType(r456));
- EXPECT_EQ(789U, shalloc3.GetType(r789));
-
- PersistentMemoryAllocator::MemoryInfo meminfo3;
- shalloc3.GetMemoryInfo(&meminfo3);
- EXPECT_EQ(meminfo1.total, meminfo3.total);
- EXPECT_EQ(meminfo1.free, meminfo3.free);
-
- // Interconnectivity test.
- Reference obj = shalloc3.Allocate(42, 42);
- ASSERT_TRUE(obj);
- shalloc3.MakeIterable(obj);
- EXPECT_EQ(obj, iter2.GetNext(&type));
- EXPECT_EQ(42U, type);
-
- // Clear-on-change test.
- Reference data_ref = shalloc3.Allocate(sizeof(int) * 4, 911);
- int* data = shalloc3.GetAsArray<int>(data_ref, 911, 4);
- ASSERT_TRUE(data);
- data[0] = 0;
- data[1] = 1;
- data[2] = 2;
- data[3] = 3;
- ASSERT_TRUE(shalloc3.ChangeType(data_ref, 119, 911, false));
- EXPECT_EQ(0, data[0]);
- EXPECT_EQ(1, data[1]);
- EXPECT_EQ(2, data[2]);
- EXPECT_EQ(3, data[3]);
- ASSERT_TRUE(shalloc3.ChangeType(data_ref, 191, 119, true));
- EXPECT_EQ(0, data[0]);
- EXPECT_EQ(0, data[1]);
- EXPECT_EQ(0, data[2]);
- EXPECT_EQ(0, data[3]);
-}
-
-
-#if !defined(OS_NACL)
-//----- FilePersistentMemoryAllocator ------------------------------------------
-
-TEST(FilePersistentMemoryAllocatorTest, CreationTest) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("persistent_memory");
-
- PersistentMemoryAllocator::MemoryInfo meminfo1;
- Reference r123, r456, r789;
- {
- LocalPersistentMemoryAllocator local(TEST_MEMORY_SIZE, TEST_ID, "");
- EXPECT_FALSE(local.IsReadonly());
- r123 = local.Allocate(123, 123);
- r456 = local.Allocate(456, 456);
- r789 = local.Allocate(789, 789);
- local.MakeIterable(r123);
- local.ChangeType(r456, 654, 456, false);
- local.MakeIterable(r789);
- local.GetMemoryInfo(&meminfo1);
- EXPECT_FALSE(local.IsFull());
- EXPECT_FALSE(local.IsCorrupt());
-
- File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
- ASSERT_TRUE(writer.IsValid());
- writer.Write(0, (const char*)local.data(), local.used());
- }
-
- std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
- mmfile->Initialize(file_path);
- EXPECT_TRUE(mmfile->IsValid());
- const size_t mmlength = mmfile->length();
- EXPECT_GE(meminfo1.total, mmlength);
-
- FilePersistentMemoryAllocator file(std::move(mmfile), 0, 0, "", false);
- EXPECT_FALSE(file.IsReadonly());
- EXPECT_EQ(TEST_ID, file.Id());
- EXPECT_FALSE(file.IsFull());
- EXPECT_FALSE(file.IsCorrupt());
-
- PersistentMemoryAllocator::Iterator iter(&file);
- uint32_t type;
- EXPECT_EQ(r123, iter.GetNext(&type));
- EXPECT_EQ(r789, iter.GetNext(&type));
- EXPECT_EQ(0U, iter.GetNext(&type));
-
- EXPECT_EQ(123U, file.GetType(r123));
- EXPECT_EQ(654U, file.GetType(r456));
- EXPECT_EQ(789U, file.GetType(r789));
-
- PersistentMemoryAllocator::MemoryInfo meminfo2;
- file.GetMemoryInfo(&meminfo2);
- EXPECT_GE(meminfo1.total, meminfo2.total);
- EXPECT_GE(meminfo1.free, meminfo2.free);
- EXPECT_EQ(mmlength, meminfo2.total);
- EXPECT_EQ(0U, meminfo2.free);
-
- // There's no way of knowing if Flush actually does anything but at least
- // verify that it runs without CHECK violations.
- file.Flush(false);
- file.Flush(true);
-}
-
-TEST(FilePersistentMemoryAllocatorTest, ExtendTest) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("extend_test");
- MemoryMappedFile::Region region = {0, 16 << 10}; // 16KiB maximum size.
-
- // Start with a small but valid file of persistent data.
- ASSERT_FALSE(PathExists(file_path));
- {
- LocalPersistentMemoryAllocator local(TEST_MEMORY_SIZE, TEST_ID, "");
- local.Allocate(1, 1);
- local.Allocate(11, 11);
-
- File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
- ASSERT_TRUE(writer.IsValid());
- writer.Write(0, (const char*)local.data(), local.used());
- }
- ASSERT_TRUE(PathExists(file_path));
- int64_t before_size;
- ASSERT_TRUE(GetFileSize(file_path, &before_size));
-
- // Map it as an extendable read/write file and append to it.
- {
- std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
- mmfile->Initialize(
- File(file_path, File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE),
- region, MemoryMappedFile::READ_WRITE_EXTEND);
- FilePersistentMemoryAllocator allocator(std::move(mmfile), region.size, 0,
- "", false);
- EXPECT_EQ(static_cast<size_t>(before_size), allocator.used());
-
- allocator.Allocate(111, 111);
- EXPECT_LT(static_cast<size_t>(before_size), allocator.used());
- }
-
- // Validate that append worked.
- int64_t after_size;
- ASSERT_TRUE(GetFileSize(file_path, &after_size));
- EXPECT_LT(before_size, after_size);
-
- // Verify that it's still an acceptable file.
- {
- std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
- mmfile->Initialize(
- File(file_path, File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE),
- region, MemoryMappedFile::READ_WRITE_EXTEND);
- EXPECT_TRUE(FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true));
- EXPECT_TRUE(
- FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, false));
- }
-}
-
-TEST(FilePersistentMemoryAllocatorTest, AcceptableTest) {
- const uint32_t kAllocAlignment =
- PersistentMemoryAllocatorTest::GetAllocAlignment();
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
- LocalPersistentMemoryAllocator local(TEST_MEMORY_SIZE, TEST_ID, "");
- local.MakeIterable(local.Allocate(1, 1));
- local.MakeIterable(local.Allocate(11, 11));
- const size_t minsize = local.used();
- std::unique_ptr<char[]> garbage(new char[minsize]);
- RandBytes(garbage.get(), minsize);
-
- std::unique_ptr<MemoryMappedFile> mmfile;
- char filename[100];
- for (size_t filesize = minsize; filesize > 0; --filesize) {
- strings::SafeSPrintf(filename, "memory_%d_A", filesize);
- FilePath file_path = temp_dir.GetPath().AppendASCII(filename);
- ASSERT_FALSE(PathExists(file_path));
- {
- File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
- ASSERT_TRUE(writer.IsValid());
- writer.Write(0, (const char*)local.data(), filesize);
- }
- ASSERT_TRUE(PathExists(file_path));
-
- // Request read/write access for some sizes that are a multple of the
- // allocator's alignment size. The allocator is strict about file size
- // being a multiple of its internal alignment when doing read/write access.
- const bool read_only = (filesize % (2 * kAllocAlignment)) != 0;
- const uint32_t file_flags =
- File::FLAG_OPEN | File::FLAG_READ | (read_only ? 0 : File::FLAG_WRITE);
- const MemoryMappedFile::Access map_access =
- read_only ? MemoryMappedFile::READ_ONLY : MemoryMappedFile::READ_WRITE;
-
- mmfile.reset(new MemoryMappedFile());
- mmfile->Initialize(File(file_path, file_flags), map_access);
- EXPECT_EQ(filesize, mmfile->length());
- if (FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, read_only)) {
- // Make sure construction doesn't crash. It will, however, cause
- // error messages warning about about a corrupted memory segment.
- FilePersistentMemoryAllocator allocator(std::move(mmfile), 0, 0, "",
- read_only);
- // Also make sure that iteration doesn't crash.
- PersistentMemoryAllocator::Iterator iter(&allocator);
- uint32_t type_id;
- Reference ref;
- while ((ref = iter.GetNext(&type_id)) != 0) {
- const char* data = allocator.GetAsArray<char>(
- ref, 0, PersistentMemoryAllocator::kSizeAny);
- uint32_t type = allocator.GetType(ref);
- size_t size = allocator.GetAllocSize(ref);
- // Ensure compiler can't optimize-out above variables.
- (void)data;
- (void)type;
- (void)size;
- }
-
- // Ensure that short files are detected as corrupt and full files are not.
- EXPECT_EQ(filesize != minsize, allocator.IsCorrupt());
- } else {
- // For filesize >= minsize, the file must be acceptable. This
- // else clause (file-not-acceptable) should be reached only if
- // filesize < minsize.
- EXPECT_LT(filesize, minsize);
- }
-
- strings::SafeSPrintf(filename, "memory_%d_B", filesize);
- file_path = temp_dir.GetPath().AppendASCII(filename);
- ASSERT_FALSE(PathExists(file_path));
- {
- File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
- ASSERT_TRUE(writer.IsValid());
- writer.Write(0, (const char*)garbage.get(), filesize);
- }
- ASSERT_TRUE(PathExists(file_path));
-
- mmfile.reset(new MemoryMappedFile());
- mmfile->Initialize(File(file_path, file_flags), map_access);
- EXPECT_EQ(filesize, mmfile->length());
- if (FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, read_only)) {
- // Make sure construction doesn't crash. It will, however, cause
- // error messages warning about about a corrupted memory segment.
- FilePersistentMemoryAllocator allocator(std::move(mmfile), 0, 0, "",
- read_only);
- EXPECT_TRUE(allocator.IsCorrupt()); // Garbage data so it should be.
- } else {
- // For filesize >= minsize, the file must be acceptable. This
- // else clause (file-not-acceptable) should be reached only if
- // filesize < minsize.
- EXPECT_GT(minsize, filesize);
- }
- }
-}
-
-TEST_F(PersistentMemoryAllocatorTest, TruncateTest) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath file_path = temp_dir.GetPath().AppendASCII("truncate_test");
-
- // Start with a small but valid file of persistent data. Keep the "used"
- // amount for both allocations.
- Reference a1_ref;
- Reference a2_ref;
- size_t a1_used;
- size_t a2_used;
- ASSERT_FALSE(PathExists(file_path));
- {
- LocalPersistentMemoryAllocator allocator(TEST_MEMORY_SIZE, TEST_ID, "");
- a1_ref = allocator.Allocate(100 << 10, 1);
- allocator.MakeIterable(a1_ref);
- a1_used = allocator.used();
- a2_ref = allocator.Allocate(200 << 10, 11);
- allocator.MakeIterable(a2_ref);
- a2_used = allocator.used();
-
- File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
- ASSERT_TRUE(writer.IsValid());
- writer.Write(0, static_cast<const char*>(allocator.data()),
- allocator.size());
- }
- ASSERT_TRUE(PathExists(file_path));
- EXPECT_LE(a1_used, a2_ref);
-
- // Truncate the file to include everything and make sure it can be read, both
- // with read-write and read-only access.
- for (size_t file_length : {a2_used, a1_used, a1_used / 2}) {
- SCOPED_TRACE(StringPrintf("file_length=%zu", file_length));
- SetFileLength(file_path, file_length);
-
- for (bool read_only : {false, true}) {
- SCOPED_TRACE(StringPrintf("read_only=%s", read_only ? "true" : "false"));
-
- std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
- mmfile->Initialize(
- File(file_path, File::FLAG_OPEN |
- (read_only ? File::FLAG_READ
- : File::FLAG_READ | File::FLAG_WRITE)),
- read_only ? MemoryMappedFile::READ_ONLY
- : MemoryMappedFile::READ_WRITE);
- ASSERT_TRUE(
- FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, read_only));
-
- FilePersistentMemoryAllocator allocator(std::move(mmfile), 0, 0, "",
- read_only);
-
- PersistentMemoryAllocator::Iterator iter(&allocator);
- uint32_t type_id;
- EXPECT_EQ(file_length >= a1_used ? a1_ref : 0U, iter.GetNext(&type_id));
- EXPECT_EQ(file_length >= a2_used ? a2_ref : 0U, iter.GetNext(&type_id));
- EXPECT_EQ(0U, iter.GetNext(&type_id));
-
- // Ensure that short files are detected as corrupt and full files are not.
- EXPECT_EQ(file_length < a2_used, allocator.IsCorrupt());
- }
-
- // Ensure that file length was not adjusted.
- int64_t actual_length;
- ASSERT_TRUE(GetFileSize(file_path, &actual_length));
- EXPECT_EQ(file_length, static_cast<size_t>(actual_length));
- }
-}
-
-#endif // !defined(OS_NACL)
-
-} // namespace base
diff --git a/base/metrics/persistent_sample_map_unittest.cc b/base/metrics/persistent_sample_map_unittest.cc
deleted file mode 100644
index b25f582..0000000
--- a/base/metrics/persistent_sample_map_unittest.cc
+++ /dev/null
@@ -1,260 +0,0 @@
-// Copyright (c) 2016 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 "base/metrics/persistent_sample_map.h"
-
-#include <memory>
-
-#include "base/memory/ptr_util.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-std::unique_ptr<PersistentHistogramAllocator> CreateHistogramAllocator(
- size_t bytes) {
- return std::make_unique<PersistentHistogramAllocator>(
- std::make_unique<LocalPersistentMemoryAllocator>(bytes, 0, ""));
-}
-
-std::unique_ptr<PersistentHistogramAllocator> DuplicateHistogramAllocator(
- PersistentHistogramAllocator* original) {
- return std::make_unique<PersistentHistogramAllocator>(
- std::make_unique<PersistentMemoryAllocator>(
- const_cast<void*>(original->data()), original->length(), 0,
- original->Id(), original->Name(), false));
-}
-
-TEST(PersistentSampleMapTest, AccumulateTest) {
- std::unique_ptr<PersistentHistogramAllocator> allocator =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta;
- PersistentSampleMap samples(1, allocator.get(), &meta);
-
- samples.Accumulate(1, 100);
- samples.Accumulate(2, 200);
- samples.Accumulate(1, -200);
- EXPECT_EQ(-100, samples.GetCount(1));
- EXPECT_EQ(200, samples.GetCount(2));
-
- EXPECT_EQ(300, samples.sum());
- EXPECT_EQ(100, samples.TotalCount());
- EXPECT_EQ(samples.redundant_count(), samples.TotalCount());
-}
-
-TEST(PersistentSampleMapTest, Accumulate_LargeValuesDontOverflow) {
- std::unique_ptr<PersistentHistogramAllocator> allocator =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta;
- PersistentSampleMap samples(1, allocator.get(), &meta);
-
- samples.Accumulate(250000000, 100);
- samples.Accumulate(500000000, 200);
- samples.Accumulate(250000000, -200);
- EXPECT_EQ(-100, samples.GetCount(250000000));
- EXPECT_EQ(200, samples.GetCount(500000000));
-
- EXPECT_EQ(75000000000LL, samples.sum());
- EXPECT_EQ(100, samples.TotalCount());
- EXPECT_EQ(samples.redundant_count(), samples.TotalCount());
-}
-
-TEST(PersistentSampleMapTest, AddSubtractTest) {
- std::unique_ptr<PersistentHistogramAllocator> allocator1 =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta1;
- PersistentSampleMap samples1(1, allocator1.get(), &meta1);
- samples1.Accumulate(1, 100);
- samples1.Accumulate(2, 100);
- samples1.Accumulate(3, 100);
-
- std::unique_ptr<PersistentHistogramAllocator> allocator2 =
- DuplicateHistogramAllocator(allocator1.get());
- HistogramSamples::LocalMetadata meta2;
- PersistentSampleMap samples2(2, allocator2.get(), &meta2);
- samples2.Accumulate(1, 200);
- samples2.Accumulate(2, 200);
- samples2.Accumulate(4, 200);
-
- samples1.Add(samples2);
- EXPECT_EQ(300, samples1.GetCount(1));
- EXPECT_EQ(300, samples1.GetCount(2));
- EXPECT_EQ(100, samples1.GetCount(3));
- EXPECT_EQ(200, samples1.GetCount(4));
- EXPECT_EQ(2000, samples1.sum());
- EXPECT_EQ(900, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-
- samples1.Subtract(samples2);
- EXPECT_EQ(100, samples1.GetCount(1));
- EXPECT_EQ(100, samples1.GetCount(2));
- EXPECT_EQ(100, samples1.GetCount(3));
- EXPECT_EQ(0, samples1.GetCount(4));
- EXPECT_EQ(600, samples1.sum());
- EXPECT_EQ(300, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-}
-
-TEST(PersistentSampleMapTest, PersistenceTest) {
- std::unique_ptr<PersistentHistogramAllocator> allocator1 =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta12;
- PersistentSampleMap samples1(12, allocator1.get(), &meta12);
- samples1.Accumulate(1, 100);
- samples1.Accumulate(2, 200);
- samples1.Accumulate(1, -200);
- samples1.Accumulate(-1, 1);
- EXPECT_EQ(-100, samples1.GetCount(1));
- EXPECT_EQ(200, samples1.GetCount(2));
- EXPECT_EQ(1, samples1.GetCount(-1));
- EXPECT_EQ(299, samples1.sum());
- EXPECT_EQ(101, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-
- std::unique_ptr<PersistentHistogramAllocator> allocator2 =
- DuplicateHistogramAllocator(allocator1.get());
- PersistentSampleMap samples2(12, allocator2.get(), &meta12);
- EXPECT_EQ(samples1.id(), samples2.id());
- EXPECT_EQ(samples1.sum(), samples2.sum());
- EXPECT_EQ(samples1.redundant_count(), samples2.redundant_count());
- EXPECT_EQ(samples1.TotalCount(), samples2.TotalCount());
- EXPECT_EQ(-100, samples2.GetCount(1));
- EXPECT_EQ(200, samples2.GetCount(2));
- EXPECT_EQ(1, samples2.GetCount(-1));
- EXPECT_EQ(299, samples2.sum());
- EXPECT_EQ(101, samples2.TotalCount());
- EXPECT_EQ(samples2.redundant_count(), samples2.TotalCount());
-
- samples1.Accumulate(-1, -1);
- EXPECT_EQ(0, samples2.GetCount(3));
- EXPECT_EQ(0, samples1.GetCount(3));
- samples2.Accumulate(3, 300);
- EXPECT_EQ(300, samples2.GetCount(3));
- EXPECT_EQ(300, samples1.GetCount(3));
- EXPECT_EQ(samples1.sum(), samples2.sum());
- EXPECT_EQ(samples1.redundant_count(), samples2.redundant_count());
- EXPECT_EQ(samples1.TotalCount(), samples2.TotalCount());
-
- EXPECT_EQ(0, samples2.GetCount(4));
- EXPECT_EQ(0, samples1.GetCount(4));
- samples1.Accumulate(4, 400);
- EXPECT_EQ(400, samples2.GetCount(4));
- EXPECT_EQ(400, samples1.GetCount(4));
- samples2.Accumulate(4, 4000);
- EXPECT_EQ(4400, samples2.GetCount(4));
- EXPECT_EQ(4400, samples1.GetCount(4));
- EXPECT_EQ(samples1.sum(), samples2.sum());
- EXPECT_EQ(samples1.redundant_count(), samples2.redundant_count());
- EXPECT_EQ(samples1.TotalCount(), samples2.TotalCount());
-}
-
-TEST(PersistentSampleMapIteratorTest, IterateTest) {
- std::unique_ptr<PersistentHistogramAllocator> allocator =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta;
- PersistentSampleMap samples(1, allocator.get(), &meta);
- samples.Accumulate(1, 100);
- samples.Accumulate(2, 200);
- samples.Accumulate(4, -300);
- samples.Accumulate(5, 0);
-
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
-
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(2, max);
- EXPECT_EQ(100, count);
- EXPECT_FALSE(it->GetBucketIndex(nullptr));
-
- it->Next();
- it->Get(&min, &max, &count);
- EXPECT_EQ(2, min);
- EXPECT_EQ(3, max);
- EXPECT_EQ(200, count);
-
- it->Next();
- it->Get(&min, &max, &count);
- EXPECT_EQ(4, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(-300, count);
-
- it->Next();
- EXPECT_TRUE(it->Done());
-}
-
-TEST(PersistentSampleMapIteratorTest, SkipEmptyRanges) {
- std::unique_ptr<PersistentHistogramAllocator> allocator1 =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta1;
- PersistentSampleMap samples1(1, allocator1.get(), &meta1);
- samples1.Accumulate(5, 1);
- samples1.Accumulate(10, 2);
- samples1.Accumulate(15, 3);
- samples1.Accumulate(20, 4);
- samples1.Accumulate(25, 5);
-
- std::unique_ptr<PersistentHistogramAllocator> allocator2 =
- DuplicateHistogramAllocator(allocator1.get());
- HistogramSamples::LocalMetadata meta2;
- PersistentSampleMap samples2(2, allocator2.get(), &meta2);
- samples2.Accumulate(5, 1);
- samples2.Accumulate(20, 4);
- samples2.Accumulate(25, 5);
-
- samples1.Subtract(samples2);
-
- std::unique_ptr<SampleCountIterator> it = samples1.Iterator();
- EXPECT_FALSE(it->Done());
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
-
- it->Get(&min, &max, &count);
- EXPECT_EQ(10, min);
- EXPECT_EQ(11, max);
- EXPECT_EQ(2, count);
-
- it->Next();
- EXPECT_FALSE(it->Done());
-
- it->Get(&min, &max, &count);
- EXPECT_EQ(15, min);
- EXPECT_EQ(16, max);
- EXPECT_EQ(3, count);
-
- it->Next();
- EXPECT_TRUE(it->Done());
-}
-
-TEST(PersistentSampleMapIteratorDeathTest, IterateDoneTest) {
- std::unique_ptr<PersistentHistogramAllocator> allocator =
- CreateHistogramAllocator(64 << 10); // 64 KiB
- HistogramSamples::LocalMetadata meta;
- PersistentSampleMap samples(1, allocator.get(), &meta);
-
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
-
- EXPECT_TRUE(it->Done());
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- EXPECT_DCHECK_DEATH(it->Get(&min, &max, &count));
-
- EXPECT_DCHECK_DEATH(it->Next());
-
- samples.Accumulate(1, 100);
- it = samples.Iterator();
- EXPECT_FALSE(it->Done());
-}
-
-} // namespace
-} // namespace base
diff --git a/base/metrics/sample_map_unittest.cc b/base/metrics/sample_map_unittest.cc
deleted file mode 100644
index 83db56f..0000000
--- a/base/metrics/sample_map_unittest.cc
+++ /dev/null
@@ -1,168 +0,0 @@
-// 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.
-
-#include "base/metrics/sample_map.h"
-
-#include <memory>
-
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-TEST(SampleMapTest, AccumulateTest) {
- SampleMap samples(1);
-
- samples.Accumulate(1, 100);
- samples.Accumulate(2, 200);
- samples.Accumulate(1, -200);
- EXPECT_EQ(-100, samples.GetCount(1));
- EXPECT_EQ(200, samples.GetCount(2));
-
- EXPECT_EQ(300, samples.sum());
- EXPECT_EQ(100, samples.TotalCount());
- EXPECT_EQ(samples.redundant_count(), samples.TotalCount());
-}
-
-TEST(SampleMapTest, Accumulate_LargeValuesDontOverflow) {
- SampleMap samples(1);
-
- samples.Accumulate(250000000, 100);
- samples.Accumulate(500000000, 200);
- samples.Accumulate(250000000, -200);
- EXPECT_EQ(-100, samples.GetCount(250000000));
- EXPECT_EQ(200, samples.GetCount(500000000));
-
- EXPECT_EQ(75000000000LL, samples.sum());
- EXPECT_EQ(100, samples.TotalCount());
- EXPECT_EQ(samples.redundant_count(), samples.TotalCount());
-}
-
-TEST(SampleMapTest, AddSubtractTest) {
- SampleMap samples1(1);
- SampleMap samples2(2);
-
- samples1.Accumulate(1, 100);
- samples1.Accumulate(2, 100);
- samples1.Accumulate(3, 100);
-
- samples2.Accumulate(1, 200);
- samples2.Accumulate(2, 200);
- samples2.Accumulate(4, 200);
-
- samples1.Add(samples2);
- EXPECT_EQ(300, samples1.GetCount(1));
- EXPECT_EQ(300, samples1.GetCount(2));
- EXPECT_EQ(100, samples1.GetCount(3));
- EXPECT_EQ(200, samples1.GetCount(4));
- EXPECT_EQ(2000, samples1.sum());
- EXPECT_EQ(900, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-
- samples1.Subtract(samples2);
- EXPECT_EQ(100, samples1.GetCount(1));
- EXPECT_EQ(100, samples1.GetCount(2));
- EXPECT_EQ(100, samples1.GetCount(3));
- EXPECT_EQ(0, samples1.GetCount(4));
- EXPECT_EQ(600, samples1.sum());
- EXPECT_EQ(300, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-}
-
-TEST(SampleMapIteratorTest, IterateTest) {
- SampleMap samples(1);
- samples.Accumulate(1, 100);
- samples.Accumulate(2, 200);
- samples.Accumulate(4, -300);
- samples.Accumulate(5, 0);
-
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
-
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(2, max);
- EXPECT_EQ(100, count);
- EXPECT_FALSE(it->GetBucketIndex(nullptr));
-
- it->Next();
- it->Get(&min, &max, &count);
- EXPECT_EQ(2, min);
- EXPECT_EQ(3, max);
- EXPECT_EQ(200, count);
-
- it->Next();
- it->Get(&min, &max, &count);
- EXPECT_EQ(4, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(-300, count);
-
- it->Next();
- EXPECT_TRUE(it->Done());
-}
-
-TEST(SampleMapIteratorTest, SkipEmptyRanges) {
- SampleMap samples(1);
- samples.Accumulate(5, 1);
- samples.Accumulate(10, 2);
- samples.Accumulate(15, 3);
- samples.Accumulate(20, 4);
- samples.Accumulate(25, 5);
-
- SampleMap samples2(2);
- samples2.Accumulate(5, 1);
- samples2.Accumulate(20, 4);
- samples2.Accumulate(25, 5);
-
- samples.Subtract(samples2);
-
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
- EXPECT_FALSE(it->Done());
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
-
- it->Get(&min, &max, &count);
- EXPECT_EQ(10, min);
- EXPECT_EQ(11, max);
- EXPECT_EQ(2, count);
-
- it->Next();
- EXPECT_FALSE(it->Done());
-
- it->Get(&min, &max, &count);
- EXPECT_EQ(15, min);
- EXPECT_EQ(16, max);
- EXPECT_EQ(3, count);
-
- it->Next();
- EXPECT_TRUE(it->Done());
-}
-
-TEST(SampleMapIteratorDeathTest, IterateDoneTest) {
- SampleMap samples(1);
-
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
-
- EXPECT_TRUE(it->Done());
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- EXPECT_DCHECK_DEATH(it->Get(&min, &max, &count));
-
- EXPECT_DCHECK_DEATH(it->Next());
-
- samples.Accumulate(1, 100);
- it = samples.Iterator();
- EXPECT_FALSE(it->Done());
-}
-
-} // namespace
-} // namespace base
diff --git a/base/metrics/sample_vector_unittest.cc b/base/metrics/sample_vector_unittest.cc
deleted file mode 100644
index 4921802..0000000
--- a/base/metrics/sample_vector_unittest.cc
+++ /dev/null
@@ -1,545 +0,0 @@
-// 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.
-
-#include "base/metrics/sample_vector.h"
-
-#include <limits.h>
-#include <stddef.h>
-
-#include <atomic>
-#include <memory>
-#include <vector>
-
-#include "base/metrics/bucket_ranges.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// This framework class has "friend" access to the SampleVector for accessing
-// non-public methods and fields.
-class SampleVectorTest : public testing::Test {
- public:
- const HistogramBase::AtomicCount* GetSamplesCounts(
- const SampleVectorBase& samples) {
- return samples.counts();
- }
-};
-
-TEST_F(SampleVectorTest, Accumulate) {
- // Custom buckets: [1, 5) [5, 10)
- BucketRanges ranges(3);
- ranges.set_range(0, 1);
- ranges.set_range(1, 5);
- ranges.set_range(2, 10);
- SampleVector samples(1, &ranges);
-
- samples.Accumulate(1, 200);
- samples.Accumulate(2, -300);
- EXPECT_EQ(-100, samples.GetCountAtIndex(0));
-
- samples.Accumulate(5, 200);
- EXPECT_EQ(200, samples.GetCountAtIndex(1));
-
- EXPECT_EQ(600, samples.sum());
- EXPECT_EQ(100, samples.redundant_count());
- EXPECT_EQ(samples.TotalCount(), samples.redundant_count());
-
- samples.Accumulate(5, -100);
- EXPECT_EQ(100, samples.GetCountAtIndex(1));
-
- EXPECT_EQ(100, samples.sum());
- EXPECT_EQ(0, samples.redundant_count());
- EXPECT_EQ(samples.TotalCount(), samples.redundant_count());
-}
-
-TEST_F(SampleVectorTest, Accumulate_LargeValuesDontOverflow) {
- // Custom buckets: [1, 250000000) [250000000, 500000000)
- BucketRanges ranges(3);
- ranges.set_range(0, 1);
- ranges.set_range(1, 250000000);
- ranges.set_range(2, 500000000);
- SampleVector samples(1, &ranges);
-
- samples.Accumulate(240000000, 200);
- samples.Accumulate(249999999, -300);
- EXPECT_EQ(-100, samples.GetCountAtIndex(0));
-
- samples.Accumulate(250000000, 200);
- EXPECT_EQ(200, samples.GetCountAtIndex(1));
-
- EXPECT_EQ(23000000300LL, samples.sum());
- EXPECT_EQ(100, samples.redundant_count());
- EXPECT_EQ(samples.TotalCount(), samples.redundant_count());
-
- samples.Accumulate(250000000, -100);
- EXPECT_EQ(100, samples.GetCountAtIndex(1));
-
- EXPECT_EQ(-1999999700LL, samples.sum());
- EXPECT_EQ(0, samples.redundant_count());
- EXPECT_EQ(samples.TotalCount(), samples.redundant_count());
-}
-
-TEST_F(SampleVectorTest, AddSubtract) {
- // Custom buckets: [0, 1) [1, 2) [2, 3) [3, INT_MAX)
- BucketRanges ranges(5);
- ranges.set_range(0, 0);
- ranges.set_range(1, 1);
- ranges.set_range(2, 2);
- ranges.set_range(3, 3);
- ranges.set_range(4, INT_MAX);
-
- SampleVector samples1(1, &ranges);
- samples1.Accumulate(0, 100);
- samples1.Accumulate(2, 100);
- samples1.Accumulate(4, 100);
- EXPECT_EQ(600, samples1.sum());
- EXPECT_EQ(300, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-
- SampleVector samples2(2, &ranges);
- samples2.Accumulate(1, 200);
- samples2.Accumulate(2, 200);
- samples2.Accumulate(4, 200);
- EXPECT_EQ(1400, samples2.sum());
- EXPECT_EQ(600, samples2.TotalCount());
- EXPECT_EQ(samples2.redundant_count(), samples2.TotalCount());
-
- samples1.Add(samples2);
- EXPECT_EQ(100, samples1.GetCountAtIndex(0));
- EXPECT_EQ(200, samples1.GetCountAtIndex(1));
- EXPECT_EQ(300, samples1.GetCountAtIndex(2));
- EXPECT_EQ(300, samples1.GetCountAtIndex(3));
- EXPECT_EQ(2000, samples1.sum());
- EXPECT_EQ(900, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-
- samples1.Subtract(samples2);
- EXPECT_EQ(100, samples1.GetCountAtIndex(0));
- EXPECT_EQ(0, samples1.GetCountAtIndex(1));
- EXPECT_EQ(100, samples1.GetCountAtIndex(2));
- EXPECT_EQ(100, samples1.GetCountAtIndex(3));
- EXPECT_EQ(600, samples1.sum());
- EXPECT_EQ(300, samples1.TotalCount());
- EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
-}
-
-TEST_F(SampleVectorTest, BucketIndexDeath) {
- // 8 buckets with exponential layout:
- // [0, 1) [1, 2) [2, 4) [4, 8) [8, 16) [16, 32) [32, 64) [64, INT_MAX)
- BucketRanges ranges(9);
- Histogram::InitializeBucketRanges(1, 64, &ranges);
- SampleVector samples(1, &ranges);
-
- // Normal case
- samples.Accumulate(0, 1);
- samples.Accumulate(3, 2);
- samples.Accumulate(64, 3);
- EXPECT_EQ(1, samples.GetCount(0));
- EXPECT_EQ(2, samples.GetCount(2));
- EXPECT_EQ(3, samples.GetCount(65));
-
- // Extreme case.
- EXPECT_DEATH_IF_SUPPORTED(samples.Accumulate(INT_MIN, 100), "");
- EXPECT_DEATH_IF_SUPPORTED(samples.Accumulate(-1, 100), "");
- EXPECT_DEATH_IF_SUPPORTED(samples.Accumulate(INT_MAX, 100), "");
-
- // Custom buckets: [1, 5) [5, 10)
- // Note, this is not a valid BucketRanges for Histogram because it does not
- // have overflow buckets.
- BucketRanges ranges2(3);
- ranges2.set_range(0, 1);
- ranges2.set_range(1, 5);
- ranges2.set_range(2, 10);
- SampleVector samples2(2, &ranges2);
-
- // Normal case.
- samples2.Accumulate(1, 1);
- samples2.Accumulate(4, 1);
- samples2.Accumulate(5, 2);
- samples2.Accumulate(9, 2);
- EXPECT_EQ(2, samples2.GetCount(1));
- EXPECT_EQ(4, samples2.GetCount(5));
-
- // Extreme case.
- EXPECT_DEATH_IF_SUPPORTED(samples2.Accumulate(0, 100), "");
- EXPECT_DEATH_IF_SUPPORTED(samples2.Accumulate(10, 100), "");
-}
-
-TEST_F(SampleVectorTest, AddSubtractBucketNotMatchDeath) {
- // Custom buckets 1: [1, 3) [3, 5)
- BucketRanges ranges1(3);
- ranges1.set_range(0, 1);
- ranges1.set_range(1, 3);
- ranges1.set_range(2, 5);
- SampleVector samples1(1, &ranges1);
-
- // Custom buckets 2: [0, 1) [1, 3) [3, 6) [6, 7)
- BucketRanges ranges2(5);
- ranges2.set_range(0, 0);
- ranges2.set_range(1, 1);
- ranges2.set_range(2, 3);
- ranges2.set_range(3, 6);
- ranges2.set_range(4, 7);
- SampleVector samples2(2, &ranges2);
-
- samples2.Accumulate(1, 100);
- samples1.Add(samples2);
- EXPECT_EQ(100, samples1.GetCountAtIndex(0));
-
- // Extra bucket in the beginning. These should CHECK in GetBucketIndex.
- samples2.Accumulate(0, 100);
- EXPECT_DEATH_IF_SUPPORTED(samples1.Add(samples2), "");
- EXPECT_DEATH_IF_SUPPORTED(samples1.Subtract(samples2), "");
-
- // Extra bucket in the end. These should cause AddSubtractImpl to fail, and
- // Add to DCHECK as a result.
- samples2.Accumulate(0, -100);
- samples2.Accumulate(6, 100);
- EXPECT_DCHECK_DEATH(samples1.Add(samples2));
- EXPECT_DCHECK_DEATH(samples1.Subtract(samples2));
-
- // Bucket not match: [3, 5) VS [3, 6). These should cause AddSubtractImpl to
- // DCHECK.
- samples2.Accumulate(6, -100);
- samples2.Accumulate(3, 100);
- EXPECT_DCHECK_DEATH(samples1.Add(samples2));
- EXPECT_DCHECK_DEATH(samples1.Subtract(samples2));
-}
-
-TEST_F(SampleVectorTest, Iterate) {
- BucketRanges ranges(5);
- ranges.set_range(0, 0);
- ranges.set_range(1, 1);
- ranges.set_range(2, 2);
- ranges.set_range(3, 3);
- ranges.set_range(4, 4);
-
- std::vector<HistogramBase::Count> counts(3);
- counts[0] = 1;
- counts[1] = 0; // Iterator will bypass this empty bucket.
- counts[2] = 2;
-
- // BucketRanges can have larger size than counts.
- SampleVectorIterator it(&counts, &ranges);
- size_t index;
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- it.Get(&min, &max, &count);
- EXPECT_EQ(0, min);
- EXPECT_EQ(1, max);
- EXPECT_EQ(1, count);
- EXPECT_TRUE(it.GetBucketIndex(&index));
- EXPECT_EQ(0u, index);
-
- it.Next();
- it.Get(&min, &max, &count);
- EXPECT_EQ(2, min);
- EXPECT_EQ(3, max);
- EXPECT_EQ(2, count);
- EXPECT_TRUE(it.GetBucketIndex(&index));
- EXPECT_EQ(2u, index);
-
- it.Next();
- EXPECT_TRUE(it.Done());
-
- // Create iterator from SampleVector.
- SampleVector samples(1, &ranges);
- samples.Accumulate(0, 0);
- samples.Accumulate(1, 1);
- samples.Accumulate(2, 2);
- samples.Accumulate(3, 3);
- std::unique_ptr<SampleCountIterator> it2 = samples.Iterator();
-
- int i;
- for (i = 1; !it2->Done(); i++, it2->Next()) {
- it2->Get(&min, &max, &count);
- EXPECT_EQ(i, min);
- EXPECT_EQ(i + 1, max);
- EXPECT_EQ(i, count);
-
- size_t index;
- EXPECT_TRUE(it2->GetBucketIndex(&index));
- EXPECT_EQ(static_cast<size_t>(i), index);
- }
- EXPECT_EQ(4, i);
-}
-
-TEST_F(SampleVectorTest, IterateDoneDeath) {
- BucketRanges ranges(5);
- ranges.set_range(0, 0);
- ranges.set_range(1, 1);
- ranges.set_range(2, 2);
- ranges.set_range(3, 3);
- ranges.set_range(4, INT_MAX);
- SampleVector samples(1, &ranges);
-
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
-
- EXPECT_TRUE(it->Done());
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- EXPECT_DCHECK_DEATH(it->Get(&min, &max, &count));
-
- EXPECT_DCHECK_DEATH(it->Next());
-
- samples.Accumulate(2, 100);
- it = samples.Iterator();
- EXPECT_FALSE(it->Done());
-}
-
-TEST_F(SampleVectorTest, SingleSample) {
- // Custom buckets: [1, 5) [5, 10)
- BucketRanges ranges(3);
- ranges.set_range(0, 1);
- ranges.set_range(1, 5);
- ranges.set_range(2, 10);
- SampleVector samples(&ranges);
-
- // Ensure that a single value accumulates correctly.
- EXPECT_FALSE(GetSamplesCounts(samples));
- samples.Accumulate(3, 200);
- EXPECT_EQ(200, samples.GetCount(3));
- EXPECT_FALSE(GetSamplesCounts(samples));
- samples.Accumulate(3, 400);
- EXPECT_EQ(600, samples.GetCount(3));
- EXPECT_FALSE(GetSamplesCounts(samples));
- EXPECT_EQ(3 * 600, samples.sum());
- EXPECT_EQ(600, samples.TotalCount());
- EXPECT_EQ(600, samples.redundant_count());
-
- // Ensure that the iterator returns only one value.
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- std::unique_ptr<SampleCountIterator> it = samples.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(600, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-
- // Ensure that it can be merged to another single-sample vector.
- SampleVector samples_copy(&ranges);
- samples_copy.Add(samples);
- EXPECT_FALSE(GetSamplesCounts(samples_copy));
- EXPECT_EQ(3 * 600, samples_copy.sum());
- EXPECT_EQ(600, samples_copy.TotalCount());
- EXPECT_EQ(600, samples_copy.redundant_count());
-
- // A different value should cause creation of the counts array.
- samples.Accumulate(8, 100);
- EXPECT_TRUE(GetSamplesCounts(samples));
- EXPECT_EQ(600, samples.GetCount(3));
- EXPECT_EQ(100, samples.GetCount(8));
- EXPECT_EQ(3 * 600 + 8 * 100, samples.sum());
- EXPECT_EQ(600 + 100, samples.TotalCount());
- EXPECT_EQ(600 + 100, samples.redundant_count());
-
- // The iterator should now return both values.
- it = samples.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(600, count);
- it->Next();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(5, min);
- EXPECT_EQ(10, max);
- EXPECT_EQ(100, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-
- // Ensure that it can merged to a single-sample vector.
- samples_copy.Add(samples);
- EXPECT_TRUE(GetSamplesCounts(samples_copy));
- EXPECT_EQ(3 * 1200 + 8 * 100, samples_copy.sum());
- EXPECT_EQ(1200 + 100, samples_copy.TotalCount());
- EXPECT_EQ(1200 + 100, samples_copy.redundant_count());
-}
-
-TEST_F(SampleVectorTest, PersistentSampleVector) {
- LocalPersistentMemoryAllocator allocator(64 << 10, 0, "");
- std::atomic<PersistentMemoryAllocator::Reference> samples_ref;
- samples_ref.store(0, std::memory_order_relaxed);
- HistogramSamples::Metadata samples_meta;
- memset(&samples_meta, 0, sizeof(samples_meta));
-
- // Custom buckets: [1, 5) [5, 10)
- BucketRanges ranges(3);
- ranges.set_range(0, 1);
- ranges.set_range(1, 5);
- ranges.set_range(2, 10);
-
- // Persistent allocation.
- const size_t counts_bytes =
- sizeof(HistogramBase::AtomicCount) * ranges.bucket_count();
- const DelayedPersistentAllocation allocation(&allocator, &samples_ref, 1,
- counts_bytes, false);
-
- PersistentSampleVector samples1(0, &ranges, &samples_meta, allocation);
- EXPECT_FALSE(GetSamplesCounts(samples1));
- samples1.Accumulate(3, 200);
- EXPECT_EQ(200, samples1.GetCount(3));
- EXPECT_FALSE(GetSamplesCounts(samples1));
- EXPECT_EQ(0, samples1.GetCount(8));
- EXPECT_FALSE(GetSamplesCounts(samples1));
-
- PersistentSampleVector samples2(0, &ranges, &samples_meta, allocation);
- EXPECT_EQ(200, samples2.GetCount(3));
- EXPECT_FALSE(GetSamplesCounts(samples2));
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- std::unique_ptr<SampleCountIterator> it = samples2.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(200, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-
- samples1.Accumulate(8, 100);
- EXPECT_TRUE(GetSamplesCounts(samples1));
-
- EXPECT_FALSE(GetSamplesCounts(samples2));
- EXPECT_EQ(200, samples2.GetCount(3));
- EXPECT_EQ(100, samples2.GetCount(8));
- EXPECT_TRUE(GetSamplesCounts(samples2));
- EXPECT_EQ(3 * 200 + 8 * 100, samples2.sum());
- EXPECT_EQ(300, samples2.TotalCount());
- EXPECT_EQ(300, samples2.redundant_count());
-
- it = samples2.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(200, count);
- it->Next();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(5, min);
- EXPECT_EQ(10, max);
- EXPECT_EQ(100, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-
- PersistentSampleVector samples3(0, &ranges, &samples_meta, allocation);
- EXPECT_TRUE(GetSamplesCounts(samples2));
- EXPECT_EQ(200, samples3.GetCount(3));
- EXPECT_EQ(100, samples3.GetCount(8));
- EXPECT_EQ(3 * 200 + 8 * 100, samples3.sum());
- EXPECT_EQ(300, samples3.TotalCount());
- EXPECT_EQ(300, samples3.redundant_count());
-
- it = samples3.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(200, count);
- it->Next();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(5, min);
- EXPECT_EQ(10, max);
- EXPECT_EQ(100, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-}
-
-TEST_F(SampleVectorTest, PersistentSampleVectorTestWithOutsideAlloc) {
- LocalPersistentMemoryAllocator allocator(64 << 10, 0, "");
- std::atomic<PersistentMemoryAllocator::Reference> samples_ref;
- samples_ref.store(0, std::memory_order_relaxed);
- HistogramSamples::Metadata samples_meta;
- memset(&samples_meta, 0, sizeof(samples_meta));
-
- // Custom buckets: [1, 5) [5, 10)
- BucketRanges ranges(3);
- ranges.set_range(0, 1);
- ranges.set_range(1, 5);
- ranges.set_range(2, 10);
-
- // Persistent allocation.
- const size_t counts_bytes =
- sizeof(HistogramBase::AtomicCount) * ranges.bucket_count();
- const DelayedPersistentAllocation allocation(&allocator, &samples_ref, 1,
- counts_bytes, false);
-
- PersistentSampleVector samples1(0, &ranges, &samples_meta, allocation);
- EXPECT_FALSE(GetSamplesCounts(samples1));
- samples1.Accumulate(3, 200);
- EXPECT_EQ(200, samples1.GetCount(3));
- EXPECT_FALSE(GetSamplesCounts(samples1));
-
- // Because the delayed allocation can be shared with other objects (the
- // |offset| parameter allows concatinating multiple data blocks into the
- // same allocation), it's possible that the allocation gets realized from
- // the outside even though the data block being accessed is all zero.
- allocation.Get();
- EXPECT_EQ(200, samples1.GetCount(3));
- EXPECT_FALSE(GetSamplesCounts(samples1));
-
- HistogramBase::Sample min;
- int64_t max;
- HistogramBase::Count count;
- std::unique_ptr<SampleCountIterator> it = samples1.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(200, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-
- // A duplicate samples object should still see the single-sample entry even
- // when storage is available.
- PersistentSampleVector samples2(0, &ranges, &samples_meta, allocation);
- EXPECT_EQ(200, samples2.GetCount(3));
-
- // New accumulations, in both directions, of the existing value should work.
- samples1.Accumulate(3, 50);
- EXPECT_EQ(250, samples1.GetCount(3));
- EXPECT_EQ(250, samples2.GetCount(3));
- samples2.Accumulate(3, 50);
- EXPECT_EQ(300, samples1.GetCount(3));
- EXPECT_EQ(300, samples2.GetCount(3));
-
- it = samples1.Iterator();
- ASSERT_FALSE(it->Done());
- it->Get(&min, &max, &count);
- EXPECT_EQ(1, min);
- EXPECT_EQ(5, max);
- EXPECT_EQ(300, count);
- it->Next();
- EXPECT_TRUE(it->Done());
-
- samples1.Accumulate(8, 100);
- EXPECT_TRUE(GetSamplesCounts(samples1));
- EXPECT_EQ(300, samples1.GetCount(3));
- EXPECT_EQ(300, samples2.GetCount(3));
- EXPECT_EQ(100, samples1.GetCount(8));
- EXPECT_EQ(100, samples2.GetCount(8));
- samples2.Accumulate(8, 100);
- EXPECT_EQ(300, samples1.GetCount(3));
- EXPECT_EQ(300, samples2.GetCount(3));
- EXPECT_EQ(200, samples1.GetCount(8));
- EXPECT_EQ(200, samples2.GetCount(8));
-}
-
-} // namespace base
diff --git a/base/metrics/single_sample_metrics_unittest.cc b/base/metrics/single_sample_metrics_unittest.cc
deleted file mode 100644
index 5a6d159..0000000
--- a/base/metrics/single_sample_metrics_unittest.cc
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright 2017 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 "base/metrics/single_sample_metrics.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/metrics/dummy_histogram.h"
-#include "base/test/gtest_util.h"
-#include "base/test/histogram_tester.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-const HistogramBase::Sample kMin = 1;
-const HistogramBase::Sample kMax = 10;
-const uint32_t kBucketCount = 10;
-const char kMetricName[] = "Single.Sample.Metric";
-
-class SingleSampleMetricsTest : public testing::Test {
- public:
- SingleSampleMetricsTest() = default;
-
- ~SingleSampleMetricsTest() override {
- // Ensure we cleanup after ourselves.
- SingleSampleMetricsFactory::DeleteFactoryForTesting();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SingleSampleMetricsTest);
-};
-
-} // namespace
-
-TEST_F(SingleSampleMetricsTest, DefaultFactoryGetSet) {
- SingleSampleMetricsFactory* factory = SingleSampleMetricsFactory::Get();
- ASSERT_TRUE(factory);
-
- // Same factory should be returned evermore.
- EXPECT_EQ(factory, SingleSampleMetricsFactory::Get());
-
- // Setting a factory after the default has been instantiated should fail.
- EXPECT_DCHECK_DEATH(SingleSampleMetricsFactory::SetFactory(
- WrapUnique<SingleSampleMetricsFactory>(nullptr)));
-}
-
-TEST_F(SingleSampleMetricsTest, CustomFactoryGetSet) {
- SingleSampleMetricsFactory* factory = new DefaultSingleSampleMetricsFactory();
- SingleSampleMetricsFactory::SetFactory(WrapUnique(factory));
- EXPECT_EQ(factory, SingleSampleMetricsFactory::Get());
-}
-
-TEST_F(SingleSampleMetricsTest, DefaultSingleSampleMetricNoValue) {
- SingleSampleMetricsFactory* factory = SingleSampleMetricsFactory::Get();
-
- HistogramTester tester;
- std::unique_ptr<SingleSampleMetric> metric =
- factory->CreateCustomCountsMetric(kMetricName, kMin, kMax, kBucketCount);
- metric.reset();
-
- // Verify that no sample is recorded if SetSample() is never called.
- tester.ExpectTotalCount(kMetricName, 0);
-}
-
-TEST_F(SingleSampleMetricsTest, DefaultSingleSampleMetricWithValue) {
- SingleSampleMetricsFactory* factory = SingleSampleMetricsFactory::Get();
-
- HistogramTester tester;
- std::unique_ptr<SingleSampleMetric> metric =
- factory->CreateCustomCountsMetric(kMetricName, kMin, kMax, kBucketCount);
-
- const HistogramBase::Sample kLastSample = 9;
- metric->SetSample(1);
- metric->SetSample(3);
- metric->SetSample(5);
- metric->SetSample(kLastSample);
- metric.reset();
-
- // Verify only the last sample sent to SetSample() is recorded.
- tester.ExpectUniqueSample(kMetricName, kLastSample, 1);
-
- // Verify construction implicitly by requesting a histogram with the same
- // parameters; this test relies on the fact that histogram objects are unique
- // per name. Different parameters will result in a Dummy histogram returned.
- EXPECT_EQ(
- DummyHistogram::GetInstance(),
- Histogram::FactoryGet(kMetricName, 1, 3, 3, HistogramBase::kNoFlags));
- EXPECT_NE(DummyHistogram::GetInstance(),
- Histogram::FactoryGet(kMetricName, kMin, kMax, kBucketCount,
- HistogramBase::kUmaTargetedHistogramFlag));
-}
-
-TEST_F(SingleSampleMetricsTest, MultipleMetricsAreDistinct) {
- SingleSampleMetricsFactory* factory = SingleSampleMetricsFactory::Get();
-
- HistogramTester tester;
- std::unique_ptr<SingleSampleMetric> metric =
- factory->CreateCustomCountsMetric(kMetricName, kMin, kMax, kBucketCount);
- std::unique_ptr<SingleSampleMetric> metric2 =
- factory->CreateCustomCountsMetric(kMetricName, kMin, kMax, kBucketCount);
- const char kMetricName2[] = "Single.Sample.Metric.2";
- std::unique_ptr<SingleSampleMetric> metric3 =
- factory->CreateCustomCountsMetric(kMetricName2, kMin, kMax, kBucketCount);
-
- const HistogramBase::Sample kSample1 = 5;
- metric->SetSample(kSample1);
- metric2->SetSample(kSample1);
-
- const HistogramBase::Sample kSample2 = 7;
- metric3->SetSample(kSample2);
-
- metric.reset();
- tester.ExpectUniqueSample(kMetricName, kSample1, 1);
-
- metric2.reset();
- tester.ExpectUniqueSample(kMetricName, kSample1, 2);
-
- metric3.reset();
- tester.ExpectUniqueSample(kMetricName2, kSample2, 1);
-}
-
-} // namespace base
diff --git a/base/metrics/sparse_histogram_unittest.cc b/base/metrics/sparse_histogram_unittest.cc
deleted file mode 100644
index 72dd905..0000000
--- a/base/metrics/sparse_histogram_unittest.cc
+++ /dev/null
@@ -1,388 +0,0 @@
-// 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.
-
-#include "base/metrics/sparse_histogram.h"
-
-#include <memory>
-#include <string>
-
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/metrics_hashes.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/metrics/sample_map.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/pickle.h"
-#include "base/strings/stringprintf.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// Test parameter indicates if a persistent memory allocator should be used
-// for histogram allocation. False will allocate histograms from the process
-// heap.
-class SparseHistogramTest : public testing::TestWithParam<bool> {
- protected:
- const int32_t kAllocatorMemorySize = 8 << 20; // 8 MiB
-
- SparseHistogramTest() : use_persistent_histogram_allocator_(GetParam()) {}
-
- void SetUp() override {
- if (use_persistent_histogram_allocator_)
- CreatePersistentMemoryAllocator();
-
- // Each test will have a clean state (no Histogram / BucketRanges
- // registered).
- InitializeStatisticsRecorder();
- }
-
- void TearDown() override {
- if (allocator_) {
- ASSERT_FALSE(allocator_->IsFull());
- ASSERT_FALSE(allocator_->IsCorrupt());
- }
- UninitializeStatisticsRecorder();
- DestroyPersistentMemoryAllocator();
- }
-
- void InitializeStatisticsRecorder() {
- DCHECK(!statistics_recorder_);
- statistics_recorder_ = StatisticsRecorder::CreateTemporaryForTesting();
- }
-
- void UninitializeStatisticsRecorder() {
- statistics_recorder_.reset();
- }
-
- void CreatePersistentMemoryAllocator() {
- GlobalHistogramAllocator::CreateWithLocalMemory(
- kAllocatorMemorySize, 0, "SparseHistogramAllocatorTest");
- allocator_ = GlobalHistogramAllocator::Get()->memory_allocator();
- }
-
- void DestroyPersistentMemoryAllocator() {
- allocator_ = nullptr;
- GlobalHistogramAllocator::ReleaseForTesting();
- }
-
- std::unique_ptr<SparseHistogram> NewSparseHistogram(const char* name) {
- // std::make_unique can't access protected ctor so do it manually. This
- // test class is a friend so can access it.
- return std::unique_ptr<SparseHistogram>(new SparseHistogram(name));
- }
-
- const bool use_persistent_histogram_allocator_;
-
- std::unique_ptr<StatisticsRecorder> statistics_recorder_;
- PersistentMemoryAllocator* allocator_ = nullptr;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SparseHistogramTest);
-};
-
-// Run all HistogramTest cases with both heap and persistent memory.
-INSTANTIATE_TEST_CASE_P(HeapAndPersistent,
- SparseHistogramTest,
- testing::Bool());
-
-
-TEST_P(SparseHistogramTest, BasicTest) {
- std::unique_ptr<SparseHistogram> histogram(NewSparseHistogram("Sparse"));
- std::unique_ptr<HistogramSamples> snapshot(histogram->SnapshotSamples());
- EXPECT_EQ(0, snapshot->TotalCount());
- EXPECT_EQ(0, snapshot->sum());
-
- histogram->Add(100);
- std::unique_ptr<HistogramSamples> snapshot1(histogram->SnapshotSamples());
- EXPECT_EQ(1, snapshot1->TotalCount());
- EXPECT_EQ(1, snapshot1->GetCount(100));
-
- histogram->Add(100);
- histogram->Add(101);
- std::unique_ptr<HistogramSamples> snapshot2(histogram->SnapshotSamples());
- EXPECT_EQ(3, snapshot2->TotalCount());
- EXPECT_EQ(2, snapshot2->GetCount(100));
- EXPECT_EQ(1, snapshot2->GetCount(101));
-}
-
-TEST_P(SparseHistogramTest, BasicTestAddCount) {
- std::unique_ptr<SparseHistogram> histogram(NewSparseHistogram("Sparse"));
- std::unique_ptr<HistogramSamples> snapshot(histogram->SnapshotSamples());
- EXPECT_EQ(0, snapshot->TotalCount());
- EXPECT_EQ(0, snapshot->sum());
-
- histogram->AddCount(100, 15);
- std::unique_ptr<HistogramSamples> snapshot1(histogram->SnapshotSamples());
- EXPECT_EQ(15, snapshot1->TotalCount());
- EXPECT_EQ(15, snapshot1->GetCount(100));
-
- histogram->AddCount(100, 15);
- histogram->AddCount(101, 25);
- std::unique_ptr<HistogramSamples> snapshot2(histogram->SnapshotSamples());
- EXPECT_EQ(55, snapshot2->TotalCount());
- EXPECT_EQ(30, snapshot2->GetCount(100));
- EXPECT_EQ(25, snapshot2->GetCount(101));
-}
-
-TEST_P(SparseHistogramTest, AddCount_LargeValuesDontOverflow) {
- std::unique_ptr<SparseHistogram> histogram(NewSparseHistogram("Sparse"));
- std::unique_ptr<HistogramSamples> snapshot(histogram->SnapshotSamples());
- EXPECT_EQ(0, snapshot->TotalCount());
- EXPECT_EQ(0, snapshot->sum());
-
- histogram->AddCount(1000000000, 15);
- std::unique_ptr<HistogramSamples> snapshot1(histogram->SnapshotSamples());
- EXPECT_EQ(15, snapshot1->TotalCount());
- EXPECT_EQ(15, snapshot1->GetCount(1000000000));
-
- histogram->AddCount(1000000000, 15);
- histogram->AddCount(1010000000, 25);
- std::unique_ptr<HistogramSamples> snapshot2(histogram->SnapshotSamples());
- EXPECT_EQ(55, snapshot2->TotalCount());
- EXPECT_EQ(30, snapshot2->GetCount(1000000000));
- EXPECT_EQ(25, snapshot2->GetCount(1010000000));
- EXPECT_EQ(55250000000LL, snapshot2->sum());
-}
-
-// Make sure that counts returned by Histogram::SnapshotDelta do not overflow
-// even when a total count (returned by Histogram::SnapshotSample) does.
-TEST_P(SparseHistogramTest, AddCount_LargeCountsDontOverflow) {
- std::unique_ptr<SparseHistogram> histogram(NewSparseHistogram("Sparse"));
- std::unique_ptr<HistogramSamples> snapshot(histogram->SnapshotSamples());
- EXPECT_EQ(0, snapshot->TotalCount());
- EXPECT_EQ(0, snapshot->sum());
-
- const int count = (1 << 30) - 1;
-
- // Repeat N times to make sure that there is no internal value overflow.
- for (int i = 0; i < 10; ++i) {
- histogram->AddCount(42, count);
- std::unique_ptr<HistogramSamples> samples = histogram->SnapshotDelta();
- EXPECT_EQ(count, samples->TotalCount());
- EXPECT_EQ(count, samples->GetCount(42));
- }
-}
-
-TEST_P(SparseHistogramTest, MacroBasicTest) {
- UmaHistogramSparse("Sparse", 100);
- UmaHistogramSparse("Sparse", 200);
- UmaHistogramSparse("Sparse", 100);
-
- const StatisticsRecorder::Histograms histograms =
- StatisticsRecorder::GetHistograms();
-
- ASSERT_THAT(histograms, testing::SizeIs(1));
- const HistogramBase* const sparse_histogram = histograms[0];
-
- EXPECT_EQ(SPARSE_HISTOGRAM, sparse_histogram->GetHistogramType());
- EXPECT_EQ("Sparse", StringPiece(sparse_histogram->histogram_name()));
- EXPECT_EQ(
- HistogramBase::kUmaTargetedHistogramFlag |
- (use_persistent_histogram_allocator_ ? HistogramBase::kIsPersistent
- : 0),
- sparse_histogram->flags());
-
- std::unique_ptr<HistogramSamples> samples =
- sparse_histogram->SnapshotSamples();
- EXPECT_EQ(3, samples->TotalCount());
- EXPECT_EQ(2, samples->GetCount(100));
- EXPECT_EQ(1, samples->GetCount(200));
-}
-
-TEST_P(SparseHistogramTest, MacroInLoopTest) {
- // Unlike the macros in histogram.h, SparseHistogram macros can have a
- // variable as histogram name.
- for (int i = 0; i < 2; i++) {
- UmaHistogramSparse(StringPrintf("Sparse%d", i), 100);
- }
-
- const StatisticsRecorder::Histograms histograms =
- StatisticsRecorder::Sort(StatisticsRecorder::GetHistograms());
- ASSERT_THAT(histograms, testing::SizeIs(2));
- EXPECT_STREQ(histograms[0]->histogram_name(), "Sparse0");
- EXPECT_STREQ(histograms[1]->histogram_name(), "Sparse1");
-}
-
-TEST_P(SparseHistogramTest, Serialize) {
- std::unique_ptr<SparseHistogram> histogram(NewSparseHistogram("Sparse"));
- histogram->SetFlags(HistogramBase::kIPCSerializationSourceFlag);
-
- Pickle pickle;
- histogram->SerializeInfo(&pickle);
-
- PickleIterator iter(pickle);
-
- int type;
- EXPECT_TRUE(iter.ReadInt(&type));
- EXPECT_EQ(SPARSE_HISTOGRAM, type);
-
- std::string name;
- EXPECT_TRUE(iter.ReadString(&name));
- EXPECT_EQ("Sparse", name);
-
- int flag;
- EXPECT_TRUE(iter.ReadInt(&flag));
- EXPECT_EQ(HistogramBase::kIPCSerializationSourceFlag, flag);
-
- // No more data in the pickle.
- EXPECT_FALSE(iter.SkipBytes(1));
-}
-
-// Ensure that race conditions that cause multiple, identical sparse histograms
-// to be created will safely resolve to a single one.
-TEST_P(SparseHistogramTest, DuplicationSafety) {
- const char histogram_name[] = "Duplicated";
- size_t histogram_count = StatisticsRecorder::GetHistogramCount();
-
- // Create a histogram that we will later duplicate.
- HistogramBase* original =
- SparseHistogram::FactoryGet(histogram_name, HistogramBase::kNoFlags);
- ++histogram_count;
- DCHECK_EQ(histogram_count, StatisticsRecorder::GetHistogramCount());
- original->Add(1);
-
- // Create a duplicate. This has to happen differently depending on where the
- // memory is taken from.
- if (use_persistent_histogram_allocator_) {
- // To allocate from persistent memory, clear the last_created reference in
- // the GlobalHistogramAllocator. This will cause an Import to recreate
- // the just-created histogram which will then be released as a duplicate.
- GlobalHistogramAllocator::Get()->ClearLastCreatedReferenceForTesting();
- // Creating a different histogram will first do an Import to ensure it
- // hasn't been created elsewhere, triggering the duplication and release.
- SparseHistogram::FactoryGet("something.new", HistogramBase::kNoFlags);
- ++histogram_count;
- } else {
- // To allocate from the heap, just call the (private) constructor directly.
- // Delete it immediately like would have happened within FactoryGet();
- std::unique_ptr<SparseHistogram> something =
- NewSparseHistogram(histogram_name);
- DCHECK_NE(original, something.get());
- }
- DCHECK_EQ(histogram_count, StatisticsRecorder::GetHistogramCount());
-
- // Re-creating the histogram via FactoryGet() will return the same one.
- HistogramBase* duplicate =
- SparseHistogram::FactoryGet(histogram_name, HistogramBase::kNoFlags);
- DCHECK_EQ(original, duplicate);
- DCHECK_EQ(histogram_count, StatisticsRecorder::GetHistogramCount());
- duplicate->Add(2);
-
- // Ensure that original histograms are still cross-functional.
- original->Add(2);
- duplicate->Add(1);
- std::unique_ptr<HistogramSamples> snapshot_orig = original->SnapshotSamples();
- std::unique_ptr<HistogramSamples> snapshot_dup = duplicate->SnapshotSamples();
- DCHECK_EQ(2, snapshot_orig->GetCount(2));
- DCHECK_EQ(2, snapshot_dup->GetCount(1));
-}
-
-TEST_P(SparseHistogramTest, FactoryTime) {
- const int kTestCreateCount = 1 << 10; // Must be power-of-2.
- const int kTestLookupCount = 100000;
- const int kTestAddCount = 100000;
-
- // Create all histogram names in advance for accurate timing below.
- std::vector<std::string> histogram_names;
- for (int i = 0; i < kTestCreateCount; ++i) {
- histogram_names.push_back(
- StringPrintf("TestHistogram.%d", i % kTestCreateCount));
- }
-
- // Calculate cost of creating histograms.
- TimeTicks create_start = TimeTicks::Now();
- for (int i = 0; i < kTestCreateCount; ++i)
- SparseHistogram::FactoryGet(histogram_names[i], HistogramBase::kNoFlags);
- TimeDelta create_ticks = TimeTicks::Now() - create_start;
- int64_t create_ms = create_ticks.InMilliseconds();
-
- VLOG(1) << kTestCreateCount << " histogram creations took " << create_ms
- << "ms or about "
- << (create_ms * 1000000) / kTestCreateCount
- << "ns each.";
-
- // Calculate cost of looking up existing histograms.
- TimeTicks lookup_start = TimeTicks::Now();
- for (int i = 0; i < kTestLookupCount; ++i) {
- // 6007 is co-prime with kTestCreateCount and so will do lookups in an
- // order less likely to be cacheable (but still hit them all) should the
- // underlying storage use the exact histogram name as the key.
- const int i_mult = 6007;
- static_assert(i_mult < INT_MAX / kTestCreateCount, "Multiplier too big");
- int index = (i * i_mult) & (kTestCreateCount - 1);
- SparseHistogram::FactoryGet(histogram_names[index],
- HistogramBase::kNoFlags);
- }
- TimeDelta lookup_ticks = TimeTicks::Now() - lookup_start;
- int64_t lookup_ms = lookup_ticks.InMilliseconds();
-
- VLOG(1) << kTestLookupCount << " histogram lookups took " << lookup_ms
- << "ms or about "
- << (lookup_ms * 1000000) / kTestLookupCount
- << "ns each.";
-
- // Calculate cost of accessing histograms.
- HistogramBase* histogram =
- SparseHistogram::FactoryGet(histogram_names[0], HistogramBase::kNoFlags);
- ASSERT_TRUE(histogram);
- TimeTicks add_start = TimeTicks::Now();
- for (int i = 0; i < kTestAddCount; ++i)
- histogram->Add(i & 127);
- TimeDelta add_ticks = TimeTicks::Now() - add_start;
- int64_t add_ms = add_ticks.InMilliseconds();
-
- VLOG(1) << kTestAddCount << " histogram adds took " << add_ms
- << "ms or about "
- << (add_ms * 1000000) / kTestAddCount
- << "ns each.";
-}
-
-TEST_P(SparseHistogramTest, ExtremeValues) {
- static const struct {
- Histogram::Sample sample;
- int64_t expected_max;
- } cases[] = {
- // Note: We use -2147483647 - 1 rather than -2147483648 because the later
- // is interpreted as - operator applied to 2147483648 and the latter can't
- // be represented as an int32 and causes a warning.
- {-2147483647 - 1, -2147483647LL},
- {0, 1},
- {2147483647, 2147483648LL},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- HistogramBase* histogram =
- SparseHistogram::FactoryGet(StringPrintf("ExtremeValues_%zu", i),
- HistogramBase::kUmaTargetedHistogramFlag);
- histogram->Add(cases[i].sample);
-
- std::unique_ptr<HistogramSamples> snapshot = histogram->SnapshotSamples();
- std::unique_ptr<SampleCountIterator> it = snapshot->Iterator();
- ASSERT_FALSE(it->Done());
-
- base::Histogram::Sample min;
- int64_t max;
- base::Histogram::Count count;
- it->Get(&min, &max, &count);
-
- EXPECT_EQ(1, count);
- EXPECT_EQ(cases[i].sample, min);
- EXPECT_EQ(cases[i].expected_max, max);
-
- it->Next();
- EXPECT_TRUE(it->Done());
- }
-}
-
-TEST_P(SparseHistogramTest, HistogramNameHash) {
- const char kName[] = "TestName";
- HistogramBase* histogram = SparseHistogram::FactoryGet(
- kName, HistogramBase::kUmaTargetedHistogramFlag);
- EXPECT_EQ(histogram->name_hash(), HashMetricName(kName));
-}
-
-} // namespace base
diff --git a/base/metrics/statistics_recorder_unittest.cc b/base/metrics/statistics_recorder_unittest.cc
deleted file mode 100644
index 63ba136..0000000
--- a/base/metrics/statistics_recorder_unittest.cc
+++ /dev/null
@@ -1,718 +0,0 @@
-// 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.
-
-#include "base/metrics/statistics_recorder.h"
-
-#include <stddef.h>
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/json/json_reader.h"
-#include "base/logging.h"
-#include "base/memory/weak_ptr.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/persistent_histogram_allocator.h"
-#include "base/metrics/record_histogram_checker.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/values.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-// Class to make sure any manipulations we do to the min log level are
-// contained (i.e., do not affect other unit tests).
-class LogStateSaver {
- public:
- LogStateSaver() : old_min_log_level_(logging::GetMinLogLevel()) {}
-
- ~LogStateSaver() { logging::SetMinLogLevel(old_min_log_level_); }
-
- private:
- int old_min_log_level_;
-
- DISALLOW_COPY_AND_ASSIGN(LogStateSaver);
-};
-
-// Test implementation of RecordHistogramChecker interface.
-class OddRecordHistogramChecker : public base::RecordHistogramChecker {
- public:
- ~OddRecordHistogramChecker() override = default;
-
- // base::RecordHistogramChecker:
- bool ShouldRecord(uint64_t histogram_hash) const override {
- return histogram_hash % 2;
- }
-};
-
-} // namespace
-
-namespace base {
-
-using testing::IsEmpty;
-using testing::SizeIs;
-using testing::UnorderedElementsAre;
-
-class StatisticsRecorderTest : public testing::TestWithParam<bool> {
- protected:
- const int32_t kAllocatorMemorySize = 64 << 10; // 64 KiB
-
- StatisticsRecorderTest() : use_persistent_histogram_allocator_(GetParam()) {
- // Each test will have a clean state (no Histogram / BucketRanges
- // registered).
- InitializeStatisticsRecorder();
-
- // Use persistent memory for histograms if so indicated by test parameter.
- if (use_persistent_histogram_allocator_) {
- GlobalHistogramAllocator::CreateWithLocalMemory(kAllocatorMemorySize, 0,
- "StatisticsRecorderTest");
- }
- }
-
- ~StatisticsRecorderTest() override {
- GlobalHistogramAllocator::ReleaseForTesting();
- UninitializeStatisticsRecorder();
- }
-
- void InitializeStatisticsRecorder() {
- DCHECK(!statistics_recorder_);
- statistics_recorder_ = StatisticsRecorder::CreateTemporaryForTesting();
- }
-
- // Deletes the global recorder if there is any. This is used by test
- // NotInitialized to ensure a clean global state.
- void UninitializeStatisticsRecorder() {
- statistics_recorder_.reset();
- delete StatisticsRecorder::top_;
- DCHECK(!StatisticsRecorder::top_);
- }
-
- bool HasGlobalRecorder() { return StatisticsRecorder::top_ != nullptr; }
-
- Histogram* CreateHistogram(const char* name,
- HistogramBase::Sample min,
- HistogramBase::Sample max,
- size_t bucket_count) {
- BucketRanges* ranges = new BucketRanges(bucket_count + 1);
- Histogram::InitializeBucketRanges(min, max, ranges);
- const BucketRanges* registered_ranges =
- StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
- return new Histogram(name, min, max, registered_ranges);
- }
-
- void InitLogOnShutdown() { StatisticsRecorder::InitLogOnShutdown(); }
-
- bool IsVLogInitialized() { return StatisticsRecorder::is_vlog_initialized_; }
-
- void ResetVLogInitialized() {
- UninitializeStatisticsRecorder();
- StatisticsRecorder::is_vlog_initialized_ = false;
- }
-
- const bool use_persistent_histogram_allocator_;
-
- std::unique_ptr<StatisticsRecorder> statistics_recorder_;
- std::unique_ptr<GlobalHistogramAllocator> old_global_allocator_;
-
- private:
- LogStateSaver log_state_saver_;
-
- DISALLOW_COPY_AND_ASSIGN(StatisticsRecorderTest);
-};
-
-// Run all HistogramTest cases with both heap and persistent memory.
-INSTANTIATE_TEST_CASE_P(Allocator, StatisticsRecorderTest, testing::Bool());
-
-TEST_P(StatisticsRecorderTest, NotInitialized) {
- UninitializeStatisticsRecorder();
- EXPECT_FALSE(HasGlobalRecorder());
-
- HistogramBase* const histogram =
- CreateHistogram("TestHistogram", 1, 1000, 10);
- EXPECT_EQ(StatisticsRecorder::RegisterOrDeleteDuplicate(histogram),
- histogram);
- EXPECT_TRUE(HasGlobalRecorder());
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram));
-
- UninitializeStatisticsRecorder();
- EXPECT_FALSE(HasGlobalRecorder());
-
- BucketRanges* const ranges = new BucketRanges(3);
- ranges->ResetChecksum();
- EXPECT_EQ(StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges),
- ranges);
- EXPECT_TRUE(HasGlobalRecorder());
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(),
- UnorderedElementsAre(ranges));
-}
-
-TEST_P(StatisticsRecorderTest, RegisterBucketRanges) {
- std::vector<const BucketRanges*> registered_ranges;
-
- BucketRanges* ranges1 = new BucketRanges(3);
- ranges1->ResetChecksum();
- BucketRanges* ranges2 = new BucketRanges(4);
- ranges2->ResetChecksum();
-
- // Register new ranges.
- EXPECT_EQ(ranges1,
- StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges1));
- EXPECT_EQ(ranges2,
- StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges2));
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(),
- UnorderedElementsAre(ranges1, ranges2));
-
- // Register some ranges again.
- EXPECT_EQ(ranges1,
- StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges1));
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(),
- UnorderedElementsAre(ranges1, ranges2));
-
- // Make sure the ranges is still the one we know.
- ASSERT_EQ(3u, ranges1->size());
- EXPECT_EQ(0, ranges1->range(0));
- EXPECT_EQ(0, ranges1->range(1));
- EXPECT_EQ(0, ranges1->range(2));
-
- // Register ranges with same values.
- BucketRanges* ranges3 = new BucketRanges(3);
- ranges3->ResetChecksum();
- EXPECT_EQ(ranges1, // returning ranges1
- StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges3));
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(),
- UnorderedElementsAre(ranges1, ranges2));
-}
-
-TEST_P(StatisticsRecorderTest, RegisterHistogram) {
- // Create a Histogram that was not registered.
- Histogram* const histogram1 = CreateHistogram("TestHistogram1", 1, 1000, 10);
-
- EXPECT_THAT(StatisticsRecorder::GetHistograms(), IsEmpty());
-
- // Register the Histogram.
- EXPECT_EQ(histogram1,
- StatisticsRecorder::RegisterOrDeleteDuplicate(histogram1));
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1));
-
- // Register the same Histogram again.
- EXPECT_EQ(histogram1,
- StatisticsRecorder::RegisterOrDeleteDuplicate(histogram1));
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1));
-
- // Register another Histogram with the same name.
- Histogram* const histogram2 = CreateHistogram("TestHistogram1", 1, 1000, 10);
- EXPECT_NE(histogram1, histogram2);
- EXPECT_EQ(histogram1,
- StatisticsRecorder::RegisterOrDeleteDuplicate(histogram2));
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1));
-
- // Register another Histogram with a different name.
- Histogram* const histogram3 = CreateHistogram("TestHistogram0", 1, 1000, 10);
- EXPECT_NE(histogram1, histogram3);
- EXPECT_EQ(histogram3,
- StatisticsRecorder::RegisterOrDeleteDuplicate(histogram3));
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1, histogram3));
-}
-
-TEST_P(StatisticsRecorderTest, FindHistogram) {
- HistogramBase* histogram1 = Histogram::FactoryGet(
- "TestHistogram1", 1, 1000, 10, HistogramBase::kNoFlags);
- HistogramBase* histogram2 = Histogram::FactoryGet(
- "TestHistogram2", 1, 1000, 10, HistogramBase::kNoFlags);
-
- EXPECT_EQ(histogram1, StatisticsRecorder::FindHistogram("TestHistogram1"));
- EXPECT_EQ(histogram2, StatisticsRecorder::FindHistogram("TestHistogram2"));
- EXPECT_FALSE(StatisticsRecorder::FindHistogram("TestHistogram"));
-
- // Create a new global allocator using the same memory as the old one. Any
- // old one is kept around so the memory doesn't get released.
- old_global_allocator_ = GlobalHistogramAllocator::ReleaseForTesting();
- if (use_persistent_histogram_allocator_) {
- GlobalHistogramAllocator::CreateWithPersistentMemory(
- const_cast<void*>(old_global_allocator_->data()),
- old_global_allocator_->length(), 0, old_global_allocator_->Id(),
- old_global_allocator_->Name());
- }
-
- // Reset statistics-recorder to validate operation from a clean start.
- UninitializeStatisticsRecorder();
- InitializeStatisticsRecorder();
-
- if (use_persistent_histogram_allocator_) {
- EXPECT_TRUE(StatisticsRecorder::FindHistogram("TestHistogram1"));
- EXPECT_TRUE(StatisticsRecorder::FindHistogram("TestHistogram2"));
- } else {
- EXPECT_FALSE(StatisticsRecorder::FindHistogram("TestHistogram1"));
- EXPECT_FALSE(StatisticsRecorder::FindHistogram("TestHistogram2"));
- }
- EXPECT_FALSE(StatisticsRecorder::FindHistogram("TestHistogram"));
-}
-
-TEST_P(StatisticsRecorderTest, WithName) {
- Histogram::FactoryGet("TestHistogram1", 1, 1000, 10, Histogram::kNoFlags);
- Histogram::FactoryGet("TestHistogram2", 1, 1000, 10, Histogram::kNoFlags);
- Histogram::FactoryGet("TestHistogram3", 1, 1000, 10, Histogram::kNoFlags);
-
- const auto histograms = StatisticsRecorder::GetHistograms();
- EXPECT_THAT(histograms, SizeIs(3));
- EXPECT_THAT(StatisticsRecorder::WithName(histograms, ""), SizeIs(3));
- EXPECT_THAT(StatisticsRecorder::WithName(histograms, "Test"), SizeIs(3));
- EXPECT_THAT(StatisticsRecorder::WithName(histograms, "1"), SizeIs(1));
- EXPECT_THAT(StatisticsRecorder::WithName(histograms, "hello"), IsEmpty());
-}
-
-TEST_P(StatisticsRecorderTest, RegisterHistogramWithFactoryGet) {
- EXPECT_THAT(StatisticsRecorder::GetHistograms(), IsEmpty());
-
- // Create a histogram.
- HistogramBase* const histogram1 = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1));
-
- // Get an existing histogram.
- HistogramBase* const histogram2 = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- EXPECT_EQ(histogram1, histogram2);
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1));
-
- // Create a LinearHistogram.
- HistogramBase* const histogram3 = LinearHistogram::FactoryGet(
- "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1, histogram3));
-
- // Create a BooleanHistogram.
- HistogramBase* const histogram4 = BooleanHistogram::FactoryGet(
- "TestBooleanHistogram", HistogramBase::kNoFlags);
- EXPECT_THAT(StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1, histogram3, histogram4));
-
- // Create a CustomHistogram.
- std::vector<int> custom_ranges;
- custom_ranges.push_back(1);
- custom_ranges.push_back(5);
- HistogramBase* const histogram5 = CustomHistogram::FactoryGet(
- "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags);
- EXPECT_THAT(
- StatisticsRecorder::GetHistograms(),
- UnorderedElementsAre(histogram1, histogram3, histogram4, histogram5));
-}
-
-TEST_P(StatisticsRecorderTest, RegisterHistogramWithMacros) {
- // Macros cache pointers and so tests that use them can only be run once.
- // Stop immediately if this test has run previously.
- static bool already_run = false;
- if (already_run)
- return;
- already_run = true;
-
- StatisticsRecorder::Histograms registered_histograms;
-
- HistogramBase* histogram = Histogram::FactoryGet(
- "TestHistogramCounts", 1, 1000000, 50, HistogramBase::kNoFlags);
-
- // The histogram we got from macro is the same as from FactoryGet.
- LOCAL_HISTOGRAM_COUNTS("TestHistogramCounts", 30);
- registered_histograms = StatisticsRecorder::GetHistograms();
- ASSERT_EQ(1u, registered_histograms.size());
- EXPECT_EQ(histogram, registered_histograms[0]);
-
- LOCAL_HISTOGRAM_TIMES("TestHistogramTimes", TimeDelta::FromDays(1));
- LOCAL_HISTOGRAM_ENUMERATION("TestHistogramEnumeration", 20, 200);
-
- EXPECT_THAT(StatisticsRecorder::GetHistograms(), SizeIs(3));
-}
-
-TEST_P(StatisticsRecorderTest, BucketRangesSharing) {
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(), IsEmpty());
-
- Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags);
- Histogram::FactoryGet("Histogram2", 1, 64, 8, HistogramBase::kNoFlags);
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(), SizeIs(1));
-
- Histogram::FactoryGet("Histogram3", 1, 64, 16, HistogramBase::kNoFlags);
- EXPECT_THAT(StatisticsRecorder::GetBucketRanges(), SizeIs(2));
-}
-
-TEST_P(StatisticsRecorderTest, ToJSON) {
- Histogram::FactoryGet("TestHistogram1", 1, 1000, 50, HistogramBase::kNoFlags)
- ->Add(30);
- Histogram::FactoryGet("TestHistogram1", 1, 1000, 50, HistogramBase::kNoFlags)
- ->Add(40);
- Histogram::FactoryGet("TestHistogram2", 1, 1000, 50, HistogramBase::kNoFlags)
- ->Add(30);
- Histogram::FactoryGet("TestHistogram2", 1, 1000, 50, HistogramBase::kNoFlags)
- ->Add(40);
-
- std::string json(StatisticsRecorder::ToJSON(JSON_VERBOSITY_LEVEL_FULL));
-
- // Check for valid JSON.
- std::unique_ptr<Value> root = JSONReader::Read(json);
- ASSERT_TRUE(root.get());
-
- DictionaryValue* root_dict = nullptr;
- ASSERT_TRUE(root->GetAsDictionary(&root_dict));
-
- // No query should be set.
- ASSERT_FALSE(root_dict->HasKey("query"));
-
- ListValue* histogram_list = nullptr;
- ASSERT_TRUE(root_dict->GetList("histograms", &histogram_list));
- ASSERT_EQ(2u, histogram_list->GetSize());
-
- // Examine the first histogram.
- DictionaryValue* histogram_dict = nullptr;
- ASSERT_TRUE(histogram_list->GetDictionary(0, &histogram_dict));
-
- int sample_count;
- ASSERT_TRUE(histogram_dict->GetInteger("count", &sample_count));
- EXPECT_EQ(2, sample_count);
-
- ListValue* buckets_list = nullptr;
- ASSERT_TRUE(histogram_dict->GetList("buckets", &buckets_list));
- EXPECT_EQ(2u, buckets_list->GetList().size());
-
- // Check the serialized JSON with a different verbosity level.
- json = StatisticsRecorder::ToJSON(JSON_VERBOSITY_LEVEL_OMIT_BUCKETS);
- root = JSONReader::Read(json);
- ASSERT_TRUE(root.get());
- root_dict = nullptr;
- ASSERT_TRUE(root->GetAsDictionary(&root_dict));
- histogram_list = nullptr;
- ASSERT_TRUE(root_dict->GetList("histograms", &histogram_list));
- ASSERT_EQ(2u, histogram_list->GetSize());
- histogram_dict = nullptr;
- ASSERT_TRUE(histogram_list->GetDictionary(0, &histogram_dict));
- sample_count = 0;
- ASSERT_TRUE(histogram_dict->GetInteger("count", &sample_count));
- EXPECT_EQ(2, sample_count);
- buckets_list = nullptr;
- // Bucket information should be omitted.
- ASSERT_FALSE(histogram_dict->GetList("buckets", &buckets_list));
-}
-
-TEST_P(StatisticsRecorderTest, IterationTest) {
- Histogram::FactoryGet("IterationTest1", 1, 64, 16, HistogramBase::kNoFlags);
- Histogram::FactoryGet("IterationTest2", 1, 64, 16, HistogramBase::kNoFlags);
-
- auto histograms = StatisticsRecorder::GetHistograms();
- EXPECT_THAT(histograms, SizeIs(2));
- histograms = StatisticsRecorder::NonPersistent(std::move(histograms));
- EXPECT_THAT(histograms, SizeIs(use_persistent_histogram_allocator_ ? 0 : 2));
-
- // Create a new global allocator using the same memory as the old one. Any
- // old one is kept around so the memory doesn't get released.
- old_global_allocator_ = GlobalHistogramAllocator::ReleaseForTesting();
- if (use_persistent_histogram_allocator_) {
- GlobalHistogramAllocator::CreateWithPersistentMemory(
- const_cast<void*>(old_global_allocator_->data()),
- old_global_allocator_->length(), 0, old_global_allocator_->Id(),
- old_global_allocator_->Name());
- }
-
- // Reset statistics-recorder to validate operation from a clean start.
- UninitializeStatisticsRecorder();
- InitializeStatisticsRecorder();
-
- histograms = StatisticsRecorder::GetHistograms();
- EXPECT_THAT(histograms, SizeIs(use_persistent_histogram_allocator_ ? 2 : 0));
- histograms = StatisticsRecorder::NonPersistent(std::move(histograms));
- EXPECT_THAT(histograms, IsEmpty());
-}
-
-namespace {
-
-// CallbackCheckWrapper is simply a convenient way to check and store that
-// a callback was actually run.
-struct CallbackCheckWrapper {
- CallbackCheckWrapper() : called(false), last_histogram_value(0) {}
-
- void OnHistogramChanged(base::HistogramBase::Sample histogram_value) {
- called = true;
- last_histogram_value = histogram_value;
- }
-
- bool called;
- base::HistogramBase::Sample last_histogram_value;
-};
-
-} // namespace
-
-// Check that you can't overwrite the callback with another.
-TEST_P(StatisticsRecorderTest, SetCallbackFailsWithoutHistogramTest) {
- CallbackCheckWrapper callback_wrapper;
-
- bool result = base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
- EXPECT_TRUE(result);
-
- result = base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
- EXPECT_FALSE(result);
-}
-
-// Check that you can't overwrite the callback with another.
-TEST_P(StatisticsRecorderTest, SetCallbackFailsWithHistogramTest) {
- HistogramBase* histogram = Histogram::FactoryGet("TestHistogram", 1, 1000, 10,
- HistogramBase::kNoFlags);
- EXPECT_TRUE(histogram);
-
- CallbackCheckWrapper callback_wrapper;
-
- bool result = base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
- EXPECT_TRUE(result);
- EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists,
- base::HistogramBase::kCallbackExists);
-
- result = base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
- EXPECT_FALSE(result);
- EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists,
- base::HistogramBase::kCallbackExists);
-
- histogram->Add(1);
-
- EXPECT_TRUE(callback_wrapper.called);
-}
-
-// Check that you can't overwrite the callback with another.
-TEST_P(StatisticsRecorderTest, ClearCallbackSuceedsWithHistogramTest) {
- HistogramBase* histogram = Histogram::FactoryGet("TestHistogram", 1, 1000, 10,
- HistogramBase::kNoFlags);
- EXPECT_TRUE(histogram);
-
- CallbackCheckWrapper callback_wrapper;
-
- bool result = base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
- EXPECT_TRUE(result);
- EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists,
- base::HistogramBase::kCallbackExists);
-
- base::StatisticsRecorder::ClearCallback("TestHistogram");
- EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists, 0);
-
- histogram->Add(1);
-
- EXPECT_FALSE(callback_wrapper.called);
-}
-
-// Check that callback is used.
-TEST_P(StatisticsRecorderTest, CallbackUsedTest) {
- {
- HistogramBase* histogram = Histogram::FactoryGet(
- "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
- EXPECT_TRUE(histogram);
-
- CallbackCheckWrapper callback_wrapper;
-
- base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
-
- histogram->Add(1);
-
- EXPECT_TRUE(callback_wrapper.called);
- EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
- }
-
- {
- HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
- "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
-
- CallbackCheckWrapper callback_wrapper;
-
- base::StatisticsRecorder::SetCallback(
- "TestLinearHistogram",
- base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
-
- linear_histogram->Add(1);
-
- EXPECT_TRUE(callback_wrapper.called);
- EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
- }
-
- {
- std::vector<int> custom_ranges;
- custom_ranges.push_back(1);
- custom_ranges.push_back(5);
- HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
- "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags);
-
- CallbackCheckWrapper callback_wrapper;
-
- base::StatisticsRecorder::SetCallback(
- "TestCustomHistogram",
- base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
-
- custom_histogram->Add(1);
-
- EXPECT_TRUE(callback_wrapper.called);
- EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
- }
-
- {
- HistogramBase* custom_histogram = SparseHistogram::FactoryGet(
- "TestSparseHistogram", HistogramBase::kNoFlags);
-
- CallbackCheckWrapper callback_wrapper;
-
- base::StatisticsRecorder::SetCallback(
- "TestSparseHistogram",
- base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
-
- custom_histogram->Add(1);
-
- EXPECT_TRUE(callback_wrapper.called);
- EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
- }
-}
-
-// Check that setting a callback before the histogram exists works.
-TEST_P(StatisticsRecorderTest, CallbackUsedBeforeHistogramCreatedTest) {
- CallbackCheckWrapper callback_wrapper;
-
- base::StatisticsRecorder::SetCallback(
- "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged,
- base::Unretained(&callback_wrapper)));
-
- HistogramBase* histogram = Histogram::FactoryGet("TestHistogram", 1, 1000, 10,
- HistogramBase::kNoFlags);
- EXPECT_TRUE(histogram);
- histogram->Add(1);
-
- EXPECT_TRUE(callback_wrapper.called);
- EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
-}
-
-TEST_P(StatisticsRecorderTest, LogOnShutdownNotInitialized) {
- ResetVLogInitialized();
- logging::SetMinLogLevel(logging::LOG_WARNING);
- InitializeStatisticsRecorder();
- EXPECT_FALSE(VLOG_IS_ON(1));
- EXPECT_FALSE(IsVLogInitialized());
- InitLogOnShutdown();
- EXPECT_FALSE(IsVLogInitialized());
-}
-
-TEST_P(StatisticsRecorderTest, LogOnShutdownInitializedExplicitly) {
- ResetVLogInitialized();
- logging::SetMinLogLevel(logging::LOG_WARNING);
- InitializeStatisticsRecorder();
- EXPECT_FALSE(VLOG_IS_ON(1));
- EXPECT_FALSE(IsVLogInitialized());
- logging::SetMinLogLevel(logging::LOG_VERBOSE);
- EXPECT_TRUE(VLOG_IS_ON(1));
- InitLogOnShutdown();
- EXPECT_TRUE(IsVLogInitialized());
-}
-
-TEST_P(StatisticsRecorderTest, LogOnShutdownInitialized) {
- ResetVLogInitialized();
- logging::SetMinLogLevel(logging::LOG_VERBOSE);
- InitializeStatisticsRecorder();
- EXPECT_TRUE(VLOG_IS_ON(1));
- EXPECT_TRUE(IsVLogInitialized());
-}
-
-class TestHistogramProvider : public StatisticsRecorder::HistogramProvider {
- public:
- TestHistogramProvider(std::unique_ptr<PersistentHistogramAllocator> allocator)
- : allocator_(std::move(allocator)), weak_factory_(this) {
- StatisticsRecorder::RegisterHistogramProvider(weak_factory_.GetWeakPtr());
- }
-
- void MergeHistogramDeltas() override {
- PersistentHistogramAllocator::Iterator hist_iter(allocator_.get());
- while (true) {
- std::unique_ptr<base::HistogramBase> histogram = hist_iter.GetNext();
- if (!histogram)
- break;
- allocator_->MergeHistogramDeltaToStatisticsRecorder(histogram.get());
- }
- }
-
- private:
- std::unique_ptr<PersistentHistogramAllocator> allocator_;
- WeakPtrFactory<TestHistogramProvider> weak_factory_;
-
- DISALLOW_COPY_AND_ASSIGN(TestHistogramProvider);
-};
-
-TEST_P(StatisticsRecorderTest, ImportHistogramsTest) {
- // Create a second SR to create some histograms for later import.
- std::unique_ptr<StatisticsRecorder> temp_sr =
- StatisticsRecorder::CreateTemporaryForTesting();
-
- // Extract any existing global allocator so a new one can be created.
- std::unique_ptr<GlobalHistogramAllocator> old_allocator =
- GlobalHistogramAllocator::ReleaseForTesting();
-
- // Create a histogram inside a new allocator for testing.
- GlobalHistogramAllocator::CreateWithLocalMemory(kAllocatorMemorySize, 0, "");
- HistogramBase* histogram = LinearHistogram::FactoryGet("Foo", 1, 10, 11, 0);
- histogram->Add(3);
-
- // Undo back to the starting point.
- std::unique_ptr<GlobalHistogramAllocator> new_allocator =
- GlobalHistogramAllocator::ReleaseForTesting();
- GlobalHistogramAllocator::Set(std::move(old_allocator));
- temp_sr.reset();
-
- // Create a provider that can supply histograms to the current SR.
- TestHistogramProvider provider(std::move(new_allocator));
-
- // Verify that the created histogram is no longer known.
- ASSERT_FALSE(StatisticsRecorder::FindHistogram(histogram->histogram_name()));
-
- // Now test that it merges.
- StatisticsRecorder::ImportProvidedHistograms();
- HistogramBase* found =
- StatisticsRecorder::FindHistogram(histogram->histogram_name());
- ASSERT_TRUE(found);
- EXPECT_NE(histogram, found);
- std::unique_ptr<HistogramSamples> snapshot = found->SnapshotSamples();
- EXPECT_EQ(1, snapshot->TotalCount());
- EXPECT_EQ(1, snapshot->GetCount(3));
-
- // Finally, verify that updates can also be merged.
- histogram->Add(3);
- histogram->Add(5);
- StatisticsRecorder::ImportProvidedHistograms();
- snapshot = found->SnapshotSamples();
- EXPECT_EQ(3, snapshot->TotalCount());
- EXPECT_EQ(2, snapshot->GetCount(3));
- EXPECT_EQ(1, snapshot->GetCount(5));
-}
-
-TEST_P(StatisticsRecorderTest, RecordHistogramChecker) {
- // Record checker isn't set
- EXPECT_TRUE(base::StatisticsRecorder::ShouldRecordHistogram(0));
- auto record_checker = std::make_unique<OddRecordHistogramChecker>();
- base::StatisticsRecorder::SetRecordChecker(std::move(record_checker));
- EXPECT_TRUE(base::StatisticsRecorder::ShouldRecordHistogram(1));
- EXPECT_FALSE(base::StatisticsRecorder::ShouldRecordHistogram(2));
-}
-
-} // namespace base
diff --git a/base/native_library_unittest.cc b/base/native_library_unittest.cc
deleted file mode 100644
index ac8ec5c..0000000
--- a/base/native_library_unittest.cc
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright 2015 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 "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/native_library.h"
-#include "base/path_service.h"
-#include "base/test/native_library_test_utils.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-const FilePath::CharType kDummyLibraryPath[] =
- FILE_PATH_LITERAL("dummy_library");
-
-TEST(NativeLibraryTest, LoadFailure) {
- NativeLibraryLoadError error;
- EXPECT_FALSE(LoadNativeLibrary(FilePath(kDummyLibraryPath), &error));
- EXPECT_FALSE(error.ToString().empty());
-}
-
-// |error| is optional and can be null.
-TEST(NativeLibraryTest, LoadFailureWithNullError) {
- EXPECT_FALSE(LoadNativeLibrary(FilePath(kDummyLibraryPath), nullptr));
-}
-
-TEST(NativeLibraryTest, GetNativeLibraryName) {
- const char kExpectedName[] =
-#if defined(OS_WIN)
- "mylib.dll";
-#elif defined(OS_IOS)
- "mylib";
-#elif defined(OS_MACOSX)
- "libmylib.dylib";
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- "libmylib.so";
-#endif
- EXPECT_EQ(kExpectedName, GetNativeLibraryName("mylib"));
-}
-
-TEST(NativeLibraryTest, GetLoadableModuleName) {
- const char kExpectedName[] =
-#if defined(OS_WIN)
- "mylib.dll";
-#elif defined(OS_IOS)
- "mylib";
-#elif defined(OS_MACOSX)
- "mylib.so";
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- "libmylib.so";
-#endif
- EXPECT_EQ(kExpectedName, GetLoadableModuleName("mylib"));
-}
-
-// We don't support dynamic loading on iOS, and ASAN will complain about our
-// intentional ODR violation because of |g_native_library_exported_value| being
-// defined globally both here and in the shared library.
-#if !defined(OS_IOS) && !defined(ADDRESS_SANITIZER)
-
-const char kTestLibraryName[] =
-#if defined(OS_WIN)
- "test_shared_library.dll";
-#elif defined(OS_MACOSX)
- "libtest_shared_library.dylib";
-#elif defined(OS_ANDROID) && defined(COMPONENT_BUILD)
- "libtest_shared_library.cr.so";
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- "libtest_shared_library.so";
-#endif
-
-class TestLibrary {
- public:
- TestLibrary() : TestLibrary(NativeLibraryOptions()) {}
-
- explicit TestLibrary(const NativeLibraryOptions& options)
- : library_(nullptr) {
- base::FilePath exe_path;
-
-#if !defined(OS_FUCHSIA)
- // Libraries do not sit alongside the executable in Fuchsia. NativeLibrary
- // is aware of this and is able to resolve library paths correctly.
- CHECK(base::PathService::Get(base::DIR_EXE, &exe_path));
-#endif
-
- library_ = LoadNativeLibraryWithOptions(
- exe_path.AppendASCII(kTestLibraryName), options, nullptr);
- CHECK(library_);
- }
-
- ~TestLibrary() {
- UnloadNativeLibrary(library_);
- }
-
- template <typename ReturnType, typename... Args>
- ReturnType Call(const char* function_name, Args... args) {
- return reinterpret_cast<ReturnType(*)(Args...)>(
- GetFunctionPointerFromNativeLibrary(library_, function_name))(args...);
- }
-
- private:
- NativeLibrary library_;
-
- DISALLOW_COPY_AND_ASSIGN(TestLibrary);
-};
-
-// NativeLibraaryTest.LoadLibrary is failing on M tablets only.
-// crbug/641309
-#if !defined(OS_ANDROID)
-
-// Verifies that we can load a native library and resolve its exported symbols.
-TEST(NativeLibraryTest, LoadLibrary) {
- TestLibrary library;
- EXPECT_EQ(5, library.Call<int>("GetSimpleTestValue"));
-}
-
-#endif // !defined(OS_ANDROID)
-
-// Android dlopen() requires further investigation, as it might vary across
-// versions with respect to symbol resolution scope.
-// TSan and MSan error out on RTLD_DEEPBIND, https://crbug.com/705255
-#if !defined(OS_ANDROID) && !defined(THREAD_SANITIZER) && \
- !defined(MEMORY_SANITIZER)
-
-// Verifies that the |prefer_own_symbols| option satisfies its guarantee that
-// a loaded library will always prefer local symbol resolution before
-// considering global symbols.
-TEST(NativeLibraryTest, LoadLibraryPreferOwnSymbols) {
- NativeLibraryOptions options;
- options.prefer_own_symbols = true;
- TestLibrary library(options);
-
- // Verify that this binary and the DSO use different storage for
- // |g_native_library_exported_value|.
- g_native_library_exported_value = 1;
- library.Call<void>("SetExportedValue", 2);
- EXPECT_EQ(1, g_native_library_exported_value);
- g_native_library_exported_value = 3;
- EXPECT_EQ(2, library.Call<int>("GetExportedValue"));
-
- // Both this binary and the library link against the
- // native_library_test_utils source library, which in turn exports the
- // NativeLibraryTestIncrement() function whose return value depends on some
- // static internal state.
- //
- // The DSO's GetIncrementValue() forwards to that function inside the DSO.
- //
- // Here we verify that direct calls to NativeLibraryTestIncrement() in this
- // binary return a sequence of values independent from the sequence returned
- // by GetIncrementValue(), ensuring that the DSO is calling its own local
- // definition of NativeLibraryTestIncrement().
- EXPECT_EQ(1, library.Call<int>("GetIncrementValue"));
- EXPECT_EQ(1, NativeLibraryTestIncrement());
- EXPECT_EQ(2, library.Call<int>("GetIncrementValue"));
- EXPECT_EQ(3, library.Call<int>("GetIncrementValue"));
- EXPECT_EQ(4, library.Call<int>("NativeLibraryTestIncrement"));
- EXPECT_EQ(2, NativeLibraryTestIncrement());
- EXPECT_EQ(3, NativeLibraryTestIncrement());
-}
-
-#endif // !defined(OS_ANDROID)
-
-#endif // !defined(OS_IOS) && !defined(ADDRESS_SANITIZER)
-
-} // namespace base
diff --git a/base/nix/xdg_util_unittest.cc b/base/nix/xdg_util_unittest.cc
deleted file mode 100644
index e195303..0000000
--- a/base/nix/xdg_util_unittest.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright (c) 2010 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 "base/nix/xdg_util.h"
-
-#include "base/environment.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::_;
-using ::testing::Eq;
-using ::testing::Return;
-using ::testing::SetArgPointee;
-
-namespace base {
-namespace nix {
-
-namespace {
-
-class MockEnvironment : public Environment {
- public:
- MOCK_METHOD2(GetVar, bool(StringPiece, std::string* result));
- MOCK_METHOD2(SetVar, bool(StringPiece, const std::string& new_value));
- MOCK_METHOD1(UnSetVar, bool(StringPiece));
-};
-
-// Needs to be const char* to make gmock happy.
-const char* const kDesktopGnome = "gnome";
-const char* const kDesktopGnomeFallback = "gnome-fallback";
-const char* const kDesktopMATE = "mate";
-const char* const kDesktopKDE4 = "kde4";
-const char* const kDesktopKDE = "kde";
-const char* const kDesktopXFCE = "xfce";
-const char* const kXdgDesktopCinnamon = "X-Cinnamon";
-const char* const kXdgDesktopGNOME = "GNOME";
-const char* const kXdgDesktopKDE = "KDE";
-const char* const kXdgDesktopPantheon = "Pantheon";
-const char* const kXdgDesktopUnity = "Unity";
-const char* const kXdgDesktopUnity7 = "Unity:Unity7";
-const char* const kXdgDesktopUnity8 = "Unity:Unity8";
-const char* const kKDESessionKDE5 = "5";
-
-const char kDesktopSession[] = "DESKTOP_SESSION";
-const char kKDESession[] = "KDE_SESSION_VERSION";
-const char kXdgDesktop[] = "XDG_CURRENT_DESKTOP";
-
-} // namespace
-
-TEST(XDGUtilTest, GetDesktopEnvironmentGnome) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kDesktopGnome), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetDesktopEnvironmentMATE) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kDesktopMATE), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetDesktopEnvironmentKDE4) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kDesktopKDE4), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE4, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetDesktopEnvironmentKDE3) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kDesktopKDE), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE3, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetDesktopEnvironmentXFCE) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kDesktopXFCE), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_XFCE, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopCinnamon) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopCinnamon), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_CINNAMON, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopGnome) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopGNOME), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopGnomeFallback) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity), Return(true)));
- EXPECT_CALL(getter, GetVar(Eq(kDesktopSession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kDesktopGnomeFallback), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_GNOME, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopKDE5) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopKDE), Return(true)));
- EXPECT_CALL(getter, GetVar(Eq(kKDESession), _))
- .WillOnce(DoAll(SetArgPointee<1>(kKDESessionKDE5), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE5, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopKDE4) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopKDE), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_KDE4, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopPantheon) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopPantheon), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_PANTHEON, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopUnity) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_UNITY, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopUnity7) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity7), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_UNITY, GetDesktopEnvironment(&getter));
-}
-
-TEST(XDGUtilTest, GetXdgDesktopUnity8) {
- MockEnvironment getter;
- EXPECT_CALL(getter, GetVar(_, _)).WillRepeatedly(Return(false));
- EXPECT_CALL(getter, GetVar(Eq(kXdgDesktop), _))
- .WillOnce(DoAll(SetArgPointee<1>(kXdgDesktopUnity8), Return(true)));
-
- EXPECT_EQ(DESKTOP_ENVIRONMENT_UNITY, GetDesktopEnvironment(&getter));
-}
-
-} // namespace nix
-} // namespace base
diff --git a/base/no_destructor_unittest.cc b/base/no_destructor_unittest.cc
deleted file mode 100644
index c552a92..0000000
--- a/base/no_destructor_unittest.cc
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2018 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 "base/no_destructor.h"
-
-#include <string>
-#include <utility>
-
-#include "base/logging.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-struct CheckOnDestroy {
- ~CheckOnDestroy() { CHECK(false); }
-};
-
-TEST(NoDestructorTest, SkipsDestructors) {
- NoDestructor<CheckOnDestroy> destructor_should_not_run;
-}
-
-struct CopyOnly {
- CopyOnly() = default;
-
- CopyOnly(const CopyOnly&) = default;
- CopyOnly& operator=(const CopyOnly&) = default;
-
- CopyOnly(CopyOnly&&) = delete;
- CopyOnly& operator=(CopyOnly&&) = delete;
-};
-
-struct MoveOnly {
- MoveOnly() = default;
-
- MoveOnly(const MoveOnly&) = delete;
- MoveOnly& operator=(const MoveOnly&) = delete;
-
- MoveOnly(MoveOnly&&) = default;
- MoveOnly& operator=(MoveOnly&&) = default;
-};
-
-struct ForwardingTestStruct {
- ForwardingTestStruct(const CopyOnly&, MoveOnly&&) {}
-};
-
-TEST(NoDestructorTest, ForwardsArguments) {
- CopyOnly copy_only;
- MoveOnly move_only;
-
- static NoDestructor<ForwardingTestStruct> test_forwarding(
- copy_only, std::move(move_only));
-}
-
-TEST(NoDestructorTest, Accessors) {
- static NoDestructor<std::string> awesome("awesome");
-
- EXPECT_EQ("awesome", *awesome);
- EXPECT_EQ(0, awesome->compare("awesome"));
- EXPECT_EQ(0, awesome.get()->compare("awesome"));
-}
-
-// Passing initializer list to a NoDestructor like in this test
-// is ambiguous in GCC.
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84849
-#if !defined(COMPILER_GCC) && !defined(__clang__)
-TEST(NoDestructorTest, InitializerList) {
- static NoDestructor<std::vector<std::string>> vector({"a", "b", "c"});
-}
-#endif
-} // namespace
-
-} // namespace base
diff --git a/base/numerics/BUILD.gn b/base/numerics/BUILD.gn
deleted file mode 100644
index 0bb8dd1..0000000
--- a/base/numerics/BUILD.gn
+++ /dev/null
@@ -1,28 +0,0 @@
-# Copyright (c) 2017 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 is a dependency-free, header-only, library, and it needs to stay that
-# way to facilitate pulling it into various third-party projects. So, this
-# file is here to protect against accidentally introducing external
-# dependencies or depending on internal implementation details.
-source_set("base_numerics") {
- visibility = [ "//base/*" ]
- sources = [
- "checked_math_impl.h",
- "clamped_math_impl.h",
- "safe_conversions_arm_impl.h",
- "safe_conversions_impl.h",
- "safe_math_arm_impl.h",
- "safe_math_clang_gcc_impl.h",
- "safe_math_shared_impl.h",
- ]
- public = [
- "checked_math.h",
- "clamped_math.h",
- "math_constants.h",
- "ranges.h",
- "safe_conversions.h",
- "safe_math.h",
- ]
-}
diff --git a/base/observer_list_unittest.cc b/base/observer_list_unittest.cc
deleted file mode 100644
index 37629ef..0000000
--- a/base/observer_list_unittest.cc
+++ /dev/null
@@ -1,1276 +0,0 @@
-// 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.
-
-#include "base/observer_list.h"
-#include "base/observer_list_threadsafe.h"
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/location.h"
-#include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/task_scheduler/task_scheduler.h"
-#include "base/test/gtest_util.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class Foo {
- public:
- virtual void Observe(int x) = 0;
- virtual ~Foo() = default;
- virtual int GetValue() const { return 0; }
-};
-
-class Adder : public Foo {
- public:
- explicit Adder(int scaler) : total(0), scaler_(scaler) {}
- ~Adder() override = default;
-
- void Observe(int x) override { total += x * scaler_; }
- int GetValue() const override { return total; }
-
- int total;
-
- private:
- int scaler_;
-};
-
-class Disrupter : public Foo {
- public:
- Disrupter(ObserverList<Foo>* list, Foo* doomed, bool remove_self)
- : list_(list), doomed_(doomed), remove_self_(remove_self) {}
- Disrupter(ObserverList<Foo>* list, Foo* doomed)
- : Disrupter(list, doomed, false) {}
- Disrupter(ObserverList<Foo>* list, bool remove_self)
- : Disrupter(list, nullptr, remove_self) {}
-
- ~Disrupter() override = default;
-
- void Observe(int x) override {
- if (remove_self_)
- list_->RemoveObserver(this);
- if (doomed_)
- list_->RemoveObserver(doomed_);
- }
-
- void SetDoomed(Foo* doomed) { doomed_ = doomed; }
-
- private:
- ObserverList<Foo>* list_;
- Foo* doomed_;
- bool remove_self_;
-};
-
-template <typename ObserverListType>
-class AddInObserve : public Foo {
- public:
- explicit AddInObserve(ObserverListType* observer_list)
- : observer_list(observer_list), to_add_() {}
-
- void SetToAdd(Foo* to_add) { to_add_ = to_add; }
-
- void Observe(int x) override {
- if (to_add_) {
- observer_list->AddObserver(to_add_);
- to_add_ = nullptr;
- }
- }
-
- ObserverListType* observer_list;
- Foo* to_add_;
-};
-
-
-static const int kThreadRunTime = 2000; // ms to run the multi-threaded test.
-
-// A thread for use in the ThreadSafeObserver test
-// which will add and remove itself from the notification
-// list repeatedly.
-class AddRemoveThread : public PlatformThread::Delegate,
- public Foo {
- public:
- AddRemoveThread(ObserverListThreadSafe<Foo>* list,
- bool notify,
- WaitableEvent* ready)
- : list_(list),
- loop_(nullptr),
- in_list_(false),
- start_(Time::Now()),
- count_observes_(0),
- count_addtask_(0),
- do_notifies_(notify),
- ready_(ready),
- weak_factory_(this) {}
-
- ~AddRemoveThread() override = default;
-
- void ThreadMain() override {
- loop_ = new MessageLoop(); // Fire up a message loop.
- loop_->task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
- ready_->Signal();
- // After ready_ is signaled, loop_ is only accessed by the main test thread
- // (i.e. not this thread) in particular by Quit() which causes Run() to
- // return, and we "control" loop_ again.
- RunLoop().Run();
- delete loop_;
- loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef);
- delete this;
- }
-
- // This task just keeps posting to itself in an attempt
- // to race with the notifier.
- void AddTask() {
- count_addtask_++;
-
- if ((Time::Now() - start_).InMilliseconds() > kThreadRunTime) {
- VLOG(1) << "DONE!";
- return;
- }
-
- if (!in_list_) {
- list_->AddObserver(this);
- in_list_ = true;
- }
-
- if (do_notifies_) {
- list_->Notify(FROM_HERE, &Foo::Observe, 10);
- }
-
- loop_->task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
- }
-
- // This function is only callable from the main thread.
- void Quit() {
- loop_->task_runner()->PostTask(
- FROM_HERE, RunLoop::QuitCurrentWhenIdleClosureDeprecated());
- }
-
- void Observe(int x) override {
- count_observes_++;
-
- // If we're getting called after we removed ourselves from
- // the list, that is very bad!
- DCHECK(in_list_);
-
- // This callback should fire on the appropriate thread
- EXPECT_EQ(loop_, MessageLoop::current());
-
- list_->RemoveObserver(this);
- in_list_ = false;
- }
-
- private:
- ObserverListThreadSafe<Foo>* list_;
- MessageLoop* loop_;
- bool in_list_; // Are we currently registered for notifications.
- // in_list_ is only used on |this| thread.
- Time start_; // The time we started the test.
-
- int count_observes_; // Number of times we observed.
- int count_addtask_; // Number of times thread AddTask was called
- bool do_notifies_; // Whether these threads should do notifications.
- WaitableEvent* ready_;
-
- base::WeakPtrFactory<AddRemoveThread> weak_factory_;
-};
-
-} // namespace
-
-TEST(ObserverListTest, BasicTest) {
- ObserverList<Foo> observer_list;
- const ObserverList<Foo>& const_observer_list = observer_list;
-
- {
- const ObserverList<Foo>::const_iterator it1 = const_observer_list.begin();
- EXPECT_EQ(it1, const_observer_list.end());
- // Iterator copy.
- const ObserverList<Foo>::const_iterator it2 = it1;
- EXPECT_EQ(it2, it1);
- // Iterator assignment.
- ObserverList<Foo>::const_iterator it3;
- it3 = it2;
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- // Self assignment.
- it3 = *&it3; // The *& defeats Clang's -Wself-assign warning.
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- }
-
- {
- const ObserverList<Foo>::iterator it1 = observer_list.begin();
- EXPECT_EQ(it1, observer_list.end());
- // Iterator copy.
- const ObserverList<Foo>::iterator it2 = it1;
- EXPECT_EQ(it2, it1);
- // Iterator assignment.
- ObserverList<Foo>::iterator it3;
- it3 = it2;
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- // Self assignment.
- it3 = *&it3; // The *& defeats Clang's -Wself-assign warning.
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- }
-
- Adder a(1), b(-1), c(1), d(-1), e(-1);
- Disrupter evil(&observer_list, &c);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
-
- EXPECT_TRUE(const_observer_list.HasObserver(&a));
- EXPECT_FALSE(const_observer_list.HasObserver(&c));
-
- {
- const ObserverList<Foo>::const_iterator it1 = const_observer_list.begin();
- EXPECT_NE(it1, const_observer_list.end());
- // Iterator copy.
- const ObserverList<Foo>::const_iterator it2 = it1;
- EXPECT_EQ(it2, it1);
- EXPECT_NE(it2, const_observer_list.end());
- // Iterator assignment.
- ObserverList<Foo>::const_iterator it3;
- it3 = it2;
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- // Self assignment.
- it3 = *&it3; // The *& defeats Clang's -Wself-assign warning.
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- // Iterator post increment.
- ObserverList<Foo>::const_iterator it4 = it3++;
- EXPECT_EQ(it4, it1);
- EXPECT_EQ(it4, it2);
- EXPECT_NE(it4, it3);
- }
-
- {
- const ObserverList<Foo>::iterator it1 = observer_list.begin();
- EXPECT_NE(it1, observer_list.end());
- // Iterator copy.
- const ObserverList<Foo>::iterator it2 = it1;
- EXPECT_EQ(it2, it1);
- EXPECT_NE(it2, observer_list.end());
- // Iterator assignment.
- ObserverList<Foo>::iterator it3;
- it3 = it2;
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- // Self assignment.
- it3 = *&it3; // The *& defeats Clang's -Wself-assign warning.
- EXPECT_EQ(it3, it1);
- EXPECT_EQ(it3, it2);
- // Iterator post increment.
- ObserverList<Foo>::iterator it4 = it3++;
- EXPECT_EQ(it4, it1);
- EXPECT_EQ(it4, it2);
- EXPECT_NE(it4, it3);
- }
-
- for (auto& observer : observer_list)
- observer.Observe(10);
-
- observer_list.AddObserver(&evil);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- // Removing an observer not in the list should do nothing.
- observer_list.RemoveObserver(&e);
-
- for (auto& observer : observer_list)
- observer.Observe(10);
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(-20, b.total);
- EXPECT_EQ(0, c.total);
- EXPECT_EQ(-10, d.total);
- EXPECT_EQ(0, e.total);
-}
-
-TEST(ObserverListTest, CompactsWhenNoActiveIterator) {
- ObserverList<const Foo> ol;
- const ObserverList<const Foo>& col = ol;
-
- const Adder a(1);
- const Adder b(2);
- const Adder c(3);
-
- ol.AddObserver(&a);
- ol.AddObserver(&b);
-
- EXPECT_TRUE(col.HasObserver(&a));
- EXPECT_FALSE(col.HasObserver(&c));
-
- EXPECT_TRUE(col.might_have_observers());
-
- using It = ObserverList<const Foo>::const_iterator;
-
- {
- It it = col.begin();
- EXPECT_NE(it, col.end());
- It ita = it;
- EXPECT_EQ(ita, it);
- EXPECT_NE(++it, col.end());
- EXPECT_NE(ita, it);
- It itb = it;
- EXPECT_EQ(itb, it);
- EXPECT_EQ(++it, col.end());
-
- EXPECT_TRUE(col.might_have_observers());
- EXPECT_EQ(&*ita, &a);
- EXPECT_EQ(&*itb, &b);
-
- ol.RemoveObserver(&a);
- EXPECT_TRUE(col.might_have_observers());
- EXPECT_FALSE(col.HasObserver(&a));
- EXPECT_EQ(&*itb, &b);
-
- ol.RemoveObserver(&b);
- EXPECT_TRUE(col.might_have_observers());
- EXPECT_FALSE(col.HasObserver(&a));
- EXPECT_FALSE(col.HasObserver(&b));
-
- it = It();
- ita = It();
- EXPECT_TRUE(col.might_have_observers());
- ita = itb;
- itb = It();
- EXPECT_TRUE(col.might_have_observers());
- ita = It();
- EXPECT_FALSE(col.might_have_observers());
- }
-
- ol.AddObserver(&a);
- ol.AddObserver(&b);
- EXPECT_TRUE(col.might_have_observers());
- ol.Clear();
- EXPECT_FALSE(col.might_have_observers());
-
- ol.AddObserver(&a);
- ol.AddObserver(&b);
- EXPECT_TRUE(col.might_have_observers());
- {
- const It it = col.begin();
- ol.Clear();
- EXPECT_TRUE(col.might_have_observers());
- }
- EXPECT_FALSE(col.might_have_observers());
-}
-
-TEST(ObserverListTest, DisruptSelf) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter evil(&observer_list, true);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
-
- for (auto& observer : observer_list)
- observer.Observe(10);
-
- observer_list.AddObserver(&evil);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& observer : observer_list)
- observer.Observe(10);
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(-20, b.total);
- EXPECT_EQ(10, c.total);
- EXPECT_EQ(-10, d.total);
-}
-
-TEST(ObserverListTest, DisruptBefore) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter evil(&observer_list, &b);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&evil);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& observer : observer_list)
- observer.Observe(10);
- for (auto& observer : observer_list)
- observer.Observe(10);
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(-10, b.total);
- EXPECT_EQ(20, c.total);
- EXPECT_EQ(-20, d.total);
-}
-
-TEST(ObserverListThreadSafeTest, BasicTest) {
- MessageLoop loop;
-
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
- Adder a(1);
- Adder b(-1);
- Adder c(1);
- Adder d(-1);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- observer_list->AddObserver(&c);
- observer_list->AddObserver(&d);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- observer_list->RemoveObserver(&c);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(-20, b.total);
- EXPECT_EQ(0, c.total);
- EXPECT_EQ(-10, d.total);
-}
-
-TEST(ObserverListThreadSafeTest, RemoveObserver) {
- MessageLoop loop;
-
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
- Adder a(1), b(1);
-
- // A workaround for the compiler bug. See http://crbug.com/121960.
- EXPECT_NE(&a, &b);
-
- // Should do nothing.
- observer_list->RemoveObserver(&a);
- observer_list->RemoveObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(0, a.total);
- EXPECT_EQ(0, b.total);
-
- observer_list->AddObserver(&a);
-
- // Should also do nothing.
- observer_list->RemoveObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(10, a.total);
- EXPECT_EQ(0, b.total);
-}
-
-TEST(ObserverListThreadSafeTest, WithoutSequence) {
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
-
- Adder a(1), b(1), c(1);
-
- // No sequence, so these should not be added.
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- {
- // Add c when there's a sequence.
- MessageLoop loop;
- observer_list->AddObserver(&c);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(0, a.total);
- EXPECT_EQ(0, b.total);
- EXPECT_EQ(10, c.total);
-
- // Now add a when there's a sequence.
- observer_list->AddObserver(&a);
-
- // Remove c when there's a sequence.
- observer_list->RemoveObserver(&c);
-
- // Notify again.
- observer_list->Notify(FROM_HERE, &Foo::Observe, 20);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(0, b.total);
- EXPECT_EQ(10, c.total);
- }
-
- // Removing should always succeed with or without a sequence.
- observer_list->RemoveObserver(&a);
-
- // Notifying should not fail but should also be a no-op.
- MessageLoop loop;
- observer_list->AddObserver(&b);
- observer_list->Notify(FROM_HERE, &Foo::Observe, 30);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(30, b.total);
- EXPECT_EQ(10, c.total);
-}
-
-class FooRemover : public Foo {
- public:
- explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {}
- ~FooRemover() override = default;
-
- void AddFooToRemove(Foo* foo) {
- foos_.push_back(foo);
- }
-
- void Observe(int x) override {
- std::vector<Foo*> tmp;
- tmp.swap(foos_);
- for (std::vector<Foo*>::iterator it = tmp.begin();
- it != tmp.end(); ++it) {
- list_->RemoveObserver(*it);
- }
- }
-
- private:
- const scoped_refptr<ObserverListThreadSafe<Foo> > list_;
- std::vector<Foo*> foos_;
-};
-
-TEST(ObserverListThreadSafeTest, RemoveMultipleObservers) {
- MessageLoop loop;
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
-
- FooRemover a(observer_list.get());
- Adder b(1);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- a.AddFooToRemove(&a);
- a.AddFooToRemove(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- RunLoop().RunUntilIdle();
-}
-
-// A test driver for a multi-threaded notification loop. Runs a number
-// of observer threads, each of which constantly adds/removes itself
-// from the observer list. Optionally, if cross_thread_notifies is set
-// to true, the observer threads will also trigger notifications to
-// all observers.
-static void ThreadSafeObserverHarness(int num_threads,
- bool cross_thread_notifies) {
- MessageLoop loop;
-
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
- Adder a(1);
- Adder b(-1);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- std::vector<AddRemoveThread*> threaded_observer;
- std::vector<base::PlatformThreadHandle> threads(num_threads);
- std::vector<std::unique_ptr<base::WaitableEvent>> ready;
- threaded_observer.reserve(num_threads);
- ready.reserve(num_threads);
- for (int index = 0; index < num_threads; index++) {
- ready.push_back(std::make_unique<WaitableEvent>(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED));
- threaded_observer.push_back(new AddRemoveThread(
- observer_list.get(), cross_thread_notifies, ready.back().get()));
- EXPECT_TRUE(
- PlatformThread::Create(0, threaded_observer.back(), &threads[index]));
- }
- ASSERT_EQ(static_cast<size_t>(num_threads), threaded_observer.size());
- ASSERT_EQ(static_cast<size_t>(num_threads), ready.size());
-
- // This makes sure that threaded_observer has gotten to set loop_, so that we
- // can call Quit() below safe-ish-ly.
- for (int i = 0; i < num_threads; ++i)
- ready[i]->Wait();
-
- Time start = Time::Now();
- while (true) {
- if ((Time::Now() - start).InMilliseconds() > kThreadRunTime)
- break;
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
-
- RunLoop().RunUntilIdle();
- }
-
- for (int index = 0; index < num_threads; index++) {
- threaded_observer[index]->Quit();
- PlatformThread::Join(threads[index]);
- }
-}
-
-TEST(ObserverListThreadSafeTest, CrossThreadObserver) {
- // Use 7 observer threads. Notifications only come from
- // the main thread.
- ThreadSafeObserverHarness(7, false);
-}
-
-TEST(ObserverListThreadSafeTest, CrossThreadNotifications) {
- // Use 3 observer threads. Notifications will fire from
- // the main thread and all 3 observer threads.
- ThreadSafeObserverHarness(3, true);
-}
-
-TEST(ObserverListThreadSafeTest, OutlivesMessageLoop) {
- MessageLoop* loop = new MessageLoop;
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
-
- Adder a(1);
- observer_list->AddObserver(&a);
- delete loop;
- // Test passes if we don't crash here.
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
-}
-
-namespace {
-
-class SequenceVerificationObserver : public Foo {
- public:
- explicit SequenceVerificationObserver(
- scoped_refptr<SequencedTaskRunner> task_runner)
- : task_runner_(std::move(task_runner)) {}
- ~SequenceVerificationObserver() override = default;
-
- void Observe(int x) override {
- called_on_valid_sequence_ = task_runner_->RunsTasksInCurrentSequence();
- }
-
- bool called_on_valid_sequence() const { return called_on_valid_sequence_; }
-
- private:
- const scoped_refptr<SequencedTaskRunner> task_runner_;
- bool called_on_valid_sequence_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(SequenceVerificationObserver);
-};
-
-} // namespace
-
-// Verify that observers are notified on the correct sequence.
-TEST(ObserverListThreadSafeTest, NotificationOnValidSequence) {
- test::ScopedTaskEnvironment scoped_task_environment;
-
- auto task_runner_1 = CreateSequencedTaskRunnerWithTraits(TaskTraits());
- auto task_runner_2 = CreateSequencedTaskRunnerWithTraits(TaskTraits());
-
- auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
-
- SequenceVerificationObserver observer_1(task_runner_1);
- SequenceVerificationObserver observer_2(task_runner_2);
-
- task_runner_1->PostTask(FROM_HERE,
- BindOnce(&ObserverListThreadSafe<Foo>::AddObserver,
- observer_list, Unretained(&observer_1)));
- task_runner_2->PostTask(FROM_HERE,
- BindOnce(&ObserverListThreadSafe<Foo>::AddObserver,
- observer_list, Unretained(&observer_2)));
-
- TaskScheduler::GetInstance()->FlushForTesting();
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
-
- TaskScheduler::GetInstance()->FlushForTesting();
-
- EXPECT_TRUE(observer_1.called_on_valid_sequence());
- EXPECT_TRUE(observer_2.called_on_valid_sequence());
-}
-
-// Verify that when an observer is added to a NOTIFY_ALL ObserverListThreadSafe
-// from a notification, it is itself notified.
-TEST(ObserverListThreadSafeTest, AddObserverFromNotificationNotifyAll) {
- test::ScopedTaskEnvironment scoped_task_environment;
- auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
-
- Adder observer_added_from_notification(1);
-
- AddInObserve<ObserverListThreadSafe<Foo>> initial_observer(
- observer_list.get());
- initial_observer.SetToAdd(&observer_added_from_notification);
- observer_list->AddObserver(&initial_observer);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
-
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(1, observer_added_from_notification.GetValue());
-}
-
-namespace {
-
-class RemoveWhileNotificationIsRunningObserver : public Foo {
- public:
- RemoveWhileNotificationIsRunningObserver()
- : notification_running_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- barrier_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
- ~RemoveWhileNotificationIsRunningObserver() override = default;
-
- void Observe(int x) override {
- notification_running_.Signal();
- ScopedAllowBaseSyncPrimitivesForTesting allow_base_sync_primitives;
- barrier_.Wait();
- }
-
- void WaitForNotificationRunning() { notification_running_.Wait(); }
- void Unblock() { barrier_.Signal(); }
-
- private:
- WaitableEvent notification_running_;
- WaitableEvent barrier_;
-
- DISALLOW_COPY_AND_ASSIGN(RemoveWhileNotificationIsRunningObserver);
-};
-
-} // namespace
-
-// Verify that there is no crash when an observer is removed while it is being
-// notified.
-TEST(ObserverListThreadSafeTest, RemoveWhileNotificationIsRunning) {
- auto observer_list = MakeRefCounted<ObserverListThreadSafe<Foo>>();
- RemoveWhileNotificationIsRunningObserver observer;
-
- WaitableEvent task_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent barrier(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // This must be after the declaration of |barrier| so that tasks posted to
- // TaskScheduler can safely use |barrier|.
- test::ScopedTaskEnvironment scoped_task_environment;
-
- CreateSequencedTaskRunnerWithTraits({})->PostTask(
- FROM_HERE, base::BindOnce(&ObserverListThreadSafe<Foo>::AddObserver,
- observer_list, Unretained(&observer)));
- TaskScheduler::GetInstance()->FlushForTesting();
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- observer.WaitForNotificationRunning();
- observer_list->RemoveObserver(&observer);
-
- observer.Unblock();
-}
-
-TEST(ObserverListTest, Existing) {
- ObserverList<Foo> observer_list(ObserverListPolicy::EXISTING_ONLY);
- Adder a(1);
- AddInObserve<ObserverList<Foo> > b(&observer_list);
- Adder c(1);
- b.SetToAdd(&c);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
-
- for (auto& observer : observer_list)
- observer.Observe(1);
-
- EXPECT_FALSE(b.to_add_);
- // B's adder should not have been notified because it was added during
- // notification.
- EXPECT_EQ(0, c.total);
-
- // Notify again to make sure b's adder is notified.
- for (auto& observer : observer_list)
- observer.Observe(1);
- EXPECT_EQ(1, c.total);
-}
-
-// Same as above, but for ObserverListThreadSafe
-TEST(ObserverListThreadSafeTest, Existing) {
- MessageLoop loop;
- scoped_refptr<ObserverListThreadSafe<Foo>> observer_list(
- new ObserverListThreadSafe<Foo>(ObserverListPolicy::EXISTING_ONLY));
- Adder a(1);
- AddInObserve<ObserverListThreadSafe<Foo> > b(observer_list.get());
- Adder c(1);
- b.SetToAdd(&c);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- RunLoop().RunUntilIdle();
-
- EXPECT_FALSE(b.to_add_);
- // B's adder should not have been notified because it was added during
- // notification.
- EXPECT_EQ(0, c.total);
-
- // Notify again to make sure b's adder is notified.
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- RunLoop().RunUntilIdle();
- EXPECT_EQ(1, c.total);
-}
-
-class AddInClearObserve : public Foo {
- public:
- explicit AddInClearObserve(ObserverList<Foo>* list)
- : list_(list), added_(false), adder_(1) {}
-
- void Observe(int /* x */) override {
- list_->Clear();
- list_->AddObserver(&adder_);
- added_ = true;
- }
-
- bool added() const { return added_; }
- const Adder& adder() const { return adder_; }
-
- private:
- ObserverList<Foo>* const list_;
-
- bool added_;
- Adder adder_;
-};
-
-TEST(ObserverListTest, ClearNotifyAll) {
- ObserverList<Foo> observer_list;
- AddInClearObserve a(&observer_list);
-
- observer_list.AddObserver(&a);
-
- for (auto& observer : observer_list)
- observer.Observe(1);
- EXPECT_TRUE(a.added());
- EXPECT_EQ(1, a.adder().total)
- << "Adder should observe once and have sum of 1.";
-}
-
-TEST(ObserverListTest, ClearNotifyExistingOnly) {
- ObserverList<Foo> observer_list(ObserverListPolicy::EXISTING_ONLY);
- AddInClearObserve a(&observer_list);
-
- observer_list.AddObserver(&a);
-
- for (auto& observer : observer_list)
- observer.Observe(1);
- EXPECT_TRUE(a.added());
- EXPECT_EQ(0, a.adder().total)
- << "Adder should not observe, so sum should still be 0.";
-}
-
-class ListDestructor : public Foo {
- public:
- explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {}
- ~ListDestructor() override = default;
-
- void Observe(int x) override { delete list_; }
-
- private:
- ObserverList<Foo>* list_;
-};
-
-
-TEST(ObserverListTest, IteratorOutlivesList) {
- ObserverList<Foo>* observer_list = new ObserverList<Foo>;
- ListDestructor a(observer_list);
- observer_list->AddObserver(&a);
-
- for (auto& observer : *observer_list)
- observer.Observe(0);
-
- // There are no EXPECT* statements for this test, if we catch
- // use-after-free errors for observer_list (eg with ASan) then
- // this test has failed. See http://crbug.com/85296.
-}
-
-TEST(ObserverListTest, BasicStdIterator) {
- using FooList = ObserverList<Foo>;
- FooList observer_list;
-
- // An optimization: begin() and end() do not involve weak pointers on
- // empty list.
- EXPECT_FALSE(observer_list.begin().list_);
- EXPECT_FALSE(observer_list.end().list_);
-
- // Iterate over empty list: no effect, no crash.
- for (auto& i : observer_list)
- i.Observe(10);
-
- Adder a(1), b(-1), c(1), d(-1);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (FooList::iterator i = observer_list.begin(), e = observer_list.end();
- i != e; ++i)
- i->Observe(1);
-
- EXPECT_EQ(1, a.total);
- EXPECT_EQ(-1, b.total);
- EXPECT_EQ(1, c.total);
- EXPECT_EQ(-1, d.total);
-
- // Check an iteration over a 'const view' for a given container.
- const FooList& const_list = observer_list;
- for (FooList::const_iterator i = const_list.begin(), e = const_list.end();
- i != e; ++i) {
- EXPECT_EQ(1, std::abs(i->GetValue()));
- }
-
- for (const auto& o : const_list)
- EXPECT_EQ(1, std::abs(o.GetValue()));
-}
-
-TEST(ObserverListTest, StdIteratorRemoveItself) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, true);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(11, a.total);
- EXPECT_EQ(-11, b.total);
- EXPECT_EQ(11, c.total);
- EXPECT_EQ(-11, d.total);
-}
-
-TEST(ObserverListTest, StdIteratorRemoveBefore) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, &b);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(11, a.total);
- EXPECT_EQ(-1, b.total);
- EXPECT_EQ(11, c.total);
- EXPECT_EQ(-11, d.total);
-}
-
-TEST(ObserverListTest, StdIteratorRemoveAfter) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, &c);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(11, a.total);
- EXPECT_EQ(-11, b.total);
- EXPECT_EQ(0, c.total);
- EXPECT_EQ(-11, d.total);
-}
-
-TEST(ObserverListTest, StdIteratorRemoveAfterFront) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, &a);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(1, a.total);
- EXPECT_EQ(-11, b.total);
- EXPECT_EQ(11, c.total);
- EXPECT_EQ(-11, d.total);
-}
-
-TEST(ObserverListTest, StdIteratorRemoveBeforeBack) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, &d);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&d);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(11, a.total);
- EXPECT_EQ(-11, b.total);
- EXPECT_EQ(11, c.total);
- EXPECT_EQ(0, d.total);
-}
-
-TEST(ObserverListTest, StdIteratorRemoveFront) {
- using FooList = ObserverList<Foo>;
- FooList observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, true);
-
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- bool test_disruptor = true;
- for (FooList::iterator i = observer_list.begin(), e = observer_list.end();
- i != e; ++i) {
- i->Observe(1);
- // Check that second call to i->Observe() would crash here.
- if (test_disruptor) {
- EXPECT_FALSE(i.GetCurrent());
- test_disruptor = false;
- }
- }
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(11, a.total);
- EXPECT_EQ(-11, b.total);
- EXPECT_EQ(11, c.total);
- EXPECT_EQ(-11, d.total);
-}
-
-TEST(ObserverListTest, StdIteratorRemoveBack) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, true);
-
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
- observer_list.AddObserver(&disrupter);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- for (auto& o : observer_list)
- o.Observe(10);
-
- EXPECT_EQ(11, a.total);
- EXPECT_EQ(-11, b.total);
- EXPECT_EQ(11, c.total);
- EXPECT_EQ(-11, d.total);
-}
-
-TEST(ObserverListTest, NestedLoop) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1), c(1), d(-1);
- Disrupter disrupter(&observer_list, true);
-
- observer_list.AddObserver(&disrupter);
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- observer_list.AddObserver(&c);
- observer_list.AddObserver(&d);
-
- for (auto& o : observer_list) {
- o.Observe(10);
-
- for (auto& o : observer_list)
- o.Observe(1);
- }
-
- EXPECT_EQ(15, a.total);
- EXPECT_EQ(-15, b.total);
- EXPECT_EQ(15, c.total);
- EXPECT_EQ(-15, d.total);
-}
-
-TEST(ObserverListTest, NonCompactList) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1);
-
- Disrupter disrupter1(&observer_list, true);
- Disrupter disrupter2(&observer_list, true);
-
- // Disrupt itself and another one.
- disrupter1.SetDoomed(&disrupter2);
-
- observer_list.AddObserver(&disrupter1);
- observer_list.AddObserver(&disrupter2);
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
-
- for (auto& o : observer_list) {
- // Get the { nullptr, nullptr, &a, &b } non-compact list
- // on the first inner pass.
- o.Observe(10);
-
- for (auto& o : observer_list)
- o.Observe(1);
- }
-
- EXPECT_EQ(13, a.total);
- EXPECT_EQ(-13, b.total);
-}
-
-TEST(ObserverListTest, BecomesEmptyThanNonEmpty) {
- ObserverList<Foo> observer_list;
- Adder a(1), b(-1);
-
- Disrupter disrupter1(&observer_list, true);
- Disrupter disrupter2(&observer_list, true);
-
- // Disrupt itself and another one.
- disrupter1.SetDoomed(&disrupter2);
-
- observer_list.AddObserver(&disrupter1);
- observer_list.AddObserver(&disrupter2);
-
- bool add_observers = true;
- for (auto& o : observer_list) {
- // Get the { nullptr, nullptr } empty list on the first inner pass.
- o.Observe(10);
-
- for (auto& o : observer_list)
- o.Observe(1);
-
- if (add_observers) {
- observer_list.AddObserver(&a);
- observer_list.AddObserver(&b);
- add_observers = false;
- }
- }
-
- EXPECT_EQ(12, a.total);
- EXPECT_EQ(-12, b.total);
-}
-
-TEST(ObserverListTest, AddObserverInTheLastObserve) {
- using FooList = ObserverList<Foo>;
- FooList observer_list;
-
- AddInObserve<FooList> a(&observer_list);
- Adder b(-1);
-
- a.SetToAdd(&b);
- observer_list.AddObserver(&a);
-
- auto it = observer_list.begin();
- while (it != observer_list.end()) {
- auto& observer = *it;
- // Intentionally increment the iterator before calling Observe(). The
- // ObserverList starts with only one observer, and it == observer_list.end()
- // should be true after the next line.
- ++it;
- // However, the first Observe() call will add a second observer: at this
- // point, it != observer_list.end() should be true, and Observe() should be
- // called on the newly added observer on the next iteration of the loop.
- observer.Observe(10);
- }
-
- EXPECT_EQ(-10, b.total);
-}
-
-class MockLogAssertHandler {
- public:
- MOCK_METHOD4(
- HandleLogAssert,
- void(const char*, int, const base::StringPiece, const base::StringPiece));
-};
-
-#if DCHECK_IS_ON()
-TEST(ObserverListTest, NonReentrantObserverList) {
- using ::testing::_;
-
- ObserverList<Foo, /*check_empty=*/false, /*allow_reentrancy=*/false>
- non_reentrant_observer_list;
- Adder a(1);
- non_reentrant_observer_list.AddObserver(&a);
-
- EXPECT_DCHECK_DEATH({
- for (const Foo& a : non_reentrant_observer_list) {
- for (const Foo& b : non_reentrant_observer_list) {
- std::ignore = a;
- std::ignore = b;
- }
- }
- });
-}
-
-TEST(ObserverListTest, ReentrantObserverList) {
- using ::testing::_;
-
- ReentrantObserverList<Foo> reentrant_observer_list;
- Adder a(1);
- reentrant_observer_list.AddObserver(&a);
- bool passed = false;
- for (const Foo& a : reentrant_observer_list) {
- for (const Foo& b : reentrant_observer_list) {
- std::ignore = a;
- std::ignore = b;
- passed = true;
- }
- }
- EXPECT_TRUE(passed);
-}
-#endif
-
-} // namespace base
diff --git a/base/optional_unittest.cc b/base/optional_unittest.cc
deleted file mode 100644
index 7bdb46b..0000000
--- a/base/optional_unittest.cc
+++ /dev/null
@@ -1,2185 +0,0 @@
-// Copyright 2016 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 "base/optional.h"
-
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::ElementsAre;
-
-namespace base {
-
-namespace {
-
-// Object used to test complex object with Optional<T> in addition of the move
-// semantics.
-class TestObject {
- public:
- enum class State {
- DEFAULT_CONSTRUCTED,
- VALUE_CONSTRUCTED,
- COPY_CONSTRUCTED,
- MOVE_CONSTRUCTED,
- MOVED_FROM,
- COPY_ASSIGNED,
- MOVE_ASSIGNED,
- SWAPPED,
- };
-
- TestObject() : foo_(0), bar_(0.0), state_(State::DEFAULT_CONSTRUCTED) {}
-
- TestObject(int foo, double bar)
- : foo_(foo), bar_(bar), state_(State::VALUE_CONSTRUCTED) {}
-
- TestObject(const TestObject& other)
- : foo_(other.foo_),
- bar_(other.bar_),
- state_(State::COPY_CONSTRUCTED),
- move_ctors_count_(other.move_ctors_count_) {}
-
- TestObject(TestObject&& other)
- : foo_(std::move(other.foo_)),
- bar_(std::move(other.bar_)),
- state_(State::MOVE_CONSTRUCTED),
- move_ctors_count_(other.move_ctors_count_ + 1) {
- other.state_ = State::MOVED_FROM;
- }
-
- TestObject& operator=(const TestObject& other) {
- foo_ = other.foo_;
- bar_ = other.bar_;
- state_ = State::COPY_ASSIGNED;
- move_ctors_count_ = other.move_ctors_count_;
- return *this;
- }
-
- TestObject& operator=(TestObject&& other) {
- foo_ = other.foo_;
- bar_ = other.bar_;
- state_ = State::MOVE_ASSIGNED;
- move_ctors_count_ = other.move_ctors_count_;
- other.state_ = State::MOVED_FROM;
- return *this;
- }
-
- void Swap(TestObject* other) {
- using std::swap;
- swap(foo_, other->foo_);
- swap(bar_, other->bar_);
- swap(move_ctors_count_, other->move_ctors_count_);
- state_ = State::SWAPPED;
- other->state_ = State::SWAPPED;
- }
-
- bool operator==(const TestObject& other) const {
- return std::tie(foo_, bar_) == std::tie(other.foo_, other.bar_);
- }
-
- bool operator!=(const TestObject& other) const { return !(*this == other); }
-
- int foo() const { return foo_; }
- State state() const { return state_; }
- int move_ctors_count() const { return move_ctors_count_; }
-
- private:
- int foo_;
- double bar_;
- State state_;
- int move_ctors_count_ = 0;
-};
-
-// Implementing Swappable concept.
-void swap(TestObject& lhs, TestObject& rhs) {
- lhs.Swap(&rhs);
-}
-
-class NonTriviallyDestructible {
- ~NonTriviallyDestructible() {}
-};
-
-class DeletedDefaultConstructor {
- public:
- DeletedDefaultConstructor() = delete;
- DeletedDefaultConstructor(int foo) : foo_(foo) {}
-
- int foo() const { return foo_; }
-
- private:
- int foo_;
-};
-
-class DeletedCopy {
- public:
- explicit DeletedCopy(int foo) : foo_(foo) {}
- DeletedCopy(const DeletedCopy&) = delete;
- DeletedCopy(DeletedCopy&&) = default;
-
- DeletedCopy& operator=(const DeletedCopy&) = delete;
- DeletedCopy& operator=(DeletedCopy&&) = default;
-
- int foo() const { return foo_; }
-
- private:
- int foo_;
-};
-
-class DeletedMove {
- public:
- explicit DeletedMove(int foo) : foo_(foo) {}
- DeletedMove(const DeletedMove&) = default;
- DeletedMove(DeletedMove&&) = delete;
-
- DeletedMove& operator=(const DeletedMove&) = default;
- DeletedMove& operator=(DeletedMove&&) = delete;
-
- int foo() const { return foo_; }
-
- private:
- int foo_;
-};
-
-class NonTriviallyDestructibleDeletedCopyConstructor {
- public:
- explicit NonTriviallyDestructibleDeletedCopyConstructor(int foo)
- : foo_(foo) {}
- NonTriviallyDestructibleDeletedCopyConstructor(
- const NonTriviallyDestructibleDeletedCopyConstructor&) = delete;
- NonTriviallyDestructibleDeletedCopyConstructor(
- NonTriviallyDestructibleDeletedCopyConstructor&&) = default;
-
- ~NonTriviallyDestructibleDeletedCopyConstructor() {}
-
- int foo() const { return foo_; }
-
- private:
- int foo_;
-};
-
-class DeleteNewOperators {
- public:
- void* operator new(size_t) = delete;
- void* operator new(size_t, void*) = delete;
- void* operator new[](size_t) = delete;
- void* operator new[](size_t, void*) = delete;
-};
-
-} // anonymous namespace
-
-static_assert(std::is_trivially_destructible<Optional<int>>::value,
- "OptionalIsTriviallyDestructible");
-
-static_assert(
- !std::is_trivially_destructible<Optional<NonTriviallyDestructible>>::value,
- "OptionalIsTriviallyDestructible");
-
-static_assert(sizeof(Optional<int>) == sizeof(internal::OptionalBase<int>),
- "internal::{Copy,Move}{Constructible,Assignable} structs "
- "should be 0-sized");
-
-TEST(OptionalTest, DefaultConstructor) {
- {
- constexpr Optional<float> o;
- EXPECT_FALSE(o);
- }
-
- {
- Optional<std::string> o;
- EXPECT_FALSE(o);
- }
-
- {
- Optional<TestObject> o;
- EXPECT_FALSE(o);
- }
-}
-
-TEST(OptionalTest, CopyConstructor) {
- {
- constexpr Optional<float> first(0.1f);
- constexpr Optional<float> other(first);
-
- EXPECT_TRUE(other);
- EXPECT_EQ(other.value(), 0.1f);
- EXPECT_EQ(first, other);
- }
-
- {
- Optional<std::string> first("foo");
- Optional<std::string> other(first);
-
- EXPECT_TRUE(other);
- EXPECT_EQ(other.value(), "foo");
- EXPECT_EQ(first, other);
- }
-
- {
- const Optional<std::string> first("foo");
- Optional<std::string> other(first);
-
- EXPECT_TRUE(other);
- EXPECT_EQ(other.value(), "foo");
- EXPECT_EQ(first, other);
- }
-
- {
- Optional<TestObject> first(TestObject(3, 0.1));
- Optional<TestObject> other(first);
-
- EXPECT_TRUE(!!other);
- EXPECT_TRUE(other.value() == TestObject(3, 0.1));
- EXPECT_TRUE(first == other);
- }
-}
-
-TEST(OptionalTest, ValueConstructor) {
- {
- constexpr float value = 0.1f;
- constexpr Optional<float> o(value);
-
- EXPECT_TRUE(o);
- EXPECT_EQ(value, o.value());
- }
-
- {
- std::string value("foo");
- Optional<std::string> o(value);
-
- EXPECT_TRUE(o);
- EXPECT_EQ(value, o.value());
- }
-
- {
- TestObject value(3, 0.1);
- Optional<TestObject> o(value);
-
- EXPECT_TRUE(o);
- EXPECT_EQ(TestObject::State::COPY_CONSTRUCTED, o->state());
- EXPECT_EQ(value, o.value());
- }
-}
-
-TEST(OptionalTest, MoveConstructor) {
- {
- constexpr Optional<float> first(0.1f);
- constexpr Optional<float> second(std::move(first));
-
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(second.value(), 0.1f);
-
- EXPECT_TRUE(first.has_value());
- }
-
- {
- Optional<std::string> first("foo");
- Optional<std::string> second(std::move(first));
-
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ("foo", second.value());
-
- EXPECT_TRUE(first.has_value());
- }
-
- {
- Optional<TestObject> first(TestObject(3, 0.1));
- Optional<TestObject> second(std::move(first));
-
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state());
- EXPECT_TRUE(TestObject(3, 0.1) == second.value());
-
- EXPECT_TRUE(first.has_value());
- EXPECT_EQ(TestObject::State::MOVED_FROM, first->state());
- }
-
- // Even if copy constructor is deleted, move constructor needs to work.
- // Note that it couldn't be constexpr.
- {
- Optional<DeletedCopy> first(in_place, 42);
- Optional<DeletedCopy> second(std::move(first));
-
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(42, second->foo());
-
- EXPECT_TRUE(first.has_value());
- }
-
- {
- Optional<DeletedMove> first(in_place, 42);
- Optional<DeletedMove> second(std::move(first));
-
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(42, second->foo());
-
- EXPECT_TRUE(first.has_value());
- }
-
- {
- Optional<NonTriviallyDestructibleDeletedCopyConstructor> first(in_place,
- 42);
- Optional<NonTriviallyDestructibleDeletedCopyConstructor> second(
- std::move(first));
-
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(42, second->foo());
-
- EXPECT_TRUE(first.has_value());
- }
-}
-
-TEST(OptionalTest, MoveValueConstructor) {
- {
- constexpr float value = 0.1f;
- constexpr Optional<float> o(std::move(value));
-
- EXPECT_TRUE(o);
- EXPECT_EQ(0.1f, o.value());
- }
-
- {
- float value = 0.1f;
- Optional<float> o(std::move(value));
-
- EXPECT_TRUE(o);
- EXPECT_EQ(0.1f, o.value());
- }
-
- {
- std::string value("foo");
- Optional<std::string> o(std::move(value));
-
- EXPECT_TRUE(o);
- EXPECT_EQ("foo", o.value());
- }
-
- {
- TestObject value(3, 0.1);
- Optional<TestObject> o(std::move(value));
-
- EXPECT_TRUE(o);
- EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, o->state());
- EXPECT_EQ(TestObject(3, 0.1), o.value());
- }
-}
-
-TEST(OptionalTest, ConvertingCopyConstructor) {
- {
- Optional<int> first(1);
- Optional<double> second(first);
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(1.0, second.value());
- }
-
- // Make sure explicit is not marked for convertible case.
- {
- Optional<int> o(1);
- ignore_result<Optional<double>>(o);
- }
-}
-
-TEST(OptionalTest, ConvertingMoveConstructor) {
- {
- Optional<int> first(1);
- Optional<double> second(std::move(first));
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(1.0, second.value());
- }
-
- // Make sure explicit is not marked for convertible case.
- {
- Optional<int> o(1);
- ignore_result<Optional<double>>(std::move(o));
- }
-
- {
- class Test1 {
- public:
- explicit Test1(int foo) : foo_(foo) {}
-
- int foo() const { return foo_; }
-
- private:
- int foo_;
- };
-
- // Not copyable but convertible from Test1.
- class Test2 {
- public:
- Test2(const Test2&) = delete;
- explicit Test2(Test1&& other) : bar_(other.foo()) {}
-
- double bar() const { return bar_; }
-
- private:
- double bar_;
- };
-
- Optional<Test1> first(in_place, 42);
- Optional<Test2> second(std::move(first));
- EXPECT_TRUE(second.has_value());
- EXPECT_EQ(42.0, second->bar());
- }
-}
-
-TEST(OptionalTest, ConstructorForwardArguments) {
- {
- constexpr Optional<float> a(base::in_place, 0.1f);
- EXPECT_TRUE(a);
- EXPECT_EQ(0.1f, a.value());
- }
-
- {
- Optional<float> a(base::in_place, 0.1f);
- EXPECT_TRUE(a);
- EXPECT_EQ(0.1f, a.value());
- }
-
- {
- Optional<std::string> a(base::in_place, "foo");
- EXPECT_TRUE(a);
- EXPECT_EQ("foo", a.value());
- }
-
- {
- Optional<TestObject> a(base::in_place, 0, 0.1);
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(TestObject(0, 0.1) == a.value());
- }
-}
-
-TEST(OptionalTest, ConstructorForwardInitListAndArguments) {
- {
- Optional<std::vector<int>> opt(in_place, {3, 1});
- EXPECT_TRUE(opt);
- EXPECT_THAT(*opt, ElementsAre(3, 1));
- EXPECT_EQ(2u, opt->size());
- }
-
- {
- Optional<std::vector<int>> opt(in_place, {3, 1}, std::allocator<int>());
- EXPECT_TRUE(opt);
- EXPECT_THAT(*opt, ElementsAre(3, 1));
- EXPECT_EQ(2u, opt->size());
- }
-}
-
-TEST(OptionalTest, ForwardConstructor) {
- {
- Optional<double> a(1);
- EXPECT_TRUE(a.has_value());
- EXPECT_EQ(1.0, a.value());
- }
-
- // Test that default type of 'U' is value_type.
- {
- struct TestData {
- int a;
- double b;
- bool c;
- };
-
- Optional<TestData> a({1, 2.0, true});
- EXPECT_TRUE(a.has_value());
- EXPECT_EQ(1, a->a);
- EXPECT_EQ(2.0, a->b);
- EXPECT_TRUE(a->c);
- }
-
- // If T has a constructor with a param Optional<U>, and another ctor with a
- // param U, then T(Optional<U>) should be used for Optional<T>(Optional<U>)
- // constructor.
- {
- enum class ParamType {
- DEFAULT_CONSTRUCTED,
- COPY_CONSTRUCTED,
- MOVE_CONSTRUCTED,
- INT,
- IN_PLACE,
- OPTIONAL_INT,
- };
- struct Test {
- Test() : param_type(ParamType::DEFAULT_CONSTRUCTED) {}
- Test(const Test& param) : param_type(ParamType::COPY_CONSTRUCTED) {}
- Test(Test&& param) : param_type(ParamType::MOVE_CONSTRUCTED) {}
- explicit Test(int param) : param_type(ParamType::INT) {}
- explicit Test(in_place_t param) : param_type(ParamType::IN_PLACE) {}
- explicit Test(Optional<int> param)
- : param_type(ParamType::OPTIONAL_INT) {}
-
- ParamType param_type;
- };
-
- // Overload resolution with copy-conversion constructor.
- {
- const Optional<int> arg(in_place, 1);
- Optional<Test> testee(arg);
- EXPECT_EQ(ParamType::OPTIONAL_INT, testee->param_type);
- }
-
- // Overload resolution with move conversion constructor.
- {
- Optional<Test> testee(Optional<int>(in_place, 1));
- EXPECT_EQ(ParamType::OPTIONAL_INT, testee->param_type);
- }
-
- // Default constructor should be used.
- {
- Optional<Test> testee(in_place);
- EXPECT_EQ(ParamType::DEFAULT_CONSTRUCTED, testee->param_type);
- }
- }
-
- {
- struct Test {
- Test(int a) {} // NOLINT(runtime/explicit)
- };
- // If T is convertible from U, it is not marked as explicit.
- static_assert(std::is_convertible<int, Test>::value,
- "Int should be convertible to Test.");
- ([](Optional<Test> param) {})(1);
- }
-}
-
-TEST(OptionalTest, NulloptConstructor) {
- constexpr Optional<int> a(base::nullopt);
- EXPECT_FALSE(a);
-}
-
-TEST(OptionalTest, AssignValue) {
- {
- Optional<float> a;
- EXPECT_FALSE(a);
- a = 0.1f;
- EXPECT_TRUE(a);
-
- Optional<float> b(0.1f);
- EXPECT_TRUE(a == b);
- }
-
- {
- Optional<std::string> a;
- EXPECT_FALSE(a);
- a = std::string("foo");
- EXPECT_TRUE(a);
-
- Optional<std::string> b(std::string("foo"));
- EXPECT_EQ(a, b);
- }
-
- {
- Optional<TestObject> a;
- EXPECT_FALSE(!!a);
- a = TestObject(3, 0.1);
- EXPECT_TRUE(!!a);
-
- Optional<TestObject> b(TestObject(3, 0.1));
- EXPECT_TRUE(a == b);
- }
-
- {
- Optional<TestObject> a = TestObject(4, 1.0);
- EXPECT_TRUE(!!a);
- a = TestObject(3, 0.1);
- EXPECT_TRUE(!!a);
-
- Optional<TestObject> b(TestObject(3, 0.1));
- EXPECT_TRUE(a == b);
- }
-}
-
-TEST(OptionalTest, AssignObject) {
- {
- Optional<float> a;
- Optional<float> b(0.1f);
- a = b;
-
- EXPECT_TRUE(a);
- EXPECT_EQ(a.value(), 0.1f);
- EXPECT_EQ(a, b);
- }
-
- {
- Optional<std::string> a;
- Optional<std::string> b("foo");
- a = b;
-
- EXPECT_TRUE(a);
- EXPECT_EQ(a.value(), "foo");
- EXPECT_EQ(a, b);
- }
-
- {
- Optional<TestObject> a;
- Optional<TestObject> b(TestObject(3, 0.1));
- a = b;
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(a.value() == TestObject(3, 0.1));
- EXPECT_TRUE(a == b);
- }
-
- {
- Optional<TestObject> a(TestObject(4, 1.0));
- Optional<TestObject> b(TestObject(3, 0.1));
- a = b;
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(a.value() == TestObject(3, 0.1));
- EXPECT_TRUE(a == b);
- }
-
- {
- Optional<DeletedMove> a(in_place, 42);
- Optional<DeletedMove> b;
- b = a;
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(a->foo(), b->foo());
- }
-
- {
- Optional<DeletedMove> a(in_place, 42);
- Optional<DeletedMove> b(in_place, 1);
- b = a;
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(a->foo(), b->foo());
- }
-
- // Converting assignment.
- {
- Optional<int> a(in_place, 1);
- Optional<double> b;
- b = a;
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(1, a.value());
- EXPECT_EQ(1.0, b.value());
- }
-
- {
- Optional<int> a(in_place, 42);
- Optional<double> b(in_place, 1);
- b = a;
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(42, a.value());
- EXPECT_EQ(42.0, b.value());
- }
-
- {
- Optional<int> a;
- Optional<double> b(in_place, 1);
- b = a;
- EXPECT_FALSE(!!a);
- EXPECT_FALSE(!!b);
- }
-}
-
-TEST(OptionalTest, AssignObject_rvalue) {
- {
- Optional<float> a;
- Optional<float> b(0.1f);
- a = std::move(b);
-
- EXPECT_TRUE(a);
- EXPECT_TRUE(b);
- EXPECT_EQ(0.1f, a.value());
- }
-
- {
- Optional<std::string> a;
- Optional<std::string> b("foo");
- a = std::move(b);
-
- EXPECT_TRUE(a);
- EXPECT_TRUE(b);
- EXPECT_EQ("foo", a.value());
- }
-
- {
- Optional<TestObject> a;
- Optional<TestObject> b(TestObject(3, 0.1));
- a = std::move(b);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_TRUE(TestObject(3, 0.1) == a.value());
-
- EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, a->state());
- EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
- }
-
- {
- Optional<TestObject> a(TestObject(4, 1.0));
- Optional<TestObject> b(TestObject(3, 0.1));
- a = std::move(b);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_TRUE(TestObject(3, 0.1) == a.value());
-
- EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, a->state());
- EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
- }
-
- {
- Optional<DeletedMove> a(in_place, 42);
- Optional<DeletedMove> b;
- b = std::move(a);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(42, b->foo());
- }
-
- {
- Optional<DeletedMove> a(in_place, 42);
- Optional<DeletedMove> b(in_place, 1);
- b = std::move(a);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(42, b->foo());
- }
-
- // Converting assignment.
- {
- Optional<int> a(in_place, 1);
- Optional<double> b;
- b = std::move(a);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(1.0, b.value());
- }
-
- {
- Optional<int> a(in_place, 42);
- Optional<double> b(in_place, 1);
- b = std::move(a);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(42.0, b.value());
- }
-
- {
- Optional<int> a;
- Optional<double> b(in_place, 1);
- b = std::move(a);
-
- EXPECT_FALSE(!!a);
- EXPECT_FALSE(!!b);
- }
-}
-
-TEST(OptionalTest, AssignNull) {
- {
- Optional<float> a(0.1f);
- Optional<float> b(0.2f);
- a = base::nullopt;
- b = base::nullopt;
- EXPECT_EQ(a, b);
- }
-
- {
- Optional<std::string> a("foo");
- Optional<std::string> b("bar");
- a = base::nullopt;
- b = base::nullopt;
- EXPECT_EQ(a, b);
- }
-
- {
- Optional<TestObject> a(TestObject(3, 0.1));
- Optional<TestObject> b(TestObject(4, 1.0));
- a = base::nullopt;
- b = base::nullopt;
- EXPECT_TRUE(a == b);
- }
-}
-
-TEST(OptionalTest, AssignOverload) {
- struct Test1 {
- enum class State {
- CONSTRUCTED,
- MOVED,
- };
- State state = State::CONSTRUCTED;
- };
-
- // Here, Optional<Test2> can be assigned from Optioanl<Test1>.
- // In case of move, marks MOVED to Test1 instance.
- struct Test2 {
- enum class State {
- DEFAULT_CONSTRUCTED,
- COPY_CONSTRUCTED_FROM_TEST1,
- MOVE_CONSTRUCTED_FROM_TEST1,
- COPY_ASSIGNED_FROM_TEST1,
- MOVE_ASSIGNED_FROM_TEST1,
- };
-
- Test2() = default;
- explicit Test2(const Test1& test1)
- : state(State::COPY_CONSTRUCTED_FROM_TEST1) {}
- explicit Test2(Test1&& test1) : state(State::MOVE_CONSTRUCTED_FROM_TEST1) {
- test1.state = Test1::State::MOVED;
- }
- Test2& operator=(const Test1& test1) {
- state = State::COPY_ASSIGNED_FROM_TEST1;
- return *this;
- }
- Test2& operator=(Test1&& test1) {
- state = State::MOVE_ASSIGNED_FROM_TEST1;
- test1.state = Test1::State::MOVED;
- return *this;
- }
-
- State state = State::DEFAULT_CONSTRUCTED;
- };
-
- {
- Optional<Test1> a(in_place);
- Optional<Test2> b;
-
- b = a;
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
- EXPECT_EQ(Test2::State::COPY_CONSTRUCTED_FROM_TEST1, b->state);
- }
-
- {
- Optional<Test1> a(in_place);
- Optional<Test2> b(in_place);
-
- b = a;
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
- EXPECT_EQ(Test2::State::COPY_ASSIGNED_FROM_TEST1, b->state);
- }
-
- {
- Optional<Test1> a(in_place);
- Optional<Test2> b;
-
- b = std::move(a);
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::MOVED, a->state);
- EXPECT_EQ(Test2::State::MOVE_CONSTRUCTED_FROM_TEST1, b->state);
- }
-
- {
- Optional<Test1> a(in_place);
- Optional<Test2> b(in_place);
-
- b = std::move(a);
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::MOVED, a->state);
- EXPECT_EQ(Test2::State::MOVE_ASSIGNED_FROM_TEST1, b->state);
- }
-
- // Similar to Test2, but Test3 also has copy/move ctor and assign operators
- // from Optional<Test1>, too. In this case, for a = b where a is
- // Optional<Test3> and b is Optional<Test1>,
- // Optional<T>::operator=(U&&) where U is Optional<Test1> should be used
- // rather than Optional<T>::operator=(Optional<U>&&) where U is Test1.
- struct Test3 {
- enum class State {
- DEFAULT_CONSTRUCTED,
- COPY_CONSTRUCTED_FROM_TEST1,
- MOVE_CONSTRUCTED_FROM_TEST1,
- COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1,
- MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1,
- COPY_ASSIGNED_FROM_TEST1,
- MOVE_ASSIGNED_FROM_TEST1,
- COPY_ASSIGNED_FROM_OPTIONAL_TEST1,
- MOVE_ASSIGNED_FROM_OPTIONAL_TEST1,
- };
-
- Test3() = default;
- explicit Test3(const Test1& test1)
- : state(State::COPY_CONSTRUCTED_FROM_TEST1) {}
- explicit Test3(Test1&& test1) : state(State::MOVE_CONSTRUCTED_FROM_TEST1) {
- test1.state = Test1::State::MOVED;
- }
- explicit Test3(const Optional<Test1>& test1)
- : state(State::COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1) {}
- explicit Test3(Optional<Test1>&& test1)
- : state(State::MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1) {
- // In the following senarios, given |test1| should always have value.
- DCHECK(test1.has_value());
- test1->state = Test1::State::MOVED;
- }
- Test3& operator=(const Test1& test1) {
- state = State::COPY_ASSIGNED_FROM_TEST1;
- return *this;
- }
- Test3& operator=(Test1&& test1) {
- state = State::MOVE_ASSIGNED_FROM_TEST1;
- test1.state = Test1::State::MOVED;
- return *this;
- }
- Test3& operator=(const Optional<Test1>& test1) {
- state = State::COPY_ASSIGNED_FROM_OPTIONAL_TEST1;
- return *this;
- }
- Test3& operator=(Optional<Test1>&& test1) {
- state = State::MOVE_ASSIGNED_FROM_OPTIONAL_TEST1;
- // In the following senarios, given |test1| should always have value.
- DCHECK(test1.has_value());
- test1->state = Test1::State::MOVED;
- return *this;
- }
-
- State state = State::DEFAULT_CONSTRUCTED;
- };
-
- {
- Optional<Test1> a(in_place);
- Optional<Test3> b;
-
- b = a;
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
- EXPECT_EQ(Test3::State::COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1, b->state);
- }
-
- {
- Optional<Test1> a(in_place);
- Optional<Test3> b(in_place);
-
- b = a;
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
- EXPECT_EQ(Test3::State::COPY_ASSIGNED_FROM_OPTIONAL_TEST1, b->state);
- }
-
- {
- Optional<Test1> a(in_place);
- Optional<Test3> b;
-
- b = std::move(a);
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::MOVED, a->state);
- EXPECT_EQ(Test3::State::MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1, b->state);
- }
-
- {
- Optional<Test1> a(in_place);
- Optional<Test3> b(in_place);
-
- b = std::move(a);
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_EQ(Test1::State::MOVED, a->state);
- EXPECT_EQ(Test3::State::MOVE_ASSIGNED_FROM_OPTIONAL_TEST1, b->state);
- }
-}
-
-TEST(OptionalTest, OperatorStar) {
- {
- Optional<float> a(0.1f);
- EXPECT_EQ(a.value(), *a);
- }
-
- {
- Optional<std::string> a("foo");
- EXPECT_EQ(a.value(), *a);
- }
-
- {
- Optional<TestObject> a(TestObject(3, 0.1));
- EXPECT_EQ(a.value(), *a);
- }
-}
-
-TEST(OptionalTest, OperatorStar_rvalue) {
- EXPECT_EQ(0.1f, *Optional<float>(0.1f));
- EXPECT_EQ(std::string("foo"), *Optional<std::string>("foo"));
- EXPECT_TRUE(TestObject(3, 0.1) == *Optional<TestObject>(TestObject(3, 0.1)));
-}
-
-TEST(OptionalTest, OperatorArrow) {
- Optional<TestObject> a(TestObject(3, 0.1));
- EXPECT_EQ(a->foo(), 3);
-}
-
-TEST(OptionalTest, Value_rvalue) {
- EXPECT_EQ(0.1f, Optional<float>(0.1f).value());
- EXPECT_EQ(std::string("foo"), Optional<std::string>("foo").value());
- EXPECT_TRUE(TestObject(3, 0.1) ==
- Optional<TestObject>(TestObject(3, 0.1)).value());
-}
-
-TEST(OptionalTest, ValueOr) {
- {
- Optional<float> a;
- EXPECT_EQ(0.0f, a.value_or(0.0f));
-
- a = 0.1f;
- EXPECT_EQ(0.1f, a.value_or(0.0f));
-
- a = base::nullopt;
- EXPECT_EQ(0.0f, a.value_or(0.0f));
- }
-
- // value_or() can be constexpr.
- {
- constexpr Optional<int> a(in_place, 1);
- constexpr int value = a.value_or(10);
- EXPECT_EQ(1, value);
- }
- {
- constexpr Optional<int> a;
- constexpr int value = a.value_or(10);
- EXPECT_EQ(10, value);
- }
-
- {
- Optional<std::string> a;
- EXPECT_EQ("bar", a.value_or("bar"));
-
- a = std::string("foo");
- EXPECT_EQ(std::string("foo"), a.value_or("bar"));
-
- a = base::nullopt;
- EXPECT_EQ(std::string("bar"), a.value_or("bar"));
- }
-
- {
- Optional<TestObject> a;
- EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
-
- a = TestObject(3, 0.1);
- EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(3, 0.1));
-
- a = base::nullopt;
- EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
- }
-}
-
-TEST(OptionalTest, Swap_bothNoValue) {
- Optional<TestObject> a, b;
- a.swap(b);
-
- EXPECT_FALSE(a);
- EXPECT_FALSE(b);
- EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
-}
-
-TEST(OptionalTest, Swap_inHasValue) {
- Optional<TestObject> a(TestObject(1, 0.3));
- Optional<TestObject> b;
- a.swap(b);
-
- EXPECT_FALSE(a);
-
- EXPECT_TRUE(!!b);
- EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
-}
-
-TEST(OptionalTest, Swap_outHasValue) {
- Optional<TestObject> a;
- Optional<TestObject> b(TestObject(1, 0.3));
- a.swap(b);
-
- EXPECT_TRUE(!!a);
- EXPECT_FALSE(!!b);
- EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
-}
-
-TEST(OptionalTest, Swap_bothValue) {
- Optional<TestObject> a(TestObject(0, 0.1));
- Optional<TestObject> b(TestObject(1, 0.3));
- a.swap(b);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
- EXPECT_EQ(TestObject::State::SWAPPED, a->state());
- EXPECT_EQ(TestObject::State::SWAPPED, b->state());
-}
-
-TEST(OptionalTest, Emplace) {
- {
- Optional<float> a(0.1f);
- EXPECT_EQ(0.3f, a.emplace(0.3f));
-
- EXPECT_TRUE(a);
- EXPECT_EQ(0.3f, a.value());
- }
-
- {
- Optional<std::string> a("foo");
- EXPECT_EQ("bar", a.emplace("bar"));
-
- EXPECT_TRUE(a);
- EXPECT_EQ("bar", a.value());
- }
-
- {
- Optional<TestObject> a(TestObject(0, 0.1));
- EXPECT_EQ(TestObject(1, 0.2), a.emplace(TestObject(1, 0.2)));
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(TestObject(1, 0.2) == a.value());
- }
-
- {
- Optional<std::vector<int>> a;
- auto& ref = a.emplace({2, 3});
- static_assert(std::is_same<std::vector<int>&, decltype(ref)>::value, "");
- EXPECT_TRUE(a);
- EXPECT_THAT(*a, ElementsAre(2, 3));
- EXPECT_EQ(&ref, &*a);
- }
-
- {
- Optional<std::vector<int>> a;
- auto& ref = a.emplace({4, 5}, std::allocator<int>());
- static_assert(std::is_same<std::vector<int>&, decltype(ref)>::value, "");
- EXPECT_TRUE(a);
- EXPECT_THAT(*a, ElementsAre(4, 5));
- EXPECT_EQ(&ref, &*a);
- }
-}
-
-TEST(OptionalTest, Equals_TwoEmpty) {
- Optional<int> a;
- Optional<int> b;
-
- EXPECT_TRUE(a == b);
-}
-
-TEST(OptionalTest, Equals_TwoEquals) {
- Optional<int> a(1);
- Optional<int> b(1);
-
- EXPECT_TRUE(a == b);
-}
-
-TEST(OptionalTest, Equals_OneEmpty) {
- Optional<int> a;
- Optional<int> b(1);
-
- EXPECT_FALSE(a == b);
-}
-
-TEST(OptionalTest, Equals_TwoDifferent) {
- Optional<int> a(0);
- Optional<int> b(1);
-
- EXPECT_FALSE(a == b);
-}
-
-TEST(OptionalTest, Equals_DifferentType) {
- Optional<int> a(0);
- Optional<double> b(0);
-
- EXPECT_TRUE(a == b);
-}
-
-TEST(OptionalTest, NotEquals_TwoEmpty) {
- Optional<int> a;
- Optional<int> b;
-
- EXPECT_FALSE(a != b);
-}
-
-TEST(OptionalTest, NotEquals_TwoEquals) {
- Optional<int> a(1);
- Optional<int> b(1);
-
- EXPECT_FALSE(a != b);
-}
-
-TEST(OptionalTest, NotEquals_OneEmpty) {
- Optional<int> a;
- Optional<int> b(1);
-
- EXPECT_TRUE(a != b);
-}
-
-TEST(OptionalTest, NotEquals_TwoDifferent) {
- Optional<int> a(0);
- Optional<int> b(1);
-
- EXPECT_TRUE(a != b);
-}
-
-TEST(OptionalTest, NotEquals_DifferentType) {
- Optional<int> a(0);
- Optional<double> b(0.0);
-
- EXPECT_FALSE(a != b);
-}
-
-TEST(OptionalTest, Less_LeftEmpty) {
- Optional<int> l;
- Optional<int> r(1);
-
- EXPECT_TRUE(l < r);
-}
-
-TEST(OptionalTest, Less_RightEmpty) {
- Optional<int> l(1);
- Optional<int> r;
-
- EXPECT_FALSE(l < r);
-}
-
-TEST(OptionalTest, Less_BothEmpty) {
- Optional<int> l;
- Optional<int> r;
-
- EXPECT_FALSE(l < r);
-}
-
-TEST(OptionalTest, Less_BothValues) {
- {
- Optional<int> l(1);
- Optional<int> r(2);
-
- EXPECT_TRUE(l < r);
- }
- {
- Optional<int> l(2);
- Optional<int> r(1);
-
- EXPECT_FALSE(l < r);
- }
- {
- Optional<int> l(1);
- Optional<int> r(1);
-
- EXPECT_FALSE(l < r);
- }
-}
-
-TEST(OptionalTest, Less_DifferentType) {
- Optional<int> l(1);
- Optional<double> r(2.0);
-
- EXPECT_TRUE(l < r);
-}
-
-TEST(OptionalTest, LessEq_LeftEmpty) {
- Optional<int> l;
- Optional<int> r(1);
-
- EXPECT_TRUE(l <= r);
-}
-
-TEST(OptionalTest, LessEq_RightEmpty) {
- Optional<int> l(1);
- Optional<int> r;
-
- EXPECT_FALSE(l <= r);
-}
-
-TEST(OptionalTest, LessEq_BothEmpty) {
- Optional<int> l;
- Optional<int> r;
-
- EXPECT_TRUE(l <= r);
-}
-
-TEST(OptionalTest, LessEq_BothValues) {
- {
- Optional<int> l(1);
- Optional<int> r(2);
-
- EXPECT_TRUE(l <= r);
- }
- {
- Optional<int> l(2);
- Optional<int> r(1);
-
- EXPECT_FALSE(l <= r);
- }
- {
- Optional<int> l(1);
- Optional<int> r(1);
-
- EXPECT_TRUE(l <= r);
- }
-}
-
-TEST(OptionalTest, LessEq_DifferentType) {
- Optional<int> l(1);
- Optional<double> r(2.0);
-
- EXPECT_TRUE(l <= r);
-}
-
-TEST(OptionalTest, Greater_BothEmpty) {
- Optional<int> l;
- Optional<int> r;
-
- EXPECT_FALSE(l > r);
-}
-
-TEST(OptionalTest, Greater_LeftEmpty) {
- Optional<int> l;
- Optional<int> r(1);
-
- EXPECT_FALSE(l > r);
-}
-
-TEST(OptionalTest, Greater_RightEmpty) {
- Optional<int> l(1);
- Optional<int> r;
-
- EXPECT_TRUE(l > r);
-}
-
-TEST(OptionalTest, Greater_BothValue) {
- {
- Optional<int> l(1);
- Optional<int> r(2);
-
- EXPECT_FALSE(l > r);
- }
- {
- Optional<int> l(2);
- Optional<int> r(1);
-
- EXPECT_TRUE(l > r);
- }
- {
- Optional<int> l(1);
- Optional<int> r(1);
-
- EXPECT_FALSE(l > r);
- }
-}
-
-TEST(OptionalTest, Greater_DifferentType) {
- Optional<int> l(1);
- Optional<double> r(2.0);
-
- EXPECT_FALSE(l > r);
-}
-
-TEST(OptionalTest, GreaterEq_BothEmpty) {
- Optional<int> l;
- Optional<int> r;
-
- EXPECT_TRUE(l >= r);
-}
-
-TEST(OptionalTest, GreaterEq_LeftEmpty) {
- Optional<int> l;
- Optional<int> r(1);
-
- EXPECT_FALSE(l >= r);
-}
-
-TEST(OptionalTest, GreaterEq_RightEmpty) {
- Optional<int> l(1);
- Optional<int> r;
-
- EXPECT_TRUE(l >= r);
-}
-
-TEST(OptionalTest, GreaterEq_BothValue) {
- {
- Optional<int> l(1);
- Optional<int> r(2);
-
- EXPECT_FALSE(l >= r);
- }
- {
- Optional<int> l(2);
- Optional<int> r(1);
-
- EXPECT_TRUE(l >= r);
- }
- {
- Optional<int> l(1);
- Optional<int> r(1);
-
- EXPECT_TRUE(l >= r);
- }
-}
-
-TEST(OptionalTest, GreaterEq_DifferentType) {
- Optional<int> l(1);
- Optional<double> r(2.0);
-
- EXPECT_FALSE(l >= r);
-}
-
-TEST(OptionalTest, OptNullEq) {
- {
- Optional<int> opt;
- EXPECT_TRUE(opt == base::nullopt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(opt == base::nullopt);
- }
-}
-
-TEST(OptionalTest, NullOptEq) {
- {
- Optional<int> opt;
- EXPECT_TRUE(base::nullopt == opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(base::nullopt == opt);
- }
-}
-
-TEST(OptionalTest, OptNullNotEq) {
- {
- Optional<int> opt;
- EXPECT_FALSE(opt != base::nullopt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(opt != base::nullopt);
- }
-}
-
-TEST(OptionalTest, NullOptNotEq) {
- {
- Optional<int> opt;
- EXPECT_FALSE(base::nullopt != opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(base::nullopt != opt);
- }
-}
-
-TEST(OptionalTest, OptNullLower) {
- {
- Optional<int> opt;
- EXPECT_FALSE(opt < base::nullopt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(opt < base::nullopt);
- }
-}
-
-TEST(OptionalTest, NullOptLower) {
- {
- Optional<int> opt;
- EXPECT_FALSE(base::nullopt < opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(base::nullopt < opt);
- }
-}
-
-TEST(OptionalTest, OptNullLowerEq) {
- {
- Optional<int> opt;
- EXPECT_TRUE(opt <= base::nullopt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(opt <= base::nullopt);
- }
-}
-
-TEST(OptionalTest, NullOptLowerEq) {
- {
- Optional<int> opt;
- EXPECT_TRUE(base::nullopt <= opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(base::nullopt <= opt);
- }
-}
-
-TEST(OptionalTest, OptNullGreater) {
- {
- Optional<int> opt;
- EXPECT_FALSE(opt > base::nullopt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(opt > base::nullopt);
- }
-}
-
-TEST(OptionalTest, NullOptGreater) {
- {
- Optional<int> opt;
- EXPECT_FALSE(base::nullopt > opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(base::nullopt > opt);
- }
-}
-
-TEST(OptionalTest, OptNullGreaterEq) {
- {
- Optional<int> opt;
- EXPECT_TRUE(opt >= base::nullopt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(opt >= base::nullopt);
- }
-}
-
-TEST(OptionalTest, NullOptGreaterEq) {
- {
- Optional<int> opt;
- EXPECT_TRUE(base::nullopt >= opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(base::nullopt >= opt);
- }
-}
-
-TEST(OptionalTest, ValueEq_Empty) {
- Optional<int> opt;
- EXPECT_FALSE(opt == 1);
-}
-
-TEST(OptionalTest, ValueEq_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_FALSE(opt == 1);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(opt == 1);
- }
-}
-
-TEST(OptionalTest, ValueEq_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(opt == 0.0);
-}
-
-TEST(OptionalTest, EqValue_Empty) {
- Optional<int> opt;
- EXPECT_FALSE(1 == opt);
-}
-
-TEST(OptionalTest, EqValue_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_FALSE(1 == opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(1 == opt);
- }
-}
-
-TEST(OptionalTest, EqValue_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(0.0 == opt);
-}
-
-TEST(OptionalTest, ValueNotEq_Empty) {
- Optional<int> opt;
- EXPECT_TRUE(opt != 1);
-}
-
-TEST(OptionalTest, ValueNotEq_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_TRUE(opt != 1);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(opt != 1);
- }
-}
-
-TEST(OPtionalTest, ValueNotEq_DifferentType) {
- Optional<int> opt(0);
- EXPECT_FALSE(opt != 0.0);
-}
-
-TEST(OptionalTest, NotEqValue_Empty) {
- Optional<int> opt;
- EXPECT_TRUE(1 != opt);
-}
-
-TEST(OptionalTest, NotEqValue_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_TRUE(1 != opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(1 != opt);
- }
-}
-
-TEST(OptionalTest, NotEqValue_DifferentType) {
- Optional<int> opt(0);
- EXPECT_FALSE(0.0 != opt);
-}
-
-TEST(OptionalTest, ValueLess_Empty) {
- Optional<int> opt;
- EXPECT_TRUE(opt < 1);
-}
-
-TEST(OptionalTest, ValueLess_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_TRUE(opt < 1);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(opt < 1);
- }
- {
- Optional<int> opt(2);
- EXPECT_FALSE(opt < 1);
- }
-}
-
-TEST(OPtionalTest, ValueLess_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(opt < 1.0);
-}
-
-TEST(OptionalTest, LessValue_Empty) {
- Optional<int> opt;
- EXPECT_FALSE(1 < opt);
-}
-
-TEST(OptionalTest, LessValue_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_FALSE(1 < opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(1 < opt);
- }
- {
- Optional<int> opt(2);
- EXPECT_TRUE(1 < opt);
- }
-}
-
-TEST(OptionalTest, LessValue_DifferentType) {
- Optional<int> opt(0);
- EXPECT_FALSE(0.0 < opt);
-}
-
-TEST(OptionalTest, ValueLessEq_Empty) {
- Optional<int> opt;
- EXPECT_TRUE(opt <= 1);
-}
-
-TEST(OptionalTest, ValueLessEq_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_TRUE(opt <= 1);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(opt <= 1);
- }
- {
- Optional<int> opt(2);
- EXPECT_FALSE(opt <= 1);
- }
-}
-
-TEST(OptionalTest, ValueLessEq_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(opt <= 0.0);
-}
-
-TEST(OptionalTest, LessEqValue_Empty) {
- Optional<int> opt;
- EXPECT_FALSE(1 <= opt);
-}
-
-TEST(OptionalTest, LessEqValue_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_FALSE(1 <= opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(1 <= opt);
- }
- {
- Optional<int> opt(2);
- EXPECT_TRUE(1 <= opt);
- }
-}
-
-TEST(OptionalTest, LessEqValue_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(0.0 <= opt);
-}
-
-TEST(OptionalTest, ValueGreater_Empty) {
- Optional<int> opt;
- EXPECT_FALSE(opt > 1);
-}
-
-TEST(OptionalTest, ValueGreater_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_FALSE(opt > 1);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(opt > 1);
- }
- {
- Optional<int> opt(2);
- EXPECT_TRUE(opt > 1);
- }
-}
-
-TEST(OptionalTest, ValueGreater_DifferentType) {
- Optional<int> opt(0);
- EXPECT_FALSE(opt > 0.0);
-}
-
-TEST(OptionalTest, GreaterValue_Empty) {
- Optional<int> opt;
- EXPECT_TRUE(1 > opt);
-}
-
-TEST(OptionalTest, GreaterValue_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_TRUE(1 > opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_FALSE(1 > opt);
- }
- {
- Optional<int> opt(2);
- EXPECT_FALSE(1 > opt);
- }
-}
-
-TEST(OptionalTest, GreaterValue_DifferentType) {
- Optional<int> opt(0);
- EXPECT_FALSE(0.0 > opt);
-}
-
-TEST(OptionalTest, ValueGreaterEq_Empty) {
- Optional<int> opt;
- EXPECT_FALSE(opt >= 1);
-}
-
-TEST(OptionalTest, ValueGreaterEq_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_FALSE(opt >= 1);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(opt >= 1);
- }
- {
- Optional<int> opt(2);
- EXPECT_TRUE(opt >= 1);
- }
-}
-
-TEST(OptionalTest, ValueGreaterEq_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(opt <= 0.0);
-}
-
-TEST(OptionalTest, GreaterEqValue_Empty) {
- Optional<int> opt;
- EXPECT_TRUE(1 >= opt);
-}
-
-TEST(OptionalTest, GreaterEqValue_NotEmpty) {
- {
- Optional<int> opt(0);
- EXPECT_TRUE(1 >= opt);
- }
- {
- Optional<int> opt(1);
- EXPECT_TRUE(1 >= opt);
- }
- {
- Optional<int> opt(2);
- EXPECT_FALSE(1 >= opt);
- }
-}
-
-TEST(OptionalTest, GreaterEqValue_DifferentType) {
- Optional<int> opt(0);
- EXPECT_TRUE(0.0 >= opt);
-}
-
-TEST(OptionalTest, NotEquals) {
- {
- Optional<float> a(0.1f);
- Optional<float> b(0.2f);
- EXPECT_NE(a, b);
- }
-
- {
- Optional<std::string> a("foo");
- Optional<std::string> b("bar");
- EXPECT_NE(a, b);
- }
-
- {
- Optional<int> a(1);
- Optional<double> b(2);
- EXPECT_NE(a, b);
- }
-
- {
- Optional<TestObject> a(TestObject(3, 0.1));
- Optional<TestObject> b(TestObject(4, 1.0));
- EXPECT_TRUE(a != b);
- }
-}
-
-TEST(OptionalTest, NotEqualsNull) {
- {
- Optional<float> a(0.1f);
- Optional<float> b(0.1f);
- b = base::nullopt;
- EXPECT_NE(a, b);
- }
-
- {
- Optional<std::string> a("foo");
- Optional<std::string> b("foo");
- b = base::nullopt;
- EXPECT_NE(a, b);
- }
-
- {
- Optional<TestObject> a(TestObject(3, 0.1));
- Optional<TestObject> b(TestObject(3, 0.1));
- b = base::nullopt;
- EXPECT_TRUE(a != b);
- }
-}
-
-TEST(OptionalTest, MakeOptional) {
- {
- Optional<float> o = make_optional(32.f);
- EXPECT_TRUE(o);
- EXPECT_EQ(32.f, *o);
-
- float value = 3.f;
- o = make_optional(std::move(value));
- EXPECT_TRUE(o);
- EXPECT_EQ(3.f, *o);
- }
-
- {
- Optional<std::string> o = make_optional(std::string("foo"));
- EXPECT_TRUE(o);
- EXPECT_EQ("foo", *o);
-
- std::string value = "bar";
- o = make_optional(std::move(value));
- EXPECT_TRUE(o);
- EXPECT_EQ(std::string("bar"), *o);
- }
-
- {
- Optional<TestObject> o = make_optional(TestObject(3, 0.1));
- EXPECT_TRUE(!!o);
- EXPECT_TRUE(TestObject(3, 0.1) == *o);
-
- TestObject value = TestObject(0, 0.42);
- o = make_optional(std::move(value));
- EXPECT_TRUE(!!o);
- EXPECT_TRUE(TestObject(0, 0.42) == *o);
- EXPECT_EQ(TestObject::State::MOVED_FROM, value.state());
- EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, o->state());
-
- EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED,
- base::make_optional(std::move(value))->state());
- }
-
- {
- struct Test {
- Test(int a, double b, bool c) : a(a), b(b), c(c) {}
-
- int a;
- double b;
- bool c;
- };
-
- Optional<Test> o = make_optional<Test>(1, 2.0, true);
- EXPECT_TRUE(!!o);
- EXPECT_EQ(1, o->a);
- EXPECT_EQ(2.0, o->b);
- EXPECT_TRUE(o->c);
- }
-
- {
- auto str1 = make_optional<std::string>({'1', '2', '3'});
- EXPECT_EQ("123", *str1);
-
- auto str2 =
- make_optional<std::string>({'a', 'b', 'c'}, std::allocator<char>());
- EXPECT_EQ("abc", *str2);
- }
-}
-
-TEST(OptionalTest, NonMemberSwap_bothNoValue) {
- Optional<TestObject> a, b;
- base::swap(a, b);
-
- EXPECT_FALSE(!!a);
- EXPECT_FALSE(!!b);
- EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
-}
-
-TEST(OptionalTest, NonMemberSwap_inHasValue) {
- Optional<TestObject> a(TestObject(1, 0.3));
- Optional<TestObject> b;
- base::swap(a, b);
-
- EXPECT_FALSE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
-}
-
-TEST(OptionalTest, NonMemberSwap_outHasValue) {
- Optional<TestObject> a;
- Optional<TestObject> b(TestObject(1, 0.3));
- base::swap(a, b);
-
- EXPECT_TRUE(!!a);
- EXPECT_FALSE(!!b);
- EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
-}
-
-TEST(OptionalTest, NonMemberSwap_bothValue) {
- Optional<TestObject> a(TestObject(0, 0.1));
- Optional<TestObject> b(TestObject(1, 0.3));
- base::swap(a, b);
-
- EXPECT_TRUE(!!a);
- EXPECT_TRUE(!!b);
- EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
- EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
- EXPECT_EQ(TestObject::State::SWAPPED, a->state());
- EXPECT_EQ(TestObject::State::SWAPPED, b->state());
-}
-
-TEST(OptionalTest, Hash_OptionalReflectsInternal) {
- {
- std::hash<int> int_hash;
- std::hash<Optional<int>> opt_int_hash;
-
- EXPECT_EQ(int_hash(1), opt_int_hash(Optional<int>(1)));
- }
-
- {
- std::hash<std::string> str_hash;
- std::hash<Optional<std::string>> opt_str_hash;
-
- EXPECT_EQ(str_hash(std::string("foobar")),
- opt_str_hash(Optional<std::string>(std::string("foobar"))));
- }
-}
-
-TEST(OptionalTest, Hash_NullOptEqualsNullOpt) {
- std::hash<Optional<int>> opt_int_hash;
- std::hash<Optional<std::string>> opt_str_hash;
-
- EXPECT_EQ(opt_str_hash(Optional<std::string>()),
- opt_int_hash(Optional<int>()));
-}
-
-TEST(OptionalTest, Hash_UseInSet) {
- std::set<Optional<int>> setOptInt;
-
- EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
-
- setOptInt.insert(Optional<int>(3));
- EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
- EXPECT_NE(setOptInt.end(), setOptInt.find(3));
-}
-
-TEST(OptionalTest, HasValue) {
- Optional<int> a;
- EXPECT_FALSE(a.has_value());
-
- a = 42;
- EXPECT_TRUE(a.has_value());
-
- a = nullopt;
- EXPECT_FALSE(a.has_value());
-
- a = 0;
- EXPECT_TRUE(a.has_value());
-
- a = Optional<int>();
- EXPECT_FALSE(a.has_value());
-}
-
-TEST(OptionalTest, Reset_int) {
- Optional<int> a(0);
- EXPECT_TRUE(a.has_value());
- EXPECT_EQ(0, a.value());
-
- a.reset();
- EXPECT_FALSE(a.has_value());
- EXPECT_EQ(-1, a.value_or(-1));
-}
-
-TEST(OptionalTest, Reset_Object) {
- Optional<TestObject> a(TestObject(0, 0.1));
- EXPECT_TRUE(a.has_value());
- EXPECT_EQ(TestObject(0, 0.1), a.value());
-
- a.reset();
- EXPECT_FALSE(a.has_value());
- EXPECT_EQ(TestObject(42, 0.0), a.value_or(TestObject(42, 0.0)));
-}
-
-TEST(OptionalTest, Reset_NoOp) {
- Optional<int> a;
- EXPECT_FALSE(a.has_value());
-
- a.reset();
- EXPECT_FALSE(a.has_value());
-}
-
-TEST(OptionalTest, AssignFromRValue) {
- Optional<TestObject> a;
- EXPECT_FALSE(a.has_value());
-
- TestObject obj;
- a = std::move(obj);
- EXPECT_TRUE(a.has_value());
- EXPECT_EQ(1, a->move_ctors_count());
-}
-
-TEST(OptionalTest, DontCallDefaultCtor) {
- Optional<DeletedDefaultConstructor> a;
- EXPECT_FALSE(a.has_value());
-
- a = base::make_optional<DeletedDefaultConstructor>(42);
- EXPECT_TRUE(a.has_value());
- EXPECT_EQ(42, a->foo());
-}
-
-TEST(OptionalTest, DontCallNewMemberFunction) {
- Optional<DeleteNewOperators> a;
- EXPECT_FALSE(a.has_value());
-
- a = DeleteNewOperators();
- EXPECT_TRUE(a.has_value());
-}
-
-TEST(OptionalTest, Noexcept) {
- // Trivial copy ctor, non-trivial move ctor, nothrow move assign.
- struct Test1 {
- Test1(const Test1&) = default;
- Test1(Test1&&) {}
- Test1& operator=(Test1&&) = default;
- };
- // Non-trivial copy ctor, trivial move ctor, throw move assign.
- struct Test2 {
- Test2(const Test2&) {}
- Test2(Test2&&) = default;
- Test2& operator=(Test2&&) { return *this; }
- };
- // Trivial copy ctor, non-trivial nothrow move ctor.
- struct Test3 {
- Test3(const Test3&) = default;
- Test3(Test3&&) noexcept {}
- };
- // Non-trivial copy ctor, non-trivial nothrow move ctor.
- struct Test4 {
- Test4(const Test4&) {}
- Test4(Test4&&) noexcept {}
- };
- // Non-trivial copy ctor, non-trivial move ctor.
- struct Test5 {
- Test5(const Test5&) {}
- Test5(Test5&&) {}
- };
-
- static_assert(
- noexcept(Optional<int>(std::declval<Optional<int>>())),
- "move constructor for noexcept move-constructible T must be noexcept "
- "(trivial copy, trivial move)");
- static_assert(
- !noexcept(Optional<Test1>(std::declval<Optional<Test1>>())),
- "move constructor for non-noexcept move-constructible T must not be "
- "noexcept (trivial copy)");
- static_assert(
- noexcept(Optional<Test2>(std::declval<Optional<Test2>>())),
- "move constructor for noexcept move-constructible T must be noexcept "
- "(non-trivial copy, trivial move)");
- static_assert(
- noexcept(Optional<Test3>(std::declval<Optional<Test3>>())),
- "move constructor for noexcept move-constructible T must be noexcept "
- "(trivial copy, non-trivial move)");
- static_assert(
- noexcept(Optional<Test4>(std::declval<Optional<Test4>>())),
- "move constructor for noexcept move-constructible T must be noexcept "
- "(non-trivial copy, non-trivial move)");
- static_assert(
- !noexcept(Optional<Test5>(std::declval<Optional<Test5>>())),
- "move constructor for non-noexcept move-constructible T must not be "
- "noexcept (non-trivial copy)");
-
- static_assert(
- noexcept(std::declval<Optional<int>>() = std::declval<Optional<int>>()),
- "move assign for noexcept move-constructible/move-assignable T "
- "must be noexcept");
- static_assert(
- !noexcept(std::declval<Optional<Test1>>() =
- std::declval<Optional<Test1>>()),
- "move assign for non-noexcept move-constructible T must not be noexcept");
- static_assert(
- !noexcept(std::declval<Optional<Test2>>() =
- std::declval<Optional<Test2>>()),
- "move assign for non-noexcept move-assignable T must not be noexcept");
-}
-
-} // namespace base
diff --git a/base/optional_unittest.nc b/base/optional_unittest.nc
deleted file mode 100644
index 62c0196..0000000
--- a/base/optional_unittest.nc
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2018 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include <type_traits>
-
-#include "base/optional.h"
-
-namespace base {
-
-#if defined(NCTEST_EXPLICIT_CONVERTING_COPY_CONSTRUCTOR) // [r"fatal error: no matching function for call to object of type"]
-
-// Optional<T>(const Optional<U>& arg) constructor is marked explicit if
-// T is not convertible from "const U&".
-void WontCompile() {
- struct Test {
- // Declares as explicit so that Test is still constructible from int,
- // but not convertible.
- explicit Test(int a) {}
- };
-
- static_assert(!std::is_convertible<const int&, Test>::value,
- "const int& to Test is convertible");
- const Optional<int> arg(in_place, 1);
- ([](Optional<Test> param) {})(arg);
-}
-
-#elif defined(NCTEST_EXPLICIT_CONVERTING_MOVE_CONSTRUCTOR) // [r"fatal error: no matching function for call to object of type"]
-
-// Optional<T>(Optional<U>&& arg) constructor is marked explicit if
-// T is not convertible from "U&&".
-void WontCompile() {
- struct Test {
- // Declares as explicit so that Test is still constructible from int,
- // but not convertible.
- explicit Test(int a) {}
- };
-
- static_assert(!std::is_convertible<int&&, Test>::value,
- "int&& to Test is convertible");
- ([](Optional<Test> param) {})(Optional<int>(in_place, 1));
-}
-
-#elif defined(NCTEST_EXPLICIT_VALUE_FORWARD_CONSTRUCTOR) // [r"fatal error: no matching function for call to object of type"]
-
-// Optional<T>(U&&) constructor is marked explicit if T is not convertible
-// from U&&.
-void WontCompile() {
- struct Test {
- // Declares as explicit so that Test is still constructible from int,
- // but not convertible.
- explicit Test(int a) {}
- };
-
- static_assert(!std::is_convertible<int&&, Test>::value,
- "int&& to Test is convertible");
- ([](Optional<Test> param) {})(1);
-}
-
-#endif
-
-} // namespace base
diff --git a/base/os_compat_android_unittest.cc b/base/os_compat_android_unittest.cc
deleted file mode 100644
index 7fbdc6d..0000000
--- a/base/os_compat_android_unittest.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-// 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.
-
-#include "base/os_compat_android.h"
-
-#include "base/files/file_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-typedef testing::Test OsCompatAndroidTest;
-
-// Keep this Unittest DISABLED_ , because it actually creates a directory in the
-// device and it may be source of flakyness. For any changes in the mkdtemp
-// function, you should run this unittest in your local machine to check if it
-// passes.
-TEST_F(OsCompatAndroidTest, DISABLED_TestMkdTemp) {
- FilePath tmp_dir;
- EXPECT_TRUE(base::GetTempDir(&tmp_dir));
-
- // Not six XXXXXX at the suffix of the path.
- FilePath sub_dir = tmp_dir.Append("XX");
- std::string sub_dir_string = sub_dir.value();
- // this should be OK since mkdtemp just replaces characters in place
- char* buffer = const_cast<char*>(sub_dir_string.c_str());
- EXPECT_EQ(NULL, mkdtemp(buffer));
-
- // Directory does not exist
- char invalid_path2[] = "doesntoexist/foobarXXXXXX";
- EXPECT_EQ(NULL, mkdtemp(invalid_path2));
-
- // Successfully create a tmp dir.
- FilePath sub_dir2 = tmp_dir.Append("XXXXXX");
- std::string sub_dir2_string = sub_dir2.value();
- // this should be OK since mkdtemp just replaces characters in place
- char* buffer2 = const_cast<char*>(sub_dir2_string.c_str());
- EXPECT_TRUE(mkdtemp(buffer2) != NULL);
-}
-
-} // namespace base
diff --git a/base/path_service_unittest.cc b/base/path_service_unittest.cc
deleted file mode 100644
index 378064a..0000000
--- a/base/path_service_unittest.cc
+++ /dev/null
@@ -1,278 +0,0 @@
-// 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.
-
-#include "base/path_service.h"
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/strings/string_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest-spi.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
-
-namespace base {
-
-namespace {
-
-// Returns true if PathService::Get returns true and sets the path parameter
-// to non-empty for the given PathService::DirType enumeration value.
-bool ReturnsValidPath(int dir_type) {
- FilePath path;
- bool result = PathService::Get(dir_type, &path);
-
- // Some paths might not exist on some platforms in which case confirming
- // |result| is true and !path.empty() is the best we can do.
- bool check_path_exists = true;
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
- // If chromium has never been started on this account, the cache path may not
- // exist.
- if (dir_type == DIR_CACHE)
- check_path_exists = false;
-#endif
-#if defined(OS_LINUX)
- // On the linux try-bots: a path is returned (e.g. /home/chrome-bot/Desktop),
- // but it doesn't exist.
- if (dir_type == DIR_USER_DESKTOP)
- check_path_exists = false;
-#endif
-#if defined(OS_IOS)
- // Bundled unittests on iOS may not have Resources directory in the bundle.
- if (dir_type == DIR_ASSETS)
- check_path_exists = false;
-#endif
-#if defined(OS_MACOSX)
- if (dir_type != DIR_EXE && dir_type != DIR_MODULE && dir_type != FILE_EXE &&
- dir_type != FILE_MODULE) {
- if (path.ReferencesParent())
- return false;
- }
-#else
- if (path.ReferencesParent())
- return false;
-#endif
- return result && !path.empty() && (!check_path_exists || PathExists(path));
-}
-
-#if defined(OS_WIN)
-// Function to test any directory keys that are not supported on some versions
-// of Windows. Checks that the function fails and that the returned path is
-// empty.
-bool ReturnsInvalidPath(int dir_type) {
- FilePath path;
- bool result = PathService::Get(dir_type, &path);
- return !result && path.empty();
-}
-#endif
-
-} // namespace
-
-// On the Mac this winds up using some autoreleased objects, so we need to
-// be a PlatformTest.
-typedef PlatformTest PathServiceTest;
-
-// Test that all PathService::Get calls return a value and a true result
-// in the development environment. (This test was created because a few
-// later changes to Get broke the semantics of the function and yielded the
-// correct value while returning false.)
-TEST_F(PathServiceTest, Get) {
- for (int key = PATH_START + 1; key < PATH_END; ++key) {
-#if defined(OS_ANDROID)
- if (key == FILE_MODULE || key == DIR_USER_DESKTOP ||
- key == DIR_HOME)
- continue; // Android doesn't implement these.
-#elif defined(OS_IOS)
- if (key == DIR_USER_DESKTOP)
- continue; // iOS doesn't implement DIR_USER_DESKTOP.
-#elif defined(OS_FUCHSIA)
- if (key == DIR_USER_DESKTOP || key == FILE_MODULE || key == DIR_MODULE)
- continue; // Fuchsia doesn't implement DIR_USER_DESKTOP, FILE_MODULE and
- // DIR_MODULE.
-#endif
- EXPECT_PRED1(ReturnsValidPath, key);
- }
-#if defined(OS_WIN)
- for (int key = PATH_WIN_START + 1; key < PATH_WIN_END; ++key) {
- bool valid = true;
- if (key == DIR_APP_SHORTCUTS)
- valid = base::win::GetVersion() >= base::win::VERSION_WIN8;
-
- if (valid)
- EXPECT_TRUE(ReturnsValidPath(key)) << key;
- else
- EXPECT_TRUE(ReturnsInvalidPath(key)) << key;
- }
-#elif defined(OS_MACOSX)
- for (int key = PATH_MAC_START + 1; key < PATH_MAC_END; ++key) {
- EXPECT_PRED1(ReturnsValidPath, key);
- }
-#elif defined(OS_ANDROID)
- for (int key = PATH_ANDROID_START + 1; key < PATH_ANDROID_END;
- ++key) {
- EXPECT_PRED1(ReturnsValidPath, key);
- }
-#elif defined(OS_POSIX) && !defined(OS_FUCHSIA)
- for (int key = PATH_POSIX_START + 1; key < PATH_POSIX_END;
- ++key) {
- EXPECT_PRED1(ReturnsValidPath, key);
- }
-#endif
-}
-
-// Test that all versions of the Override function of PathService do what they
-// are supposed to do.
-TEST_F(PathServiceTest, Override) {
- int my_special_key = 666;
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath fake_cache_dir(temp_dir.GetPath().AppendASCII("cache"));
- // PathService::Override should always create the path provided if it doesn't
- // exist.
- EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir));
- EXPECT_TRUE(PathExists(fake_cache_dir));
-
- FilePath fake_cache_dir2(temp_dir.GetPath().AppendASCII("cache2"));
- // PathService::OverrideAndCreateIfNeeded should obey the |create| parameter.
- PathService::OverrideAndCreateIfNeeded(my_special_key,
- fake_cache_dir2,
- false,
- false);
- EXPECT_FALSE(PathExists(fake_cache_dir2));
- EXPECT_TRUE(PathService::OverrideAndCreateIfNeeded(my_special_key,
- fake_cache_dir2,
- false,
- true));
- EXPECT_TRUE(PathExists(fake_cache_dir2));
-
-#if defined(OS_POSIX)
- FilePath non_existent(
- MakeAbsoluteFilePath(temp_dir.GetPath()).AppendASCII("non_existent"));
- EXPECT_TRUE(non_existent.IsAbsolute());
- EXPECT_FALSE(PathExists(non_existent));
-#if !defined(OS_ANDROID)
- // This fails because MakeAbsoluteFilePath fails for non-existent files.
- // Earlier versions of Bionic libc don't fail for non-existent files, so
- // skip this check on Android.
- EXPECT_FALSE(PathService::OverrideAndCreateIfNeeded(my_special_key,
- non_existent,
- false,
- false));
-#endif
- // This works because indicating that |non_existent| is absolute skips the
- // internal MakeAbsoluteFilePath call.
- EXPECT_TRUE(PathService::OverrideAndCreateIfNeeded(my_special_key,
- non_existent,
- true,
- false));
- // Check that the path has been overridden and no directory was created.
- EXPECT_FALSE(PathExists(non_existent));
- FilePath path;
- EXPECT_TRUE(PathService::Get(my_special_key, &path));
- EXPECT_EQ(non_existent, path);
-#endif
-}
-
-// Check if multiple overrides can co-exist.
-TEST_F(PathServiceTest, OverrideMultiple) {
- int my_special_key = 666;
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath fake_cache_dir1(temp_dir.GetPath().AppendASCII("1"));
- EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir1));
- EXPECT_TRUE(PathExists(fake_cache_dir1));
- ASSERT_EQ(1, WriteFile(fake_cache_dir1.AppendASCII("t1"), ".", 1));
-
- FilePath fake_cache_dir2(temp_dir.GetPath().AppendASCII("2"));
- EXPECT_TRUE(PathService::Override(my_special_key + 1, fake_cache_dir2));
- EXPECT_TRUE(PathExists(fake_cache_dir2));
- ASSERT_EQ(1, WriteFile(fake_cache_dir2.AppendASCII("t2"), ".", 1));
-
- FilePath result;
- EXPECT_TRUE(PathService::Get(my_special_key, &result));
- // Override might have changed the path representation but our test file
- // should be still there.
- EXPECT_TRUE(PathExists(result.AppendASCII("t1")));
- EXPECT_TRUE(PathService::Get(my_special_key + 1, &result));
- EXPECT_TRUE(PathExists(result.AppendASCII("t2")));
-}
-
-TEST_F(PathServiceTest, RemoveOverride) {
- // Before we start the test we have to call RemoveOverride at least once to
- // clear any overrides that might have been left from other tests.
- PathService::RemoveOverride(DIR_TEMP);
-
- FilePath original_user_data_dir;
- EXPECT_TRUE(PathService::Get(DIR_TEMP, &original_user_data_dir));
- EXPECT_FALSE(PathService::RemoveOverride(DIR_TEMP));
-
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- EXPECT_TRUE(PathService::Override(DIR_TEMP, temp_dir.GetPath()));
- FilePath new_user_data_dir;
- EXPECT_TRUE(PathService::Get(DIR_TEMP, &new_user_data_dir));
- EXPECT_NE(original_user_data_dir, new_user_data_dir);
-
- EXPECT_TRUE(PathService::RemoveOverride(DIR_TEMP));
- EXPECT_TRUE(PathService::Get(DIR_TEMP, &new_user_data_dir));
- EXPECT_EQ(original_user_data_dir, new_user_data_dir);
-}
-
-#if defined(OS_WIN)
-TEST_F(PathServiceTest, GetProgramFiles) {
- FilePath programfiles_dir;
-#if defined(_WIN64)
- // 64-bit on 64-bit.
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files"));
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILESX86,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files (x86)"));
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES6432,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files"));
-#else
- if (base::win::OSInfo::GetInstance()->wow64_status() ==
- base::win::OSInfo::WOW64_ENABLED) {
- // 32-bit on 64-bit.
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files (x86)"));
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILESX86,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files (x86)"));
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES6432,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files"));
- } else {
- // 32-bit on 32-bit.
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files"));
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILESX86,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files"));
- EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES6432,
- &programfiles_dir));
- EXPECT_EQ(programfiles_dir.value(),
- FILE_PATH_LITERAL("C:\\Program Files"));
- }
-#endif
-}
-#endif
-
-} // namespace base
diff --git a/base/pickle_unittest.cc b/base/pickle_unittest.cc
deleted file mode 100644
index 4563047..0000000
--- a/base/pickle_unittest.cc
+++ /dev/null
@@ -1,573 +0,0 @@
-// 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.
-
-#include "base/pickle.h"
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-const bool testbool1 = false;
-const bool testbool2 = true;
-const int testint = 2'093'847'192;
-const long testlong = 1'093'847'192;
-const uint16_t testuint16 = 32123;
-const uint32_t testuint32 = 1593847192;
-const int64_t testint64 = -0x7E8CA925'3104BDFCLL;
-const uint64_t testuint64 = 0xCE8CA925'3104BDF7ULL;
-const float testfloat = 3.1415926935f;
-const double testdouble = 2.71828182845904523;
-const std::string teststring("Hello world"); // note non-aligned string length
-const std::wstring testwstring(L"Hello, world");
-const string16 teststring16(ASCIIToUTF16("Hello, world"));
-const char testrawstring[] = "Hello new world"; // Test raw string writing
-// Test raw char16 writing, assumes UTF16 encoding is ANSI for alpha chars.
-const char16 testrawstring16[] = {'A', 'l', 'o', 'h', 'a', 0};
-const char testdata[] = "AAA\0BBB\0";
-const int testdatalen = arraysize(testdata) - 1;
-
-// checks that the results can be read correctly from the Pickle
-void VerifyResult(const Pickle& pickle) {
- PickleIterator iter(pickle);
-
- bool outbool;
- EXPECT_TRUE(iter.ReadBool(&outbool));
- EXPECT_FALSE(outbool);
- EXPECT_TRUE(iter.ReadBool(&outbool));
- EXPECT_TRUE(outbool);
-
- int outint;
- EXPECT_TRUE(iter.ReadInt(&outint));
- EXPECT_EQ(testint, outint);
-
- long outlong;
- EXPECT_TRUE(iter.ReadLong(&outlong));
- EXPECT_EQ(testlong, outlong);
-
- uint16_t outuint16;
- EXPECT_TRUE(iter.ReadUInt16(&outuint16));
- EXPECT_EQ(testuint16, outuint16);
-
- uint32_t outuint32;
- EXPECT_TRUE(iter.ReadUInt32(&outuint32));
- EXPECT_EQ(testuint32, outuint32);
-
- int64_t outint64;
- EXPECT_TRUE(iter.ReadInt64(&outint64));
- EXPECT_EQ(testint64, outint64);
-
- uint64_t outuint64;
- EXPECT_TRUE(iter.ReadUInt64(&outuint64));
- EXPECT_EQ(testuint64, outuint64);
-
- float outfloat;
- EXPECT_TRUE(iter.ReadFloat(&outfloat));
- EXPECT_EQ(testfloat, outfloat);
-
- double outdouble;
- EXPECT_TRUE(iter.ReadDouble(&outdouble));
- EXPECT_EQ(testdouble, outdouble);
-
- std::string outstring;
- EXPECT_TRUE(iter.ReadString(&outstring));
- EXPECT_EQ(teststring, outstring);
-
- string16 outstring16;
- EXPECT_TRUE(iter.ReadString16(&outstring16));
- EXPECT_EQ(teststring16, outstring16);
-
- StringPiece outstringpiece;
- EXPECT_TRUE(iter.ReadStringPiece(&outstringpiece));
- EXPECT_EQ(testrawstring, outstringpiece);
-
- StringPiece16 outstringpiece16;
- EXPECT_TRUE(iter.ReadStringPiece16(&outstringpiece16));
- EXPECT_EQ(testrawstring16, outstringpiece16);
-
- const char* outdata;
- int outdatalen;
- EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen));
- EXPECT_EQ(testdatalen, outdatalen);
- EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0);
-
- // reads past the end should fail
- EXPECT_FALSE(iter.ReadInt(&outint));
-}
-
-} // namespace
-
-TEST(PickleTest, EncodeDecode) {
- Pickle pickle;
-
- pickle.WriteBool(testbool1);
- pickle.WriteBool(testbool2);
- pickle.WriteInt(testint);
- pickle.WriteLong(testlong);
- pickle.WriteUInt16(testuint16);
- pickle.WriteUInt32(testuint32);
- pickle.WriteInt64(testint64);
- pickle.WriteUInt64(testuint64);
- pickle.WriteFloat(testfloat);
- pickle.WriteDouble(testdouble);
- pickle.WriteString(teststring);
- pickle.WriteString16(teststring16);
- pickle.WriteString(testrawstring);
- pickle.WriteString16(testrawstring16);
- pickle.WriteData(testdata, testdatalen);
- VerifyResult(pickle);
-
- // test copy constructor
- Pickle pickle2(pickle);
- VerifyResult(pickle2);
-
- // test operator=
- Pickle pickle3;
- pickle3 = pickle;
- VerifyResult(pickle3);
-}
-
-// Tests that reading/writing a long works correctly when the source process
-// is 64-bit. We rely on having both 32- and 64-bit trybots to validate both
-// arms of the conditional in this test.
-TEST(PickleTest, LongFrom64Bit) {
- Pickle pickle;
- // Under the hood long is always written as a 64-bit value, so simulate a
- // 64-bit long even on 32-bit architectures by explicitly writing an int64_t.
- pickle.WriteInt64(testint64);
-
- PickleIterator iter(pickle);
- long outlong;
- if (sizeof(long) < sizeof(int64_t)) {
- // ReadLong() should return false when the original written value can't be
- // represented as a long.
-#if GTEST_HAS_DEATH_TEST
- EXPECT_DEATH(ignore_result(iter.ReadLong(&outlong)), "");
-#endif
- } else {
- EXPECT_TRUE(iter.ReadLong(&outlong));
- EXPECT_EQ(testint64, outlong);
- }
-}
-
-// Tests that we can handle really small buffers.
-TEST(PickleTest, SmallBuffer) {
- std::unique_ptr<char[]> buffer(new char[1]);
-
- // We should not touch the buffer.
- Pickle pickle(buffer.get(), 1);
-
- PickleIterator iter(pickle);
- int data;
- EXPECT_FALSE(iter.ReadInt(&data));
-}
-
-// Tests that we can handle improper headers.
-TEST(PickleTest, BigSize) {
- int buffer[] = { 0x56035200, 25, 40, 50 };
-
- Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer));
-
- PickleIterator iter(pickle);
- int data;
- EXPECT_FALSE(iter.ReadInt(&data));
-}
-
-TEST(PickleTest, UnalignedSize) {
- int buffer[] = { 10, 25, 40, 50 };
-
- Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer));
-
- PickleIterator iter(pickle);
- int data;
- EXPECT_FALSE(iter.ReadInt(&data));
-}
-
-TEST(PickleTest, ZeroLenStr) {
- Pickle pickle;
- pickle.WriteString(std::string());
-
- PickleIterator iter(pickle);
- std::string outstr;
- EXPECT_TRUE(iter.ReadString(&outstr));
- EXPECT_EQ("", outstr);
-}
-
-TEST(PickleTest, ZeroLenStr16) {
- Pickle pickle;
- pickle.WriteString16(string16());
-
- PickleIterator iter(pickle);
- std::string outstr;
- EXPECT_TRUE(iter.ReadString(&outstr));
- EXPECT_EQ("", outstr);
-}
-
-TEST(PickleTest, BadLenStr) {
- Pickle pickle;
- pickle.WriteInt(-2);
-
- PickleIterator iter(pickle);
- std::string outstr;
- EXPECT_FALSE(iter.ReadString(&outstr));
-}
-
-TEST(PickleTest, BadLenStr16) {
- Pickle pickle;
- pickle.WriteInt(-1);
-
- PickleIterator iter(pickle);
- string16 outstr;
- EXPECT_FALSE(iter.ReadString16(&outstr));
-}
-
-TEST(PickleTest, PeekNext) {
- struct CustomHeader : base::Pickle::Header {
- int cookies[10];
- };
-
- Pickle pickle(sizeof(CustomHeader));
-
- pickle.WriteString("Goooooooooooogle");
-
- const char* pickle_data = static_cast<const char*>(pickle.data());
-
- size_t pickle_size;
-
- // Data range doesn't contain header
- EXPECT_FALSE(Pickle::PeekNext(
- sizeof(CustomHeader),
- pickle_data,
- pickle_data + sizeof(CustomHeader) - 1,
- &pickle_size));
-
- // Data range contains header
- EXPECT_TRUE(Pickle::PeekNext(
- sizeof(CustomHeader),
- pickle_data,
- pickle_data + sizeof(CustomHeader),
- &pickle_size));
- EXPECT_EQ(pickle_size, pickle.size());
-
- // Data range contains header and some other data
- EXPECT_TRUE(Pickle::PeekNext(
- sizeof(CustomHeader),
- pickle_data,
- pickle_data + sizeof(CustomHeader) + 1,
- &pickle_size));
- EXPECT_EQ(pickle_size, pickle.size());
-
- // Data range contains full pickle
- EXPECT_TRUE(Pickle::PeekNext(
- sizeof(CustomHeader),
- pickle_data,
- pickle_data + pickle.size(),
- &pickle_size));
- EXPECT_EQ(pickle_size, pickle.size());
-}
-
-TEST(PickleTest, PeekNextOverflow) {
- struct CustomHeader : base::Pickle::Header {
- int cookies[10];
- };
-
- CustomHeader header;
-
- // Check if we can wrap around at all
- if (sizeof(size_t) > sizeof(header.payload_size))
- return;
-
- const char* pickle_data = reinterpret_cast<const char*>(&header);
-
- size_t pickle_size;
-
- // Wrapping around is detected and reported as maximum size_t value
- header.payload_size = static_cast<uint32_t>(
- 1 - static_cast<int32_t>(sizeof(CustomHeader)));
- EXPECT_TRUE(Pickle::PeekNext(
- sizeof(CustomHeader),
- pickle_data,
- pickle_data + sizeof(CustomHeader),
- &pickle_size));
- EXPECT_EQ(pickle_size, std::numeric_limits<size_t>::max());
-
- // Ridiculous pickle sizes are fine (callers are supposed to
- // verify them)
- header.payload_size =
- std::numeric_limits<uint32_t>::max() / 2 - sizeof(CustomHeader);
- EXPECT_TRUE(Pickle::PeekNext(
- sizeof(CustomHeader),
- pickle_data,
- pickle_data + sizeof(CustomHeader),
- &pickle_size));
- EXPECT_EQ(pickle_size, std::numeric_limits<uint32_t>::max() / 2);
-}
-
-TEST(PickleTest, FindNext) {
- Pickle pickle;
- pickle.WriteInt(1);
- pickle.WriteString("Domo");
-
- const char* start = reinterpret_cast<const char*>(pickle.data());
- const char* end = start + pickle.size();
-
- EXPECT_EQ(end, Pickle::FindNext(pickle.header_size_, start, end));
- EXPECT_EQ(nullptr, Pickle::FindNext(pickle.header_size_, start, end - 1));
- EXPECT_EQ(end, Pickle::FindNext(pickle.header_size_, start, end + 1));
-}
-
-TEST(PickleTest, FindNextWithIncompleteHeader) {
- size_t header_size = sizeof(Pickle::Header);
- std::unique_ptr<char[]> buffer(new char[header_size - 1]);
- memset(buffer.get(), 0x1, header_size - 1);
-
- const char* start = buffer.get();
- const char* end = start + header_size - 1;
-
- EXPECT_EQ(nullptr, Pickle::FindNext(header_size, start, end));
-}
-
-#if defined(COMPILER_MSVC)
-#pragma warning(push)
-#pragma warning(disable: 4146)
-#endif
-TEST(PickleTest, FindNextOverflow) {
- size_t header_size = sizeof(Pickle::Header);
- size_t header_size2 = 2 * header_size;
- size_t payload_received = 100;
- std::unique_ptr<char[]> buffer(new char[header_size2 + payload_received]);
- const char* start = buffer.get();
- Pickle::Header* header = reinterpret_cast<Pickle::Header*>(buffer.get());
- const char* end = start + header_size2 + payload_received;
- // It is impossible to construct an overflow test otherwise.
- if (sizeof(size_t) > sizeof(header->payload_size) ||
- sizeof(uintptr_t) > sizeof(header->payload_size))
- return;
-
- header->payload_size = -(reinterpret_cast<uintptr_t>(start) + header_size2);
- EXPECT_EQ(nullptr, Pickle::FindNext(header_size2, start, end));
-
- header->payload_size = -header_size2;
- EXPECT_EQ(nullptr, Pickle::FindNext(header_size2, start, end));
-
- header->payload_size = 0;
- end = start + header_size;
- EXPECT_EQ(nullptr, Pickle::FindNext(header_size2, start, end));
-}
-#if defined(COMPILER_MSVC)
-#pragma warning(pop)
-#endif
-
-TEST(PickleTest, GetReadPointerAndAdvance) {
- Pickle pickle;
-
- PickleIterator iter(pickle);
- EXPECT_FALSE(iter.GetReadPointerAndAdvance(1));
-
- pickle.WriteInt(1);
- pickle.WriteInt(2);
- int bytes = sizeof(int) * 2;
-
- EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(0));
- EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(1));
- EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(-1));
- EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes));
- EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes + 1));
- EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MAX));
- EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MIN));
-}
-
-TEST(PickleTest, Resize) {
- size_t unit = Pickle::kPayloadUnit;
- std::unique_ptr<char[]> data(new char[unit]);
- char* data_ptr = data.get();
- for (size_t i = 0; i < unit; i++)
- data_ptr[i] = 'G';
-
- // construct a message that will be exactly the size of one payload unit,
- // note that any data will have a 4-byte header indicating the size
- const size_t payload_size_after_header = unit - sizeof(uint32_t);
- Pickle pickle;
- pickle.WriteData(
- data_ptr, static_cast<int>(payload_size_after_header - sizeof(uint32_t)));
- size_t cur_payload = payload_size_after_header;
-
- // note: we assume 'unit' is a power of 2
- EXPECT_EQ(unit, pickle.capacity_after_header());
- EXPECT_EQ(pickle.payload_size(), payload_size_after_header);
-
- // fill out a full page (noting data header)
- pickle.WriteData(data_ptr, static_cast<int>(unit - sizeof(uint32_t)));
- cur_payload += unit;
- EXPECT_EQ(unit * 2, pickle.capacity_after_header());
- EXPECT_EQ(cur_payload, pickle.payload_size());
-
- // one more byte should double the capacity
- pickle.WriteData(data_ptr, 1);
- cur_payload += 8;
- EXPECT_EQ(unit * 4, pickle.capacity_after_header());
- EXPECT_EQ(cur_payload, pickle.payload_size());
-}
-
-namespace {
-
-struct CustomHeader : Pickle::Header {
- int blah;
-};
-
-} // namespace
-
-TEST(PickleTest, HeaderPadding) {
- const uint32_t kMagic = 0x12345678;
-
- Pickle pickle(sizeof(CustomHeader));
- pickle.WriteInt(kMagic);
-
- // this should not overwrite the 'int' payload
- pickle.headerT<CustomHeader>()->blah = 10;
-
- PickleIterator iter(pickle);
- int result;
- ASSERT_TRUE(iter.ReadInt(&result));
-
- EXPECT_EQ(static_cast<uint32_t>(result), kMagic);
-}
-
-TEST(PickleTest, EqualsOperator) {
- Pickle source;
- source.WriteInt(1);
-
- Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()),
- source.size());
- Pickle copy;
- copy = copy_refs_source_buffer;
- ASSERT_EQ(source.size(), copy.size());
-}
-
-TEST(PickleTest, EvilLengths) {
- Pickle source;
- std::string str(100000, 'A');
- source.WriteData(str.c_str(), 100000);
- // ReadString16 used to have its read buffer length calculation wrong leading
- // to out-of-bounds reading.
- PickleIterator iter(source);
- string16 str16;
- EXPECT_FALSE(iter.ReadString16(&str16));
-
- // And check we didn't break ReadString16.
- str16 = (wchar_t) 'A';
- Pickle str16_pickle;
- str16_pickle.WriteString16(str16);
- iter = PickleIterator(str16_pickle);
- EXPECT_TRUE(iter.ReadString16(&str16));
- EXPECT_EQ(1U, str16.length());
-
- // Check we don't fail in a length check with invalid String16 size.
- // (1<<31) * sizeof(char16) == 0, so this is particularly evil.
- Pickle bad_len;
- bad_len.WriteInt(1 << 31);
- iter = PickleIterator(bad_len);
- EXPECT_FALSE(iter.ReadString16(&str16));
-}
-
-// Check we can write zero bytes of data and 'data' can be NULL.
-TEST(PickleTest, ZeroLength) {
- Pickle pickle;
- pickle.WriteData(nullptr, 0);
-
- PickleIterator iter(pickle);
- const char* outdata;
- int outdatalen;
- EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen));
- EXPECT_EQ(0, outdatalen);
- // We can't assert that outdata is NULL.
-}
-
-// Check that ReadBytes works properly with an iterator initialized to NULL.
-TEST(PickleTest, ReadBytes) {
- Pickle pickle;
- int data = 0x7abcd;
- pickle.WriteBytes(&data, sizeof(data));
-
- PickleIterator iter(pickle);
- const char* outdata_char = nullptr;
- EXPECT_TRUE(iter.ReadBytes(&outdata_char, sizeof(data)));
-
- int outdata;
- memcpy(&outdata, outdata_char, sizeof(outdata));
- EXPECT_EQ(data, outdata);
-}
-
-// Checks that when a pickle is deep-copied, the result is not larger than
-// needed.
-TEST(PickleTest, DeepCopyResize) {
- Pickle pickle;
- while (pickle.capacity_after_header() != pickle.payload_size())
- pickle.WriteBool(true);
-
- // Make a deep copy.
- Pickle pickle2(pickle);
-
- // Check that there isn't any extraneous capacity.
- EXPECT_EQ(pickle.capacity_after_header(), pickle2.capacity_after_header());
-}
-
-namespace {
-
-// Publicly exposes the ClaimBytes interface for testing.
-class TestingPickle : public Pickle {
- public:
- TestingPickle() = default;
-
- void* ClaimBytes(size_t num_bytes) { return Pickle::ClaimBytes(num_bytes); }
-};
-
-} // namespace
-
-// Checks that claimed bytes are zero-initialized.
-TEST(PickleTest, ClaimBytesInitialization) {
- static const int kChunkSize = 64;
- TestingPickle pickle;
- const char* bytes = static_cast<const char*>(pickle.ClaimBytes(kChunkSize));
- for (size_t i = 0; i < kChunkSize; ++i) {
- EXPECT_EQ(0, bytes[i]);
- }
-}
-
-// Checks that ClaimBytes properly advances the write offset.
-TEST(PickleTest, ClaimBytes) {
- std::string data("Hello, world!");
-
- TestingPickle pickle;
- pickle.WriteUInt32(data.size());
- void* bytes = pickle.ClaimBytes(data.size());
- pickle.WriteInt(42);
- memcpy(bytes, data.data(), data.size());
-
- PickleIterator iter(pickle);
- uint32_t out_data_length;
- EXPECT_TRUE(iter.ReadUInt32(&out_data_length));
- EXPECT_EQ(data.size(), out_data_length);
-
- const char* out_data = nullptr;
- EXPECT_TRUE(iter.ReadBytes(&out_data, out_data_length));
- EXPECT_EQ(data, std::string(out_data, out_data_length));
-
- int out_value;
- EXPECT_TRUE(iter.ReadInt(&out_value));
- EXPECT_EQ(42, out_value);
-}
-
-} // namespace base
diff --git a/base/posix/file_descriptor_shuffle_unittest.cc b/base/posix/file_descriptor_shuffle_unittest.cc
deleted file mode 100644
index 3dfbf7e..0000000
--- a/base/posix/file_descriptor_shuffle_unittest.cc
+++ /dev/null
@@ -1,281 +0,0 @@
-// 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.
-
-#include "base/posix/file_descriptor_shuffle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-// 'Duplicated' file descriptors start at this number
-const int kDuplicateBase = 1000;
-
-} // namespace
-
-namespace base {
-
-struct Action {
- enum Type {
- CLOSE,
- MOVE,
- DUPLICATE,
- };
-
- Action(Type in_type, int in_fd1, int in_fd2 = -1)
- : type(in_type),
- fd1(in_fd1),
- fd2(in_fd2) {
- }
-
- bool operator==(const Action& other) const {
- return other.type == type &&
- other.fd1 == fd1 &&
- other.fd2 == fd2;
- }
-
- Type type;
- int fd1;
- int fd2;
-};
-
-class InjectionTracer : public InjectionDelegate {
- public:
- InjectionTracer()
- : next_duplicate_(kDuplicateBase) {
- }
-
- bool Duplicate(int* result, int fd) override {
- *result = next_duplicate_++;
- actions_.push_back(Action(Action::DUPLICATE, *result, fd));
- return true;
- }
-
- bool Move(int src, int dest) override {
- actions_.push_back(Action(Action::MOVE, src, dest));
- return true;
- }
-
- void Close(int fd) override { actions_.push_back(Action(Action::CLOSE, fd)); }
-
- const std::vector<Action>& actions() const { return actions_; }
-
- private:
- int next_duplicate_;
- std::vector<Action> actions_;
-};
-
-TEST(FileDescriptorShuffleTest, Empty) {
- InjectiveMultimap map;
- InjectionTracer tracer;
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- EXPECT_EQ(0u, tracer.actions().size());
-}
-
-TEST(FileDescriptorShuffleTest, Noop) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 0, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- EXPECT_EQ(0u, tracer.actions().size());
-}
-
-TEST(FileDescriptorShuffleTest, NoopAndClose) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 0, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- EXPECT_EQ(0u, tracer.actions().size());
-}
-
-TEST(FileDescriptorShuffleTest, Simple1) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(1u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
-}
-
-TEST(FileDescriptorShuffleTest, Simple2) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, false));
- map.push_back(InjectionArc(2, 3, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(2u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 2, 3));
-}
-
-TEST(FileDescriptorShuffleTest, Simple3) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(2u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::CLOSE, 0));
-}
-
-TEST(FileDescriptorShuffleTest, Simple4) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(10, 0, true));
- map.push_back(InjectionArc(1, 1, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(2u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 10, 0));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::CLOSE, 10));
-}
-
-TEST(FileDescriptorShuffleTest, Cycle) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, false));
- map.push_back(InjectionArc(1, 0, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(4u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] ==
- Action(Action::DUPLICATE, kDuplicateBase, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::MOVE, kDuplicateBase, 0));
- EXPECT_TRUE(tracer.actions()[3] == Action(Action::CLOSE, kDuplicateBase));
-}
-
-TEST(FileDescriptorShuffleTest, CycleAndClose1) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, true));
- map.push_back(InjectionArc(1, 0, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(4u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] ==
- Action(Action::DUPLICATE, kDuplicateBase, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::MOVE, kDuplicateBase, 0));
- EXPECT_TRUE(tracer.actions()[3] == Action(Action::CLOSE, kDuplicateBase));
-}
-
-TEST(FileDescriptorShuffleTest, CycleAndClose2) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, false));
- map.push_back(InjectionArc(1, 0, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(4u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] ==
- Action(Action::DUPLICATE, kDuplicateBase, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::MOVE, kDuplicateBase, 0));
- EXPECT_TRUE(tracer.actions()[3] == Action(Action::CLOSE, kDuplicateBase));
-}
-
-TEST(FileDescriptorShuffleTest, CycleAndClose3) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, true));
- map.push_back(InjectionArc(1, 0, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(4u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] ==
- Action(Action::DUPLICATE, kDuplicateBase, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::MOVE, kDuplicateBase, 0));
- EXPECT_TRUE(tracer.actions()[3] == Action(Action::CLOSE, kDuplicateBase));
-}
-
-TEST(FileDescriptorShuffleTest, Fanout) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, false));
- map.push_back(InjectionArc(0, 2, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(2u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 2));
-}
-
-TEST(FileDescriptorShuffleTest, FanoutAndClose1) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, true));
- map.push_back(InjectionArc(0, 2, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(3u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 2));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::CLOSE, 0));
-}
-
-TEST(FileDescriptorShuffleTest, FanoutAndClose2) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, false));
- map.push_back(InjectionArc(0, 2, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(3u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 2));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::CLOSE, 0));
-}
-
-TEST(FileDescriptorShuffleTest, FanoutAndClose3) {
- InjectiveMultimap map;
- InjectionTracer tracer;
- map.push_back(InjectionArc(0, 1, true));
- map.push_back(InjectionArc(0, 2, true));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
- ASSERT_EQ(3u, tracer.actions().size());
- EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
- EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 2));
- EXPECT_TRUE(tracer.actions()[2] == Action(Action::CLOSE, 0));
-}
-
-class FailingDelegate : public InjectionDelegate {
- public:
- bool Duplicate(int* result, int fd) override { return false; }
-
- bool Move(int src, int dest) override { return false; }
-
- void Close(int fd) override {}
-};
-
-TEST(FileDescriptorShuffleTest, EmptyWithFailure) {
- InjectiveMultimap map;
- FailingDelegate failing;
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &failing));
-}
-
-TEST(FileDescriptorShuffleTest, NoopWithFailure) {
- InjectiveMultimap map;
- FailingDelegate failing;
- map.push_back(InjectionArc(0, 0, false));
-
- EXPECT_TRUE(PerformInjectiveMultimap(map, &failing));
-}
-
-TEST(FileDescriptorShuffleTest, Simple1WithFailure) {
- InjectiveMultimap map;
- FailingDelegate failing;
- map.push_back(InjectionArc(0, 1, false));
-
- EXPECT_FALSE(PerformInjectiveMultimap(map, &failing));
-}
-
-} // namespace base
diff --git a/base/posix/unix_domain_socket_unittest.cc b/base/posix/unix_domain_socket_unittest.cc
deleted file mode 100644
index f626de5..0000000
--- a/base/posix/unix_domain_socket_unittest.cc
+++ /dev/null
@@ -1,183 +0,0 @@
-// 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 "build_config.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/location.h"
-#include "base/pickle.h"
-#include "base/posix/unix_domain_socket.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Callers should use ASSERT_NO_FATAL_FAILURE with this function, to
-// ensure that execution is aborted if the function has assertion failure.
-void CreateSocketPair(int fds[2]) {
-#if defined(OS_MACOSX)
- // Mac OS does not support SOCK_SEQPACKET.
- int flags = SOCK_STREAM;
-#else
- int flags = SOCK_SEQPACKET;
-#endif
- ASSERT_EQ(0, socketpair(AF_UNIX, flags, 0, fds));
-#if defined(OS_MACOSX)
- // On OSX an attempt to read or write to a closed socket may generate a
- // SIGPIPE rather than returning -1, corrected with SO_NOSIGPIPE option.
- int nosigpipe = 1;
- ASSERT_EQ(0, setsockopt(fds[0], SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe,
- sizeof(nosigpipe)));
- ASSERT_EQ(0, setsockopt(fds[1], SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe,
- sizeof(nosigpipe)));
-#endif
-}
-
-TEST(UnixDomainSocketTest, SendRecvMsgAbortOnReplyFDClose) {
- Thread message_thread("UnixDomainSocketTest");
- ASSERT_TRUE(message_thread.Start());
- int fds[2];
- ASSERT_NO_FATAL_FAILURE(CreateSocketPair(fds));
- ScopedFD scoped_fd0(fds[0]);
- ScopedFD scoped_fd1(fds[1]);
-
- // Have the thread send a synchronous message via the socket.
- Pickle request;
- message_thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(IgnoreResult(&UnixDomainSocket::SendRecvMsg), fds[1],
- nullptr, 0U, nullptr, request));
-
- // Receive the message.
- std::vector<ScopedFD> message_fds;
- uint8_t buffer[16];
- ASSERT_EQ(
- static_cast<int>(request.size()),
- UnixDomainSocket::RecvMsg(fds[0], buffer, sizeof(buffer), &message_fds));
- ASSERT_EQ(1U, message_fds.size());
-
- // Close the reply FD.
- message_fds.clear();
-
- // Check that the thread didn't get blocked.
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- message_thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&event)));
- ASSERT_TRUE(event.TimedWait(TimeDelta::FromMilliseconds(5000)));
-}
-
-TEST(UnixDomainSocketTest, SendRecvMsgAvoidsSIGPIPE) {
- // Make sure SIGPIPE isn't being ignored.
- struct sigaction act = {}, oldact;
- act.sa_handler = SIG_DFL;
- ASSERT_EQ(0, sigaction(SIGPIPE, &act, &oldact));
- int fds[2];
- ASSERT_NO_FATAL_FAILURE(CreateSocketPair(fds));
- ScopedFD scoped_fd1(fds[1]);
- ASSERT_EQ(0, IGNORE_EINTR(close(fds[0])));
-
- // Have the thread send a synchronous message via the socket. Unless the
- // message is sent with MSG_NOSIGNAL, this shall result in SIGPIPE.
- Pickle request;
- ASSERT_EQ(
- -1, UnixDomainSocket::SendRecvMsg(fds[1], nullptr, 0U, nullptr, request));
- ASSERT_EQ(EPIPE, errno);
- // Restore the SIGPIPE handler.
- ASSERT_EQ(0, sigaction(SIGPIPE, &oldact, nullptr));
-}
-
-// Simple sanity check within a single process that receiving PIDs works.
-TEST(UnixDomainSocketTest, RecvPid) {
- int fds[2];
- ASSERT_NO_FATAL_FAILURE(CreateSocketPair(fds));
- ScopedFD recv_sock(fds[0]);
- ScopedFD send_sock(fds[1]);
-
- ASSERT_TRUE(UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
-
- static const char kHello[] = "hello";
- ASSERT_TRUE(UnixDomainSocket::SendMsg(send_sock.get(), kHello, sizeof(kHello),
- std::vector<int>()));
-
- // Extra receiving buffer space to make sure we really received only
- // sizeof(kHello) bytes and it wasn't just truncated to fit the buffer.
- char buf[sizeof(kHello) + 1];
- ProcessId sender_pid;
- std::vector<ScopedFD> fd_vec;
- const ssize_t nread = UnixDomainSocket::RecvMsgWithPid(
- recv_sock.get(), buf, sizeof(buf), &fd_vec, &sender_pid);
- ASSERT_EQ(sizeof(kHello), static_cast<size_t>(nread));
- ASSERT_EQ(0, memcmp(buf, kHello, sizeof(kHello)));
- ASSERT_EQ(0U, fd_vec.size());
-
- ASSERT_EQ(getpid(), sender_pid);
-}
-
-// Same as above, but send the max number of file descriptors too.
-TEST(UnixDomainSocketTest, RecvPidWithMaxDescriptors) {
- int fds[2];
- ASSERT_NO_FATAL_FAILURE(CreateSocketPair(fds));
- ScopedFD recv_sock(fds[0]);
- ScopedFD send_sock(fds[1]);
-
- ASSERT_TRUE(UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
-
- static const char kHello[] = "hello";
- std::vector<int> send_fds(UnixDomainSocket::kMaxFileDescriptors,
- send_sock.get());
- ASSERT_TRUE(UnixDomainSocket::SendMsg(send_sock.get(), kHello, sizeof(kHello),
- send_fds));
-
- // Extra receiving buffer space to make sure we really received only
- // sizeof(kHello) bytes and it wasn't just truncated to fit the buffer.
- char buf[sizeof(kHello) + 1];
- ProcessId sender_pid;
- std::vector<ScopedFD> recv_fds;
- const ssize_t nread = UnixDomainSocket::RecvMsgWithPid(
- recv_sock.get(), buf, sizeof(buf), &recv_fds, &sender_pid);
- ASSERT_EQ(sizeof(kHello), static_cast<size_t>(nread));
- ASSERT_EQ(0, memcmp(buf, kHello, sizeof(kHello)));
- ASSERT_EQ(UnixDomainSocket::kMaxFileDescriptors, recv_fds.size());
-
- ASSERT_EQ(getpid(), sender_pid);
-}
-
-// Check that RecvMsgWithPid doesn't DCHECK fail when reading EOF from a
-// disconnected socket.
-TEST(UnixDomianSocketTest, RecvPidDisconnectedSocket) {
- int fds[2];
- ASSERT_NO_FATAL_FAILURE(CreateSocketPair(fds));
- ScopedFD recv_sock(fds[0]);
- ScopedFD send_sock(fds[1]);
-
- ASSERT_TRUE(UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
-
- send_sock.reset();
-
- char ch;
- ProcessId sender_pid;
- std::vector<ScopedFD> recv_fds;
- const ssize_t nread = UnixDomainSocket::RecvMsgWithPid(
- recv_sock.get(), &ch, sizeof(ch), &recv_fds, &sender_pid);
- ASSERT_EQ(0, nread);
- ASSERT_EQ(-1, sender_pid);
- ASSERT_EQ(0U, recv_fds.size());
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/power_monitor/power_monitor_unittest.cc b/base/power_monitor/power_monitor_unittest.cc
deleted file mode 100644
index 7f2a84b..0000000
--- a/base/power_monitor/power_monitor_unittest.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 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 "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/power_monitor/power_monitor.h"
-#include "base/test/power_monitor_test_base.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-class PowerMonitorTest : public testing::Test {
- protected:
- PowerMonitorTest() {
- power_monitor_source_ = new PowerMonitorTestSource();
- power_monitor_.reset(new PowerMonitor(
- std::unique_ptr<PowerMonitorSource>(power_monitor_source_)));
- }
- ~PowerMonitorTest() override = default;
-
- PowerMonitorTestSource* source() { return power_monitor_source_; }
- PowerMonitor* monitor() { return power_monitor_.get(); }
-
- private:
- base::MessageLoop message_loop_;
- PowerMonitorTestSource* power_monitor_source_;
- std::unique_ptr<PowerMonitor> power_monitor_;
-
- DISALLOW_COPY_AND_ASSIGN(PowerMonitorTest);
-};
-
-// PowerMonitorSource is tightly coupled with the PowerMonitor, so this test
-// Will cover both classes
-TEST_F(PowerMonitorTest, PowerNotifications) {
- const int kObservers = 5;
-
- PowerMonitorTestObserver observers[kObservers];
- for (int index = 0; index < kObservers; ++index)
- monitor()->AddObserver(&observers[index]);
-
- // Sending resume when not suspended should have no effect.
- source()->GenerateResumeEvent();
- EXPECT_EQ(observers[0].resumes(), 0);
-
- // Pretend we suspended.
- source()->GenerateSuspendEvent();
- // Ensure all observers were notified of the event
- for (int index = 0; index < kObservers; ++index)
- EXPECT_EQ(observers[index].suspends(), 1);
-
- // Send a second suspend notification. This should be suppressed.
- source()->GenerateSuspendEvent();
- EXPECT_EQ(observers[0].suspends(), 1);
-
- // Pretend we were awakened.
- source()->GenerateResumeEvent();
- EXPECT_EQ(observers[0].resumes(), 1);
-
- // Send a duplicate resume notification. This should be suppressed.
- source()->GenerateResumeEvent();
- EXPECT_EQ(observers[0].resumes(), 1);
-
- // Pretend the device has gone on battery power
- source()->GeneratePowerStateEvent(true);
- EXPECT_EQ(observers[0].power_state_changes(), 1);
- EXPECT_EQ(observers[0].last_power_state(), true);
-
- // Repeated indications the device is on battery power should be suppressed.
- source()->GeneratePowerStateEvent(true);
- EXPECT_EQ(observers[0].power_state_changes(), 1);
-
- // Pretend the device has gone off battery power
- source()->GeneratePowerStateEvent(false);
- EXPECT_EQ(observers[0].power_state_changes(), 2);
- EXPECT_EQ(observers[0].last_power_state(), false);
-
- // Repeated indications the device is off battery power should be suppressed.
- source()->GeneratePowerStateEvent(false);
- EXPECT_EQ(observers[0].power_state_changes(), 2);
-}
-
-} // namespace base
diff --git a/base/process/memory_unittest.cc b/base/process/memory_unittest.cc
deleted file mode 100644
index 3a565ee..0000000
--- a/base/process/memory_unittest.cc
+++ /dev/null
@@ -1,91 +0,0 @@
-// 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.
-
-#define _CRT_SECURE_NO_WARNINGS
-
-#include "base/process/memory.h"
-
-#include <stddef.h>
-
-#include <limits>
-
-#include "base/allocator/allocator_check.h"
-#include "base/compiler_specific.h"
-#include "base/debug/alias.h"
-#include "base/memory/aligned_memory.h"
-#include "base/strings/stringprintf.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-#if defined(OS_POSIX)
-#include <errno.h>
-#endif
-#if defined(OS_MACOSX)
-#include <malloc/malloc.h>
-#include "base/allocator/allocator_interception_mac.h"
-#include "base/allocator/allocator_shim.h"
-#include "base/process/memory_unittest_mac.h"
-#endif
-#if defined(OS_LINUX)
-#include <malloc.h>
-#include "base/test/malloc_wrapper.h"
-#endif
-
-#if defined(OS_WIN)
-
-#if defined(COMPILER_MSVC)
-// ssize_t needed for OutOfMemoryTest.
-#if defined(_WIN64)
-typedef __int64 ssize_t;
-#else
-typedef long ssize_t;
-#endif
-#endif
-
-// HeapQueryInformation function pointer.
-typedef BOOL (WINAPI* HeapQueryFn) \
- (HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T);
-
-#endif // defined(OS_WIN)
-
-#if defined(OS_MACOSX)
-
-// For the following Mac tests:
-// Note that base::EnableTerminationOnHeapCorruption() is called as part of
-// test suite setup and does not need to be done again, else mach_override
-// will fail.
-
-TEST(ProcessMemoryTest, MacTerminateOnHeapCorruption) {
- // Assert that freeing an unallocated pointer will crash the process.
- char buf[9];
- asm("" : "=r" (buf)); // Prevent clang from being too smart.
-#if ARCH_CPU_64_BITS
- // On 64 bit Macs, the malloc system automatically abort()s on heap corruption
- // but does not output anything.
- ASSERT_DEATH(free(buf), "");
-#elif defined(ADDRESS_SANITIZER)
- // AddressSanitizer replaces malloc() and prints a different error message on
- // heap corruption.
- ASSERT_DEATH(free(buf), "attempting free on address which "
- "was not malloc\\(\\)-ed");
-#else
- ADD_FAILURE() << "This test is not supported in this build configuration.";
-#endif
-}
-
-#endif // defined(OS_MACOSX)
-
-TEST(MemoryTest, AllocatorShimWorking) {
-#if defined(OS_MACOSX)
- base::allocator::InterceptAllocationsMac();
-#endif
- ASSERT_TRUE(base::allocator::IsAllocatorInitialized());
-
-#if defined(OS_MACOSX)
- base::allocator::UninterceptMallocZonesForTesting();
-#endif
-}
diff --git a/base/process/process_info_unittest.cc b/base/process/process_info_unittest.cc
deleted file mode 100644
index 51b15b9..0000000
--- a/base/process/process_info_unittest.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2017 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 "base/process/process_info.h"
-
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// See https://crbug.com/726484 for Fuchsia.
-// Cannot read boot time on Android O, crbug.com/788870.
-#if !defined(OS_IOS) && !defined(OS_FUCHSIA) && !defined(OS_ANDROID)
-TEST(ProcessInfoTest, CreationTime) {
- Time creation_time = CurrentProcessInfo::CreationTime();
- ASSERT_FALSE(creation_time.is_null());
-}
-#endif // !defined(OS_IOS) && !defined(OS_FUCHSIA) && !defined(OS_ANDROID)
-
-} // namespace base
diff --git a/base/process/process_metrics_unittest.cc b/base/process/process_metrics_unittest.cc
deleted file mode 100644
index aec7be1..0000000
--- a/base/process/process_metrics_unittest.cc
+++ /dev/null
@@ -1,633 +0,0 @@
-// Copyright 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 "base/process/process_metrics.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/command_line.h"
-#include "base/files/file.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/sys_info.h"
-#include "base/test/multiprocess_test.h"
-#include "base/threading/thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-#if defined(OS_MACOSX)
-#include <sys/mman.h>
-#endif
-
-namespace base {
-namespace debug {
-
-#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_WIN)
-namespace {
-
-void BusyWork(std::vector<std::string>* vec) {
- int64_t test_value = 0;
- for (int i = 0; i < 100000; ++i) {
- ++test_value;
- vec->push_back(Int64ToString(test_value));
- }
-}
-
-} // namespace
-#endif // defined(OS_LINUX) || defined(OS_CHROMEOS)
-
-// Tests for SystemMetrics.
-// Exists as a class so it can be a friend of SystemMetrics.
-class SystemMetricsTest : public testing::Test {
- public:
- SystemMetricsTest() = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SystemMetricsTest);
-};
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-TEST_F(SystemMetricsTest, IsValidDiskName) {
- const char invalid_input1[] = "";
- const char invalid_input2[] = "s";
- const char invalid_input3[] = "sdz+";
- const char invalid_input4[] = "hda0";
- const char invalid_input5[] = "mmcbl";
- const char invalid_input6[] = "mmcblka";
- const char invalid_input7[] = "mmcblkb";
- const char invalid_input8[] = "mmmblk0";
-
- EXPECT_FALSE(IsValidDiskName(invalid_input1));
- EXPECT_FALSE(IsValidDiskName(invalid_input2));
- EXPECT_FALSE(IsValidDiskName(invalid_input3));
- EXPECT_FALSE(IsValidDiskName(invalid_input4));
- EXPECT_FALSE(IsValidDiskName(invalid_input5));
- EXPECT_FALSE(IsValidDiskName(invalid_input6));
- EXPECT_FALSE(IsValidDiskName(invalid_input7));
- EXPECT_FALSE(IsValidDiskName(invalid_input8));
-
- const char valid_input1[] = "sda";
- const char valid_input2[] = "sdaaaa";
- const char valid_input3[] = "hdz";
- const char valid_input4[] = "mmcblk0";
- const char valid_input5[] = "mmcblk999";
-
- EXPECT_TRUE(IsValidDiskName(valid_input1));
- EXPECT_TRUE(IsValidDiskName(valid_input2));
- EXPECT_TRUE(IsValidDiskName(valid_input3));
- EXPECT_TRUE(IsValidDiskName(valid_input4));
- EXPECT_TRUE(IsValidDiskName(valid_input5));
-}
-
-TEST_F(SystemMetricsTest, ParseMeminfo) {
- SystemMemoryInfoKB meminfo;
- const char invalid_input1[] = "abc";
- const char invalid_input2[] = "MemTotal:";
- // Partial file with no MemTotal
- const char invalid_input3[] =
- "MemFree: 3913968 kB\n"
- "Buffers: 2348340 kB\n"
- "Cached: 49071596 kB\n"
- "SwapCached: 12 kB\n"
- "Active: 36393900 kB\n"
- "Inactive: 21221496 kB\n"
- "Active(anon): 5674352 kB\n"
- "Inactive(anon): 633992 kB\n";
- EXPECT_FALSE(ParseProcMeminfo(invalid_input1, &meminfo));
- EXPECT_FALSE(ParseProcMeminfo(invalid_input2, &meminfo));
- EXPECT_FALSE(ParseProcMeminfo(invalid_input3, &meminfo));
-
- const char valid_input1[] =
- "MemTotal: 3981504 kB\n"
- "MemFree: 140764 kB\n"
- "MemAvailable: 535413 kB\n"
- "Buffers: 116480 kB\n"
- "Cached: 406160 kB\n"
- "SwapCached: 21304 kB\n"
- "Active: 3152040 kB\n"
- "Inactive: 472856 kB\n"
- "Active(anon): 2972352 kB\n"
- "Inactive(anon): 270108 kB\n"
- "Active(file): 179688 kB\n"
- "Inactive(file): 202748 kB\n"
- "Unevictable: 0 kB\n"
- "Mlocked: 0 kB\n"
- "SwapTotal: 5832280 kB\n"
- "SwapFree: 3672368 kB\n"
- "Dirty: 184 kB\n"
- "Writeback: 0 kB\n"
- "AnonPages: 3101224 kB\n"
- "Mapped: 142296 kB\n"
- "Shmem: 140204 kB\n"
- "Slab: 54212 kB\n"
- "SReclaimable: 30936 kB\n"
- "SUnreclaim: 23276 kB\n"
- "KernelStack: 2464 kB\n"
- "PageTables: 24812 kB\n"
- "NFS_Unstable: 0 kB\n"
- "Bounce: 0 kB\n"
- "WritebackTmp: 0 kB\n"
- "CommitLimit: 7823032 kB\n"
- "Committed_AS: 7973536 kB\n"
- "VmallocTotal: 34359738367 kB\n"
- "VmallocUsed: 375940 kB\n"
- "VmallocChunk: 34359361127 kB\n"
- "DirectMap4k: 72448 kB\n"
- "DirectMap2M: 4061184 kB\n";
- // output from a much older kernel where the Active and Inactive aren't
- // broken down into anon and file and Huge Pages are enabled
- const char valid_input2[] =
- "MemTotal: 255908 kB\n"
- "MemFree: 69936 kB\n"
- "Buffers: 15812 kB\n"
- "Cached: 115124 kB\n"
- "SwapCached: 0 kB\n"
- "Active: 92700 kB\n"
- "Inactive: 63792 kB\n"
- "HighTotal: 0 kB\n"
- "HighFree: 0 kB\n"
- "LowTotal: 255908 kB\n"
- "LowFree: 69936 kB\n"
- "SwapTotal: 524280 kB\n"
- "SwapFree: 524200 kB\n"
- "Dirty: 4 kB\n"
- "Writeback: 0 kB\n"
- "Mapped: 42236 kB\n"
- "Slab: 25912 kB\n"
- "Committed_AS: 118680 kB\n"
- "PageTables: 1236 kB\n"
- "VmallocTotal: 3874808 kB\n"
- "VmallocUsed: 1416 kB\n"
- "VmallocChunk: 3872908 kB\n"
- "HugePages_Total: 0\n"
- "HugePages_Free: 0\n"
- "Hugepagesize: 4096 kB\n";
-
- EXPECT_TRUE(ParseProcMeminfo(valid_input1, &meminfo));
- EXPECT_EQ(meminfo.total, 3981504);
- EXPECT_EQ(meminfo.free, 140764);
- EXPECT_EQ(meminfo.available, 535413);
- EXPECT_EQ(meminfo.buffers, 116480);
- EXPECT_EQ(meminfo.cached, 406160);
- EXPECT_EQ(meminfo.active_anon, 2972352);
- EXPECT_EQ(meminfo.active_file, 179688);
- EXPECT_EQ(meminfo.inactive_anon, 270108);
- EXPECT_EQ(meminfo.inactive_file, 202748);
- EXPECT_EQ(meminfo.swap_total, 5832280);
- EXPECT_EQ(meminfo.swap_free, 3672368);
- EXPECT_EQ(meminfo.dirty, 184);
- EXPECT_EQ(meminfo.reclaimable, 30936);
-#if defined(OS_CHROMEOS)
- EXPECT_EQ(meminfo.shmem, 140204);
- EXPECT_EQ(meminfo.slab, 54212);
-#endif
- EXPECT_EQ(355725,
- base::SysInfo::AmountOfAvailablePhysicalMemory(meminfo) / 1024);
- // Simulate as if there is no MemAvailable.
- meminfo.available = 0;
- EXPECT_EQ(374448,
- base::SysInfo::AmountOfAvailablePhysicalMemory(meminfo) / 1024);
- meminfo = {};
- EXPECT_TRUE(ParseProcMeminfo(valid_input2, &meminfo));
- EXPECT_EQ(meminfo.total, 255908);
- EXPECT_EQ(meminfo.free, 69936);
- EXPECT_EQ(meminfo.available, 0);
- EXPECT_EQ(meminfo.buffers, 15812);
- EXPECT_EQ(meminfo.cached, 115124);
- EXPECT_EQ(meminfo.swap_total, 524280);
- EXPECT_EQ(meminfo.swap_free, 524200);
- EXPECT_EQ(meminfo.dirty, 4);
- EXPECT_EQ(69936,
- base::SysInfo::AmountOfAvailablePhysicalMemory(meminfo) / 1024);
-}
-
-TEST_F(SystemMetricsTest, ParseVmstat) {
- VmStatInfo vmstat;
- // part of vmstat from a 3.2 kernel with numa enabled
- const char valid_input1[] =
- "nr_free_pages 905104\n"
- "nr_inactive_anon 142478"
- "nr_active_anon 1520046\n"
- "nr_inactive_file 4481001\n"
- "nr_active_file 8313439\n"
- "nr_unevictable 5044\n"
- "nr_mlock 5044\n"
- "nr_anon_pages 1633780\n"
- "nr_mapped 104742\n"
- "nr_file_pages 12828218\n"
- "nr_dirty 245\n"
- "nr_writeback 0\n"
- "nr_slab_reclaimable 831609\n"
- "nr_slab_unreclaimable 41164\n"
- "nr_page_table_pages 31470\n"
- "nr_kernel_stack 1735\n"
- "nr_unstable 0\n"
- "nr_bounce 0\n"
- "nr_vmscan_write 406\n"
- "nr_vmscan_immediate_reclaim 281\n"
- "nr_writeback_temp 0\n"
- "nr_isolated_anon 0\n"
- "nr_isolated_file 0\n"
- "nr_shmem 28820\n"
- "nr_dirtied 84674644\n"
- "nr_written 75307109\n"
- "nr_anon_transparent_hugepages 0\n"
- "nr_dirty_threshold 1536206\n"
- "nr_dirty_background_threshold 768103\n"
- "pgpgin 30777108\n"
- "pgpgout 319023278\n"
- "pswpin 179\n"
- "pswpout 406\n"
- "pgalloc_dma 0\n"
- "pgalloc_dma32 20833399\n"
- "pgalloc_normal 1622609290\n"
- "pgalloc_movable 0\n"
- "pgfree 1644355583\n"
- "pgactivate 75391882\n"
- "pgdeactivate 4121019\n"
- "pgfault 2542879679\n"
- "pgmajfault 487192\n";
- const char valid_input2[] =
- "nr_free_pages 180125\n"
- "nr_inactive_anon 51\n"
- "nr_active_anon 38832\n"
- "nr_inactive_file 50171\n"
- "nr_active_file 47510\n"
- "nr_unevictable 0\n"
- "nr_mlock 0\n"
- "nr_anon_pages 38825\n"
- "nr_mapped 24043\n"
- "nr_file_pages 97733\n"
- "nr_dirty 0\n"
- "nr_writeback 0\n"
- "nr_slab_reclaimable 4032\n"
- "nr_slab_unreclaimable 2848\n"
- "nr_page_table_pages 1505\n"
- "nr_kernel_stack 626\n"
- "nr_unstable 0\n"
- "nr_bounce 0\n"
- "nr_vmscan_write 0\n"
- "nr_vmscan_immediate_reclaim 0\n"
- "nr_writeback_temp 0\n"
- "nr_isolated_anon 0\n"
- "nr_isolated_file 0\n"
- "nr_shmem 58\n"
- "nr_dirtied 435358\n"
- "nr_written 401258\n"
- "nr_anon_transparent_hugepages 0\n"
- "nr_dirty_threshold 18566\n"
- "nr_dirty_background_threshold 4641\n"
- "pgpgin 299464\n"
- "pgpgout 2437788\n"
- "pswpin 12\n"
- "pswpout 901\n"
- "pgalloc_normal 144213030\n"
- "pgalloc_high 164501274\n"
- "pgalloc_movable 0\n"
- "pgfree 308894908\n"
- "pgactivate 239320\n"
- "pgdeactivate 1\n"
- "pgfault 716044601\n"
- "pgmajfault 2023\n"
- "pgrefill_normal 0\n"
- "pgrefill_high 0\n"
- "pgrefill_movable 0\n";
- EXPECT_TRUE(ParseProcVmstat(valid_input1, &vmstat));
- EXPECT_EQ(179LU, vmstat.pswpin);
- EXPECT_EQ(406LU, vmstat.pswpout);
- EXPECT_EQ(487192LU, vmstat.pgmajfault);
- EXPECT_TRUE(ParseProcVmstat(valid_input2, &vmstat));
- EXPECT_EQ(12LU, vmstat.pswpin);
- EXPECT_EQ(901LU, vmstat.pswpout);
- EXPECT_EQ(2023LU, vmstat.pgmajfault);
-
- const char missing_pgmajfault_input[] =
- "pswpin 12\n"
- "pswpout 901\n";
- EXPECT_FALSE(ParseProcVmstat(missing_pgmajfault_input, &vmstat));
- const char empty_input[] = "";
- EXPECT_FALSE(ParseProcVmstat(empty_input, &vmstat));
-}
-#endif // defined(OS_LINUX) || defined(OS_ANDROID)
-
-#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_WIN)
-
-// Test that ProcessMetrics::GetPlatformIndependentCPUUsage() doesn't return
-// negative values when the number of threads running on the process decreases
-// between two successive calls to it.
-TEST_F(SystemMetricsTest, TestNoNegativeCpuUsage) {
- ProcessHandle handle = GetCurrentProcessHandle();
- std::unique_ptr<ProcessMetrics> metrics(
- ProcessMetrics::CreateProcessMetrics(handle));
-
- EXPECT_GE(metrics->GetPlatformIndependentCPUUsage(), 0.0);
- Thread thread1("thread1");
- Thread thread2("thread2");
- Thread thread3("thread3");
-
- thread1.StartAndWaitForTesting();
- thread2.StartAndWaitForTesting();
- thread3.StartAndWaitForTesting();
-
- ASSERT_TRUE(thread1.IsRunning());
- ASSERT_TRUE(thread2.IsRunning());
- ASSERT_TRUE(thread3.IsRunning());
-
- std::vector<std::string> vec1;
- std::vector<std::string> vec2;
- std::vector<std::string> vec3;
-
- thread1.task_runner()->PostTask(FROM_HERE, BindOnce(&BusyWork, &vec1));
- thread2.task_runner()->PostTask(FROM_HERE, BindOnce(&BusyWork, &vec2));
- thread3.task_runner()->PostTask(FROM_HERE, BindOnce(&BusyWork, &vec3));
-
- TimeDelta prev_cpu_usage = metrics->GetCumulativeCPUUsage();
- EXPECT_GE(prev_cpu_usage, TimeDelta());
- EXPECT_GE(metrics->GetPlatformIndependentCPUUsage(), 0.0);
-
- thread1.Stop();
- TimeDelta current_cpu_usage = metrics->GetCumulativeCPUUsage();
- EXPECT_GE(current_cpu_usage, prev_cpu_usage);
- prev_cpu_usage = current_cpu_usage;
- EXPECT_GE(metrics->GetPlatformIndependentCPUUsage(), 0.0);
-
- thread2.Stop();
- current_cpu_usage = metrics->GetCumulativeCPUUsage();
- EXPECT_GE(current_cpu_usage, prev_cpu_usage);
- prev_cpu_usage = current_cpu_usage;
- EXPECT_GE(metrics->GetPlatformIndependentCPUUsage(), 0.0);
-
- thread3.Stop();
- current_cpu_usage = metrics->GetCumulativeCPUUsage();
- EXPECT_GE(current_cpu_usage, prev_cpu_usage);
- EXPECT_GE(metrics->GetPlatformIndependentCPUUsage(), 0.0);
-}
-
-#endif // defined(OS_LINUX) || defined(OS_CHROMEOS)
-
-#if defined(OS_CHROMEOS)
-TEST_F(SystemMetricsTest, ParseZramMmStat) {
- SwapInfo swapinfo;
-
- const char invalid_input1[] = "aaa";
- const char invalid_input2[] = "1 2 3 4 5 6";
- const char invalid_input3[] = "a 2 3 4 5 6 7";
- EXPECT_FALSE(ParseZramMmStat(invalid_input1, &swapinfo));
- EXPECT_FALSE(ParseZramMmStat(invalid_input2, &swapinfo));
- EXPECT_FALSE(ParseZramMmStat(invalid_input3, &swapinfo));
-
- const char valid_input1[] =
- "17715200 5008166 566062 0 1225715712 127 183842";
- EXPECT_TRUE(ParseZramMmStat(valid_input1, &swapinfo));
- EXPECT_EQ(17715200ULL, swapinfo.orig_data_size);
- EXPECT_EQ(5008166ULL, swapinfo.compr_data_size);
- EXPECT_EQ(566062ULL, swapinfo.mem_used_total);
-}
-
-TEST_F(SystemMetricsTest, ParseZramStat) {
- SwapInfo swapinfo;
-
- const char invalid_input1[] = "aaa";
- const char invalid_input2[] = "1 2 3 4 5 6 7 8 9 10";
- const char invalid_input3[] = "a 2 3 4 5 6 7 8 9 10 11";
- EXPECT_FALSE(ParseZramStat(invalid_input1, &swapinfo));
- EXPECT_FALSE(ParseZramStat(invalid_input2, &swapinfo));
- EXPECT_FALSE(ParseZramStat(invalid_input3, &swapinfo));
-
- const char valid_input1[] =
- "299 0 2392 0 1 0 8 0 0 0 0";
- EXPECT_TRUE(ParseZramStat(valid_input1, &swapinfo));
- EXPECT_EQ(299ULL, swapinfo.num_reads);
- EXPECT_EQ(1ULL, swapinfo.num_writes);
-}
-#endif // defined(OS_CHROMEOS)
-
-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || \
- defined(OS_ANDROID)
-TEST(SystemMetrics2Test, GetSystemMemoryInfo) {
- SystemMemoryInfoKB info;
- EXPECT_TRUE(GetSystemMemoryInfo(&info));
-
- // Ensure each field received a value.
- EXPECT_GT(info.total, 0);
-#if defined(OS_WIN)
- EXPECT_GT(info.avail_phys, 0);
-#else
- EXPECT_GT(info.free, 0);
-#endif
-#if defined(OS_LINUX) || defined(OS_ANDROID)
- EXPECT_GT(info.buffers, 0);
- EXPECT_GT(info.cached, 0);
- EXPECT_GT(info.active_anon, 0);
- EXPECT_GT(info.inactive_anon, 0);
- EXPECT_GT(info.active_file, 0);
- EXPECT_GT(info.inactive_file, 0);
-#endif // defined(OS_LINUX) || defined(OS_ANDROID)
-
- // All the values should be less than the total amount of memory.
-#if !defined(OS_WIN) && !defined(OS_IOS)
- // TODO(crbug.com/711450): re-enable the following assertion on iOS.
- EXPECT_LT(info.free, info.total);
-#endif
-#if defined(OS_LINUX) || defined(OS_ANDROID)
- EXPECT_LT(info.buffers, info.total);
- EXPECT_LT(info.cached, info.total);
- EXPECT_LT(info.active_anon, info.total);
- EXPECT_LT(info.inactive_anon, info.total);
- EXPECT_LT(info.active_file, info.total);
- EXPECT_LT(info.inactive_file, info.total);
-#endif // defined(OS_LINUX) || defined(OS_ANDROID)
-
-#if defined(OS_MACOSX) || defined(OS_IOS)
- EXPECT_GT(info.file_backed, 0);
-#endif
-
-#if defined(OS_CHROMEOS)
- // Chrome OS exposes shmem.
- EXPECT_GT(info.shmem, 0);
- EXPECT_LT(info.shmem, info.total);
- // Chrome unit tests are not run on actual Chrome OS hardware, so gem_objects
- // and gem_size cannot be tested here.
-#endif
-}
-#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ||
- // defined(OS_ANDROID)
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-TEST(ProcessMetricsTest, ParseProcStatCPU) {
- // /proc/self/stat for a process running "top".
- const char kTopStat[] = "960 (top) S 16230 960 16230 34818 960 "
- "4202496 471 0 0 0 "
- "12 16 0 0 " // <- These are the goods.
- "20 0 1 0 121946157 15077376 314 18446744073709551615 4194304 "
- "4246868 140733983044336 18446744073709551615 140244213071219 "
- "0 0 0 138047495 0 0 0 17 1 0 0 0 0 0";
- EXPECT_EQ(12 + 16, ParseProcStatCPU(kTopStat));
-
- // cat /proc/self/stat on a random other machine I have.
- const char kSelfStat[] = "5364 (cat) R 5354 5364 5354 34819 5364 "
- "0 142 0 0 0 "
- "0 0 0 0 " // <- No CPU, apparently.
- "16 0 1 0 1676099790 2957312 114 4294967295 134512640 134528148 "
- "3221224832 3221224344 3086339742 0 0 0 0 0 0 0 17 0 0 0";
-
- EXPECT_EQ(0, ParseProcStatCPU(kSelfStat));
-
- // Some weird long-running process with a weird name that I created for the
- // purposes of this test.
- const char kWeirdNameStat[] = "26115 (Hello) You ())) ) R 24614 26115 24614"
- " 34839 26115 4218880 227 0 0 0 "
- "5186 11 0 0 "
- "20 0 1 0 36933953 4296704 90 18446744073709551615 4194304 4196116 "
- "140735857761568 140735857761160 4195644 0 0 0 0 0 0 0 17 14 0 0 0 0 0 "
- "6295056 6295616 16519168 140735857770710 140735857770737 "
- "140735857770737 140735857774557 0";
- EXPECT_EQ(5186 + 11, ParseProcStatCPU(kWeirdNameStat));
-}
-#endif // defined(OS_LINUX) || defined(OS_ANDROID)
-
-// Disable on Android because base_unittests runs inside a Dalvik VM that
-// starts and stop threads (crbug.com/175563).
-#if defined(OS_LINUX)
-// http://crbug.com/396455
-TEST(ProcessMetricsTest, DISABLED_GetNumberOfThreads) {
- const ProcessHandle current = GetCurrentProcessHandle();
- const int initial_threads = GetNumberOfThreads(current);
- ASSERT_GT(initial_threads, 0);
- const int kNumAdditionalThreads = 10;
- {
- std::unique_ptr<Thread> my_threads[kNumAdditionalThreads];
- for (int i = 0; i < kNumAdditionalThreads; ++i) {
- my_threads[i].reset(new Thread("GetNumberOfThreadsTest"));
- my_threads[i]->Start();
- ASSERT_EQ(GetNumberOfThreads(current), initial_threads + 1 + i);
- }
- }
- // The Thread destructor will stop them.
- ASSERT_EQ(initial_threads, GetNumberOfThreads(current));
-}
-#endif // defined(OS_LINUX)
-
-#if defined(OS_LINUX)
-namespace {
-
-// Keep these in sync so the GetChildOpenFdCount test can refer to correct test
-// main.
-#define ChildMain ChildFdCount
-#define ChildMainString "ChildFdCount"
-
-// Command line flag name and file name used for synchronization.
-const char kTempDirFlag[] = "temp-dir";
-const char kSignalClosed[] = "closed";
-
-bool SignalEvent(const FilePath& signal_dir, const char* signal_file) {
- File file(signal_dir.AppendASCII(signal_file),
- File::FLAG_CREATE | File::FLAG_WRITE);
- return file.IsValid();
-}
-
-// Check whether an event was signaled.
-bool CheckEvent(const FilePath& signal_dir, const char* signal_file) {
- File file(signal_dir.AppendASCII(signal_file),
- File::FLAG_OPEN | File::FLAG_READ);
- return file.IsValid();
-}
-
-// Busy-wait for an event to be signaled.
-void WaitForEvent(const FilePath& signal_dir, const char* signal_file) {
- while (!CheckEvent(signal_dir, signal_file))
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
-}
-
-// Subprocess to test the number of open file descriptors.
-MULTIPROCESS_TEST_MAIN(ChildMain) {
- CommandLine* command_line = CommandLine::ForCurrentProcess();
- const FilePath temp_path = command_line->GetSwitchValuePath(kTempDirFlag);
- CHECK(DirectoryExists(temp_path));
-
- // Try to close all the file descriptors, so the open count goes to 0.
- for (size_t i = 0; i < 1000; ++i)
- close(i);
- CHECK(SignalEvent(temp_path, kSignalClosed));
-
- // Wait to be terminated.
- while (true)
- PlatformThread::Sleep(TimeDelta::FromSeconds(1));
- return 0;
-}
-
-} // namespace
-
-TEST(ProcessMetricsTest, GetChildOpenFdCount) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- const FilePath temp_path = temp_dir.GetPath();
- CommandLine child_command_line(GetMultiProcessTestChildBaseCommandLine());
- child_command_line.AppendSwitchPath(kTempDirFlag, temp_path);
- Process child = SpawnMultiProcessTestChild(
- ChildMainString, child_command_line, LaunchOptions());
- ASSERT_TRUE(child.IsValid());
- WaitForEvent(temp_path, kSignalClosed);
-
- std::unique_ptr<ProcessMetrics> metrics(
- ProcessMetrics::CreateProcessMetrics(child.Handle()));
- EXPECT_EQ(0, metrics->GetOpenFdCount());
- ASSERT_TRUE(child.Terminate(0, true));
-}
-#endif // defined(OS_LINUX)
-
-#if defined(OS_ANDROID) || defined(OS_LINUX)
-
-TEST(ProcessMetricsTest, GetOpenFdCount) {
- std::unique_ptr<base::ProcessMetrics> metrics(
- base::ProcessMetrics::CreateProcessMetrics(
- base::GetCurrentProcessHandle()));
- int fd_count = metrics->GetOpenFdCount();
- EXPECT_GT(fd_count, 0);
- ScopedFILE file(fopen("/proc/self/statm", "r"));
- EXPECT_TRUE(file);
- int new_fd_count = metrics->GetOpenFdCount();
- EXPECT_GT(new_fd_count, 0);
- EXPECT_EQ(new_fd_count, fd_count + 1);
-}
-
-TEST(ProcessMetricsTestLinux, GetPageFaultCounts) {
- std::unique_ptr<base::ProcessMetrics> process_metrics(
- base::ProcessMetrics::CreateProcessMetrics(
- base::GetCurrentProcessHandle()));
-
- PageFaultCounts counts;
- ASSERT_TRUE(process_metrics->GetPageFaultCounts(&counts));
- ASSERT_GT(counts.minor, 0);
- ASSERT_GE(counts.major, 0);
-
- {
- // Allocate and touch memory. Touching it is required to make sure that the
- // page fault count goes up, as memory is typically mapped lazily.
- const size_t kMappedSize = 4 * (1 << 20);
- SharedMemory memory;
- ASSERT_TRUE(memory.CreateAndMapAnonymous(kMappedSize));
- memset(memory.memory(), 42, kMappedSize);
- memory.Unmap();
- }
-
- PageFaultCounts counts_after;
- ASSERT_TRUE(process_metrics->GetPageFaultCounts(&counts_after));
- ASSERT_GT(counts_after.minor, counts.minor);
- ASSERT_GE(counts_after.major, counts.major);
-}
-#endif // defined(OS_ANDROID) || defined(OS_LINUX)
-
-} // namespace debug
-} // namespace base
diff --git a/base/process/process_unittest.cc b/base/process/process_unittest.cc
deleted file mode 100644
index 0f05d24..0000000
--- a/base/process/process_unittest.cc
+++ /dev/null
@@ -1,330 +0,0 @@
-// Copyright 2014 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 "base/process/process.h"
-
-#include <utility>
-
-#include "base/at_exit.h"
-#include "base/process/kill.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace {
-
-#if defined(OS_WIN)
-const int kExpectedStillRunningExitCode = 0x102;
-#else
-const int kExpectedStillRunningExitCode = 0;
-#endif
-
-#if defined(OS_MACOSX)
-// Fake port provider that returns the calling process's
-// task port, ignoring its argument.
-class FakePortProvider : public base::PortProvider {
- mach_port_t TaskForPid(base::ProcessHandle process) const override {
- return mach_task_self();
- }
-};
-#endif
-
-} // namespace
-
-namespace base {
-
-class ProcessTest : public MultiProcessTest {
-};
-
-TEST_F(ProcessTest, Create) {
- Process process(SpawnChild("SimpleChildProcess"));
- ASSERT_TRUE(process.IsValid());
- ASSERT_FALSE(process.is_current());
- EXPECT_NE(process.Pid(), kNullProcessId);
- process.Close();
- ASSERT_FALSE(process.IsValid());
-}
-
-TEST_F(ProcessTest, CreateCurrent) {
- Process process = Process::Current();
- ASSERT_TRUE(process.IsValid());
- ASSERT_TRUE(process.is_current());
- EXPECT_NE(process.Pid(), kNullProcessId);
- process.Close();
- ASSERT_FALSE(process.IsValid());
-}
-
-TEST_F(ProcessTest, Move) {
- Process process1(SpawnChild("SimpleChildProcess"));
- EXPECT_TRUE(process1.IsValid());
-
- Process process2;
- EXPECT_FALSE(process2.IsValid());
-
- process2 = std::move(process1);
- EXPECT_TRUE(process2.IsValid());
- EXPECT_FALSE(process1.IsValid());
- EXPECT_FALSE(process2.is_current());
-
- Process process3 = Process::Current();
- process2 = std::move(process3);
- EXPECT_TRUE(process2.is_current());
- EXPECT_TRUE(process2.IsValid());
- EXPECT_FALSE(process3.IsValid());
-}
-
-TEST_F(ProcessTest, Duplicate) {
- Process process1(SpawnChild("SimpleChildProcess"));
- ASSERT_TRUE(process1.IsValid());
-
- Process process2 = process1.Duplicate();
- ASSERT_TRUE(process1.IsValid());
- ASSERT_TRUE(process2.IsValid());
- EXPECT_EQ(process1.Pid(), process2.Pid());
- EXPECT_FALSE(process1.is_current());
- EXPECT_FALSE(process2.is_current());
-
- process1.Close();
- ASSERT_TRUE(process2.IsValid());
-}
-
-TEST_F(ProcessTest, DuplicateCurrent) {
- Process process1 = Process::Current();
- ASSERT_TRUE(process1.IsValid());
-
- Process process2 = process1.Duplicate();
- ASSERT_TRUE(process1.IsValid());
- ASSERT_TRUE(process2.IsValid());
- EXPECT_EQ(process1.Pid(), process2.Pid());
- EXPECT_TRUE(process1.is_current());
- EXPECT_TRUE(process2.is_current());
-
- process1.Close();
- ASSERT_TRUE(process2.IsValid());
-}
-
-TEST_F(ProcessTest, DeprecatedGetProcessFromHandle) {
- Process process1(SpawnChild("SimpleChildProcess"));
- ASSERT_TRUE(process1.IsValid());
-
- Process process2 = Process::DeprecatedGetProcessFromHandle(process1.Handle());
- ASSERT_TRUE(process1.IsValid());
- ASSERT_TRUE(process2.IsValid());
- EXPECT_EQ(process1.Pid(), process2.Pid());
- EXPECT_FALSE(process1.is_current());
- EXPECT_FALSE(process2.is_current());
-
- process1.Close();
- ASSERT_TRUE(process2.IsValid());
-}
-
-MULTIPROCESS_TEST_MAIN(SleepyChildProcess) {
- PlatformThread::Sleep(TestTimeouts::action_max_timeout());
- return 0;
-}
-
-TEST_F(ProcessTest, Terminate) {
- Process process(SpawnChild("SleepyChildProcess"));
- ASSERT_TRUE(process.IsValid());
-
- const int kDummyExitCode = 42;
- int exit_code = kDummyExitCode;
- EXPECT_EQ(TERMINATION_STATUS_STILL_RUNNING,
- GetTerminationStatus(process.Handle(), &exit_code));
- EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
-
- exit_code = kDummyExitCode;
- int kExpectedExitCode = 250;
- process.Terminate(kExpectedExitCode, false);
- process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
- &exit_code);
-
- EXPECT_NE(TERMINATION_STATUS_STILL_RUNNING,
- GetTerminationStatus(process.Handle(), &exit_code));
-#if !defined(OS_POSIX) && !defined(OS_FUCHSIA)
- // The POSIX implementation actually ignores the exit_code.
- EXPECT_EQ(kExpectedExitCode, exit_code);
-#endif
-}
-
-void AtExitHandler(void*) {
- // At-exit handler should not be called at
- // Process::TerminateCurrentProcessImmediately.
- DCHECK(false);
-}
-
-class ThreadLocalObject {
- ~ThreadLocalObject() {
- // Thread-local storage should not be destructed at
- // Process::TerminateCurrentProcessImmediately.
- DCHECK(false);
- }
-};
-
-MULTIPROCESS_TEST_MAIN(TerminateCurrentProcessImmediatelyWithCode0) {
- base::ThreadLocalPointer<ThreadLocalObject> object;
- base::AtExitManager::RegisterCallback(&AtExitHandler, nullptr);
- Process::TerminateCurrentProcessImmediately(0);
-}
-
-TEST_F(ProcessTest, TerminateCurrentProcessImmediatelyWithZeroExitCode) {
- Process process(SpawnChild("TerminateCurrentProcessImmediatelyWithCode0"));
- ASSERT_TRUE(process.IsValid());
- int exit_code = 42;
- ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
- &exit_code));
- EXPECT_EQ(0, exit_code);
-}
-
-MULTIPROCESS_TEST_MAIN(TerminateCurrentProcessImmediatelyWithCode250) {
- Process::TerminateCurrentProcessImmediately(250);
-}
-
-TEST_F(ProcessTest, TerminateCurrentProcessImmediatelyWithNonZeroExitCode) {
- Process process(SpawnChild("TerminateCurrentProcessImmediatelyWithCode250"));
- ASSERT_TRUE(process.IsValid());
- int exit_code = 42;
- ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
- &exit_code));
- EXPECT_EQ(250, exit_code);
-}
-
-MULTIPROCESS_TEST_MAIN(FastSleepyChildProcess) {
- PlatformThread::Sleep(TestTimeouts::tiny_timeout() * 10);
- return 0;
-}
-
-TEST_F(ProcessTest, WaitForExit) {
- Process process(SpawnChild("FastSleepyChildProcess"));
- ASSERT_TRUE(process.IsValid());
-
- const int kDummyExitCode = 42;
- int exit_code = kDummyExitCode;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_EQ(0, exit_code);
-}
-
-TEST_F(ProcessTest, WaitForExitWithTimeout) {
- Process process(SpawnChild("SleepyChildProcess"));
- ASSERT_TRUE(process.IsValid());
-
- const int kDummyExitCode = 42;
- int exit_code = kDummyExitCode;
- TimeDelta timeout = TestTimeouts::tiny_timeout();
- EXPECT_FALSE(process.WaitForExitWithTimeout(timeout, &exit_code));
- EXPECT_EQ(kDummyExitCode, exit_code);
-
- process.Terminate(kDummyExitCode, false);
-}
-
-// Ensure that the priority of a process is restored correctly after
-// backgrounding and restoring.
-// Note: a platform may not be willing or able to lower the priority of
-// a process. The calls to SetProcessBackground should be noops then.
-TEST_F(ProcessTest, SetProcessBackgrounded) {
- if (!Process::CanBackgroundProcesses())
- return;
- Process process(SpawnChild("SimpleChildProcess"));
- int old_priority = process.GetPriority();
-#if defined(OS_WIN)
- EXPECT_TRUE(process.SetProcessBackgrounded(true));
- EXPECT_TRUE(process.IsProcessBackgrounded());
- EXPECT_TRUE(process.SetProcessBackgrounded(false));
- EXPECT_FALSE(process.IsProcessBackgrounded());
-#elif defined(OS_MACOSX)
- // On the Mac, backgrounding a process requires a port to that process.
- // In the browser it's available through the MachBroker class, which is not
- // part of base. Additionally, there is an indefinite amount of time between
- // spawning a process and receiving its port. Because this test just checks
- // the ability to background/foreground a process, we can use the current
- // process's port instead.
- FakePortProvider provider;
- EXPECT_TRUE(process.SetProcessBackgrounded(&provider, true));
- EXPECT_TRUE(process.IsProcessBackgrounded(&provider));
- EXPECT_TRUE(process.SetProcessBackgrounded(&provider, false));
- EXPECT_FALSE(process.IsProcessBackgrounded(&provider));
-
-#else
- process.SetProcessBackgrounded(true);
- process.SetProcessBackgrounded(false);
-#endif
- int new_priority = process.GetPriority();
- EXPECT_EQ(old_priority, new_priority);
-}
-
-// Same as SetProcessBackgrounded but to this very process. It uses
-// a different code path at least for Windows.
-TEST_F(ProcessTest, SetProcessBackgroundedSelf) {
- if (!Process::CanBackgroundProcesses())
- return;
- Process process = Process::Current();
- int old_priority = process.GetPriority();
-#if defined(OS_WIN)
- EXPECT_TRUE(process.SetProcessBackgrounded(true));
- EXPECT_TRUE(process.IsProcessBackgrounded());
- EXPECT_TRUE(process.SetProcessBackgrounded(false));
- EXPECT_FALSE(process.IsProcessBackgrounded());
-#elif defined(OS_MACOSX)
- FakePortProvider provider;
- EXPECT_TRUE(process.SetProcessBackgrounded(&provider, true));
- EXPECT_TRUE(process.IsProcessBackgrounded(&provider));
- EXPECT_TRUE(process.SetProcessBackgrounded(&provider, false));
- EXPECT_FALSE(process.IsProcessBackgrounded(&provider));
-#else
- process.SetProcessBackgrounded(true);
- process.SetProcessBackgrounded(false);
-#endif
- int new_priority = process.GetPriority();
- EXPECT_EQ(old_priority, new_priority);
-}
-
-// Consumers can use WaitForExitWithTimeout(base::TimeDelta(), nullptr) to check
-// whether the process is still running. This may not be safe because of the
-// potential reusing of the process id. So we won't export Process::IsRunning()
-// on all platforms. But for the controllable scenario in the test cases, the
-// behavior should be guaranteed.
-TEST_F(ProcessTest, CurrentProcessIsRunning) {
- EXPECT_FALSE(Process::Current().WaitForExitWithTimeout(
- base::TimeDelta(), nullptr));
-}
-
-#if defined(OS_MACOSX)
-// On Mac OSX, we can detect whether a non-child process is running.
-TEST_F(ProcessTest, PredefinedProcessIsRunning) {
- // Process 1 is the /sbin/launchd, it should be always running.
- EXPECT_FALSE(Process::Open(1).WaitForExitWithTimeout(
- base::TimeDelta(), nullptr));
-}
-#endif
-
-TEST_F(ProcessTest, ChildProcessIsRunning) {
- Process process(SpawnChild("SleepyChildProcess"));
- EXPECT_FALSE(process.WaitForExitWithTimeout(
- base::TimeDelta(), nullptr));
- process.Terminate(0, true);
- EXPECT_TRUE(process.WaitForExitWithTimeout(
- base::TimeDelta(), nullptr));
-}
-
-#if defined(OS_CHROMEOS)
-
-// Tests that the function IsProcessBackgroundedCGroup() can parse the contents
-// of the /proc/<pid>/cgroup file successfully.
-TEST_F(ProcessTest, TestIsProcessBackgroundedCGroup) {
- const char kNotBackgrounded[] = "5:cpuacct,cpu,cpuset:/daemons\n";
- const char kBackgrounded[] =
- "2:freezer:/chrome_renderers/to_be_frozen\n"
- "1:cpu:/chrome_renderers/background\n";
-
- EXPECT_FALSE(IsProcessBackgroundedCGroup(kNotBackgrounded));
- EXPECT_TRUE(IsProcessBackgroundedCGroup(kBackgrounded));
-}
-
-#endif // defined(OS_CHROMEOS)
-
-} // namespace base
diff --git a/base/process/process_util_unittest.cc b/base/process/process_util_unittest.cc
deleted file mode 100644
index 81c31b2..0000000
--- a/base/process/process_util_unittest.cc
+++ /dev/null
@@ -1,1140 +0,0 @@
-// 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.
-
-#define _CRT_SECURE_NO_WARNINGS
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-
-#include "base/command_line.h"
-#include "base/debug/alias.h"
-#include "base/debug/stack_trace.h"
-#include "base/files/file_enumerator.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/path_service.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/process/kill.h"
-#include "base/process/launch.h"
-#include "base/process/memory.h"
-#include "base/process/process.h"
-#include "base/process/process_metrics.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-#if defined(OS_LINUX)
-#include <malloc.h>
-#include <sched.h>
-#include <sys/syscall.h>
-#endif
-#if defined(OS_POSIX)
-#include <sys/resource.h>
-#endif
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <dlfcn.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <sched.h>
-#include <signal.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#endif
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-#if defined(OS_MACOSX)
-#include <mach/vm_param.h>
-#include <malloc/malloc.h>
-#endif
-#if defined(OS_ANDROID)
-#include "third_party/lss/linux_syscall_support.h"
-#endif
-#if defined(OS_FUCHSIA)
-#include <fdio/limits.h>
-#include <zircon/process.h>
-#include <zircon/processargs.h>
-#include <zircon/syscalls.h>
-#include "base/base_paths_fuchsia.h"
-#endif
-
-namespace base {
-
-namespace {
-
-const char kSignalFileSlow[] = "SlowChildProcess.die";
-const char kSignalFileKill[] = "KilledChildProcess.die";
-const char kTestHelper[] = "test_child_process";
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-const char kSignalFileTerm[] = "TerminatedChildProcess.die";
-#endif
-
-#if defined(OS_FUCHSIA)
-const char kSignalFileClone[] = "ClonedTmpDir.die";
-#endif
-
-#if defined(OS_WIN)
-const int kExpectedStillRunningExitCode = 0x102;
-const int kExpectedKilledExitCode = 1;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-const int kExpectedStillRunningExitCode = 0;
-#endif
-
-// Sleeps until file filename is created.
-void WaitToDie(const char* filename) {
- FILE* fp;
- do {
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
- fp = fopen(filename, "r");
- } while (!fp);
- fclose(fp);
-}
-
-// Signals children they should die now.
-void SignalChildren(const char* filename) {
- FILE* fp = fopen(filename, "w");
- fclose(fp);
-}
-
-// Using a pipe to the child to wait for an event was considered, but
-// there were cases in the past where pipes caused problems (other
-// libraries closing the fds, child deadlocking). This is a simple
-// case, so it's not worth the risk. Using wait loops is discouraged
-// in most instances.
-TerminationStatus WaitForChildTermination(ProcessHandle handle,
- int* exit_code) {
- // Now we wait until the result is something other than STILL_RUNNING.
- TerminationStatus status = TERMINATION_STATUS_STILL_RUNNING;
- const TimeDelta kInterval = TimeDelta::FromMilliseconds(20);
- TimeDelta waited;
- do {
- status = GetTerminationStatus(handle, exit_code);
- PlatformThread::Sleep(kInterval);
- waited += kInterval;
- } while (status == TERMINATION_STATUS_STILL_RUNNING &&
- waited < TestTimeouts::action_max_timeout());
-
- return status;
-}
-
-} // namespace
-
-const int kSuccess = 0;
-
-class ProcessUtilTest : public MultiProcessTest {
- public:
- void SetUp() override {
- ASSERT_TRUE(PathService::Get(DIR_ASSETS, &test_helper_path_));
- test_helper_path_ = test_helper_path_.AppendASCII(kTestHelper);
- }
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
- // Spawn a child process that counts how many file descriptors are open.
- int CountOpenFDsInChild();
-#endif
- // Converts the filename to a platform specific filepath.
- // On Android files can not be created in arbitrary directories.
- static std::string GetSignalFilePath(const char* filename);
-
- protected:
- base::FilePath test_helper_path_;
-};
-
-std::string ProcessUtilTest::GetSignalFilePath(const char* filename) {
-#if defined(OS_ANDROID) || defined(OS_FUCHSIA)
- FilePath tmp_dir;
- PathService::Get(DIR_TEMP, &tmp_dir);
- tmp_dir = tmp_dir.Append(filename);
- return tmp_dir.value();
-#else
- return filename;
-#endif
-}
-
-MULTIPROCESS_TEST_MAIN(SimpleChildProcess) {
- return kSuccess;
-}
-
-// TODO(viettrungluu): This should be in a "MultiProcessTestTest".
-TEST_F(ProcessUtilTest, SpawnChild) {
- Process process = SpawnChild("SimpleChildProcess");
- ASSERT_TRUE(process.IsValid());
- int exit_code;
- EXPECT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
- &exit_code));
-}
-
-MULTIPROCESS_TEST_MAIN(SlowChildProcess) {
- WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileSlow).c_str());
- return kSuccess;
-}
-
-TEST_F(ProcessUtilTest, KillSlowChild) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
- remove(signal_file.c_str());
- Process process = SpawnChild("SlowChildProcess");
- ASSERT_TRUE(process.IsValid());
- SignalChildren(signal_file.c_str());
- int exit_code;
- EXPECT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
- &exit_code));
- remove(signal_file.c_str());
-}
-
-// Times out on Linux and Win, flakes on other platforms, http://crbug.com/95058
-TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
- remove(signal_file.c_str());
- Process process = SpawnChild("SlowChildProcess");
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = 42;
- EXPECT_EQ(TERMINATION_STATUS_STILL_RUNNING,
- GetTerminationStatus(process.Handle(), &exit_code));
- EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
-
- SignalChildren(signal_file.c_str());
- exit_code = 42;
- TerminationStatus status =
- WaitForChildTermination(process.Handle(), &exit_code);
- EXPECT_EQ(TERMINATION_STATUS_NORMAL_TERMINATION, status);
- EXPECT_EQ(kSuccess, exit_code);
- remove(signal_file.c_str());
-}
-
-#if defined(OS_FUCHSIA)
-
-MULTIPROCESS_TEST_MAIN(CheckTmpFileExists) {
- // Look through the filesystem to ensure that no other directories
- // besides "tmp" are in the namespace.
- base::FileEnumerator enumerator(
- base::FilePath("/"), false,
- base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
- base::FilePath next_path;
- while (!(next_path = enumerator.Next()).empty()) {
- if (next_path != base::FilePath("/tmp")) {
- LOG(ERROR) << "Clone policy violation: found non-tmp directory "
- << next_path.MaybeAsASCII();
- return 1;
- }
- }
- WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileClone).c_str());
- return kSuccess;
-}
-
-TEST_F(ProcessUtilTest, SelectivelyClonedDir) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileClone);
- remove(signal_file.c_str());
-
- LaunchOptions options;
- options.paths_to_map.push_back(base::FilePath("/tmp"));
- options.clone_flags = LP_CLONE_FDIO_STDIO;
-
- Process process(SpawnChildWithOptions("CheckTmpFileExists", options));
- ASSERT_TRUE(process.IsValid());
-
- SignalChildren(signal_file.c_str());
-
- int exit_code = 42;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_EQ(kSuccess, exit_code);
-}
-
-// Test that we can clone other directories. CheckTmpFileExists will return an
-// error code if it detects a directory other than "/tmp", so we can use that as
-// a signal that it successfully detected another entry in the root namespace.
-TEST_F(ProcessUtilTest, CloneAlternateDir) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileClone);
- remove(signal_file.c_str());
-
- LaunchOptions options;
- options.paths_to_map.push_back(base::FilePath("/tmp"));
- options.paths_to_map.push_back(base::FilePath("/data"));
- options.clone_flags = LP_CLONE_FDIO_STDIO;
-
- Process process(SpawnChildWithOptions("CheckTmpFileExists", options));
- ASSERT_TRUE(process.IsValid());
-
- SignalChildren(signal_file.c_str());
-
- int exit_code = 42;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_EQ(1, exit_code);
-}
-
-#endif // defined(OS_FUCHSIA)
-
-// On Android SpawnProcess() doesn't use LaunchProcess() and doesn't support
-// LaunchOptions::current_directory.
-#if !defined(OS_ANDROID)
-MULTIPROCESS_TEST_MAIN(CheckCwdProcess) {
- FilePath expected;
- CHECK(GetTempDir(&expected));
- expected = MakeAbsoluteFilePath(expected);
- CHECK(!expected.empty());
-
- FilePath actual;
- CHECK(GetCurrentDirectory(&actual));
- actual = MakeAbsoluteFilePath(actual);
- CHECK(!actual.empty());
-
- CHECK(expected == actual) << "Expected: " << expected.value()
- << " Actual: " << actual.value();
- return kSuccess;
-}
-
-TEST_F(ProcessUtilTest, CurrentDirectory) {
- // TODO(rickyz): Add support for passing arguments to multiprocess children,
- // then create a special directory for this test.
- FilePath tmp_dir;
- ASSERT_TRUE(GetTempDir(&tmp_dir));
-
- LaunchOptions options;
- options.current_directory = tmp_dir;
-
- Process process(SpawnChildWithOptions("CheckCwdProcess", options));
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = 42;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_EQ(kSuccess, exit_code);
-}
-#endif // !defined(OS_ANDROID)
-
-#if defined(OS_WIN)
-// TODO(cpu): figure out how to test this in other platforms.
-TEST_F(ProcessUtilTest, GetProcId) {
- ProcessId id1 = GetProcId(GetCurrentProcess());
- EXPECT_NE(0ul, id1);
- Process process = SpawnChild("SimpleChildProcess");
- ASSERT_TRUE(process.IsValid());
- ProcessId id2 = process.Pid();
- EXPECT_NE(0ul, id2);
- EXPECT_NE(id1, id2);
-}
-#endif // defined(OS_WIN)
-
-#if !defined(OS_MACOSX) && !defined(OS_ANDROID)
-// This test is disabled on Mac, since it's flaky due to ReportCrash
-// taking a variable amount of time to parse and load the debug and
-// symbol data for this unit test's executable before firing the
-// signal handler.
-//
-// TODO(gspencer): turn this test process into a very small program
-// with no symbols (instead of using the multiprocess testing
-// framework) to reduce the ReportCrash overhead.
-//
-// It is disabled on Android as MultiprocessTests are started as services that
-// the framework restarts on crashes.
-const char kSignalFileCrash[] = "CrashingChildProcess.die";
-
-MULTIPROCESS_TEST_MAIN(CrashingChildProcess) {
- WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileCrash).c_str());
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
- // Have to disable to signal handler for segv so we can get a crash
- // instead of an abnormal termination through the crash dump handler.
- ::signal(SIGSEGV, SIG_DFL);
-#endif
- // Make this process have a segmentation fault.
- volatile int* oops = nullptr;
- *oops = 0xDEAD;
- return 1;
-}
-
-// This test intentionally crashes, so we don't need to run it under
-// AddressSanitizer.
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_GetTerminationStatusCrash DISABLED_GetTerminationStatusCrash
-#else
-#define MAYBE_GetTerminationStatusCrash GetTerminationStatusCrash
-#endif
-TEST_F(ProcessUtilTest, MAYBE_GetTerminationStatusCrash) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileCrash);
- remove(signal_file.c_str());
- Process process = SpawnChild("CrashingChildProcess");
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = 42;
- EXPECT_EQ(TERMINATION_STATUS_STILL_RUNNING,
- GetTerminationStatus(process.Handle(), &exit_code));
- EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
-
- SignalChildren(signal_file.c_str());
- exit_code = 42;
- TerminationStatus status =
- WaitForChildTermination(process.Handle(), &exit_code);
- EXPECT_EQ(TERMINATION_STATUS_PROCESS_CRASHED, status);
-
-#if defined(OS_WIN)
- EXPECT_EQ(static_cast<int>(0xc0000005), exit_code);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- int signaled = WIFSIGNALED(exit_code);
- EXPECT_NE(0, signaled);
- int signal = WTERMSIG(exit_code);
- EXPECT_EQ(SIGSEGV, signal);
-#endif
-
- // Reset signal handlers back to "normal".
- debug::EnableInProcessStackDumping();
- remove(signal_file.c_str());
-}
-#endif // !defined(OS_MACOSX) && !defined(OS_ANDROID)
-
-MULTIPROCESS_TEST_MAIN(KilledChildProcess) {
- WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileKill).c_str());
-#if defined(OS_WIN)
- // Kill ourselves.
- HANDLE handle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, ::GetCurrentProcessId());
- ::TerminateProcess(handle, kExpectedKilledExitCode);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- // Send a SIGKILL to this process, just like the OOM killer would.
- ::kill(getpid(), SIGKILL);
-#endif
- return 1;
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-MULTIPROCESS_TEST_MAIN(TerminatedChildProcess) {
- WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileTerm).c_str());
- // Send a SIGTERM to this process.
- ::kill(getpid(), SIGTERM);
- return 1;
-}
-#endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-TEST_F(ProcessUtilTest, GetTerminationStatusSigKill) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileKill);
- remove(signal_file.c_str());
- Process process = SpawnChild("KilledChildProcess");
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = 42;
- EXPECT_EQ(TERMINATION_STATUS_STILL_RUNNING,
- GetTerminationStatus(process.Handle(), &exit_code));
- EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
-
- SignalChildren(signal_file.c_str());
- exit_code = 42;
- TerminationStatus status =
- WaitForChildTermination(process.Handle(), &exit_code);
-#if defined(OS_CHROMEOS)
- EXPECT_EQ(TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM, status);
-#else
- EXPECT_EQ(TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
-#endif
-
-#if defined(OS_WIN)
- EXPECT_EQ(kExpectedKilledExitCode, exit_code);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- int signaled = WIFSIGNALED(exit_code);
- EXPECT_NE(0, signaled);
- int signal = WTERMSIG(exit_code);
- EXPECT_EQ(SIGKILL, signal);
-#endif
- remove(signal_file.c_str());
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-TEST_F(ProcessUtilTest, GetTerminationStatusSigTerm) {
- const std::string signal_file =
- ProcessUtilTest::GetSignalFilePath(kSignalFileTerm);
- remove(signal_file.c_str());
- Process process = SpawnChild("TerminatedChildProcess");
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = 42;
- EXPECT_EQ(TERMINATION_STATUS_STILL_RUNNING,
- GetTerminationStatus(process.Handle(), &exit_code));
- EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
-
- SignalChildren(signal_file.c_str());
- exit_code = 42;
- TerminationStatus status =
- WaitForChildTermination(process.Handle(), &exit_code);
- EXPECT_EQ(TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
-
- int signaled = WIFSIGNALED(exit_code);
- EXPECT_NE(0, signaled);
- int signal = WTERMSIG(exit_code);
- EXPECT_EQ(SIGTERM, signal);
- remove(signal_file.c_str());
-}
-#endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-TEST_F(ProcessUtilTest, EnsureTerminationUndying) {
- test::ScopedTaskEnvironment task_environment;
-
- Process child_process = SpawnChild("process_util_test_never_die");
- ASSERT_TRUE(child_process.IsValid());
-
- EnsureProcessTerminated(child_process.Duplicate());
-
- // Allow a generous timeout, to cope with slow/loaded test bots.
- EXPECT_TRUE(child_process.WaitForExitWithTimeout(
- TestTimeouts::action_max_timeout(), nullptr));
-}
-
-MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
- while (1) {
- PlatformThread::Sleep(TimeDelta::FromSeconds(500));
- }
- return kSuccess;
-}
-
-TEST_F(ProcessUtilTest, EnsureTerminationGracefulExit) {
- test::ScopedTaskEnvironment task_environment;
-
- Process child_process = SpawnChild("process_util_test_die_immediately");
- ASSERT_TRUE(child_process.IsValid());
-
- // Wait for the child process to actually exit.
- child_process.Duplicate().WaitForExitWithTimeout(
- TestTimeouts::action_max_timeout(), nullptr);
-
- EnsureProcessTerminated(child_process.Duplicate());
-
- // Verify that the process is really, truly gone.
- EXPECT_TRUE(child_process.WaitForExitWithTimeout(
- TestTimeouts::action_max_timeout(), nullptr));
-}
-
-MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
- return kSuccess;
-}
-
-#if defined(OS_WIN)
-// TODO(estade): if possible, port this test.
-TEST_F(ProcessUtilTest, LaunchAsUser) {
- UserTokenHandle token;
- ASSERT_TRUE(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token));
- LaunchOptions options;
- options.as_user = token;
- EXPECT_TRUE(
- LaunchProcess(MakeCmdLine("SimpleChildProcess"), options).IsValid());
-}
-
-static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle";
-
-MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) {
- std::string handle_value_string =
- CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
- kEventToTriggerHandleSwitch);
- CHECK(!handle_value_string.empty());
-
- uint64_t handle_value_uint64;
- CHECK(StringToUint64(handle_value_string, &handle_value_uint64));
- // Give ownership of the handle to |event|.
- WaitableEvent event(
- win::ScopedHandle(reinterpret_cast<HANDLE>(handle_value_uint64)));
-
- event.Signal();
-
- return 0;
-}
-
-TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
- // Manually create the event, so that it can be inheritable.
- SECURITY_ATTRIBUTES security_attributes = {};
- security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes));
- security_attributes.lpSecurityDescriptor = NULL;
- security_attributes.bInheritHandle = true;
-
- // Takes ownership of the event handle.
- WaitableEvent event(
- win::ScopedHandle(CreateEvent(&security_attributes, true, false, NULL)));
- LaunchOptions options;
- options.handles_to_inherit.emplace_back(event.handle());
-
- CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
- cmd_line.AppendSwitchASCII(
- kEventToTriggerHandleSwitch,
- NumberToString(reinterpret_cast<uint64_t>(event.handle())));
-
- // Launch the process and wait for it to trigger the event.
- ASSERT_TRUE(LaunchProcess(cmd_line, options).IsValid());
- EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
-}
-#endif // defined(OS_WIN)
-
-TEST_F(ProcessUtilTest, GetAppOutput) {
- base::CommandLine command(test_helper_path_);
- command.AppendArg("hello");
- command.AppendArg("there");
- command.AppendArg("good");
- command.AppendArg("people");
- std::string output;
- EXPECT_TRUE(GetAppOutput(command, &output));
- EXPECT_EQ("hello there good people", output);
- output.clear();
-
- const char* kEchoMessage = "blah";
- command = base::CommandLine(test_helper_path_);
- command.AppendArg("-x");
- command.AppendArg("28");
- command.AppendArg(kEchoMessage);
- EXPECT_FALSE(GetAppOutput(command, &output));
- EXPECT_EQ(kEchoMessage, output);
-}
-
-TEST_F(ProcessUtilTest, GetAppOutputWithExitCode) {
- const char* kEchoMessage1 = "doge";
- int exit_code = -1;
- base::CommandLine command(test_helper_path_);
- command.AppendArg(kEchoMessage1);
- std::string output;
- EXPECT_TRUE(GetAppOutputWithExitCode(command, &output, &exit_code));
- EXPECT_EQ(kEchoMessage1, output);
- EXPECT_EQ(0, exit_code);
- output.clear();
-
- const char* kEchoMessage2 = "pupper";
- const int kExpectedExitCode = 42;
- command = base::CommandLine(test_helper_path_);
- command.AppendArg("-x");
- command.AppendArg(base::IntToString(kExpectedExitCode));
- command.AppendArg(kEchoMessage2);
-#if defined(OS_WIN)
- // On Windows, anything that quits with a nonzero status code is handled as a
- // "crash", so just ignore GetAppOutputWithExitCode's return value.
- GetAppOutputWithExitCode(command, &output, &exit_code);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- EXPECT_TRUE(GetAppOutputWithExitCode(command, &output, &exit_code));
-#endif
- EXPECT_EQ(kEchoMessage2, output);
- EXPECT_EQ(kExpectedExitCode, exit_code);
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-namespace {
-
-// Returns the maximum number of files that a process can have open.
-// Returns 0 on error.
-int GetMaxFilesOpenInProcess() {
-#if defined(OS_FUCHSIA)
- return FDIO_MAX_FD;
-#else
- struct rlimit rlim;
- if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
- return 0;
- }
-
- // rlim_t is a uint64_t - clip to maxint. We do this since FD #s are ints
- // which are all 32 bits on the supported platforms.
- rlim_t max_int = static_cast<rlim_t>(std::numeric_limits<int32_t>::max());
- if (rlim.rlim_cur > max_int) {
- return max_int;
- }
-
- return rlim.rlim_cur;
-#endif // defined(OS_FUCHSIA)
-}
-
-const int kChildPipe = 20; // FD # for write end of pipe in child process.
-
-#if defined(OS_MACOSX)
-
-// <http://opensource.apple.com/source/xnu/xnu-2422.1.72/bsd/sys/guarded.h>
-#if !defined(_GUARDID_T)
-#define _GUARDID_T
-typedef __uint64_t guardid_t;
-#endif // _GUARDID_T
-
-// From .../MacOSX10.9.sdk/usr/include/sys/syscall.h
-#if !defined(SYS_change_fdguard_np)
-#define SYS_change_fdguard_np 444
-#endif
-
-// <http://opensource.apple.com/source/xnu/xnu-2422.1.72/bsd/sys/guarded.h>
-#if !defined(GUARD_DUP)
-#define GUARD_DUP (1u << 1)
-#endif
-
-// <http://opensource.apple.com/source/xnu/xnu-2422.1.72/bsd/kern/kern_guarded.c?txt>
-//
-// Atomically replaces |guard|/|guardflags| with |nguard|/|nguardflags| on |fd|.
-int change_fdguard_np(int fd,
- const guardid_t *guard, u_int guardflags,
- const guardid_t *nguard, u_int nguardflags,
- int *fdflagsp) {
- return syscall(SYS_change_fdguard_np, fd, guard, guardflags,
- nguard, nguardflags, fdflagsp);
-}
-
-// Attempt to set a file-descriptor guard on |fd|. In case of success, remove
-// it and return |true| to indicate that it can be guarded. Returning |false|
-// means either that |fd| is guarded by some other code, or more likely EBADF.
-//
-// Starting with 10.9, libdispatch began setting GUARD_DUP on a file descriptor.
-// Unfortunately, it is spun up as part of +[NSApplication initialize], which is
-// not really something that Chromium can avoid using on OSX. See
-// <http://crbug.com/338157>. This function allows querying whether the file
-// descriptor is guarded before attempting to close it.
-bool CanGuardFd(int fd) {
- // Saves the original flags to reset later.
- int original_fdflags = 0;
-
- // This can be any value at all, it just has to match up between the two
- // calls.
- const guardid_t kGuard = 15;
-
- // Attempt to change the guard. This can fail with EBADF if the file
- // descriptor is bad, or EINVAL if the fd already has a guard set.
- int ret =
- change_fdguard_np(fd, NULL, 0, &kGuard, GUARD_DUP, &original_fdflags);
- if (ret == -1)
- return false;
-
- // Remove the guard. It should not be possible to fail in removing the guard
- // just added.
- ret = change_fdguard_np(fd, &kGuard, GUARD_DUP, NULL, 0, &original_fdflags);
- DPCHECK(ret == 0);
-
- return true;
-}
-#endif // defined(OS_MACOSX)
-
-} // namespace
-
-MULTIPROCESS_TEST_MAIN(ProcessUtilsLeakFDChildProcess) {
- // This child process counts the number of open FDs, it then writes that
- // number out to a pipe connected to the parent.
- int num_open_files = 0;
- int write_pipe = kChildPipe;
- int max_files = GetMaxFilesOpenInProcess();
- for (int i = STDERR_FILENO + 1; i < max_files; i++) {
-#if defined(OS_MACOSX)
- // Ignore guarded or invalid file descriptors.
- if (!CanGuardFd(i))
- continue;
-#endif
-
- if (i != kChildPipe) {
- int fd;
- if ((fd = HANDLE_EINTR(dup(i))) != -1) {
- close(fd);
- num_open_files += 1;
- }
- }
- }
-
- int written = HANDLE_EINTR(write(write_pipe, &num_open_files,
- sizeof(num_open_files)));
- DCHECK_EQ(static_cast<size_t>(written), sizeof(num_open_files));
- int ret = IGNORE_EINTR(close(write_pipe));
- DPCHECK(ret == 0);
-
- return 0;
-}
-
-int ProcessUtilTest::CountOpenFDsInChild() {
- int fds[2];
- if (pipe(fds) < 0)
- NOTREACHED();
-
- LaunchOptions options;
- options.fds_to_remap.emplace_back(fds[1], kChildPipe);
- Process process =
- SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options);
- CHECK(process.IsValid());
- int ret = IGNORE_EINTR(close(fds[1]));
- DPCHECK(ret == 0);
-
- // Read number of open files in client process from pipe;
- int num_open_files = -1;
- ssize_t bytes_read =
- HANDLE_EINTR(read(fds[0], &num_open_files, sizeof(num_open_files)));
- CHECK_EQ(bytes_read, static_cast<ssize_t>(sizeof(num_open_files)));
-
-#if defined(THREAD_SANITIZER)
- // Compiler-based ThreadSanitizer makes this test slow.
- TimeDelta timeout = TimeDelta::FromSeconds(3);
-#else
- TimeDelta timeout = TimeDelta::FromSeconds(1);
-#endif
- int exit_code;
- CHECK(process.WaitForExitWithTimeout(timeout, &exit_code));
- ret = IGNORE_EINTR(close(fds[0]));
- DPCHECK(ret == 0);
-
- return num_open_files;
-}
-
-#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
-// ProcessUtilTest.FDRemapping is flaky when ran under xvfb-run on Precise.
-// The problem is 100% reproducible with both ASan and TSan.
-// See http://crbug.com/136720.
-#define MAYBE_FDRemapping DISABLED_FDRemapping
-#else
-#define MAYBE_FDRemapping FDRemapping
-#endif // defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
-TEST_F(ProcessUtilTest, MAYBE_FDRemapping) {
- int fds_before = CountOpenFDsInChild();
-
- // open some dummy fds to make sure they don't propagate over to the
- // child process.
- int dev_null = open("/dev/null", O_RDONLY);
- DPCHECK(dev_null != -1);
- int sockets[2];
- int ret = socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
- DPCHECK(ret == 0);
-
- int fds_after = CountOpenFDsInChild();
-
- ASSERT_EQ(fds_after, fds_before);
-
- ret = IGNORE_EINTR(close(sockets[0]));
- DPCHECK(ret == 0);
- ret = IGNORE_EINTR(close(sockets[1]));
- DPCHECK(ret == 0);
- ret = IGNORE_EINTR(close(dev_null));
- DPCHECK(ret == 0);
-}
-
-const char kPipeValue = '\xcc';
-MULTIPROCESS_TEST_MAIN(ProcessUtilsVerifyStdio) {
- // Write to stdio so the parent process can observe output.
- CHECK_EQ(1, HANDLE_EINTR(write(STDOUT_FILENO, &kPipeValue, 1)));
-
- // Close all of the handles, to verify they are valid.
- CHECK_EQ(0, IGNORE_EINTR(close(STDIN_FILENO)));
- CHECK_EQ(0, IGNORE_EINTR(close(STDOUT_FILENO)));
- CHECK_EQ(0, IGNORE_EINTR(close(STDERR_FILENO)));
- return 0;
-}
-
-TEST_F(ProcessUtilTest, FDRemappingIncludesStdio) {
- int dev_null = open("/dev/null", O_RDONLY);
- ASSERT_LT(2, dev_null);
-
- // Backup stdio and replace it with the write end of a pipe, for our
- // child process to inherit.
- int pipe_fds[2];
- int result = pipe(pipe_fds);
- ASSERT_EQ(0, result);
- int backup_stdio = HANDLE_EINTR(dup(STDOUT_FILENO));
- ASSERT_LE(0, backup_stdio);
- result = dup2(pipe_fds[1], STDOUT_FILENO);
- ASSERT_EQ(STDOUT_FILENO, result);
-
- // Launch the test process, which should inherit our pipe stdio.
- LaunchOptions options;
- options.fds_to_remap.emplace_back(dev_null, dev_null);
- Process process = SpawnChildWithOptions("ProcessUtilsVerifyStdio", options);
- ASSERT_TRUE(process.IsValid());
-
- // Restore stdio, so we can output stuff.
- result = dup2(backup_stdio, STDOUT_FILENO);
- ASSERT_EQ(STDOUT_FILENO, result);
-
- // Close our copy of the write end of the pipe, so that the read()
- // from the other end will see EOF if it wasn't copied to the child.
- result = IGNORE_EINTR(close(pipe_fds[1]));
- ASSERT_EQ(0, result);
-
- result = IGNORE_EINTR(close(backup_stdio));
- ASSERT_EQ(0, result);
- result = IGNORE_EINTR(close(dev_null));
- ASSERT_EQ(0, result);
-
- // Read from the pipe to verify that it is connected to the child
- // process' stdio.
- char buf[16] = {};
- EXPECT_EQ(1, HANDLE_EINTR(read(pipe_fds[0], buf, sizeof(buf))));
- EXPECT_EQ(kPipeValue, buf[0]);
-
- result = IGNORE_EINTR(close(pipe_fds[0]));
- ASSERT_EQ(0, result);
-
- int exit_code;
- ASSERT_TRUE(
- process.WaitForExitWithTimeout(TimeDelta::FromSeconds(5), &exit_code));
- EXPECT_EQ(0, exit_code);
-}
-
-#if defined(OS_FUCHSIA)
-
-const uint16_t kStartupHandleId = 43;
-MULTIPROCESS_TEST_MAIN(ProcessUtilsVerifyHandle) {
- zx_handle_t handle =
- zx_get_startup_handle(PA_HND(PA_USER0, kStartupHandleId));
- CHECK_NE(ZX_HANDLE_INVALID, handle);
-
- // Write to the pipe so the parent process can observe output.
- size_t bytes_written = 0;
- zx_status_t result = zx_socket_write(handle, 0, &kPipeValue,
- sizeof(kPipeValue), &bytes_written);
- CHECK_EQ(ZX_OK, result);
- CHECK_EQ(1u, bytes_written);
-
- CHECK_EQ(ZX_OK, zx_handle_close(handle));
- return 0;
-}
-
-TEST_F(ProcessUtilTest, LaunchWithHandleTransfer) {
- // Create a pipe to pass to the child process.
- zx_handle_t handles[2];
- zx_status_t result =
- zx_socket_create(ZX_SOCKET_STREAM, &handles[0], &handles[1]);
- ASSERT_EQ(ZX_OK, result);
-
- // Launch the test process, and pass it one end of the pipe.
- LaunchOptions options;
- options.handles_to_transfer.push_back(
- {PA_HND(PA_USER0, kStartupHandleId), handles[0]});
- Process process = SpawnChildWithOptions("ProcessUtilsVerifyHandle", options);
- ASSERT_TRUE(process.IsValid());
-
- // Read from the pipe to verify that the child received it.
- zx_signals_t signals = 0;
- result = zx_object_wait_one(
- handles[1], ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED,
- (base::TimeTicks::Now() + TestTimeouts::action_timeout()).ToZxTime(),
- &signals);
- ASSERT_EQ(ZX_OK, result);
- ASSERT_TRUE(signals & ZX_SOCKET_READABLE);
-
- size_t bytes_read = 0;
- char buf[16] = {0};
- result = zx_socket_read(handles[1], 0, buf, sizeof(buf), &bytes_read);
- EXPECT_EQ(ZX_OK, result);
- EXPECT_EQ(1u, bytes_read);
- EXPECT_EQ(kPipeValue, buf[0]);
-
- CHECK_EQ(ZX_OK, zx_handle_close(handles[1]));
-
- int exit_code;
- ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
- &exit_code));
- EXPECT_EQ(0, exit_code);
-}
-
-#endif // defined(OS_FUCHSIA)
-
-namespace {
-
-std::string TestLaunchProcess(const std::vector<std::string>& args,
- const EnvironmentMap& env_changes,
- const bool clear_environ,
- const int clone_flags) {
- int fds[2];
- PCHECK(pipe(fds) == 0);
-
- LaunchOptions options;
- options.wait = true;
- options.environ = env_changes;
- options.clear_environ = clear_environ;
- options.fds_to_remap.emplace_back(fds[1], 1);
-#if defined(OS_LINUX)
- options.clone_flags = clone_flags;
-#else
- CHECK_EQ(0, clone_flags);
-#endif // defined(OS_LINUX)
- EXPECT_TRUE(LaunchProcess(args, options).IsValid());
- PCHECK(IGNORE_EINTR(close(fds[1])) == 0);
-
- char buf[512];
- const ssize_t n = HANDLE_EINTR(read(fds[0], buf, sizeof(buf)));
-
- PCHECK(IGNORE_EINTR(close(fds[0])) == 0);
-
- return std::string(buf, n);
-}
-
-const char kLargeString[] =
- "0123456789012345678901234567890123456789012345678901234567890123456789"
- "0123456789012345678901234567890123456789012345678901234567890123456789"
- "0123456789012345678901234567890123456789012345678901234567890123456789"
- "0123456789012345678901234567890123456789012345678901234567890123456789"
- "0123456789012345678901234567890123456789012345678901234567890123456789"
- "0123456789012345678901234567890123456789012345678901234567890123456789"
- "0123456789012345678901234567890123456789012345678901234567890123456789";
-
-} // namespace
-
-TEST_F(ProcessUtilTest, LaunchProcess) {
- const int no_clone_flags = 0;
- const bool no_clear_environ = false;
- const char kBaseTest[] = "BASE_TEST";
- const std::vector<std::string> kPrintEnvCommand = {test_helper_path_.value(),
- "-e", kBaseTest};
-
- EnvironmentMap env_changes;
- env_changes[kBaseTest] = "bar";
- EXPECT_EQ("bar", TestLaunchProcess(kPrintEnvCommand, env_changes,
- no_clear_environ, no_clone_flags));
- env_changes.clear();
-
- EXPECT_EQ(0, setenv(kBaseTest, "testing", 1 /* override */));
- EXPECT_EQ("testing", TestLaunchProcess(kPrintEnvCommand, env_changes,
- no_clear_environ, no_clone_flags));
-
- env_changes[kBaseTest] = std::string();
- EXPECT_EQ("", TestLaunchProcess(kPrintEnvCommand, env_changes,
- no_clear_environ, no_clone_flags));
-
- env_changes[kBaseTest] = "foo";
- EXPECT_EQ("foo", TestLaunchProcess(kPrintEnvCommand, env_changes,
- no_clear_environ, no_clone_flags));
-
- env_changes.clear();
- EXPECT_EQ(0, setenv(kBaseTest, kLargeString, 1 /* override */));
- EXPECT_EQ(std::string(kLargeString),
- TestLaunchProcess(kPrintEnvCommand, env_changes, no_clear_environ,
- no_clone_flags));
-
- env_changes[kBaseTest] = "wibble";
- EXPECT_EQ("wibble", TestLaunchProcess(kPrintEnvCommand, env_changes,
- no_clear_environ, no_clone_flags));
-
-#if defined(OS_LINUX)
- // Test a non-trival value for clone_flags.
- EXPECT_EQ("wibble", TestLaunchProcess(kPrintEnvCommand, env_changes,
- no_clear_environ, CLONE_FS));
-
- EXPECT_EQ("wibble",
- TestLaunchProcess(kPrintEnvCommand, env_changes,
- true /* clear_environ */, no_clone_flags));
- env_changes.clear();
- EXPECT_EQ("", TestLaunchProcess(kPrintEnvCommand, env_changes,
- true /* clear_environ */, no_clone_flags));
-#endif // defined(OS_LINUX)
-}
-
-// There's no such thing as a parent process id on Fuchsia.
-#if !defined(OS_FUCHSIA)
-TEST_F(ProcessUtilTest, GetParentProcessId) {
- ProcessId ppid = GetParentProcessId(GetCurrentProcessHandle());
- EXPECT_EQ(ppid, static_cast<ProcessId>(getppid()));
-}
-#endif // !defined(OS_FUCHSIA)
-
-#if !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-class WriteToPipeDelegate : public LaunchOptions::PreExecDelegate {
- public:
- explicit WriteToPipeDelegate(int fd) : fd_(fd) {}
- ~WriteToPipeDelegate() override = default;
- void RunAsyncSafe() override {
- RAW_CHECK(HANDLE_EINTR(write(fd_, &kPipeValue, 1)) == 1);
- RAW_CHECK(IGNORE_EINTR(close(fd_)) == 0);
- }
-
- private:
- int fd_;
- DISALLOW_COPY_AND_ASSIGN(WriteToPipeDelegate);
-};
-
-TEST_F(ProcessUtilTest, PreExecHook) {
- int pipe_fds[2];
- ASSERT_EQ(0, pipe(pipe_fds));
-
- ScopedFD read_fd(pipe_fds[0]);
- ScopedFD write_fd(pipe_fds[1]);
-
- WriteToPipeDelegate write_to_pipe_delegate(write_fd.get());
- LaunchOptions options;
- options.fds_to_remap.emplace_back(write_fd.get(), write_fd.get());
- options.pre_exec_delegate = &write_to_pipe_delegate;
- Process process(SpawnChildWithOptions("SimpleChildProcess", options));
- ASSERT_TRUE(process.IsValid());
-
- write_fd.reset();
- char c;
- ASSERT_EQ(1, HANDLE_EINTR(read(read_fd.get(), &c, 1)));
- EXPECT_EQ(c, kPipeValue);
-
- int exit_code = 42;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_EQ(0, exit_code);
-}
-#endif // !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-
-#endif // !defined(OS_MACOSX) && !defined(OS_ANDROID)
-
-#if defined(OS_LINUX)
-MULTIPROCESS_TEST_MAIN(CheckPidProcess) {
- const pid_t kInitPid = 1;
- const pid_t pid = syscall(__NR_getpid);
- CHECK(pid == kInitPid);
- CHECK(getpid() == pid);
- return kSuccess;
-}
-
-#if defined(CLONE_NEWUSER) && defined(CLONE_NEWPID)
-TEST_F(ProcessUtilTest, CloneFlags) {
- if (!PathExists(FilePath("/proc/self/ns/user")) ||
- !PathExists(FilePath("/proc/self/ns/pid"))) {
- // User or PID namespaces are not supported.
- return;
- }
-
- LaunchOptions options;
- options.clone_flags = CLONE_NEWUSER | CLONE_NEWPID;
-
- Process process(SpawnChildWithOptions("CheckPidProcess", options));
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = 42;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_EQ(kSuccess, exit_code);
-}
-#endif // defined(CLONE_NEWUSER) && defined(CLONE_NEWPID)
-
-TEST(ForkWithFlagsTest, UpdatesPidCache) {
- // Warm up the libc pid cache, if there is one.
- ASSERT_EQ(syscall(__NR_getpid), getpid());
-
- pid_t ctid = 0;
- const pid_t pid = ForkWithFlags(SIGCHLD | CLONE_CHILD_SETTID, nullptr, &ctid);
- if (pid == 0) {
- // In child. Check both the raw getpid syscall and the libc getpid wrapper
- // (which may rely on a pid cache).
- RAW_CHECK(syscall(__NR_getpid) == ctid);
- RAW_CHECK(getpid() == ctid);
- _exit(kSuccess);
- }
-
- ASSERT_NE(-1, pid);
- int status = 42;
- ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
- ASSERT_TRUE(WIFEXITED(status));
- EXPECT_EQ(kSuccess, WEXITSTATUS(status));
-}
-
-TEST_F(ProcessUtilTest, InvalidCurrentDirectory) {
- LaunchOptions options;
- options.current_directory = FilePath("/dev/null");
-
- Process process(SpawnChildWithOptions("SimpleChildProcess", options));
- ASSERT_TRUE(process.IsValid());
-
- int exit_code = kSuccess;
- EXPECT_TRUE(process.WaitForExit(&exit_code));
- EXPECT_NE(kSuccess, exit_code);
-}
-#endif // defined(OS_LINUX)
-
-} // namespace base
diff --git a/base/profiler/stack_sampling_profiler_unittest.cc b/base/profiler/stack_sampling_profiler_unittest.cc
deleted file mode 100644
index b25943f..0000000
--- a/base/profiler/stack_sampling_profiler_unittest.cc
+++ /dev/null
@@ -1,1506 +0,0 @@
-// Copyright 2015 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 <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <cstdlib>
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/files/file_util.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/native_library.h"
-#include "base/path_service.h"
-#include "base/profiler/native_stack_sampler.h"
-#include "base/profiler/stack_sampling_profiler.h"
-#include "base/run_loop.h"
-#include "base/scoped_native_library.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <intrin.h>
-#include <malloc.h>
-#include <windows.h>
-#else
-#include <alloca.h>
-#endif
-
-// STACK_SAMPLING_PROFILER_SUPPORTED is used to conditionally enable the tests
-// below for supported platforms (currently Win x64 and Mac x64).
-#if defined(_WIN64) || (defined(OS_MACOSX) && !defined(OS_IOS))
-#define STACK_SAMPLING_PROFILER_SUPPORTED 1
-#endif
-
-#if defined(OS_WIN)
-#pragma intrinsic(_ReturnAddress)
-#endif
-
-namespace base {
-
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
-#define PROFILER_TEST_F(TestClass, TestName) TEST_F(TestClass, TestName)
-#else
-#define PROFILER_TEST_F(TestClass, TestName) \
- TEST_F(TestClass, DISABLED_##TestName)
-#endif
-
-using SamplingParams = StackSamplingProfiler::SamplingParams;
-using Frame = StackSamplingProfiler::Frame;
-using Frames = std::vector<StackSamplingProfiler::Frame>;
-using Module = StackSamplingProfiler::Module;
-using Sample = StackSamplingProfiler::Sample;
-using CallStackProfile = StackSamplingProfiler::CallStackProfile;
-using CallStackProfiles = StackSamplingProfiler::CallStackProfiles;
-
-namespace {
-
-// Configuration for the frames that appear on the stack.
-struct StackConfiguration {
- enum Config { NORMAL, WITH_ALLOCA, WITH_OTHER_LIBRARY };
-
- explicit StackConfiguration(Config config)
- : StackConfiguration(config, nullptr) {
- EXPECT_NE(config, WITH_OTHER_LIBRARY);
- }
-
- StackConfiguration(Config config, NativeLibrary library)
- : config(config), library(library) {
- EXPECT_TRUE(config != WITH_OTHER_LIBRARY || library);
- }
-
- Config config;
-
- // Only used if config == WITH_OTHER_LIBRARY.
- NativeLibrary library;
-};
-
-// Signature for a target function that is expected to appear in the stack. See
-// SignalAndWaitUntilSignaled() below. The return value should be a program
-// counter pointer near the end of the function.
-using TargetFunction = const void*(*)(WaitableEvent*, WaitableEvent*,
- const StackConfiguration*);
-
-// A thread to target for profiling, whose stack is guaranteed to contain
-// SignalAndWaitUntilSignaled() when coordinated with the main thread.
-class TargetThread : public PlatformThread::Delegate {
- public:
- explicit TargetThread(const StackConfiguration& stack_config);
-
- // PlatformThread::Delegate:
- void ThreadMain() override;
-
- // Waits for the thread to have started and be executing in
- // SignalAndWaitUntilSignaled().
- void WaitForThreadStart();
-
- // Allows the thread to return from SignalAndWaitUntilSignaled() and finish
- // execution.
- void SignalThreadToFinish();
-
- // This function is guaranteed to be executing between calls to
- // WaitForThreadStart() and SignalThreadToFinish() when invoked with
- // |thread_started_event_| and |finish_event_|. Returns a program counter
- // value near the end of the function. May be invoked with null WaitableEvents
- // to just return the program counter.
- //
- // This function is static so that we can get a straightforward address
- // for it in one of the tests below, rather than dealing with the complexity
- // of a member function pointer representation.
- static const void* SignalAndWaitUntilSignaled(
- WaitableEvent* thread_started_event,
- WaitableEvent* finish_event,
- const StackConfiguration* stack_config);
-
- // Calls into SignalAndWaitUntilSignaled() after allocating memory on the
- // stack with alloca.
- static const void* CallWithAlloca(WaitableEvent* thread_started_event,
- WaitableEvent* finish_event,
- const StackConfiguration* stack_config);
-
- // Calls into SignalAndWaitUntilSignaled() via a function in
- // base_profiler_test_support_library.
- static const void* CallThroughOtherLibrary(
- WaitableEvent* thread_started_event,
- WaitableEvent* finish_event,
- const StackConfiguration* stack_config);
-
- PlatformThreadId id() const { return id_; }
-
- private:
- struct TargetFunctionArgs {
- WaitableEvent* thread_started_event;
- WaitableEvent* finish_event;
- const StackConfiguration* stack_config;
- };
-
- // Callback function to be provided when calling through the other library.
- static void OtherLibraryCallback(void *arg);
-
- // Returns the current program counter, or a value very close to it.
- static const void* GetProgramCounter();
-
- WaitableEvent thread_started_event_;
- WaitableEvent finish_event_;
- PlatformThreadId id_;
- const StackConfiguration stack_config_;
-
- DISALLOW_COPY_AND_ASSIGN(TargetThread);
-};
-
-TargetThread::TargetThread(const StackConfiguration& stack_config)
- : thread_started_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- finish_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- id_(0),
- stack_config_(stack_config) {}
-
-void TargetThread::ThreadMain() {
- id_ = PlatformThread::CurrentId();
- switch (stack_config_.config) {
- case StackConfiguration::NORMAL:
- SignalAndWaitUntilSignaled(&thread_started_event_, &finish_event_,
- &stack_config_);
- break;
-
- case StackConfiguration::WITH_ALLOCA:
- CallWithAlloca(&thread_started_event_, &finish_event_, &stack_config_);
- break;
-
- case StackConfiguration::WITH_OTHER_LIBRARY:
- CallThroughOtherLibrary(&thread_started_event_, &finish_event_,
- &stack_config_);
- break;
- }
-}
-
-void TargetThread::WaitForThreadStart() {
- thread_started_event_.Wait();
-}
-
-void TargetThread::SignalThreadToFinish() {
- finish_event_.Signal();
-}
-
-// static
-// Disable inlining for this function so that it gets its own stack frame.
-NOINLINE const void* TargetThread::SignalAndWaitUntilSignaled(
- WaitableEvent* thread_started_event,
- WaitableEvent* finish_event,
- const StackConfiguration* stack_config) {
- if (thread_started_event && finish_event) {
- thread_started_event->Signal();
- finish_event->Wait();
- }
-
- // Volatile to prevent a tail call to GetProgramCounter().
- const void* volatile program_counter = GetProgramCounter();
- return program_counter;
-}
-
-// static
-// Disable inlining for this function so that it gets its own stack frame.
-NOINLINE const void* TargetThread::CallWithAlloca(
- WaitableEvent* thread_started_event,
- WaitableEvent* finish_event,
- const StackConfiguration* stack_config) {
- const size_t alloca_size = 100;
- // Memset to 0 to generate a clean failure.
- std::memset(alloca(alloca_size), 0, alloca_size);
-
- SignalAndWaitUntilSignaled(thread_started_event, finish_event, stack_config);
-
- // Volatile to prevent a tail call to GetProgramCounter().
- const void* volatile program_counter = GetProgramCounter();
- return program_counter;
-}
-
-// static
-NOINLINE const void* TargetThread::CallThroughOtherLibrary(
- WaitableEvent* thread_started_event,
- WaitableEvent* finish_event,
- const StackConfiguration* stack_config) {
- if (stack_config) {
- // A function whose arguments are a function accepting void*, and a void*.
- using InvokeCallbackFunction = void(*)(void (*)(void*), void*);
- EXPECT_TRUE(stack_config->library);
- InvokeCallbackFunction function = reinterpret_cast<InvokeCallbackFunction>(
- GetFunctionPointerFromNativeLibrary(stack_config->library,
- "InvokeCallbackFunction"));
- EXPECT_TRUE(function);
-
- TargetFunctionArgs args = {
- thread_started_event,
- finish_event,
- stack_config
- };
- (*function)(&OtherLibraryCallback, &args);
- }
-
- // Volatile to prevent a tail call to GetProgramCounter().
- const void* volatile program_counter = GetProgramCounter();
- return program_counter;
-}
-
-// static
-void TargetThread::OtherLibraryCallback(void *arg) {
- const TargetFunctionArgs* args = static_cast<TargetFunctionArgs*>(arg);
- SignalAndWaitUntilSignaled(args->thread_started_event, args->finish_event,
- args->stack_config);
- // Prevent tail call.
- volatile int i = 0;
- ALLOW_UNUSED_LOCAL(i);
-}
-
-// static
-// Disable inlining for this function so that it gets its own stack frame.
-NOINLINE const void* TargetThread::GetProgramCounter() {
-#if defined(OS_WIN)
- return _ReturnAddress();
-#else
- return __builtin_return_address(0);
-#endif
-}
-
-// Loads the other library, which defines a function to be called in the
-// WITH_OTHER_LIBRARY configuration.
-NativeLibrary LoadOtherLibrary() {
- // The lambda gymnastics works around the fact that we can't use ASSERT_*
- // macros in a function returning non-null.
- const auto load = [](NativeLibrary* library) {
- FilePath other_library_path;
- ASSERT_TRUE(PathService::Get(DIR_EXE, &other_library_path));
- other_library_path = other_library_path.AppendASCII(
- GetNativeLibraryName("base_profiler_test_support_library"));
- NativeLibraryLoadError load_error;
- *library = LoadNativeLibrary(other_library_path, &load_error);
- ASSERT_TRUE(*library) << "error loading " << other_library_path.value()
- << ": " << load_error.ToString();
- };
-
- NativeLibrary library = nullptr;
- load(&library);
- return library;
-}
-
-// Unloads |library| and returns when it has completed unloading. Unloading a
-// library is asynchronous on Windows, so simply calling UnloadNativeLibrary()
-// is insufficient to ensure it's been unloaded.
-void SynchronousUnloadNativeLibrary(NativeLibrary library) {
- UnloadNativeLibrary(library);
-#if defined(OS_WIN)
- // NativeLibrary is a typedef for HMODULE, which is actually the base address
- // of the module.
- uintptr_t module_base_address = reinterpret_cast<uintptr_t>(library);
- HMODULE module_handle;
- // Keep trying to get the module handle until the call fails.
- while (::GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
- GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
- reinterpret_cast<LPCTSTR>(module_base_address),
- &module_handle) ||
- ::GetLastError() != ERROR_MOD_NOT_FOUND) {
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
- }
-#elif defined(OS_MACOSX)
-// Unloading a library on the Mac is synchronous.
-#else
- NOTIMPLEMENTED();
-#endif
-}
-
-// Called on the profiler thread when complete, to collect profiles.
-void SaveProfiles(CallStackProfiles* profiles,
- CallStackProfiles pending_profiles) {
- *profiles = std::move(pending_profiles);
-}
-
-// Called on the profiler thread when complete. Collects profiles produced by
-// the profiler, and signals an event to allow the main thread to know that that
-// the profiler is done.
-void SaveProfilesAndSignalEvent(CallStackProfiles* profiles,
- WaitableEvent* event,
- CallStackProfiles pending_profiles) {
- *profiles = std::move(pending_profiles);
- event->Signal();
-}
-
-// Executes the function with the target thread running and executing within
-// SignalAndWaitUntilSignaled(). Performs all necessary target thread startup
-// and shutdown work before and afterward.
-template <class Function>
-void WithTargetThread(Function function,
- const StackConfiguration& stack_config) {
- TargetThread target_thread(stack_config);
- PlatformThreadHandle target_thread_handle;
- EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
-
- target_thread.WaitForThreadStart();
-
- function(target_thread.id());
-
- target_thread.SignalThreadToFinish();
-
- PlatformThread::Join(target_thread_handle);
-}
-
-template <class Function>
-void WithTargetThread(Function function) {
- WithTargetThread(function, StackConfiguration(StackConfiguration::NORMAL));
-}
-
-struct TestProfilerInfo {
- TestProfilerInfo(PlatformThreadId thread_id,
- const SamplingParams& params,
- NativeStackSamplerTestDelegate* delegate = nullptr)
- : completed(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- profiler(thread_id,
- params,
- Bind(&SaveProfilesAndSignalEvent,
- Unretained(&profiles),
- Unretained(&completed)),
- delegate) {}
-
- // The order here is important to ensure objects being referenced don't get
- // destructed until after the objects referencing them.
- CallStackProfiles profiles;
- WaitableEvent completed;
- StackSamplingProfiler profiler;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TestProfilerInfo);
-};
-
-// Creates multiple profilers based on a vector of parameters.
-std::vector<std::unique_ptr<TestProfilerInfo>> CreateProfilers(
- PlatformThreadId target_thread_id,
- const std::vector<SamplingParams>& params) {
- DCHECK(!params.empty());
-
- std::vector<std::unique_ptr<TestProfilerInfo>> profilers;
- for (size_t i = 0; i < params.size(); ++i) {
- profilers.push_back(
- std::make_unique<TestProfilerInfo>(target_thread_id, params[i]));
- }
-
- return profilers;
-}
-
-// Captures profiles as specified by |params| on the TargetThread, and returns
-// them in |profiles|. Waits up to |profiler_wait_time| for the profiler to
-// complete.
-void CaptureProfiles(const SamplingParams& params, TimeDelta profiler_wait_time,
- CallStackProfiles* profiles) {
- WithTargetThread([¶ms, profiles,
- profiler_wait_time](PlatformThreadId target_thread_id) {
- TestProfilerInfo info(target_thread_id, params);
- info.profiler.Start();
- info.completed.TimedWait(profiler_wait_time);
- info.profiler.Stop();
- info.completed.Wait();
-
- *profiles = std::move(info.profiles);
- });
-}
-
-// Waits for one of multiple samplings to complete.
-size_t WaitForSamplingComplete(
- const std::vector<std::unique_ptr<TestProfilerInfo>>& infos) {
- // Map unique_ptrs to something that WaitMany can accept.
- std::vector<WaitableEvent*> sampling_completed_rawptrs(infos.size());
- std::transform(infos.begin(), infos.end(), sampling_completed_rawptrs.begin(),
- [](const std::unique_ptr<TestProfilerInfo>& info) {
- return &info.get()->completed;
- });
- // Wait for one profiler to finish.
- return WaitableEvent::WaitMany(sampling_completed_rawptrs.data(),
- sampling_completed_rawptrs.size());
-}
-
-// If this executable was linked with /INCREMENTAL (the default for non-official
-// debug and release builds on Windows), function addresses do not correspond to
-// function code itself, but instead to instructions in the Incremental Link
-// Table that jump to the functions. Checks for a jump instruction and if
-// present does a little decompilation to find the function's actual starting
-// address.
-const void* MaybeFixupFunctionAddressForILT(const void* function_address) {
-#if defined(_WIN64)
- const unsigned char* opcode =
- reinterpret_cast<const unsigned char*>(function_address);
- if (*opcode == 0xe9) {
- // This is a relative jump instruction. Assume we're in the ILT and compute
- // the function start address from the instruction offset.
- const int32_t* offset = reinterpret_cast<const int32_t*>(opcode + 1);
- const unsigned char* next_instruction =
- reinterpret_cast<const unsigned char*>(offset + 1);
- return next_instruction + *offset;
- }
-#endif
- return function_address;
-}
-
-// Searches through the frames in |sample|, returning an iterator to the first
-// frame that has an instruction pointer within |target_function|. Returns
-// sample.end() if no such frames are found.
-Frames::const_iterator FindFirstFrameWithinFunction(
- const Sample& sample,
- TargetFunction target_function) {
- uintptr_t function_start = reinterpret_cast<uintptr_t>(
- MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- target_function)));
- uintptr_t function_end =
- reinterpret_cast<uintptr_t>(target_function(nullptr, nullptr, nullptr));
- for (auto it = sample.frames.begin(); it != sample.frames.end(); ++it) {
- if ((it->instruction_pointer >= function_start) &&
- (it->instruction_pointer <= function_end))
- return it;
- }
- return sample.frames.end();
-}
-
-// Formats a sample into a string that can be output for test diagnostics.
-std::string FormatSampleForDiagnosticOutput(
- const Sample& sample,
- const std::vector<Module>& modules) {
- std::string output;
- for (const Frame& frame : sample.frames) {
- output += StringPrintf(
- "0x%p %s\n", reinterpret_cast<const void*>(frame.instruction_pointer),
- modules[frame.module_index].filename.AsUTF8Unsafe().c_str());
- }
- return output;
-}
-
-// Returns a duration that is longer than the test timeout. We would use
-// TimeDelta::Max() but https://crbug.com/465948.
-TimeDelta AVeryLongTimeDelta() { return TimeDelta::FromDays(1); }
-
-// Tests the scenario where the library is unloaded after copying the stack, but
-// before walking it. If |wait_until_unloaded| is true, ensures that the
-// asynchronous library loading has completed before walking the stack. If
-// false, the unloading may still be occurring during the stack walk.
-void TestLibraryUnload(bool wait_until_unloaded) {
- // Test delegate that supports intervening between the copying of the stack
- // and the walking of the stack.
- class StackCopiedSignaler : public NativeStackSamplerTestDelegate {
- public:
- StackCopiedSignaler(WaitableEvent* stack_copied,
- WaitableEvent* start_stack_walk,
- bool wait_to_walk_stack)
- : stack_copied_(stack_copied),
- start_stack_walk_(start_stack_walk),
- wait_to_walk_stack_(wait_to_walk_stack) {}
-
- void OnPreStackWalk() override {
- stack_copied_->Signal();
- if (wait_to_walk_stack_)
- start_stack_walk_->Wait();
- }
-
- private:
- WaitableEvent* const stack_copied_;
- WaitableEvent* const start_stack_walk_;
- const bool wait_to_walk_stack_;
- };
-
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- NativeLibrary other_library = LoadOtherLibrary();
- TargetThread target_thread(StackConfiguration(
- StackConfiguration::WITH_OTHER_LIBRARY,
- other_library));
-
- PlatformThreadHandle target_thread_handle;
- EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
-
- target_thread.WaitForThreadStart();
-
- WaitableEvent sampling_thread_completed(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- std::vector<CallStackProfile> profiles;
- const StackSamplingProfiler::CompletedCallback callback =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
- Unretained(&sampling_thread_completed));
- WaitableEvent stack_copied(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent start_stack_walk(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- StackCopiedSignaler test_delegate(&stack_copied, &start_stack_walk,
- wait_until_unloaded);
- StackSamplingProfiler profiler(target_thread.id(), params, callback,
- &test_delegate);
-
- profiler.Start();
-
- // Wait for the stack to be copied and the target thread to be resumed.
- stack_copied.Wait();
-
- // Cause the target thread to finish, so that it's no longer executing code in
- // the library we're about to unload.
- target_thread.SignalThreadToFinish();
- PlatformThread::Join(target_thread_handle);
-
- // Unload the library now that it's not being used.
- if (wait_until_unloaded)
- SynchronousUnloadNativeLibrary(other_library);
- else
- UnloadNativeLibrary(other_library);
-
- // Let the stack walk commence after unloading the library, if we're waiting
- // on that event.
- start_stack_walk.Signal();
-
- // Wait for the sampling thread to complete and fill out |profiles|.
- sampling_thread_completed.Wait();
-
- // Look up the sample.
- ASSERT_EQ(1u, profiles.size());
- const CallStackProfile& profile = profiles[0];
- ASSERT_EQ(1u, profile.samples.size());
- const Sample& sample = profile.samples[0];
-
- // Check that the stack contains a frame for
- // TargetThread::SignalAndWaitUntilSignaled().
- Frames::const_iterator end_frame = FindFirstFrameWithinFunction(
- sample, &TargetThread::SignalAndWaitUntilSignaled);
- ASSERT_TRUE(end_frame != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- &TargetThread::SignalAndWaitUntilSignaled))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-
- if (wait_until_unloaded) {
- // The stack should look like this, resulting one frame after
- // SignalAndWaitUntilSignaled. The frame in the now-unloaded library is not
- // recorded since we can't get module information.
- //
- // ... WaitableEvent and system frames ...
- // TargetThread::SignalAndWaitUntilSignaled
- // TargetThread::OtherLibraryCallback
- EXPECT_EQ(2, sample.frames.end() - end_frame)
- << "Stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
- } else {
- // We didn't wait for the asynchronous unloading to complete, so the results
- // are non-deterministic: if the library finished unloading we should have
- // the same stack as |wait_until_unloaded|, if not we should have the full
- // stack. The important thing is that we should not crash.
-
- if (sample.frames.end() - end_frame == 2) {
- // This is the same case as |wait_until_unloaded|.
- return;
- }
-
- // Check that the stack contains a frame for
- // TargetThread::CallThroughOtherLibrary().
- Frames::const_iterator other_library_frame = FindFirstFrameWithinFunction(
- sample, &TargetThread::CallThroughOtherLibrary);
- ASSERT_TRUE(other_library_frame != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- &TargetThread::CallThroughOtherLibrary))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-
- // The stack should look like this, resulting in three frames between
- // SignalAndWaitUntilSignaled and CallThroughOtherLibrary:
- //
- // ... WaitableEvent and system frames ...
- // TargetThread::SignalAndWaitUntilSignaled
- // TargetThread::OtherLibraryCallback
- // InvokeCallbackFunction (in other library)
- // TargetThread::CallThroughOtherLibrary
- EXPECT_EQ(3, other_library_frame - end_frame)
- << "Stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
- }
-}
-
-// Provide a suitable (and clean) environment for the tests below. All tests
-// must use this class to ensure that proper clean-up is done and thus be
-// usable in a later test.
-class StackSamplingProfilerTest : public testing::Test {
- public:
- void SetUp() override {
- // The idle-shutdown time is too long for convenient (and accurate) testing.
- // That behavior is checked instead by artificially triggering it through
- // the TestAPI.
- StackSamplingProfiler::TestAPI::DisableIdleShutdown();
- }
-
- void TearDown() override {
- // Be a good citizen and clean up after ourselves. This also re-enables the
- // idle-shutdown behavior.
- StackSamplingProfiler::TestAPI::Reset();
- }
-};
-
-} // namespace
-
-// Checks that the basic expected information is present in a sampled call stack
-// profile.
-// macOS ASAN is not yet supported - crbug.com/718628.
-#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
-#define MAYBE_Basic Basic
-#else
-#define MAYBE_Basic DISABLED_Basic
-#endif
-PROFILER_TEST_F(StackSamplingProfilerTest, MAYBE_Basic) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
-
- // Check that the profile and samples sizes are correct, and the module
- // indices are in range.
- ASSERT_EQ(1u, profiles.size());
- const CallStackProfile& profile = profiles[0];
- ASSERT_EQ(1u, profile.samples.size());
- EXPECT_EQ(params.sampling_interval, profile.sampling_period);
- const Sample& sample = profile.samples[0];
- EXPECT_EQ(0u, sample.process_milestones);
- for (const auto& frame : sample.frames) {
- ASSERT_GE(frame.module_index, 0u);
- ASSERT_LT(frame.module_index, profile.modules.size());
- }
-
- // Check that the stack contains a frame for
- // TargetThread::SignalAndWaitUntilSignaled() and that the frame has this
- // executable's module.
- Frames::const_iterator loc = FindFirstFrameWithinFunction(
- sample, &TargetThread::SignalAndWaitUntilSignaled);
- ASSERT_TRUE(loc != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- &TargetThread::SignalAndWaitUntilSignaled))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
- FilePath executable_path;
- EXPECT_TRUE(PathService::Get(FILE_EXE, &executable_path));
- EXPECT_EQ(executable_path,
- MakeAbsoluteFilePath(profile.modules[loc->module_index].filename));
-}
-
-// Checks that annotations are recorded in samples.
-PROFILER_TEST_F(StackSamplingProfilerTest, Annotations) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- // Check that a run picks up annotations.
- StackSamplingProfiler::SetProcessMilestone(1);
- std::vector<CallStackProfile> profiles1;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles1);
- ASSERT_EQ(1u, profiles1.size());
- const CallStackProfile& profile1 = profiles1[0];
- ASSERT_EQ(1u, profile1.samples.size());
- const Sample& sample1 = profile1.samples[0];
- EXPECT_EQ(1u << 1, sample1.process_milestones);
-
- // Run it a second time but with changed annotations. These annotations
- // should appear in the first acquired sample.
- StackSamplingProfiler::SetProcessMilestone(2);
- std::vector<CallStackProfile> profiles2;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles2);
- ASSERT_EQ(1u, profiles2.size());
- const CallStackProfile& profile2 = profiles2[0];
- ASSERT_EQ(1u, profile2.samples.size());
- const Sample& sample2 = profile2.samples[0];
- EXPECT_EQ(sample1.process_milestones | (1u << 2), sample2.process_milestones);
-}
-
-// Checks that the profiler handles stacks containing dynamically-allocated
-// stack memory.
-// macOS ASAN is not yet supported - crbug.com/718628.
-#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
-#define MAYBE_Alloca Alloca
-#else
-#define MAYBE_Alloca DISABLED_Alloca
-#endif
-PROFILER_TEST_F(StackSamplingProfilerTest, MAYBE_Alloca) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- WithTargetThread(
- [¶ms, &profiles](PlatformThreadId target_thread_id) {
- WaitableEvent sampling_thread_completed(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- const StackSamplingProfiler::CompletedCallback callback =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
- Unretained(&sampling_thread_completed));
- StackSamplingProfiler profiler(target_thread_id, params, callback);
- profiler.Start();
- sampling_thread_completed.Wait();
- },
- StackConfiguration(StackConfiguration::WITH_ALLOCA));
-
- // Look up the sample.
- ASSERT_EQ(1u, profiles.size());
- const CallStackProfile& profile = profiles[0];
- ASSERT_EQ(1u, profile.samples.size());
- const Sample& sample = profile.samples[0];
-
- // Check that the stack contains a frame for
- // TargetThread::SignalAndWaitUntilSignaled().
- Frames::const_iterator end_frame = FindFirstFrameWithinFunction(
- sample, &TargetThread::SignalAndWaitUntilSignaled);
- ASSERT_TRUE(end_frame != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- &TargetThread::SignalAndWaitUntilSignaled))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-
- // Check that the stack contains a frame for TargetThread::CallWithAlloca().
- Frames::const_iterator alloca_frame =
- FindFirstFrameWithinFunction(sample, &TargetThread::CallWithAlloca);
- ASSERT_TRUE(alloca_frame != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(
- reinterpret_cast<const void*>(&TargetThread::CallWithAlloca))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-
- // These frames should be adjacent on the stack.
- EXPECT_EQ(1, alloca_frame - end_frame)
- << "Stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-}
-
-// Checks that the expected number of profiles and samples are present in the
-// call stack profiles produced.
-PROFILER_TEST_F(StackSamplingProfilerTest, MultipleProfilesAndSamples) {
- SamplingParams params;
- params.burst_interval = params.sampling_interval =
- TimeDelta::FromMilliseconds(0);
- params.bursts = 2;
- params.samples_per_burst = 3;
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
-
- ASSERT_EQ(2u, profiles.size());
- EXPECT_EQ(3u, profiles[0].samples.size());
- EXPECT_EQ(3u, profiles[1].samples.size());
-}
-
-// Checks that a profiler can stop/destruct without ever having started.
-PROFILER_TEST_F(StackSamplingProfilerTest, StopWithoutStarting) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- CallStackProfiles profiles;
- WaitableEvent sampling_completed(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- const StackSamplingProfiler::CompletedCallback callback =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
- Unretained(&sampling_completed));
- StackSamplingProfiler profiler(target_thread_id, params, callback);
-
- profiler.Stop(); // Constructed but never started.
- EXPECT_FALSE(sampling_completed.IsSignaled());
- });
-}
-
-// Checks that its okay to stop a profiler before it finishes even when the
-// sampling thread continues to run.
-PROFILER_TEST_F(StackSamplingProfilerTest, StopSafely) {
- // Test delegate that counts samples.
- class SampleRecordedCounter : public NativeStackSamplerTestDelegate {
- public:
- SampleRecordedCounter() = default;
-
- void OnPreStackWalk() override {
- AutoLock lock(lock_);
- ++count_;
- }
-
- size_t Get() {
- AutoLock lock(lock_);
- return count_;
- }
-
- private:
- Lock lock_;
- size_t count_ = 0;
- };
-
- WithTargetThread([](PlatformThreadId target_thread_id) {
- SamplingParams params[2];
-
- // Providing an initial delay makes it more likely that both will be
- // scheduled before either starts to run. Once started, samples will
- // run ordered by their scheduled, interleaved times regardless of
- // whatever interval the thread wakes up.
- params[0].initial_delay = TimeDelta::FromMilliseconds(10);
- params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[0].samples_per_burst = 100000;
-
- params[1].initial_delay = TimeDelta::FromMilliseconds(10);
- params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[1].samples_per_burst = 100000;
-
- SampleRecordedCounter samples_recorded[arraysize(params)];
-
- TestProfilerInfo profiler_info0(target_thread_id, params[0],
- &samples_recorded[0]);
- TestProfilerInfo profiler_info1(target_thread_id, params[1],
- &samples_recorded[1]);
-
- profiler_info0.profiler.Start();
- profiler_info1.profiler.Start();
-
- // Wait for both to start accumulating samples. Using a WaitableEvent is
- // possible but gets complicated later on because there's no way of knowing
- // if 0 or 1 additional sample will be taken after Stop() and thus no way
- // of knowing how many Wait() calls to make on it.
- while (samples_recorded[0].Get() == 0 || samples_recorded[1].Get() == 0)
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
-
- // Ensure that the first sampler can be safely stopped while the second
- // continues to run. The stopped first profiler will still have a
- // PerformCollectionTask pending that will do nothing when executed because
- // the collection will have been removed by Stop().
- profiler_info0.profiler.Stop();
- profiler_info0.completed.Wait();
- size_t count0 = samples_recorded[0].Get();
- size_t count1 = samples_recorded[1].Get();
-
- // Waiting for the second sampler to collect a couple samples ensures that
- // the pending PerformCollectionTask for the first has executed because
- // tasks are always ordered by their next scheduled time.
- while (samples_recorded[1].Get() < count1 + 2)
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
-
- // Ensure that the first profiler didn't do anything since it was stopped.
- EXPECT_EQ(count0, samples_recorded[0].Get());
- });
-}
-
-// Checks that no call stack profiles are captured if the profiling is stopped
-// during the initial delay.
-PROFILER_TEST_F(StackSamplingProfilerTest, StopDuringInitialDelay) {
- SamplingParams params;
- params.initial_delay = TimeDelta::FromSeconds(60);
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, TimeDelta::FromMilliseconds(0), &profiles);
-
- EXPECT_TRUE(profiles.empty());
-}
-
-// Checks that the single completed call stack profile is captured if the
-// profiling is stopped between bursts.
-PROFILER_TEST_F(StackSamplingProfilerTest, StopDuringInterBurstInterval) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.burst_interval = TimeDelta::FromSeconds(60);
- params.bursts = 2;
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, TimeDelta::FromMilliseconds(50), &profiles);
-
- ASSERT_EQ(1u, profiles.size());
- EXPECT_EQ(1u, profiles[0].samples.size());
-}
-
-// Checks that tasks can be stopped before completion and incomplete call stack
-// profiles are captured.
-PROFILER_TEST_F(StackSamplingProfilerTest, StopDuringInterSampleInterval) {
- // Test delegate that counts samples.
- class SampleRecordedEvent : public NativeStackSamplerTestDelegate {
- public:
- SampleRecordedEvent()
- : sample_recorded_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- void OnPreStackWalk() override { sample_recorded_.Signal(); }
-
- void WaitForSample() { sample_recorded_.Wait(); }
-
- private:
- WaitableEvent sample_recorded_;
- };
-
- WithTargetThread([](PlatformThreadId target_thread_id) {
- SamplingParams params;
-
- params.sampling_interval = AVeryLongTimeDelta();
- params.samples_per_burst = 2;
-
- SampleRecordedEvent samples_recorded;
- TestProfilerInfo profiler_info(target_thread_id, params, &samples_recorded);
-
- profiler_info.profiler.Start();
-
- // Wait for profiler to start accumulating samples.
- samples_recorded.WaitForSample();
-
- // Ensure that it can stop safely.
- profiler_info.profiler.Stop();
- profiler_info.completed.Wait();
-
- ASSERT_EQ(1u, profiler_info.profiles.size());
- EXPECT_EQ(1u, profiler_info.profiles[0].samples.size());
- });
-}
-
-// Checks that we can destroy the profiler while profiling.
-PROFILER_TEST_F(StackSamplingProfilerTest, DestroyProfilerWhileProfiling) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(10);
-
- CallStackProfiles profiles;
- WithTargetThread([¶ms, &profiles](PlatformThreadId target_thread_id) {
- std::unique_ptr<StackSamplingProfiler> profiler;
- profiler.reset(new StackSamplingProfiler(
- target_thread_id, params, Bind(&SaveProfiles, Unretained(&profiles))));
- profiler->Start();
- profiler.reset();
-
- // Wait longer than a sample interval to catch any use-after-free actions by
- // the profiler thread.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
- });
-}
-
-// Checks that the same profiler may be run multiple times.
-PROFILER_TEST_F(StackSamplingProfilerTest, CanRunMultipleTimes) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- CallStackProfiles profiles;
- WaitableEvent sampling_completed(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- const StackSamplingProfiler::CompletedCallback callback =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
- Unretained(&sampling_completed));
- StackSamplingProfiler profiler(target_thread_id, params, callback);
-
- // Just start and stop to execute code paths.
- profiler.Start();
- profiler.Stop();
- sampling_completed.Wait();
-
- // Ensure a second request will run and not block.
- sampling_completed.Reset();
- profiles.clear();
- profiler.Start();
- sampling_completed.Wait();
- profiler.Stop();
- ASSERT_EQ(1u, profiles.size());
- });
-}
-
-// Checks that the different profilers may be run.
-PROFILER_TEST_F(StackSamplingProfilerTest, CanRunMultipleProfilers) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
- ASSERT_EQ(1u, profiles.size());
-
- profiles.clear();
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
- ASSERT_EQ(1u, profiles.size());
-}
-
-// Checks that a sampler can be started while another is running.
-PROFILER_TEST_F(StackSamplingProfilerTest, MultipleStart) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- std::vector<SamplingParams> params(2);
-
- params[0].initial_delay = AVeryLongTimeDelta();
- params[0].samples_per_burst = 1;
-
- params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[1].samples_per_burst = 1;
-
- std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
- CreateProfilers(target_thread_id, params);
-
- profiler_infos[0]->profiler.Start();
- profiler_infos[1]->profiler.Start();
- profiler_infos[1]->completed.Wait();
- EXPECT_EQ(1u, profiler_infos[1]->profiles.size());
- });
-}
-
-// Checks that the sampling thread can shut down.
-PROFILER_TEST_F(StackSamplingProfilerTest, SamplerIdleShutdown) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
- ASSERT_EQ(1u, profiles.size());
-
- // Capture thread should still be running at this point.
- ASSERT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
-
- // Initiate an "idle" shutdown and ensure it happens. Idle-shutdown was
- // disabled by the test fixture so the test will fail due to a timeout if
- // it does not exit.
- StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(false);
-
- // While the shutdown has been initiated, the actual exit of the thread still
- // happens asynchronously. Watch until the thread actually exits. This test
- // will time-out in the case of failure.
- while (StackSamplingProfiler::TestAPI::IsSamplingThreadRunning())
- PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
-}
-
-// Checks that additional requests will restart a stopped profiler.
-PROFILER_TEST_F(StackSamplingProfilerTest,
- WillRestartSamplerAfterIdleShutdown) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
- ASSERT_EQ(1u, profiles.size());
-
- // Capture thread should still be running at this point.
- ASSERT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
-
- // Post a ShutdownTask on the sampling thread which, when executed, will
- // mark the thread as EXITING and begin shut down of the thread.
- StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(false);
-
- // Ensure another capture will start the sampling thread and run.
- profiles.clear();
- CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
- ASSERT_EQ(1u, profiles.size());
- EXPECT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
-}
-
-// Checks that it's safe to stop a task after it's completed and the sampling
-// thread has shut-down for being idle.
-PROFILER_TEST_F(StackSamplingProfilerTest, StopAfterIdleShutdown) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- SamplingParams params;
-
- params.sampling_interval = TimeDelta::FromMilliseconds(1);
- params.samples_per_burst = 1;
-
- TestProfilerInfo profiler_info(target_thread_id, params);
-
- profiler_info.profiler.Start();
- profiler_info.completed.Wait();
-
- // Capture thread should still be running at this point.
- ASSERT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
-
- // Perform an idle shutdown.
- StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(false);
-
- // Stop should be safe though its impossible to know at this moment if the
- // sampling thread has completely exited or will just "stop soon".
- profiler_info.profiler.Stop();
- });
-}
-
-// Checks that profilers can run both before and after the sampling thread has
-// started.
-PROFILER_TEST_F(StackSamplingProfilerTest,
- ProfileBeforeAndAfterSamplingThreadRunning) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- std::vector<SamplingParams> params(2);
-
- params[0].initial_delay = AVeryLongTimeDelta();
- params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[0].samples_per_burst = 1;
-
- params[1].initial_delay = TimeDelta::FromMilliseconds(0);
- params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[1].samples_per_burst = 1;
-
- std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
- CreateProfilers(target_thread_id, params);
-
- // First profiler is started when there has never been a sampling thread.
- EXPECT_FALSE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
- profiler_infos[0]->profiler.Start();
- // Second profiler is started when sampling thread is already running.
- EXPECT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
- profiler_infos[1]->profiler.Start();
-
- // Only the second profiler should finish before test times out.
- size_t completed_profiler = WaitForSamplingComplete(profiler_infos);
- EXPECT_EQ(1U, completed_profiler);
- });
-}
-
-// Checks that an idle-shutdown task will abort if a new profiler starts
-// between when it was posted and when it runs.
-PROFILER_TEST_F(StackSamplingProfilerTest, IdleShutdownAbort) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- SamplingParams params;
-
- params.sampling_interval = TimeDelta::FromMilliseconds(1);
- params.samples_per_burst = 1;
-
- TestProfilerInfo profiler_info(target_thread_id, params);
-
- profiler_info.profiler.Start();
- profiler_info.completed.Wait();
- EXPECT_EQ(1u, profiler_info.profiles.size());
-
- // Perform an idle shutdown but simulate that a new capture is started
- // before it can actually run.
- StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(true);
-
- // Though the shutdown-task has been executed, any actual exit of the
- // thread is asynchronous so there is no way to detect that *didn't* exit
- // except to wait a reasonable amount of time and then check. Since the
- // thread was just running ("perform" blocked until it was), it should
- // finish almost immediately and without any waiting for tasks or events.
- PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
- EXPECT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
-
- // Ensure that it's still possible to run another sampler.
- TestProfilerInfo another_info(target_thread_id, params);
- another_info.profiler.Start();
- another_info.completed.Wait();
- EXPECT_EQ(1u, another_info.profiles.size());
- });
-}
-
-// Checks that synchronized multiple sampling requests execute in parallel.
-PROFILER_TEST_F(StackSamplingProfilerTest, ConcurrentProfiling_InSync) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- std::vector<SamplingParams> params(2);
-
- // Providing an initial delay makes it more likely that both will be
- // scheduled before either starts to run. Once started, samples will
- // run ordered by their scheduled, interleaved times regardless of
- // whatever interval the thread wakes up. Thus, total execution time
- // will be 10ms (delay) + 10x1ms (sampling) + 1/2 timer minimum interval.
- params[0].initial_delay = TimeDelta::FromMilliseconds(10);
- params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[0].samples_per_burst = 9;
-
- params[1].initial_delay = TimeDelta::FromMilliseconds(11);
- params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
- params[1].samples_per_burst = 8;
-
- std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
- CreateProfilers(target_thread_id, params);
-
- profiler_infos[0]->profiler.Start();
- profiler_infos[1]->profiler.Start();
-
- // Wait for one profiler to finish.
- size_t completed_profiler = WaitForSamplingComplete(profiler_infos);
- ASSERT_EQ(1u, profiler_infos[completed_profiler]->profiles.size());
-
- size_t other_profiler = 1 - completed_profiler;
- // Wait for the other profiler to finish.
- profiler_infos[other_profiler]->completed.Wait();
- ASSERT_EQ(1u, profiler_infos[other_profiler]->profiles.size());
-
- // Ensure each got the correct number of samples.
- EXPECT_EQ(9u, profiler_infos[0]->profiles[0].samples.size());
- EXPECT_EQ(8u, profiler_infos[1]->profiles[0].samples.size());
- });
-}
-
-// Checks that several mixed sampling requests execute in parallel.
-PROFILER_TEST_F(StackSamplingProfilerTest, ConcurrentProfiling_Mixed) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- std::vector<SamplingParams> params(3);
-
- params[0].initial_delay = TimeDelta::FromMilliseconds(8);
- params[0].sampling_interval = TimeDelta::FromMilliseconds(4);
- params[0].samples_per_burst = 10;
-
- params[1].initial_delay = TimeDelta::FromMilliseconds(9);
- params[1].sampling_interval = TimeDelta::FromMilliseconds(3);
- params[1].samples_per_burst = 10;
-
- params[2].initial_delay = TimeDelta::FromMilliseconds(10);
- params[2].sampling_interval = TimeDelta::FromMilliseconds(2);
- params[2].samples_per_burst = 10;
-
- std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
- CreateProfilers(target_thread_id, params);
-
- for (size_t i = 0; i < profiler_infos.size(); ++i)
- profiler_infos[i]->profiler.Start();
-
- // Wait for one profiler to finish.
- size_t completed_profiler = WaitForSamplingComplete(profiler_infos);
- EXPECT_EQ(1u, profiler_infos[completed_profiler]->profiles.size());
- // Stop and destroy all profilers, always in the same order. Don't crash.
- for (size_t i = 0; i < profiler_infos.size(); ++i)
- profiler_infos[i]->profiler.Stop();
- for (size_t i = 0; i < profiler_infos.size(); ++i)
- profiler_infos[i].reset();
- });
-}
-
-// Checks that a stack that runs through another library produces a stack with
-// the expected functions.
-// macOS ASAN is not yet supported - crbug.com/718628.
-#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
-#define MAYBE_OtherLibrary OtherLibrary
-#else
-#define MAYBE_OtherLibrary DISABLED_OtherLibrary
-#endif
-PROFILER_TEST_F(StackSamplingProfilerTest, MAYBE_OtherLibrary) {
- SamplingParams params;
- params.sampling_interval = TimeDelta::FromMilliseconds(0);
- params.samples_per_burst = 1;
-
- std::vector<CallStackProfile> profiles;
- {
- ScopedNativeLibrary other_library(LoadOtherLibrary());
- WithTargetThread(
- [¶ms, &profiles](PlatformThreadId target_thread_id) {
- WaitableEvent sampling_thread_completed(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- const StackSamplingProfiler::CompletedCallback callback =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
- Unretained(&sampling_thread_completed));
- StackSamplingProfiler profiler(target_thread_id, params, callback);
- profiler.Start();
- sampling_thread_completed.Wait();
- },
- StackConfiguration(StackConfiguration::WITH_OTHER_LIBRARY,
- other_library.get()));
- }
-
- // Look up the sample.
- ASSERT_EQ(1u, profiles.size());
- const CallStackProfile& profile = profiles[0];
- ASSERT_EQ(1u, profile.samples.size());
- const Sample& sample = profile.samples[0];
-
- // Check that the stack contains a frame for
- // TargetThread::CallThroughOtherLibrary().
- Frames::const_iterator other_library_frame = FindFirstFrameWithinFunction(
- sample, &TargetThread::CallThroughOtherLibrary);
- ASSERT_TRUE(other_library_frame != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- &TargetThread::CallThroughOtherLibrary))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-
- // Check that the stack contains a frame for
- // TargetThread::SignalAndWaitUntilSignaled().
- Frames::const_iterator end_frame = FindFirstFrameWithinFunction(
- sample, &TargetThread::SignalAndWaitUntilSignaled);
- ASSERT_TRUE(end_frame != sample.frames.end())
- << "Function at "
- << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
- &TargetThread::SignalAndWaitUntilSignaled))
- << " was not found in stack:\n"
- << FormatSampleForDiagnosticOutput(sample, profile.modules);
-
- // The stack should look like this, resulting in three frames between
- // SignalAndWaitUntilSignaled and CallThroughOtherLibrary:
- //
- // ... WaitableEvent and system frames ...
- // TargetThread::SignalAndWaitUntilSignaled
- // TargetThread::OtherLibraryCallback
- // InvokeCallbackFunction (in other library)
- // TargetThread::CallThroughOtherLibrary
- EXPECT_EQ(3, other_library_frame - end_frame)
- << "Stack:\n" << FormatSampleForDiagnosticOutput(sample, profile.modules);
-}
-
-// Checks that a stack that runs through a library that is unloading produces a
-// stack, and doesn't crash.
-// Unloading is synchronous on the Mac, so this test is inapplicable.
-#if !defined(OS_MACOSX)
-#define MAYBE_UnloadingLibrary UnloadingLibrary
-#else
-#define MAYBE_UnloadingLibrary DISABLED_UnloadingLibrary
-#endif
-PROFILER_TEST_F(StackSamplingProfilerTest, MAYBE_UnloadingLibrary) {
- TestLibraryUnload(false);
-}
-
-// Checks that a stack that runs through a library that has been unloaded
-// produces a stack, and doesn't crash.
-// macOS ASAN is not yet supported - crbug.com/718628.
-#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
-#define MAYBE_UnloadedLibrary UnloadedLibrary
-#else
-#define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
-#endif
-PROFILER_TEST_F(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
- TestLibraryUnload(true);
-}
-
-// Checks that different threads can be sampled in parallel.
-PROFILER_TEST_F(StackSamplingProfilerTest, MultipleSampledThreads) {
- // Create target threads. The extra parethesis around the StackConfiguration
- // call are to avoid the most-vexing-parse problem.
- TargetThread target_thread1((StackConfiguration(StackConfiguration::NORMAL)));
- TargetThread target_thread2((StackConfiguration(StackConfiguration::NORMAL)));
- PlatformThreadHandle target_thread_handle1, target_thread_handle2;
- EXPECT_TRUE(
- PlatformThread::Create(0, &target_thread1, &target_thread_handle1));
- EXPECT_TRUE(
- PlatformThread::Create(0, &target_thread2, &target_thread_handle2));
- target_thread1.WaitForThreadStart();
- target_thread2.WaitForThreadStart();
-
- // Providing an initial delay makes it more likely that both will be
- // scheduled before either starts to run. Once started, samples will
- // run ordered by their scheduled, interleaved times regardless of
- // whatever interval the thread wakes up.
- SamplingParams params1, params2;
- params1.initial_delay = TimeDelta::FromMilliseconds(10);
- params1.sampling_interval = TimeDelta::FromMilliseconds(1);
- params1.samples_per_burst = 9;
- params2.initial_delay = TimeDelta::FromMilliseconds(10);
- params2.sampling_interval = TimeDelta::FromMilliseconds(1);
- params2.samples_per_burst = 8;
-
- std::vector<CallStackProfile> profiles1, profiles2;
-
- WaitableEvent sampling_thread_completed1(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- const StackSamplingProfiler::CompletedCallback callback1 =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles1),
- Unretained(&sampling_thread_completed1));
- StackSamplingProfiler profiler1(target_thread1.id(), params1, callback1);
-
- WaitableEvent sampling_thread_completed2(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- const StackSamplingProfiler::CompletedCallback callback2 =
- Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles2),
- Unretained(&sampling_thread_completed2));
- StackSamplingProfiler profiler2(target_thread2.id(), params2, callback2);
-
- // Finally the real work.
- profiler1.Start();
- profiler2.Start();
- sampling_thread_completed1.Wait();
- sampling_thread_completed2.Wait();
- ASSERT_EQ(1u, profiles1.size());
- EXPECT_EQ(9u, profiles1[0].samples.size());
- ASSERT_EQ(1u, profiles2.size());
- EXPECT_EQ(8u, profiles2[0].samples.size());
-
- target_thread1.SignalThreadToFinish();
- target_thread2.SignalThreadToFinish();
- PlatformThread::Join(target_thread_handle1);
- PlatformThread::Join(target_thread_handle2);
-}
-
-// A simple thread that runs a profiler on another thread.
-class ProfilerThread : public SimpleThread {
- public:
- ProfilerThread(const std::string& name,
- PlatformThreadId thread_id,
- const SamplingParams& params)
- : SimpleThread(name, Options()),
- run_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- completed_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- profiler_(thread_id,
- params,
- Bind(&SaveProfilesAndSignalEvent,
- Unretained(&profiles_),
- Unretained(&completed_))) {}
-
- void Run() override {
- run_.Wait();
- profiler_.Start();
- }
-
- void Go() { run_.Signal(); }
-
- void Wait() { completed_.Wait(); }
-
- CallStackProfiles& profiles() { return profiles_; }
-
- private:
- WaitableEvent run_;
-
- CallStackProfiles profiles_;
- WaitableEvent completed_;
- StackSamplingProfiler profiler_;
-};
-
-// Checks that different threads can run samplers in parallel.
-PROFILER_TEST_F(StackSamplingProfilerTest, MultipleProfilerThreads) {
- WithTargetThread([](PlatformThreadId target_thread_id) {
- // Providing an initial delay makes it more likely that both will be
- // scheduled before either starts to run. Once started, samples will
- // run ordered by their scheduled, interleaved times regardless of
- // whatever interval the thread wakes up.
- SamplingParams params1, params2;
- params1.initial_delay = TimeDelta::FromMilliseconds(10);
- params1.sampling_interval = TimeDelta::FromMilliseconds(1);
- params1.samples_per_burst = 9;
- params2.initial_delay = TimeDelta::FromMilliseconds(10);
- params2.sampling_interval = TimeDelta::FromMilliseconds(1);
- params2.samples_per_burst = 8;
-
- // Start the profiler threads and give them a moment to get going.
- ProfilerThread profiler_thread1("profiler1", target_thread_id, params1);
- ProfilerThread profiler_thread2("profiler2", target_thread_id, params2);
- profiler_thread1.Start();
- profiler_thread2.Start();
- PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
-
- // This will (approximately) synchronize the two threads.
- profiler_thread1.Go();
- profiler_thread2.Go();
-
- // Wait for them both to finish and validate collection.
- profiler_thread1.Wait();
- profiler_thread2.Wait();
- ASSERT_EQ(1u, profiler_thread1.profiles().size());
- EXPECT_EQ(9u, profiler_thread1.profiles()[0].samples.size());
- ASSERT_EQ(1u, profiler_thread2.profiles().size());
- EXPECT_EQ(8u, profiler_thread2.profiles()[0].samples.size());
-
- profiler_thread1.Join();
- profiler_thread2.Join();
- });
-}
-
-} // namespace base
diff --git a/base/profiler/win32_stack_frame_unwinder_unittest.cc b/base/profiler/win32_stack_frame_unwinder_unittest.cc
deleted file mode 100644
index cecfe22..0000000
--- a/base/profiler/win32_stack_frame_unwinder_unittest.cc
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2015 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 "base/profiler/win32_stack_frame_unwinder.h"
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class TestUnwindFunctions : public Win32StackFrameUnwinder::UnwindFunctions {
- public:
- TestUnwindFunctions();
-
- PRUNTIME_FUNCTION LookupFunctionEntry(DWORD64 program_counter,
- PDWORD64 image_base) override;
- void VirtualUnwind(DWORD64 image_base,
- DWORD64 program_counter,
- PRUNTIME_FUNCTION runtime_function,
- CONTEXT* context) override;
- ScopedModuleHandle GetModuleForProgramCounter(
- DWORD64 program_counter) override;
-
- // Instructs GetModuleForProgramCounter to return null on the next call.
- void SetUnloadedModule();
-
- // These functions set whether the next frame will have a RUNTIME_FUNCTION.
- void SetHasRuntimeFunction(CONTEXT* context);
- void SetNoRuntimeFunction(CONTEXT* context);
-
- private:
- enum { kImageBaseIncrement = 1 << 20 };
-
- static RUNTIME_FUNCTION* const kInvalidRuntimeFunction;
-
- bool module_is_loaded_;
- DWORD64 expected_program_counter_;
- DWORD64 next_image_base_;
- DWORD64 expected_image_base_;
- RUNTIME_FUNCTION* next_runtime_function_;
- std::vector<RUNTIME_FUNCTION> runtime_functions_;
-
- DISALLOW_COPY_AND_ASSIGN(TestUnwindFunctions);
-};
-
-RUNTIME_FUNCTION* const TestUnwindFunctions::kInvalidRuntimeFunction =
- reinterpret_cast<RUNTIME_FUNCTION*>(static_cast<uintptr_t>(-1));
-
-TestUnwindFunctions::TestUnwindFunctions()
- : module_is_loaded_(true),
- expected_program_counter_(0),
- next_image_base_(kImageBaseIncrement),
- expected_image_base_(0),
- next_runtime_function_(kInvalidRuntimeFunction) {
-}
-
-PRUNTIME_FUNCTION TestUnwindFunctions::LookupFunctionEntry(
- DWORD64 program_counter,
- PDWORD64 image_base) {
- EXPECT_EQ(expected_program_counter_, program_counter);
- *image_base = expected_image_base_ = next_image_base_;
- next_image_base_ += kImageBaseIncrement;
- RUNTIME_FUNCTION* return_value = next_runtime_function_;
- next_runtime_function_ = kInvalidRuntimeFunction;
- return return_value;
-}
-
-void TestUnwindFunctions::VirtualUnwind(DWORD64 image_base,
- DWORD64 program_counter,
- PRUNTIME_FUNCTION runtime_function,
- CONTEXT* context) {
- ASSERT_NE(kInvalidRuntimeFunction, runtime_function)
- << "expected call to SetHasRuntimeFunction() or SetNoRuntimeFunction() "
- << "before invoking TryUnwind()";
- EXPECT_EQ(expected_image_base_, image_base);
- expected_image_base_ = 0;
- EXPECT_EQ(expected_program_counter_, program_counter);
- expected_program_counter_ = 0;
- // This function should only be called when LookupFunctionEntry returns
- // a RUNTIME_FUNCTION.
- EXPECT_EQ(&runtime_functions_.back(), runtime_function);
-}
-
-ScopedModuleHandle TestUnwindFunctions::GetModuleForProgramCounter(
- DWORD64 program_counter) {
- bool return_non_null_value = module_is_loaded_;
- module_is_loaded_ = true;
- return ScopedModuleHandle(return_non_null_value ?
- ModuleHandleTraits::kNonNullModuleForTesting :
- nullptr);
-}
-
-void TestUnwindFunctions::SetUnloadedModule() {
- module_is_loaded_ = false;
-}
-
-void TestUnwindFunctions::SetHasRuntimeFunction(CONTEXT* context) {
- RUNTIME_FUNCTION runtime_function = {};
- runtime_function.BeginAddress = 16;
- runtime_function.EndAddress = runtime_function.BeginAddress + 256;
- runtime_functions_.push_back(runtime_function);
- next_runtime_function_ = &runtime_functions_.back();
-
- expected_program_counter_ = context->Rip =
- next_image_base_ + runtime_function.BeginAddress + 8;
-}
-
-void TestUnwindFunctions::SetNoRuntimeFunction(CONTEXT* context) {
- expected_program_counter_ = context->Rip = 100;
- next_runtime_function_ = nullptr;
-}
-
-} // namespace
-
-class Win32StackFrameUnwinderTest : public testing::Test {
- protected:
- Win32StackFrameUnwinderTest() {}
-
- // This exists so that Win32StackFrameUnwinder's constructor can be private
- // with a single friend declaration of this test fixture.
- std::unique_ptr<Win32StackFrameUnwinder> CreateUnwinder();
-
- // Weak pointer to the unwind functions used by last created unwinder.
- TestUnwindFunctions* unwind_functions_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(Win32StackFrameUnwinderTest);
-};
-
-std::unique_ptr<Win32StackFrameUnwinder>
-Win32StackFrameUnwinderTest::CreateUnwinder() {
- std::unique_ptr<TestUnwindFunctions> unwind_functions(
- new TestUnwindFunctions);
- unwind_functions_ = unwind_functions.get();
- return WrapUnique(
- new Win32StackFrameUnwinder(std::move(unwind_functions)));
-}
-
-// Checks the case where all frames have unwind information.
-TEST_F(Win32StackFrameUnwinderTest, FramesWithUnwindInfo) {
- std::unique_ptr<Win32StackFrameUnwinder> unwinder = CreateUnwinder();
- CONTEXT context = {0};
- ScopedModuleHandle module;
-
- unwind_functions_->SetHasRuntimeFunction(&context);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_TRUE(module.IsValid());
-
- unwind_functions_->SetHasRuntimeFunction(&context);
- module.Set(nullptr);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_TRUE(module.IsValid());
-
- unwind_functions_->SetHasRuntimeFunction(&context);
- module.Set(nullptr);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_TRUE(module.IsValid());
-}
-
-// Checks that an instruction pointer in an unloaded module fails to unwind.
-TEST_F(Win32StackFrameUnwinderTest, UnloadedModule) {
- std::unique_ptr<Win32StackFrameUnwinder> unwinder = CreateUnwinder();
- CONTEXT context = {0};
- ScopedModuleHandle module;
-
- unwind_functions_->SetUnloadedModule();
- EXPECT_FALSE(unwinder->TryUnwind(&context, &module));
-}
-
-// Checks that the CONTEXT's stack pointer gets popped when the top frame has no
-// unwind information.
-TEST_F(Win32StackFrameUnwinderTest, FrameAtTopWithoutUnwindInfo) {
- std::unique_ptr<Win32StackFrameUnwinder> unwinder = CreateUnwinder();
- CONTEXT context = {0};
- ScopedModuleHandle module;
- DWORD64 next_ip = 0x0123456789abcdef;
- DWORD64 original_rsp = reinterpret_cast<DWORD64>(&next_ip);
- context.Rsp = original_rsp;
-
- unwind_functions_->SetNoRuntimeFunction(&context);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_EQ(next_ip, context.Rip);
- EXPECT_EQ(original_rsp + 8, context.Rsp);
- EXPECT_TRUE(module.IsValid());
-
- unwind_functions_->SetHasRuntimeFunction(&context);
- module.Set(nullptr);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_TRUE(module.IsValid());
-
- unwind_functions_->SetHasRuntimeFunction(&context);
- module.Set(nullptr);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_TRUE(module.IsValid());
-}
-
-// Checks that a frame below the top of the stack with missing unwind info
-// terminates the unwinding.
-TEST_F(Win32StackFrameUnwinderTest, FrameBelowTopWithoutUnwindInfo) {
- {
- // First stack, with a bad function below the top of the stack.
- std::unique_ptr<Win32StackFrameUnwinder> unwinder = CreateUnwinder();
- CONTEXT context = {0};
- ScopedModuleHandle module;
- unwind_functions_->SetHasRuntimeFunction(&context);
- EXPECT_TRUE(unwinder->TryUnwind(&context, &module));
- EXPECT_TRUE(module.IsValid());
-
- unwind_functions_->SetNoRuntimeFunction(&context);
- EXPECT_FALSE(unwinder->TryUnwind(&context, &module));
- }
-}
-
-} // namespace base
diff --git a/base/rand_util_unittest.cc b/base/rand_util_unittest.cc
deleted file mode 100644
index 11a118a..0000000
--- a/base/rand_util_unittest.cc
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright (c) 2011 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 "base/rand_util.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <limits>
-#include <memory>
-
-#include "base/logging.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-const int kIntMin = std::numeric_limits<int>::min();
-const int kIntMax = std::numeric_limits<int>::max();
-
-} // namespace
-
-TEST(RandUtilTest, RandInt) {
- EXPECT_EQ(base::RandInt(0, 0), 0);
- EXPECT_EQ(base::RandInt(kIntMin, kIntMin), kIntMin);
- EXPECT_EQ(base::RandInt(kIntMax, kIntMax), kIntMax);
-
- // Check that the DCHECKS in RandInt() don't fire due to internal overflow.
- // There was a 50% chance of that happening, so calling it 40 times means
- // the chances of this passing by accident are tiny (9e-13).
- for (int i = 0; i < 40; ++i)
- base::RandInt(kIntMin, kIntMax);
-}
-
-TEST(RandUtilTest, RandDouble) {
- // Force 64-bit precision, making sure we're not in a 80-bit FPU register.
- volatile double number = base::RandDouble();
- EXPECT_GT(1.0, number);
- EXPECT_LE(0.0, number);
-}
-
-TEST(RandUtilTest, RandBytes) {
- const size_t buffer_size = 50;
- char buffer[buffer_size];
- memset(buffer, 0, buffer_size);
- base::RandBytes(buffer, buffer_size);
- std::sort(buffer, buffer + buffer_size);
- // Probability of occurrence of less than 25 unique bytes in 50 random bytes
- // is below 10^-25.
- EXPECT_GT(std::unique(buffer, buffer + buffer_size) - buffer, 25);
-}
-
-// Verify that calling base::RandBytes with an empty buffer doesn't fail.
-TEST(RandUtilTest, RandBytes0) {
- base::RandBytes(nullptr, 0);
-}
-
-TEST(RandUtilTest, RandBytesAsString) {
- std::string random_string = base::RandBytesAsString(1);
- EXPECT_EQ(1U, random_string.size());
- random_string = base::RandBytesAsString(145);
- EXPECT_EQ(145U, random_string.size());
- char accumulator = 0;
- for (size_t i = 0; i < random_string.size(); ++i)
- accumulator |= random_string[i];
- // In theory this test can fail, but it won't before the universe dies of
- // heat death.
- EXPECT_NE(0, accumulator);
-}
-
-// Make sure that it is still appropriate to use RandGenerator in conjunction
-// with std::random_shuffle().
-TEST(RandUtilTest, RandGeneratorForRandomShuffle) {
- EXPECT_EQ(base::RandGenerator(1), 0U);
- EXPECT_LE(std::numeric_limits<ptrdiff_t>::max(),
- std::numeric_limits<int64_t>::max());
-}
-
-TEST(RandUtilTest, RandGeneratorIsUniform) {
- // Verify that RandGenerator has a uniform distribution. This is a
- // regression test that consistently failed when RandGenerator was
- // implemented this way:
- //
- // return base::RandUint64() % max;
- //
- // A degenerate case for such an implementation is e.g. a top of
- // range that is 2/3rds of the way to MAX_UINT64, in which case the
- // bottom half of the range would be twice as likely to occur as the
- // top half. A bit of calculus care of jar@ shows that the largest
- // measurable delta is when the top of the range is 3/4ths of the
- // way, so that's what we use in the test.
- const uint64_t kTopOfRange =
- (std::numeric_limits<uint64_t>::max() / 4ULL) * 3ULL;
- const uint64_t kExpectedAverage = kTopOfRange / 2ULL;
- const uint64_t kAllowedVariance = kExpectedAverage / 50ULL; // +/- 2%
- const int kMinAttempts = 1000;
- const int kMaxAttempts = 1000000;
-
- double cumulative_average = 0.0;
- int count = 0;
- while (count < kMaxAttempts) {
- uint64_t value = base::RandGenerator(kTopOfRange);
- cumulative_average = (count * cumulative_average + value) / (count + 1);
-
- // Don't quit too quickly for things to start converging, or we may have
- // a false positive.
- if (count > kMinAttempts &&
- kExpectedAverage - kAllowedVariance < cumulative_average &&
- cumulative_average < kExpectedAverage + kAllowedVariance) {
- break;
- }
-
- ++count;
- }
-
- ASSERT_LT(count, kMaxAttempts) << "Expected average was " <<
- kExpectedAverage << ", average ended at " << cumulative_average;
-}
-
-TEST(RandUtilTest, RandUint64ProducesBothValuesOfAllBits) {
- // This tests to see that our underlying random generator is good
- // enough, for some value of good enough.
- uint64_t kAllZeros = 0ULL;
- uint64_t kAllOnes = ~kAllZeros;
- uint64_t found_ones = kAllZeros;
- uint64_t found_zeros = kAllOnes;
-
- for (size_t i = 0; i < 1000; ++i) {
- uint64_t value = base::RandUint64();
- found_ones |= value;
- found_zeros &= value;
-
- if (found_zeros == kAllZeros && found_ones == kAllOnes)
- return;
- }
-
- FAIL() << "Didn't achieve all bit values in maximum number of tries.";
-}
-
-TEST(RandUtilTest, RandBytesLonger) {
- // Fuchsia can only retrieve 256 bytes of entropy at a time, so make sure we
- // handle longer requests than that.
- std::string random_string0 = base::RandBytesAsString(255);
- EXPECT_EQ(255u, random_string0.size());
- std::string random_string1 = base::RandBytesAsString(1023);
- EXPECT_EQ(1023u, random_string1.size());
- std::string random_string2 = base::RandBytesAsString(4097);
- EXPECT_EQ(4097u, random_string2.size());
-}
-
-// Benchmark test for RandBytes(). Disabled since it's intentionally slow and
-// does not test anything that isn't already tested by the existing RandBytes()
-// tests.
-TEST(RandUtilTest, DISABLED_RandBytesPerf) {
- // Benchmark the performance of |kTestIterations| of RandBytes() using a
- // buffer size of |kTestBufferSize|.
- const int kTestIterations = 10;
- const size_t kTestBufferSize = 1 * 1024 * 1024;
-
- std::unique_ptr<uint8_t[]> buffer(new uint8_t[kTestBufferSize]);
- const base::TimeTicks now = base::TimeTicks::Now();
- for (int i = 0; i < kTestIterations; ++i)
- base::RandBytes(buffer.get(), kTestBufferSize);
- const base::TimeTicks end = base::TimeTicks::Now();
-
- LOG(INFO) << "RandBytes(" << kTestBufferSize << ") took: "
- << (end - now).InMicroseconds() << "µs";
-}
diff --git a/base/run_loop_unittest.cc b/base/run_loop_unittest.cc
deleted file mode 100644
index 3564a2e..0000000
--- a/base/run_loop_unittest.cc
+++ /dev/null
@@ -1,636 +0,0 @@
-// Copyright 2016 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 "base/run_loop.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/containers/queue.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/gtest_util.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_checker_impl.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-void QuitWhenIdleTask(RunLoop* run_loop, int* counter) {
- run_loop->QuitWhenIdle();
- ++(*counter);
-}
-
-void ShouldRunTask(int* counter) {
- ++(*counter);
-}
-
-void ShouldNotRunTask() {
- ADD_FAILURE() << "Ran a task that shouldn't run.";
-}
-
-void RunNestedLoopTask(int* counter) {
- RunLoop nested_run_loop(RunLoop::Type::kNestableTasksAllowed);
-
- // This task should quit |nested_run_loop| but not the main RunLoop.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&QuitWhenIdleTask, Unretained(&nested_run_loop),
- Unretained(counter)));
-
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
-
- nested_run_loop.Run();
-
- ++(*counter);
-}
-
-// A simple SingleThreadTaskRunner that just queues undelayed tasks (and ignores
-// delayed tasks). Tasks can then be processed one by one by ProcessTask() which
-// will return true if it processed a task and false otherwise.
-class SimpleSingleThreadTaskRunner : public SingleThreadTaskRunner {
- public:
- SimpleSingleThreadTaskRunner() = default;
-
- bool PostDelayedTask(const Location& from_here,
- OnceClosure task,
- base::TimeDelta delay) override {
- if (delay > base::TimeDelta())
- return false;
- AutoLock auto_lock(tasks_lock_);
- pending_tasks_.push(std::move(task));
- return true;
- }
-
- bool PostNonNestableDelayedTask(const Location& from_here,
- OnceClosure task,
- base::TimeDelta delay) override {
- return PostDelayedTask(from_here, std::move(task), delay);
- }
-
- bool RunsTasksInCurrentSequence() const override {
- return origin_thread_checker_.CalledOnValidThread();
- }
-
- bool ProcessSingleTask() {
- OnceClosure task;
- {
- AutoLock auto_lock(tasks_lock_);
- if (pending_tasks_.empty())
- return false;
- task = std::move(pending_tasks_.front());
- pending_tasks_.pop();
- }
- // It's important to Run() after pop() and outside the lock as |task| may
- // run a nested loop which will re-enter ProcessSingleTask().
- std::move(task).Run();
- return true;
- }
-
- private:
- ~SimpleSingleThreadTaskRunner() override = default;
-
- Lock tasks_lock_;
- base::queue<OnceClosure> pending_tasks_;
-
- // RunLoop relies on RunsTasksInCurrentSequence() signal. Use a
- // ThreadCheckerImpl to be able to reliably provide that signal even in
- // non-dcheck builds.
- ThreadCheckerImpl origin_thread_checker_;
-
- DISALLOW_COPY_AND_ASSIGN(SimpleSingleThreadTaskRunner);
-};
-
-// The basis of all TestDelegates, allows safely injecting a OnceClosure to be
-// run in the next idle phase of this delegate's Run() implementation. This can
-// be used to have code run on a thread that is otherwise livelocked in an idle
-// phase (sometimes a simple PostTask() won't do it -- e.g. when processing
-// application tasks is disallowed).
-class InjectableTestDelegate : public RunLoop::Delegate {
- public:
- void InjectClosureOnDelegate(OnceClosure closure) {
- AutoLock auto_lock(closure_lock_);
- closure_ = std::move(closure);
- }
-
- bool RunInjectedClosure() {
- AutoLock auto_lock(closure_lock_);
- if (closure_.is_null())
- return false;
- std::move(closure_).Run();
- return true;
- }
-
- private:
- Lock closure_lock_;
- OnceClosure closure_;
-};
-
-// A simple test RunLoop::Delegate to exercise Runloop logic independent of any
-// other base constructs. BindToCurrentThread() must be called before this
-// TestBoundDelegate is operational.
-class TestBoundDelegate final : public InjectableTestDelegate {
- public:
- TestBoundDelegate() = default;
-
- // Makes this TestBoundDelegate become the RunLoop::Delegate and
- // ThreadTaskRunnerHandle for this thread.
- void BindToCurrentThread() {
- thread_task_runner_handle_ =
- std::make_unique<ThreadTaskRunnerHandle>(simple_task_runner_);
- RunLoop::RegisterDelegateForCurrentThread(this);
- }
-
- private:
- void Run(bool application_tasks_allowed) override {
- if (nested_run_allowing_tasks_incoming_) {
- EXPECT_TRUE(RunLoop::IsNestedOnCurrentThread());
- EXPECT_TRUE(application_tasks_allowed);
- } else if (RunLoop::IsNestedOnCurrentThread()) {
- EXPECT_FALSE(application_tasks_allowed);
- }
- nested_run_allowing_tasks_incoming_ = false;
-
- while (!should_quit_) {
- if (application_tasks_allowed && simple_task_runner_->ProcessSingleTask())
- continue;
-
- if (ShouldQuitWhenIdle())
- break;
-
- if (RunInjectedClosure())
- continue;
-
- PlatformThread::YieldCurrentThread();
- }
- should_quit_ = false;
- }
-
- void Quit() override { should_quit_ = true; }
-
- void EnsureWorkScheduled() override {
- nested_run_allowing_tasks_incoming_ = true;
- }
-
- // True if the next invocation of Run() is expected to be from a
- // kNestableTasksAllowed RunLoop.
- bool nested_run_allowing_tasks_incoming_ = false;
-
- scoped_refptr<SimpleSingleThreadTaskRunner> simple_task_runner_ =
- MakeRefCounted<SimpleSingleThreadTaskRunner>();
-
- std::unique_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_;
-
- bool should_quit_ = false;
-};
-
-enum class RunLoopTestType {
- // Runs all RunLoopTests under a ScopedTaskEnvironment to make sure real world
- // scenarios work.
- kRealEnvironment,
-
- // Runs all RunLoopTests under a test RunLoop::Delegate to make sure the
- // delegate interface fully works standalone.
- kTestDelegate,
-};
-
-// The task environment for the RunLoopTest of a given type. A separate class
-// so it can be instantiated on the stack in the RunLoopTest fixture.
-class RunLoopTestEnvironment {
- public:
- RunLoopTestEnvironment(RunLoopTestType type) {
- switch (type) {
- case RunLoopTestType::kRealEnvironment: {
- task_environment_ = std::make_unique<test::ScopedTaskEnvironment>();
- break;
- }
- case RunLoopTestType::kTestDelegate: {
- auto test_delegate = std::make_unique<TestBoundDelegate>();
- test_delegate->BindToCurrentThread();
- test_delegate_ = std::move(test_delegate);
- break;
- }
- }
- }
-
- private:
- // Instantiates one or the other based on the RunLoopTestType.
- std::unique_ptr<test::ScopedTaskEnvironment> task_environment_;
- std::unique_ptr<InjectableTestDelegate> test_delegate_;
-};
-
-class RunLoopTest : public testing::TestWithParam<RunLoopTestType> {
- protected:
- RunLoopTest() : test_environment_(GetParam()) {}
-
- RunLoopTestEnvironment test_environment_;
- RunLoop run_loop_;
- int counter_ = 0;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(RunLoopTest);
-};
-
-} // namespace
-
-TEST_P(RunLoopTest, QuitWhenIdle) {
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&QuitWhenIdleTask, Unretained(&run_loop_),
- Unretained(&counter_)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&ShouldRunTask, Unretained(&counter_)));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
-
- run_loop_.Run();
- EXPECT_EQ(2, counter_);
-}
-
-TEST_P(RunLoopTest, QuitWhenIdleNestedLoop) {
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&RunNestedLoopTask, Unretained(&counter_)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&QuitWhenIdleTask, Unretained(&run_loop_),
- Unretained(&counter_)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&ShouldRunTask, Unretained(&counter_)));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
-
- run_loop_.Run();
- EXPECT_EQ(4, counter_);
-}
-
-TEST_P(RunLoopTest, QuitWhenIdleClosure) {
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- run_loop_.QuitWhenIdleClosure());
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&ShouldRunTask, Unretained(&counter_)));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
-
- run_loop_.Run();
- EXPECT_EQ(1, counter_);
-}
-
-// Verify that the QuitWhenIdleClosure() can run after the RunLoop has been
-// deleted. It should have no effect.
-TEST_P(RunLoopTest, QuitWhenIdleClosureAfterRunLoopScope) {
- Closure quit_when_idle_closure;
- {
- RunLoop run_loop;
- quit_when_idle_closure = run_loop.QuitWhenIdleClosure();
- run_loop.RunUntilIdle();
- }
- quit_when_idle_closure.Run();
-}
-
-// Verify that Quit can be executed from another sequence.
-TEST_P(RunLoopTest, QuitFromOtherSequence) {
- Thread other_thread("test");
- other_thread.Start();
- scoped_refptr<SequencedTaskRunner> other_sequence =
- other_thread.task_runner();
-
- // Always expected to run before asynchronous Quit() kicks in.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- WaitableEvent loop_was_quit(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- other_sequence->PostTask(
- FROM_HERE, base::BindOnce([](RunLoop* run_loop) { run_loop->Quit(); },
- Unretained(&run_loop_)));
- other_sequence->PostTask(
- FROM_HERE,
- base::BindOnce(&WaitableEvent::Signal, base::Unretained(&loop_was_quit)));
-
- // Anything that's posted after the Quit closure was posted back to this
- // sequence shouldn't get a chance to run.
- loop_was_quit.Wait();
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::BindOnce(&ShouldNotRunTask));
-
- run_loop_.Run();
-
- EXPECT_EQ(1, counter_);
-}
-
-// Verify that QuitClosure can be executed from another sequence.
-TEST_P(RunLoopTest, QuitFromOtherSequenceWithClosure) {
- Thread other_thread("test");
- other_thread.Start();
- scoped_refptr<SequencedTaskRunner> other_sequence =
- other_thread.task_runner();
-
- // Always expected to run before asynchronous Quit() kicks in.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- WaitableEvent loop_was_quit(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- other_sequence->PostTask(FROM_HERE, run_loop_.QuitClosure());
- other_sequence->PostTask(
- FROM_HERE,
- base::BindOnce(&WaitableEvent::Signal, base::Unretained(&loop_was_quit)));
-
- // Anything that's posted after the Quit closure was posted back to this
- // sequence shouldn't get a chance to run.
- loop_was_quit.Wait();
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::BindOnce(&ShouldNotRunTask));
-
- run_loop_.Run();
-
- EXPECT_EQ(1, counter_);
-}
-
-// Verify that Quit can be executed from another sequence even when the
-// Quit is racing with Run() -- i.e. forgo the WaitableEvent used above.
-TEST_P(RunLoopTest, QuitFromOtherSequenceRacy) {
- Thread other_thread("test");
- other_thread.Start();
- scoped_refptr<SequencedTaskRunner> other_sequence =
- other_thread.task_runner();
-
- // Always expected to run before asynchronous Quit() kicks in.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- other_sequence->PostTask(
- FROM_HERE, base::BindOnce([](RunLoop* run_loop) { run_loop->Quit(); },
- Unretained(&run_loop_)));
-
- run_loop_.Run();
-
- EXPECT_EQ(1, counter_);
-}
-
-// Verify that QuitClosure can be executed from another sequence even when the
-// Quit is racing with Run() -- i.e. forgo the WaitableEvent used above.
-TEST_P(RunLoopTest, QuitFromOtherSequenceRacyWithClosure) {
- Thread other_thread("test");
- other_thread.Start();
- scoped_refptr<SequencedTaskRunner> other_sequence =
- other_thread.task_runner();
-
- // Always expected to run before asynchronous Quit() kicks in.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- other_sequence->PostTask(FROM_HERE, run_loop_.QuitClosure());
-
- run_loop_.Run();
-
- EXPECT_EQ(1, counter_);
-}
-
-// Verify that QuitWhenIdle can be executed from another sequence.
-TEST_P(RunLoopTest, QuitWhenIdleFromOtherSequence) {
- Thread other_thread("test");
- other_thread.Start();
- scoped_refptr<SequencedTaskRunner> other_sequence =
- other_thread.task_runner();
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- other_sequence->PostTask(
- FROM_HERE,
- base::BindOnce([](RunLoop* run_loop) { run_loop->QuitWhenIdle(); },
- Unretained(&run_loop_)));
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- run_loop_.Run();
-
- // Regardless of the outcome of the race this thread shouldn't have been idle
- // until the counter was ticked twice.
- EXPECT_EQ(2, counter_);
-}
-
-// Verify that QuitWhenIdleClosure can be executed from another sequence.
-TEST_P(RunLoopTest, QuitWhenIdleFromOtherSequenceWithClosure) {
- Thread other_thread("test");
- other_thread.Start();
- scoped_refptr<SequencedTaskRunner> other_sequence =
- other_thread.task_runner();
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- other_sequence->PostTask(FROM_HERE, run_loop_.QuitWhenIdleClosure());
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::BindOnce(&ShouldRunTask, Unretained(&counter_)));
-
- run_loop_.Run();
-
- // Regardless of the outcome of the race this thread shouldn't have been idle
- // until the counter was ticked twice.
- EXPECT_EQ(2, counter_);
-}
-
-TEST_P(RunLoopTest, IsRunningOnCurrentThread) {
- EXPECT_FALSE(RunLoop::IsRunningOnCurrentThread());
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce([]() { EXPECT_TRUE(RunLoop::IsRunningOnCurrentThread()); }));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop_.QuitClosure());
- run_loop_.Run();
-}
-
-TEST_P(RunLoopTest, IsNestedOnCurrentThread) {
- EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce([]() {
- EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
-
- RunLoop nested_run_loop(RunLoop::Type::kNestableTasksAllowed);
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce([]() {
- EXPECT_TRUE(RunLoop::IsNestedOnCurrentThread());
- }));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_run_loop.QuitClosure());
-
- EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
- nested_run_loop.Run();
- EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
- }));
-
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop_.QuitClosure());
- run_loop_.Run();
-}
-
-namespace {
-
-class MockNestingObserver : public RunLoop::NestingObserver {
- public:
- MockNestingObserver() = default;
-
- // RunLoop::NestingObserver:
- MOCK_METHOD0(OnBeginNestedRunLoop, void());
- MOCK_METHOD0(OnExitNestedRunLoop, void());
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MockNestingObserver);
-};
-
-class MockTask {
- public:
- MockTask() = default;
- MOCK_METHOD0(Task, void());
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MockTask);
-};
-
-} // namespace
-
-TEST_P(RunLoopTest, NestingObservers) {
- testing::StrictMock<MockNestingObserver> nesting_observer;
- testing::StrictMock<MockTask> mock_task_a;
- testing::StrictMock<MockTask> mock_task_b;
-
- RunLoop::AddNestingObserverOnCurrentThread(&nesting_observer);
-
- const RepeatingClosure run_nested_loop = Bind([]() {
- RunLoop nested_run_loop(RunLoop::Type::kNestableTasksAllowed);
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- nested_run_loop.QuitClosure());
- nested_run_loop.Run();
- });
-
- // Generate a stack of nested RunLoops. OnBeginNestedRunLoop() is expected
- // when beginning each nesting depth and OnExitNestedRunLoop() is expected
- // when exiting each nesting depth. Each one of these tasks is ahead of the
- // QuitClosures as those are only posted at the end of the queue when
- // |run_nested_loop| is executed.
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_nested_loop);
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::BindOnce(&MockTask::Task, base::Unretained(&mock_task_a)));
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_nested_loop);
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::BindOnce(&MockTask::Task, base::Unretained(&mock_task_b)));
-
- {
- testing::InSequence in_sequence;
- EXPECT_CALL(nesting_observer, OnBeginNestedRunLoop());
- EXPECT_CALL(mock_task_a, Task());
- EXPECT_CALL(nesting_observer, OnBeginNestedRunLoop());
- EXPECT_CALL(mock_task_b, Task());
- EXPECT_CALL(nesting_observer, OnExitNestedRunLoop()).Times(2);
- }
- run_loop_.RunUntilIdle();
-
- RunLoop::RemoveNestingObserverOnCurrentThread(&nesting_observer);
-}
-
-TEST_P(RunLoopTest, DisallowRunningForTesting) {
- RunLoop::ScopedDisallowRunningForTesting disallow_running;
- EXPECT_DCHECK_DEATH({ run_loop_.RunUntilIdle(); });
-}
-
-TEST_P(RunLoopTest, ExpiredDisallowRunningForTesting) {
- { RunLoop::ScopedDisallowRunningForTesting disallow_running; }
- // Running should be fine after |disallow_running| goes out of scope.
- run_loop_.RunUntilIdle();
-}
-
-INSTANTIATE_TEST_CASE_P(Real,
- RunLoopTest,
- testing::Values(RunLoopTestType::kRealEnvironment));
-INSTANTIATE_TEST_CASE_P(Mock,
- RunLoopTest,
- testing::Values(RunLoopTestType::kTestDelegate));
-
-TEST(RunLoopDeathTest, MustRegisterBeforeInstantiating) {
- TestBoundDelegate unbound_test_delegate_;
- // RunLoop::RunLoop() should CHECK fetching the ThreadTaskRunnerHandle.
- EXPECT_DEATH_IF_SUPPORTED({ RunLoop(); }, "");
-}
-
-TEST(RunLoopDelegateTest, NestableTasksDontRunInDefaultNestedLoops) {
- TestBoundDelegate test_delegate;
- test_delegate.BindToCurrentThread();
-
- base::Thread other_thread("test");
- other_thread.Start();
-
- RunLoop main_loop;
- // A nested run loop which isn't kNestableTasksAllowed.
- RunLoop nested_run_loop(RunLoop::Type::kDefault);
-
- bool nested_run_loop_ended = false;
-
- // The first task on the main loop will result in a nested run loop. Since
- // it's not kNestableTasksAllowed, no further task should be processed until
- // it's quit.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- BindOnce([](RunLoop* nested_run_loop) { nested_run_loop->Run(); },
- Unretained(&nested_run_loop)));
-
- // Post a task that will fail if it runs inside the nested run loop.
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(
- [](const bool& nested_run_loop_ended,
- OnceClosure continuation_callback) {
- EXPECT_TRUE(nested_run_loop_ended);
- EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
- std::move(continuation_callback).Run();
- },
- ConstRef(nested_run_loop_ended), main_loop.QuitClosure()));
-
- // Post a task flipping the boolean bit for extra verification right before
- // quitting |nested_run_loop|.
- other_thread.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(
- [](bool* nested_run_loop_ended) {
- EXPECT_FALSE(*nested_run_loop_ended);
- *nested_run_loop_ended = true;
- },
- Unretained(&nested_run_loop_ended)),
- TestTimeouts::tiny_timeout());
- // Post an async delayed task to exit the run loop when idle. This confirms
- // that (1) the test task only ran in the main loop after the nested loop
- // exited and (2) the nested run loop actually considers itself idle while
- // spinning. Note: The quit closure needs to be injected directly on the
- // delegate as invoking QuitWhenIdle() off-thread results in a thread bounce
- // which will not processed because of the very logic under test (nestable
- // tasks don't run in |nested_run_loop|).
- other_thread.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(
- [](TestBoundDelegate* test_delegate, OnceClosure injected_closure) {
- test_delegate->InjectClosureOnDelegate(std::move(injected_closure));
- },
- Unretained(&test_delegate), nested_run_loop.QuitWhenIdleClosure()),
- TestTimeouts::tiny_timeout());
-
- main_loop.Run();
-}
-
-} // namespace base
diff --git a/base/safe_numerics_unittest.cc b/base/safe_numerics_unittest.cc
deleted file mode 100644
index 7fcc5d1..0000000
--- a/base/safe_numerics_unittest.cc
+++ /dev/null
@@ -1,1640 +0,0 @@
-// Copyright 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 <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-#include <type_traits>
-
-#include "base/compiler_specific.h"
-
-// WARNING: This block must come before the base/numerics headers are included.
-// These tests deliberately cause arithmetic boundary errors. If the compiler is
-// aggressive enough, it can const detect these errors, so we disable warnings.
-#if defined(OS_WIN)
-#pragma warning(disable : 4756) // Arithmetic overflow.
-#pragma warning(disable : 4293) // Invalid shift.
-#endif
-
-// This may not need to come before the base/numerics headers, but let's keep
-// it close to the MSVC equivalent.
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winteger-overflow"
-#endif
-
-#include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/numerics/safe_math.h"
-#include "base/test/gtest_util.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
-#include <mmintrin.h>
-#endif
-
-namespace base {
-namespace internal {
-
-using std::numeric_limits;
-
-// This is a helper function for finding the maximum value in Src that can be
-// wholy represented as the destination floating-point type.
-template <typename Dst, typename Src>
-Dst GetMaxConvertibleToFloat() {
- using DstLimits = numeric_limits<Dst>;
- using SrcLimits = numeric_limits<Src>;
- static_assert(SrcLimits::is_specialized, "Source must be numeric.");
- static_assert(DstLimits::is_specialized, "Destination must be numeric.");
- CHECK(DstLimits::is_iec559);
-
- if (SrcLimits::digits <= DstLimits::digits &&
- MaxExponent<Src>::value <= MaxExponent<Dst>::value)
- return SrcLimits::max();
- Src max = SrcLimits::max() / 2 + (SrcLimits::is_integer ? 1 : 0);
- while (max != static_cast<Src>(static_cast<Dst>(max))) {
- max /= 2;
- }
- return static_cast<Dst>(max);
-}
-
-// Test corner case promotions used
-static_assert(IsIntegerArithmeticSafe<int32_t, int8_t, int8_t>::value, "");
-static_assert(IsIntegerArithmeticSafe<int32_t, int16_t, int8_t>::value, "");
-static_assert(IsIntegerArithmeticSafe<int32_t, int8_t, int16_t>::value, "");
-static_assert(!IsIntegerArithmeticSafe<int32_t, int32_t, int8_t>::value, "");
-static_assert(BigEnoughPromotion<int16_t, int8_t>::is_contained, "");
-static_assert(BigEnoughPromotion<int32_t, uint32_t>::is_contained, "");
-static_assert(BigEnoughPromotion<intmax_t, int8_t>::is_contained, "");
-static_assert(!BigEnoughPromotion<uintmax_t, int8_t>::is_contained, "");
-static_assert(
- std::is_same<BigEnoughPromotion<int16_t, int8_t>::type, int16_t>::value,
- "");
-static_assert(
- std::is_same<BigEnoughPromotion<int32_t, uint32_t>::type, int64_t>::value,
- "");
-static_assert(
- std::is_same<BigEnoughPromotion<intmax_t, int8_t>::type, intmax_t>::value,
- "");
-static_assert(
- std::is_same<BigEnoughPromotion<uintmax_t, int8_t>::type, uintmax_t>::value,
- "");
-static_assert(BigEnoughPromotion<int16_t, int8_t>::is_contained, "");
-static_assert(BigEnoughPromotion<int32_t, uint32_t>::is_contained, "");
-static_assert(BigEnoughPromotion<intmax_t, int8_t>::is_contained, "");
-static_assert(!BigEnoughPromotion<uintmax_t, int8_t>::is_contained, "");
-static_assert(
- std::is_same<FastIntegerArithmeticPromotion<int16_t, int8_t>::type,
- int32_t>::value,
- "");
-static_assert(
- std::is_same<FastIntegerArithmeticPromotion<int32_t, uint32_t>::type,
- int64_t>::value,
- "");
-static_assert(
- std::is_same<FastIntegerArithmeticPromotion<intmax_t, int8_t>::type,
- intmax_t>::value,
- "");
-static_assert(
- std::is_same<FastIntegerArithmeticPromotion<uintmax_t, int8_t>::type,
- uintmax_t>::value,
- "");
-static_assert(FastIntegerArithmeticPromotion<int16_t, int8_t>::is_contained,
- "");
-static_assert(FastIntegerArithmeticPromotion<int32_t, uint32_t>::is_contained,
- "");
-static_assert(!FastIntegerArithmeticPromotion<intmax_t, int8_t>::is_contained,
- "");
-static_assert(!FastIntegerArithmeticPromotion<uintmax_t, int8_t>::is_contained,
- "");
-
-template <typename U>
-U GetNumericValueForTest(const CheckedNumeric<U>& src) {
- return src.state_.value();
-}
-
-template <typename U>
-U GetNumericValueForTest(const ClampedNumeric<U>& src) {
- return static_cast<U>(src);
-}
-
-template <typename U>
-U GetNumericValueForTest(const U& src) {
- return src;
-}
-
-// Logs the ValueOrDie() failure instead of crashing.
-struct LogOnFailure {
- template <typename T>
- static T HandleFailure() {
- LOG(WARNING) << "ValueOrDie() failed unexpectedly.";
- return T();
- }
-};
-
-template <typename T>
-constexpr T GetValue(const T& src) {
- return src;
-}
-
-template <typename T, typename U>
-constexpr T GetValueAsDest(const U& src) {
- return static_cast<T>(src);
-}
-
-template <typename T>
-constexpr T GetValue(const CheckedNumeric<T>& src) {
- return src.template ValueOrDie<T, LogOnFailure>();
-}
-
-template <typename T, typename U>
-constexpr T GetValueAsDest(const CheckedNumeric<U>& src) {
- return src.template ValueOrDie<T, LogOnFailure>();
-}
-
-template <typename T>
-constexpr T GetValue(const ClampedNumeric<T>& src) {
- return static_cast<T>(src);
-}
-
-template <typename T, typename U>
-constexpr T GetValueAsDest(const ClampedNumeric<U>& src) {
- return static_cast<T>(src);
-}
-
-// Helper macros to wrap displaying the conversion types and line numbers.
-#define TEST_EXPECTED_VALIDITY(expected, actual) \
- EXPECT_EQ(expected, (actual).template Cast<Dst>().IsValid()) \
- << "Result test: Value " << GetNumericValueForTest(actual) << " as " \
- << dst << " on line " << line
-
-#define TEST_EXPECTED_SUCCESS(actual) TEST_EXPECTED_VALIDITY(true, actual)
-#define TEST_EXPECTED_FAILURE(actual) TEST_EXPECTED_VALIDITY(false, actual)
-
-// We have to handle promotions, so infer the underlying type below from actual.
-#define TEST_EXPECTED_VALUE(expected, actual) \
- EXPECT_EQ(GetValue(expected), GetValueAsDest<decltype(expected)>(actual)) \
- << "Result test: Value " << GetNumericValueForTest(actual) << " as " \
- << dst << " on line " << line
-
-// Test the simple pointer arithmetic overrides.
-template <typename Dst>
-void TestStrictPointerMath() {
- Dst dummy_value = 0;
- Dst* dummy_ptr = &dummy_value;
- static const Dst kDummyOffset = 2; // Don't want to go too far.
- EXPECT_EQ(dummy_ptr + kDummyOffset,
- dummy_ptr + StrictNumeric<Dst>(kDummyOffset));
- EXPECT_EQ(dummy_ptr - kDummyOffset,
- dummy_ptr - StrictNumeric<Dst>(kDummyOffset));
- EXPECT_NE(dummy_ptr, dummy_ptr + StrictNumeric<Dst>(kDummyOffset));
- EXPECT_NE(dummy_ptr, dummy_ptr - StrictNumeric<Dst>(kDummyOffset));
- EXPECT_DEATH_IF_SUPPORTED(
- dummy_ptr + StrictNumeric<size_t>(std::numeric_limits<size_t>::max()),
- "");
-}
-
-// Signed integer arithmetic.
-template <typename Dst>
-static void TestSpecializedArithmetic(
- const char* dst,
- int line,
- typename std::enable_if<numeric_limits<Dst>::is_integer &&
- numeric_limits<Dst>::is_signed,
- int>::type = 0) {
- using DstLimits = SaturationDefaultLimits<Dst>;
- TEST_EXPECTED_FAILURE(-CheckedNumeric<Dst>(DstLimits::lowest()));
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()).Abs());
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).Abs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- MakeCheckedNum(-DstLimits::max()).Abs());
-
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- -ClampedNumeric<Dst>(DstLimits::lowest()));
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()).Abs());
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(-1).Abs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- MakeClampedNum(-DstLimits::max()).Abs());
-
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::max()) + -1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) + -1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) +
- DstLimits::lowest());
-
- TEST_EXPECTED_VALUE(DstLimits::max() - 1,
- ClampedNumeric<Dst>(DstLimits::max()) + -1);
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) + -1);
- TEST_EXPECTED_VALUE(
- DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) + DstLimits::lowest());
-
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) - 1);
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()) - -1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) -
- DstLimits::lowest());
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) -
- DstLimits::max());
-
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) - 1);
- TEST_EXPECTED_VALUE(DstLimits::lowest() + 1,
- ClampedNumeric<Dst>(DstLimits::lowest()) - -1);
- TEST_EXPECTED_VALUE(
- DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::max()) - DstLimits::lowest());
- TEST_EXPECTED_VALUE(
- DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) - DstLimits::max());
-
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) * 2);
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) * 2);
-
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) / -1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(-1) / 2);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) * -1);
- TEST_EXPECTED_VALUE(DstLimits::max(),
- CheckedNumeric<Dst>(DstLimits::lowest() + 1) * Dst(-1));
- TEST_EXPECTED_VALUE(DstLimits::max(),
- CheckedNumeric<Dst>(-1) * Dst(DstLimits::lowest() + 1));
- TEST_EXPECTED_VALUE(DstLimits::lowest(),
- CheckedNumeric<Dst>(DstLimits::lowest()) * Dst(1));
- TEST_EXPECTED_VALUE(DstLimits::lowest(),
- CheckedNumeric<Dst>(1) * Dst(DstLimits::lowest()));
- TEST_EXPECTED_VALUE(
- typename std::make_unsigned<Dst>::type(0) - DstLimits::lowest(),
- MakeCheckedNum(DstLimits::lowest()).UnsignedAbs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- MakeCheckedNum(DstLimits::max()).UnsignedAbs());
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0).UnsignedAbs());
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).UnsignedAbs());
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).UnsignedAbs());
-
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) / -1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(-1) / 2);
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) * -1);
- TEST_EXPECTED_VALUE(DstLimits::max(),
- ClampedNumeric<Dst>(DstLimits::lowest() + 1) * Dst(-1));
- TEST_EXPECTED_VALUE(DstLimits::max(),
- ClampedNumeric<Dst>(-1) * Dst(DstLimits::lowest() + 1));
- TEST_EXPECTED_VALUE(DstLimits::lowest(),
- ClampedNumeric<Dst>(DstLimits::lowest()) * Dst(1));
- TEST_EXPECTED_VALUE(DstLimits::lowest(),
- ClampedNumeric<Dst>(1) * Dst(DstLimits::lowest()));
- TEST_EXPECTED_VALUE(
- typename std::make_unsigned<Dst>::type(0) - DstLimits::lowest(),
- MakeClampedNum(DstLimits::lowest()).UnsignedAbs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- MakeClampedNum(DstLimits::max()).UnsignedAbs());
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0).UnsignedAbs());
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1).UnsignedAbs());
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(-1).UnsignedAbs());
-
- // Modulus is legal only for integers.
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() % 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
- TEST_EXPECTED_VALUE(-1, CheckedNumeric<Dst>(-1) % 2);
- TEST_EXPECTED_VALUE(-1, CheckedNumeric<Dst>(-1) % -2);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % 2);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % 2);
- // Test all the different modulus combinations.
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, 1 % CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
- CheckedNumeric<Dst> checked_dst = 1;
- TEST_EXPECTED_VALUE(0, checked_dst %= 1);
- // Test that div by 0 is avoided but returns invalid result.
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) % 0);
- // Test bit shifts.
- volatile Dst negative_one = -1;
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) << negative_one);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1)
- << (IntegerBitsPlusSign<Dst>::value - 1));
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(0)
- << IntegerBitsPlusSign<Dst>::value);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) << 1);
- TEST_EXPECTED_VALUE(
- static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2),
- CheckedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2));
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0)
- << (IntegerBitsPlusSign<Dst>::value - 1));
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) << 0);
- TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) << 1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >>
- IntegerBitsPlusSign<Dst>::value);
- TEST_EXPECTED_VALUE(
- 0, CheckedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1));
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >> negative_one);
-
- // Modulus is legal only for integers.
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>() % 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
- TEST_EXPECTED_VALUE(-1, ClampedNumeric<Dst>(-1) % 2);
- TEST_EXPECTED_VALUE(-1, ClampedNumeric<Dst>(-1) % -2);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % 2);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(DstLimits::max()) % 2);
- // Test all the different modulus combinations.
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, 1 % ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
- ClampedNumeric<Dst> clamped_dst = 1;
- TEST_EXPECTED_VALUE(0, clamped_dst %= 1);
- TEST_EXPECTED_VALUE(Dst(1), ClampedNumeric<Dst>(1) % 0);
- // Test bit shifts.
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(1)
- << (IntegerBitsPlusSign<Dst>::value - 1U));
- TEST_EXPECTED_VALUE(Dst(0), ClampedNumeric<Dst>(0)
- << (IntegerBitsPlusSign<Dst>::value + 0U));
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::max()) << 1U);
- TEST_EXPECTED_VALUE(
- static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2U),
- ClampedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2U));
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0)
- << (IntegerBitsPlusSign<Dst>::value - 1U));
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) << 0U);
- TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) << 1U);
- TEST_EXPECTED_VALUE(
- 0, ClampedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value + 0U));
- TEST_EXPECTED_VALUE(
- 0, ClampedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1U));
- TEST_EXPECTED_VALUE(
- -1, ClampedNumeric<Dst>(-1) >> (IntegerBitsPlusSign<Dst>::value - 1U));
- TEST_EXPECTED_VALUE(-1, ClampedNumeric<Dst>(DstLimits::lowest()) >>
- (IntegerBitsPlusSign<Dst>::value - 0U));
-
- TestStrictPointerMath<Dst>();
-}
-
-// Unsigned integer arithmetic.
-template <typename Dst>
-static void TestSpecializedArithmetic(
- const char* dst,
- int line,
- typename std::enable_if<numeric_limits<Dst>::is_integer &&
- !numeric_limits<Dst>::is_signed,
- int>::type = 0) {
- using DstLimits = SaturationDefaultLimits<Dst>;
- TEST_EXPECTED_SUCCESS(-CheckedNumeric<Dst>(DstLimits::lowest()));
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()).Abs());
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) + -1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) - 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) * 2);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) / 2);
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()).UnsignedAbs());
- TEST_EXPECTED_SUCCESS(
- CheckedNumeric<typename std::make_signed<Dst>::type>(
- std::numeric_limits<typename std::make_signed<Dst>::type>::lowest())
- .UnsignedAbs());
- TEST_EXPECTED_VALUE(DstLimits::lowest(),
- MakeCheckedNum(DstLimits::lowest()).UnsignedAbs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- MakeCheckedNum(DstLimits::max()).UnsignedAbs());
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0).UnsignedAbs());
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).UnsignedAbs());
-
- TEST_EXPECTED_VALUE(0, -ClampedNumeric<Dst>(DstLimits::lowest()));
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()).Abs());
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) + -1);
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) - 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) * 2);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) / 2);
- TEST_EXPECTED_VALUE(0,
- ClampedNumeric<Dst>(DstLimits::lowest()).UnsignedAbs());
- TEST_EXPECTED_VALUE(
- as_unsigned(
- std::numeric_limits<typename std::make_signed<Dst>::type>::lowest()),
- ClampedNumeric<typename std::make_signed<Dst>::type>(
- std::numeric_limits<typename std::make_signed<Dst>::type>::lowest())
- .UnsignedAbs());
- TEST_EXPECTED_VALUE(DstLimits::lowest(),
- MakeClampedNum(DstLimits::lowest()).UnsignedAbs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- MakeClampedNum(DstLimits::max()).UnsignedAbs());
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0).UnsignedAbs());
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1).UnsignedAbs());
-
- // Modulus is legal only for integers.
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() % 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) % 2);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % 2);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % 2);
- // Test all the different modulus combinations.
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, 1 % CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
- CheckedNumeric<Dst> checked_dst = 1;
- TEST_EXPECTED_VALUE(0, checked_dst %= 1);
- // Test that div by 0 is avoided but returns invalid result.
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) % 0);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1)
- << IntegerBitsPlusSign<Dst>::value);
- // Test bit shifts.
- volatile int negative_one = -1;
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) << negative_one);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1)
- << IntegerBitsPlusSign<Dst>::value);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(0)
- << IntegerBitsPlusSign<Dst>::value);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) << 1);
- TEST_EXPECTED_VALUE(
- static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1),
- CheckedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1));
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) << 0);
- TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) << 1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >>
- IntegerBitsPlusSign<Dst>::value);
- TEST_EXPECTED_VALUE(
- 0, CheckedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1));
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >> negative_one);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) & 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) & 0);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) & 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) & 0);
- TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
- MakeCheckedNum(DstLimits::max()) & -1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) | 1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) | 0);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(0) | 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) | 0);
- TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
- CheckedNumeric<Dst>(0) | static_cast<Dst>(-1));
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) ^ 1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) ^ 0);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(0) ^ 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) ^ 0);
- TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
- CheckedNumeric<Dst>(0) ^ static_cast<Dst>(-1));
- TEST_EXPECTED_VALUE(DstLimits::max(), ~CheckedNumeric<Dst>(0));
-
- // Modulus is legal only for integers.
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>() % 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) % 2);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % 2);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(DstLimits::max()) % 2);
- // Test all the different modulus combinations.
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, 1 % ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
- ClampedNumeric<Dst> clamped_dst = 1;
- TEST_EXPECTED_VALUE(0, clamped_dst %= 1);
- // Test that div by 0 is avoided but returns invalid result.
- TEST_EXPECTED_VALUE(Dst(1), ClampedNumeric<Dst>(1) % 0);
- // Test bit shifts.
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(1)
- << as_unsigned(IntegerBitsPlusSign<Dst>::value));
- TEST_EXPECTED_VALUE(Dst(0), ClampedNumeric<Dst>(0) << as_unsigned(
- IntegerBitsPlusSign<Dst>::value));
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::max()) << 1U);
- TEST_EXPECTED_VALUE(
- static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1U),
- ClampedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1U));
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) << 0U);
- TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) << 1U);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) >>
- as_unsigned(IntegerBitsPlusSign<Dst>::value));
- TEST_EXPECTED_VALUE(
- 0, ClampedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1U));
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) & 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) & 0);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) & 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) & 0);
- TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
- MakeClampedNum(DstLimits::max()) & -1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) | 1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) | 0);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(0) | 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) | 0);
- TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
- ClampedNumeric<Dst>(0) | static_cast<Dst>(-1));
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) ^ 1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) ^ 0);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(0) ^ 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) ^ 0);
- TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
- ClampedNumeric<Dst>(0) ^ static_cast<Dst>(-1));
- TEST_EXPECTED_VALUE(DstLimits::max(), ~ClampedNumeric<Dst>(0));
-
- TestStrictPointerMath<Dst>();
-}
-
-// Floating point arithmetic.
-template <typename Dst>
-void TestSpecializedArithmetic(
- const char* dst,
- int line,
- typename std::enable_if<numeric_limits<Dst>::is_iec559, int>::type = 0) {
- using DstLimits = SaturationDefaultLimits<Dst>;
- TEST_EXPECTED_SUCCESS(-CheckedNumeric<Dst>(DstLimits::lowest()));
-
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()).Abs());
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).Abs());
-
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()) + -1);
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::max()) + 1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) +
- DstLimits::lowest());
-
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) -
- DstLimits::lowest());
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) -
- DstLimits::max());
-
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) * 2);
-
- TEST_EXPECTED_VALUE(-0.5, CheckedNumeric<Dst>(-1.0) / 2);
-
- TEST_EXPECTED_VALUE(DstLimits::max(),
- -ClampedNumeric<Dst>(DstLimits::lowest()));
-
- TEST_EXPECTED_VALUE(DstLimits::max(),
- ClampedNumeric<Dst>(DstLimits::lowest()).Abs());
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(-1).Abs());
-
- TEST_EXPECTED_VALUE(DstLimits::lowest() - 1,
- ClampedNumeric<Dst>(DstLimits::lowest()) + -1);
- TEST_EXPECTED_VALUE(DstLimits::max() + 1,
- ClampedNumeric<Dst>(DstLimits::max()) + 1);
- TEST_EXPECTED_VALUE(
- DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) + DstLimits::lowest());
-
- TEST_EXPECTED_VALUE(
- DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::max()) - DstLimits::lowest());
- TEST_EXPECTED_VALUE(
- DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) - DstLimits::max());
-
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::lowest()) * 2);
-
- TEST_EXPECTED_VALUE(-0.5, ClampedNumeric<Dst>(-1.0) / 2);
-}
-
-// Generic arithmetic tests.
-template <typename Dst>
-static void TestArithmetic(const char* dst, int line) {
- using DstLimits = SaturationDefaultLimits<Dst>;
-
- EXPECT_EQ(true, CheckedNumeric<Dst>().IsValid());
- EXPECT_EQ(false, CheckedNumeric<Dst>(CheckedNumeric<Dst>(DstLimits::max()) *
- DstLimits::max())
- .IsValid());
- EXPECT_EQ(static_cast<Dst>(0), CheckedNumeric<Dst>().ValueOrDie());
- EXPECT_EQ(static_cast<Dst>(0), CheckedNumeric<Dst>().ValueOrDefault(1));
- EXPECT_EQ(static_cast<Dst>(1),
- CheckedNumeric<Dst>(CheckedNumeric<Dst>(DstLimits::max()) *
- DstLimits::max())
- .ValueOrDefault(1));
-
- // Test the operator combinations.
- TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) + CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) - CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) * CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(2, 1 + CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, 1 - CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, 1 * CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, 1 / CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) + 1);
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) - 1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) * 1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / 1);
- CheckedNumeric<Dst> checked_dst = 1;
- TEST_EXPECTED_VALUE(2, checked_dst += 1);
- checked_dst = 1;
- TEST_EXPECTED_VALUE(0, checked_dst -= 1);
- checked_dst = 1;
- TEST_EXPECTED_VALUE(1, checked_dst *= 1);
- checked_dst = 1;
- TEST_EXPECTED_VALUE(1, checked_dst /= 1);
-
- TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) + ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) - ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) * ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) / ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(2, 1 + ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(0, 1 - ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, 1 * ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, 1 / ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) + 1);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) - 1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) * 1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) / 1);
- ClampedNumeric<Dst> clamped_dst = 1;
- TEST_EXPECTED_VALUE(2, clamped_dst += 1);
- clamped_dst = 1;
- TEST_EXPECTED_VALUE(0, clamped_dst -= 1);
- clamped_dst = 1;
- TEST_EXPECTED_VALUE(1, clamped_dst *= 1);
- clamped_dst = 1;
- TEST_EXPECTED_VALUE(1, clamped_dst /= 1);
-
- // Generic negation.
- if (DstLimits::is_signed) {
- TEST_EXPECTED_VALUE(0, -CheckedNumeric<Dst>());
- TEST_EXPECTED_VALUE(-1, -CheckedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, -CheckedNumeric<Dst>(-1));
- TEST_EXPECTED_VALUE(static_cast<Dst>(DstLimits::max() * -1),
- -CheckedNumeric<Dst>(DstLimits::max()));
-
- TEST_EXPECTED_VALUE(0, -ClampedNumeric<Dst>());
- TEST_EXPECTED_VALUE(-1, -ClampedNumeric<Dst>(1));
- TEST_EXPECTED_VALUE(1, -ClampedNumeric<Dst>(-1));
- TEST_EXPECTED_VALUE(static_cast<Dst>(DstLimits::max() * -1),
- -ClampedNumeric<Dst>(DstLimits::max()));
-
- // The runtime paths for saturated negation differ significantly from what
- // gets evaluated at compile-time. Making this test volatile forces the
- // compiler to generate code rather than fold constant expressions.
- volatile Dst value = Dst(0);
- TEST_EXPECTED_VALUE(0, -MakeClampedNum(value));
- value = Dst(1);
- TEST_EXPECTED_VALUE(-1, -MakeClampedNum(value));
- value = Dst(2);
- TEST_EXPECTED_VALUE(-2, -MakeClampedNum(value));
- value = Dst(-1);
- TEST_EXPECTED_VALUE(1, -MakeClampedNum(value));
- value = Dst(-2);
- TEST_EXPECTED_VALUE(2, -MakeClampedNum(value));
- value = DstLimits::max();
- TEST_EXPECTED_VALUE(Dst(DstLimits::max() * -1), -MakeClampedNum(value));
- value = Dst(-1 * DstLimits::max());
- TEST_EXPECTED_VALUE(DstLimits::max(), -MakeClampedNum(value));
- value = DstLimits::lowest();
- TEST_EXPECTED_VALUE(DstLimits::max(), -MakeClampedNum(value));
- }
-
- // Generic absolute value.
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>().Abs());
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).Abs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- CheckedNumeric<Dst>(DstLimits::max()).Abs());
-
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>().Abs());
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1).Abs());
- TEST_EXPECTED_VALUE(DstLimits::max(),
- ClampedNumeric<Dst>(DstLimits::max()).Abs());
-
- // Generic addition.
- TEST_EXPECTED_VALUE(1, (CheckedNumeric<Dst>() + 1));
- TEST_EXPECTED_VALUE(2, (CheckedNumeric<Dst>(1) + 1));
- if (numeric_limits<Dst>::is_signed)
- TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(-1) + 1));
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()) + 1);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) +
- DstLimits::max());
-
- TEST_EXPECTED_VALUE(1, (ClampedNumeric<Dst>() + 1));
- TEST_EXPECTED_VALUE(2, (ClampedNumeric<Dst>(1) + 1));
- if (numeric_limits<Dst>::is_signed)
- TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(-1) + 1));
- TEST_EXPECTED_VALUE(DstLimits::lowest() + 1,
- ClampedNumeric<Dst>(DstLimits::lowest()) + 1);
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::max()) + DstLimits::max());
-
- // Generic subtraction.
- TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(1) - 1));
- TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::max()) - 1);
- if (numeric_limits<Dst>::is_signed) {
- TEST_EXPECTED_VALUE(-1, (CheckedNumeric<Dst>() - 1));
- TEST_EXPECTED_VALUE(-2, (CheckedNumeric<Dst>(-1) - 1));
- } else {
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) - -1);
- }
-
- TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(1) - 1));
- TEST_EXPECTED_VALUE(DstLimits::max() - 1,
- ClampedNumeric<Dst>(DstLimits::max()) - 1);
- if (numeric_limits<Dst>::is_signed) {
- TEST_EXPECTED_VALUE(-1, (ClampedNumeric<Dst>() - 1));
- TEST_EXPECTED_VALUE(-2, (ClampedNumeric<Dst>(-1) - 1));
- } else {
- TEST_EXPECTED_VALUE(DstLimits::max(),
- ClampedNumeric<Dst>(DstLimits::max()) - -1);
- }
-
- // Generic multiplication.
- TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>() * 1));
- TEST_EXPECTED_VALUE(1, (CheckedNumeric<Dst>(1) * 1));
- TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(0) * 0));
- if (numeric_limits<Dst>::is_signed) {
- TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(-1) * 0));
- TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(0) * -1));
- TEST_EXPECTED_VALUE(-2, (CheckedNumeric<Dst>(-1) * 2));
- } else {
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) * -2);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) *
- CheckedNumeric<uintmax_t>(-2));
- }
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) *
- DstLimits::max());
-
- TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>() * 1));
- TEST_EXPECTED_VALUE(1, (ClampedNumeric<Dst>(1) * 1));
- TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(0) * 0));
- if (numeric_limits<Dst>::is_signed) {
- TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(-1) * 0));
- TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(0) * -1));
- TEST_EXPECTED_VALUE(-2, (ClampedNumeric<Dst>(-1) * 2));
- } else {
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- ClampedNumeric<Dst>(DstLimits::max()) * -2);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::max()) *
- ClampedNumeric<uintmax_t>(-2));
- }
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- ClampedNumeric<Dst>(DstLimits::max()) * DstLimits::max());
-
- // Generic division.
- TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() / 1);
- TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / 1);
- TEST_EXPECTED_VALUE(DstLimits::lowest() / 2,
- CheckedNumeric<Dst>(DstLimits::lowest()) / 2);
- TEST_EXPECTED_VALUE(DstLimits::max() / 2,
- CheckedNumeric<Dst>(DstLimits::max()) / 2);
- TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) / 0);
-
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>() / 1);
- TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) / 1);
- TEST_EXPECTED_VALUE(DstLimits::lowest() / 2,
- ClampedNumeric<Dst>(DstLimits::lowest()) / 2);
- TEST_EXPECTED_VALUE(DstLimits::max() / 2,
- ClampedNumeric<Dst>(DstLimits::max()) / 2);
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), ClampedNumeric<Dst>(1) / 0);
- TEST_EXPECTED_VALUE(DstLimits::Underflow(), ClampedNumeric<Dst>(-1) / 0);
- TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) / 0);
-
- TestSpecializedArithmetic<Dst>(dst, line);
-}
-
-// Helper macro to wrap displaying the conversion types and line numbers.
-#define TEST_ARITHMETIC(Dst) TestArithmetic<Dst>(#Dst, __LINE__)
-
-TEST(SafeNumerics, SignedIntegerMath) {
- TEST_ARITHMETIC(int8_t);
- TEST_ARITHMETIC(int16_t);
- TEST_ARITHMETIC(int);
- TEST_ARITHMETIC(intptr_t);
- TEST_ARITHMETIC(intmax_t);
-}
-
-TEST(SafeNumerics, UnsignedIntegerMath) {
- TEST_ARITHMETIC(uint8_t);
- TEST_ARITHMETIC(uint16_t);
- TEST_ARITHMETIC(unsigned int);
- TEST_ARITHMETIC(uintptr_t);
- TEST_ARITHMETIC(uintmax_t);
-}
-
-TEST(SafeNumerics, FloatingPointMath) {
- TEST_ARITHMETIC(float);
- TEST_ARITHMETIC(double);
-}
-
-// Enumerates the five different conversions types we need to test.
-enum NumericConversionType {
- SIGN_PRESERVING_VALUE_PRESERVING,
- SIGN_PRESERVING_NARROW,
- SIGN_TO_UNSIGN_WIDEN_OR_EQUAL,
- SIGN_TO_UNSIGN_NARROW,
- UNSIGN_TO_SIGN_NARROW_OR_EQUAL,
-};
-
-// Template covering the different conversion tests.
-template <typename Dst, typename Src, NumericConversionType conversion>
-struct TestNumericConversion {};
-
-enum RangeConstraint {
- RANGE_VALID = 0x0, // Value can be represented by the destination type.
- RANGE_UNDERFLOW = 0x1, // Value would underflow.
- RANGE_OVERFLOW = 0x2, // Value would overflow.
- RANGE_INVALID = RANGE_UNDERFLOW | RANGE_OVERFLOW // Invalid (i.e. NaN).
-};
-
-// These are some wrappers to make the tests a bit cleaner.
-constexpr RangeConstraint RangeCheckToEnum(const RangeCheck constraint) {
- return static_cast<RangeConstraint>(
- static_cast<int>(constraint.IsOverflowFlagSet()) << 1 |
- static_cast<int>(constraint.IsUnderflowFlagSet()));
-}
-
-// EXPECT_EQ wrappers providing specific detail on test failures.
-#define TEST_EXPECTED_RANGE(expected, actual) \
- EXPECT_EQ(expected, \
- RangeCheckToEnum(DstRangeRelationToSrcRange<Dst>(actual))) \
- << "Conversion test: " << src << " value " << actual << " to " << dst \
- << " on line " << line
-
-template <typename Dst, typename Src>
-void TestStrictComparison(const char* dst, const char* src, int line) {
- using DstLimits = numeric_limits<Dst>;
- using SrcLimits = numeric_limits<Src>;
- static_assert(StrictNumeric<Src>(SrcLimits::lowest()) < DstLimits::max(), "");
- static_assert(StrictNumeric<Src>(SrcLimits::lowest()) < SrcLimits::max(), "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) >= DstLimits::max()),
- "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) >= SrcLimits::max()),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::lowest()) <= DstLimits::max(),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::lowest()) <= SrcLimits::max(),
- "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) > DstLimits::max()),
- "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) > SrcLimits::max()),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::max()) > DstLimits::lowest(), "");
- static_assert(StrictNumeric<Src>(SrcLimits::max()) > SrcLimits::lowest(), "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::max()) <= DstLimits::lowest()),
- "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::max()) <= SrcLimits::lowest()),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::max()) >= DstLimits::lowest(),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::max()) >= SrcLimits::lowest(),
- "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::max()) < DstLimits::lowest()),
- "");
- static_assert(!(StrictNumeric<Src>(SrcLimits::max()) < SrcLimits::lowest()),
- "");
- static_assert(StrictNumeric<Src>(static_cast<Src>(1)) == static_cast<Dst>(1),
- "");
- static_assert(StrictNumeric<Src>(static_cast<Src>(1)) != static_cast<Dst>(0),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::max()) != static_cast<Dst>(0),
- "");
- static_assert(StrictNumeric<Src>(SrcLimits::max()) != DstLimits::lowest(),
- "");
- static_assert(
- !(StrictNumeric<Src>(static_cast<Src>(1)) != static_cast<Dst>(1)), "");
- static_assert(
- !(StrictNumeric<Src>(static_cast<Src>(1)) == static_cast<Dst>(0)), "");
-
- // Due to differences in float handling between compilers, these aren't
- // compile-time constants everywhere. So, we use run-time tests.
- EXPECT_EQ(
- SrcLimits::max(),
- MakeCheckedNum(SrcLimits::max()).Max(DstLimits::lowest()).ValueOrDie());
- EXPECT_EQ(
- DstLimits::max(),
- MakeCheckedNum(SrcLimits::lowest()).Max(DstLimits::max()).ValueOrDie());
- EXPECT_EQ(
- DstLimits::lowest(),
- MakeCheckedNum(SrcLimits::max()).Min(DstLimits::lowest()).ValueOrDie());
- EXPECT_EQ(
- SrcLimits::lowest(),
- MakeCheckedNum(SrcLimits::lowest()).Min(DstLimits::max()).ValueOrDie());
- EXPECT_EQ(SrcLimits::lowest(), CheckMin(MakeStrictNum(1), MakeCheckedNum(0),
- DstLimits::max(), SrcLimits::lowest())
- .ValueOrDie());
- EXPECT_EQ(DstLimits::max(), CheckMax(MakeStrictNum(1), MakeCheckedNum(0),
- DstLimits::max(), SrcLimits::lowest())
- .ValueOrDie());
-
- EXPECT_EQ(SrcLimits::max(),
- MakeClampedNum(SrcLimits::max()).Max(DstLimits::lowest()));
- EXPECT_EQ(DstLimits::max(),
- MakeClampedNum(SrcLimits::lowest()).Max(DstLimits::max()));
- EXPECT_EQ(DstLimits::lowest(),
- MakeClampedNum(SrcLimits::max()).Min(DstLimits::lowest()));
- EXPECT_EQ(SrcLimits::lowest(),
- MakeClampedNum(SrcLimits::lowest()).Min(DstLimits::max()));
- EXPECT_EQ(SrcLimits::lowest(),
- ClampMin(MakeStrictNum(1), MakeClampedNum(0), DstLimits::max(),
- SrcLimits::lowest()));
- EXPECT_EQ(DstLimits::max(), ClampMax(MakeStrictNum(1), MakeClampedNum(0),
- DstLimits::max(), SrcLimits::lowest()));
-
- if (IsValueInRangeForNumericType<Dst>(SrcLimits::max())) {
- TEST_EXPECTED_VALUE(Dst(SrcLimits::max()), (CommonMax<Dst, Src>()));
- TEST_EXPECTED_VALUE(Dst(SrcLimits::max()),
- (CommonMaxOrMin<Dst, Src>(false)));
- } else {
- TEST_EXPECTED_VALUE(DstLimits::max(), (CommonMax<Dst, Src>()));
- TEST_EXPECTED_VALUE(DstLimits::max(), (CommonMaxOrMin<Dst, Src>(false)));
- }
-
- if (IsValueInRangeForNumericType<Dst>(SrcLimits::lowest())) {
- TEST_EXPECTED_VALUE(Dst(SrcLimits::lowest()), (CommonMin<Dst, Src>()));
- TEST_EXPECTED_VALUE(Dst(SrcLimits::lowest()),
- (CommonMaxOrMin<Dst, Src>(true)));
- } else {
- TEST_EXPECTED_VALUE(DstLimits::lowest(), (CommonMin<Dst, Src>()));
- TEST_EXPECTED_VALUE(DstLimits::lowest(), (CommonMaxOrMin<Dst, Src>(true)));
- }
-}
-
-template <typename Dst, typename Src>
-struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_VALUE_PRESERVING> {
- static void Test(const char* dst, const char* src, int line) {
- using SrcLimits = SaturationDefaultLimits<Src>;
- using DstLimits = SaturationDefaultLimits<Dst>;
- // Integral to floating.
- static_assert((DstLimits::is_iec559 && SrcLimits::is_integer) ||
- // Not floating to integral and...
- (!(DstLimits::is_integer && SrcLimits::is_iec559) &&
- // Same sign, same numeric, source is narrower or same.
- ((SrcLimits::is_signed == DstLimits::is_signed &&
- MaxExponent<Dst>::value >= MaxExponent<Src>::value) ||
- // Or signed destination and source is smaller
- (DstLimits::is_signed &&
- MaxExponent<Dst>::value >= MaxExponent<Src>::value))),
- "Comparison must be sign preserving and value preserving");
-
- TestStrictComparison<Dst, Src>(dst, src, line);
-
- const CheckedNumeric<Dst> checked_dst = SrcLimits::max();
- const ClampedNumeric<Dst> clamped_dst = SrcLimits::max();
- TEST_EXPECTED_SUCCESS(checked_dst);
- TEST_EXPECTED_VALUE(Dst(SrcLimits::max()), clamped_dst);
- if (MaxExponent<Dst>::value > MaxExponent<Src>::value) {
- if (MaxExponent<Dst>::value >= MaxExponent<Src>::value * 2 - 1) {
- // At least twice larger type.
- TEST_EXPECTED_SUCCESS(SrcLimits::max() * checked_dst);
- TEST_EXPECTED_VALUE(SrcLimits::max() * clamped_dst,
- Dst(SrcLimits::max()) * SrcLimits::max());
- } else { // Larger, but not at least twice as large.
- TEST_EXPECTED_FAILURE(SrcLimits::max() * checked_dst);
- TEST_EXPECTED_SUCCESS(checked_dst + 1);
- TEST_EXPECTED_VALUE(DstLimits::Overflow(),
- SrcLimits::max() * clamped_dst);
- TEST_EXPECTED_VALUE(Dst(SrcLimits::max()) + Dst(1),
- clamped_dst + Dst(1));
- }
- } else { // Same width type.
- TEST_EXPECTED_FAILURE(checked_dst + 1);
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + Dst(1));
- }
-
- TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max());
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
- if (SrcLimits::is_iec559) {
- TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max() * static_cast<Src>(-1));
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
- TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
- } else if (numeric_limits<Src>::is_signed) {
- // This block reverses the Src to Dst relationship so we don't have to
- // complicate the test macros.
- if (!std::is_same<Src, Dst>::value) {
- TEST_EXPECTED_SUCCESS(CheckDiv(SrcLimits::lowest(), Dst(-1)));
- }
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
- TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::lowest());
- }
- }
-};
-
-template <typename Dst, typename Src>
-struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_NARROW> {
- static void Test(const char* dst, const char* src, int line) {
- using SrcLimits = SaturationDefaultLimits<Src>;
- using DstLimits = SaturationDefaultLimits<Dst>;
- static_assert(SrcLimits::is_signed == DstLimits::is_signed,
- "Destination and source sign must be the same");
- static_assert(MaxExponent<Dst>::value <= MaxExponent<Src>::value,
- "Destination must be narrower than source");
-
- TestStrictComparison<Dst, Src>(dst, src, line);
-
- const CheckedNumeric<Dst> checked_dst;
- TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::max());
- TEST_EXPECTED_VALUE(1, checked_dst + Src(1));
- TEST_EXPECTED_FAILURE(checked_dst - SrcLimits::max());
-
- ClampedNumeric<Dst> clamped_dst;
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + SrcLimits::max());
- TEST_EXPECTED_VALUE(1, clamped_dst + Src(1));
- TEST_EXPECTED_VALUE(DstLimits::Underflow(), clamped_dst - SrcLimits::max());
- clamped_dst += SrcLimits::max();
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
- clamped_dst = DstLimits::max();
- clamped_dst += SrcLimits::max();
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
- clamped_dst = DstLimits::max();
- clamped_dst -= SrcLimits::max();
- TEST_EXPECTED_VALUE(DstLimits::Underflow(), clamped_dst);
- clamped_dst = 0;
-
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
- if (SrcLimits::is_iec559) {
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::max() * -1);
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
- TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
- if (DstLimits::is_integer) {
- if (SrcLimits::digits < DstLimits::digits) {
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW,
- static_cast<Src>(DstLimits::max()));
- } else {
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::max()));
- }
- TEST_EXPECTED_RANGE(
- RANGE_VALID,
- static_cast<Src>(GetMaxConvertibleToFloat<Src, Dst>()));
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::lowest()));
- }
- } else if (SrcLimits::is_signed) {
- TEST_EXPECTED_VALUE(-1, checked_dst - static_cast<Src>(1));
- TEST_EXPECTED_VALUE(-1, clamped_dst - static_cast<Src>(1));
- TEST_EXPECTED_VALUE(Src(Src(0) - DstLimits::lowest()),
- ClampDiv(DstLimits::lowest(), Src(-1)));
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::lowest());
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
- } else {
- TEST_EXPECTED_FAILURE(checked_dst - static_cast<Src>(1));
- TEST_EXPECTED_VALUE(Dst(0), clamped_dst - static_cast<Src>(1));
- TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::lowest());
- }
- }
-};
-
-template <typename Dst, typename Src>
-struct TestNumericConversion<Dst, Src, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL> {
- static void Test(const char* dst, const char* src, int line) {
- using SrcLimits = SaturationDefaultLimits<Src>;
- using DstLimits = SaturationDefaultLimits<Dst>;
- static_assert(MaxExponent<Dst>::value >= MaxExponent<Src>::value,
- "Destination must be equal or wider than source.");
- static_assert(SrcLimits::is_signed, "Source must be signed");
- static_assert(!DstLimits::is_signed, "Destination must be unsigned");
-
- TestStrictComparison<Dst, Src>(dst, src, line);
-
- const CheckedNumeric<Dst> checked_dst;
- TEST_EXPECTED_VALUE(SrcLimits::max(), checked_dst + SrcLimits::max());
- TEST_EXPECTED_FAILURE(checked_dst + static_cast<Src>(-1));
- TEST_EXPECTED_SUCCESS(checked_dst * static_cast<Src>(-1));
- TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::lowest());
- TEST_EXPECTED_VALUE(Dst(0), CheckDiv(Dst(0), Src(-1)));
-
- const ClampedNumeric<Dst> clamped_dst;
- TEST_EXPECTED_VALUE(SrcLimits::max(), clamped_dst + SrcLimits::max());
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- clamped_dst + static_cast<Src>(-1));
- TEST_EXPECTED_VALUE(0, clamped_dst * static_cast<Src>(-1));
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- clamped_dst + SrcLimits::lowest());
-
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::lowest());
- TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max());
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, static_cast<Src>(-1));
- }
-};
-
-template <typename Dst, typename Src>
-struct TestNumericConversion<Dst, Src, SIGN_TO_UNSIGN_NARROW> {
- static void Test(const char* dst, const char* src, int line) {
- using SrcLimits = SaturationDefaultLimits<Src>;
- using DstLimits = SaturationDefaultLimits<Dst>;
- static_assert(MaxExponent<Dst>::value < MaxExponent<Src>::value,
- "Destination must be narrower than source.");
- static_assert(SrcLimits::is_signed, "Source must be signed.");
- static_assert(!DstLimits::is_signed, "Destination must be unsigned.");
-
- TestStrictComparison<Dst, Src>(dst, src, line);
-
- const CheckedNumeric<Dst> checked_dst;
- TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
- TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::max());
- TEST_EXPECTED_FAILURE(checked_dst + static_cast<Src>(-1));
- TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::lowest());
-
- ClampedNumeric<Dst> clamped_dst;
- TEST_EXPECTED_VALUE(1, clamped_dst + static_cast<Src>(1));
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + SrcLimits::max());
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- clamped_dst + static_cast<Src>(-1));
- TEST_EXPECTED_VALUE(DstLimits::Underflow(),
- clamped_dst + SrcLimits::lowest());
- clamped_dst += SrcLimits::max();
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
- clamped_dst = DstLimits::max();
- clamped_dst += SrcLimits::max();
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
- clamped_dst = DstLimits::max();
- clamped_dst -= SrcLimits::max();
- TEST_EXPECTED_VALUE(DstLimits::Underflow(), clamped_dst);
- clamped_dst = 0;
-
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, static_cast<Src>(-1));
-
- // Additional saturation tests.
- EXPECT_EQ(DstLimits::max(), saturated_cast<Dst>(SrcLimits::max()));
- EXPECT_EQ(DstLimits::lowest(), saturated_cast<Dst>(SrcLimits::lowest()));
-
- if (SrcLimits::is_iec559) {
- EXPECT_EQ(Dst(0), saturated_cast<Dst>(SrcLimits::quiet_NaN()));
-
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::max() * -1);
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
- TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
- if (DstLimits::is_integer) {
- if (SrcLimits::digits < DstLimits::digits) {
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW,
- static_cast<Src>(DstLimits::max()));
- } else {
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::max()));
- }
- TEST_EXPECTED_RANGE(
- RANGE_VALID,
- static_cast<Src>(GetMaxConvertibleToFloat<Src, Dst>()));
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::lowest()));
- }
- } else {
- TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::lowest());
- }
- }
-};
-
-template <typename Dst, typename Src>
-struct TestNumericConversion<Dst, Src, UNSIGN_TO_SIGN_NARROW_OR_EQUAL> {
- static void Test(const char* dst, const char* src, int line) {
- using SrcLimits = SaturationDefaultLimits<Src>;
- using DstLimits = SaturationDefaultLimits<Dst>;
- static_assert(MaxExponent<Dst>::value <= MaxExponent<Src>::value,
- "Destination must be narrower or equal to source.");
- static_assert(!SrcLimits::is_signed, "Source must be unsigned.");
- static_assert(DstLimits::is_signed, "Destination must be signed.");
-
- TestStrictComparison<Dst, Src>(dst, src, line);
-
- const CheckedNumeric<Dst> checked_dst;
- TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
- TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::max());
- TEST_EXPECTED_VALUE(SrcLimits::lowest(), checked_dst + SrcLimits::lowest());
-
- const ClampedNumeric<Dst> clamped_dst;
- TEST_EXPECTED_VALUE(1, clamped_dst + static_cast<Src>(1));
- TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + SrcLimits::max());
- TEST_EXPECTED_VALUE(SrcLimits::lowest(), clamped_dst + SrcLimits::lowest());
-
- TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::lowest());
- TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
- TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
-
- // Additional saturation tests.
- EXPECT_EQ(DstLimits::max(), saturated_cast<Dst>(SrcLimits::max()));
- EXPECT_EQ(Dst(0), saturated_cast<Dst>(SrcLimits::lowest()));
- }
-};
-
-// Helper macro to wrap displaying the conversion types and line numbers
-#define TEST_NUMERIC_CONVERSION(d, s, t) \
- TestNumericConversion<d, s, t>::Test(#d, #s, __LINE__)
-
-TEST(SafeNumerics, IntMinOperations) {
- TEST_NUMERIC_CONVERSION(int8_t, int8_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(uint8_t, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
-
- TEST_NUMERIC_CONVERSION(int8_t, int16_t, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(int8_t, int, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(uint8_t, uint16_t, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(uint8_t, unsigned int, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(int8_t, float, SIGN_PRESERVING_NARROW);
-
- TEST_NUMERIC_CONVERSION(uint8_t, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
-
- TEST_NUMERIC_CONVERSION(uint8_t, int16_t, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(uint8_t, int, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(uint8_t, intmax_t, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(uint8_t, float, SIGN_TO_UNSIGN_NARROW);
-
- TEST_NUMERIC_CONVERSION(int8_t, uint16_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(int8_t, unsigned int, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(int8_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
-}
-
-TEST(SafeNumerics, Int16Operations) {
- TEST_NUMERIC_CONVERSION(int16_t, int16_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(uint16_t, uint16_t, SIGN_PRESERVING_VALUE_PRESERVING);
-
- TEST_NUMERIC_CONVERSION(int16_t, int, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(uint16_t, unsigned int, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(int16_t, float, SIGN_PRESERVING_NARROW);
-
- TEST_NUMERIC_CONVERSION(uint16_t, int16_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
-
- TEST_NUMERIC_CONVERSION(uint16_t, int, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(uint16_t, intmax_t, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(uint16_t, float, SIGN_TO_UNSIGN_NARROW);
-
- TEST_NUMERIC_CONVERSION(int16_t, unsigned int,
- UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(int16_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
-}
-
-TEST(SafeNumerics, IntOperations) {
- TEST_NUMERIC_CONVERSION(int, int, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(unsigned int, unsigned int,
- SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(int, int8_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(unsigned int, uint8_t,
- SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(int, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
-
- TEST_NUMERIC_CONVERSION(int, intmax_t, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(unsigned int, uintmax_t, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(int, float, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(int, double, SIGN_PRESERVING_NARROW);
-
- TEST_NUMERIC_CONVERSION(unsigned int, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(unsigned int, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
-
- TEST_NUMERIC_CONVERSION(unsigned int, intmax_t, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(unsigned int, float, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(unsigned int, double, SIGN_TO_UNSIGN_NARROW);
-
- TEST_NUMERIC_CONVERSION(int, unsigned int, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(int, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
-}
-
-TEST(SafeNumerics, IntMaxOperations) {
- TEST_NUMERIC_CONVERSION(intmax_t, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(uintmax_t, uintmax_t,
- SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(intmax_t, int, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(uintmax_t, unsigned int,
- SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(intmax_t, unsigned int,
- SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(intmax_t, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
-
- TEST_NUMERIC_CONVERSION(intmax_t, float, SIGN_PRESERVING_NARROW);
- TEST_NUMERIC_CONVERSION(intmax_t, double, SIGN_PRESERVING_NARROW);
-
- TEST_NUMERIC_CONVERSION(uintmax_t, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(uintmax_t, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
-
- TEST_NUMERIC_CONVERSION(uintmax_t, float, SIGN_TO_UNSIGN_NARROW);
- TEST_NUMERIC_CONVERSION(uintmax_t, double, SIGN_TO_UNSIGN_NARROW);
-
- TEST_NUMERIC_CONVERSION(intmax_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
-}
-
-TEST(SafeNumerics, FloatOperations) {
- TEST_NUMERIC_CONVERSION(float, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(float, uintmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(float, int, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(float, unsigned int,
- SIGN_PRESERVING_VALUE_PRESERVING);
-
- TEST_NUMERIC_CONVERSION(float, double, SIGN_PRESERVING_NARROW);
-}
-
-TEST(SafeNumerics, DoubleOperations) {
- TEST_NUMERIC_CONVERSION(double, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(double, uintmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(double, int, SIGN_PRESERVING_VALUE_PRESERVING);
- TEST_NUMERIC_CONVERSION(double, unsigned int,
- SIGN_PRESERVING_VALUE_PRESERVING);
-}
-
-TEST(SafeNumerics, SizeTOperations) {
- TEST_NUMERIC_CONVERSION(size_t, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
- TEST_NUMERIC_CONVERSION(int, size_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
-}
-
-// A one-off test to ensure StrictNumeric won't resolve to an incorrect type.
-// If this fails we'll just get a compiler error on an ambiguous overload.
-int TestOverload(int) { // Overload fails.
- return 0;
-}
-uint8_t TestOverload(uint8_t) { // Overload fails.
- return 0;
-}
-size_t TestOverload(size_t) { // Overload succeeds.
- return 0;
-}
-
-static_assert(
- std::is_same<decltype(TestOverload(StrictNumeric<int>())), int>::value,
- "");
-static_assert(std::is_same<decltype(TestOverload(StrictNumeric<size_t>())),
- size_t>::value,
- "");
-
-template <typename T>
-struct CastTest1 {
- static constexpr T NaN() { return -1; }
- static constexpr T max() { return numeric_limits<T>::max() - 1; }
- static constexpr T Overflow() { return max(); }
- static constexpr T lowest() { return numeric_limits<T>::lowest() + 1; }
- static constexpr T Underflow() { return lowest(); }
-};
-
-template <typename T>
-struct CastTest2 {
- static constexpr T NaN() { return 11; }
- static constexpr T max() { return 10; }
- static constexpr T Overflow() { return max(); }
- static constexpr T lowest() { return 1; }
- static constexpr T Underflow() { return lowest(); }
-};
-
-TEST(SafeNumerics, CastTests) {
-// MSVC catches and warns that we're forcing saturation in these tests.
-// Since that's intentional, we need to shut this warning off.
-#if defined(COMPILER_MSVC)
-#pragma warning(disable : 4756)
-#endif
-
- int small_positive = 1;
- int small_negative = -1;
- double double_small = 1.0;
- double double_large = numeric_limits<double>::max();
- double double_infinity = numeric_limits<float>::infinity();
- double double_large_int = numeric_limits<int>::max();
- double double_small_int = numeric_limits<int>::lowest();
-
- // Just test that the casts compile, since the other tests cover logic.
- EXPECT_EQ(0, checked_cast<int>(static_cast<size_t>(0)));
- EXPECT_EQ(0, strict_cast<int>(static_cast<char>(0)));
- EXPECT_EQ(0, strict_cast<int>(static_cast<unsigned char>(0)));
- EXPECT_EQ(0U, strict_cast<unsigned>(static_cast<unsigned char>(0)));
- EXPECT_EQ(1ULL, static_cast<uint64_t>(StrictNumeric<size_t>(1U)));
- EXPECT_EQ(1ULL, static_cast<uint64_t>(SizeT(1U)));
- EXPECT_EQ(1U, static_cast<size_t>(StrictNumeric<unsigned>(1U)));
-
- EXPECT_TRUE(CheckedNumeric<uint64_t>(StrictNumeric<unsigned>(1U)).IsValid());
- EXPECT_TRUE(CheckedNumeric<int>(StrictNumeric<unsigned>(1U)).IsValid());
- EXPECT_FALSE(CheckedNumeric<unsigned>(StrictNumeric<int>(-1)).IsValid());
-
- EXPECT_TRUE(IsValueNegative(-1));
- EXPECT_TRUE(IsValueNegative(numeric_limits<int>::lowest()));
- EXPECT_FALSE(IsValueNegative(numeric_limits<unsigned>::lowest()));
- EXPECT_TRUE(IsValueNegative(numeric_limits<double>::lowest()));
- EXPECT_FALSE(IsValueNegative(0));
- EXPECT_FALSE(IsValueNegative(1));
- EXPECT_FALSE(IsValueNegative(0u));
- EXPECT_FALSE(IsValueNegative(1u));
- EXPECT_FALSE(IsValueNegative(numeric_limits<int>::max()));
- EXPECT_FALSE(IsValueNegative(numeric_limits<unsigned>::max()));
- EXPECT_FALSE(IsValueNegative(numeric_limits<double>::max()));
-
- // These casts and coercions will fail to compile:
- // EXPECT_EQ(0, strict_cast<int>(static_cast<size_t>(0)));
- // EXPECT_EQ(0, strict_cast<size_t>(static_cast<int>(0)));
- // EXPECT_EQ(1ULL, StrictNumeric<size_t>(1));
- // EXPECT_EQ(1, StrictNumeric<size_t>(1U));
-
- // Test various saturation corner cases.
- EXPECT_EQ(saturated_cast<int>(small_negative),
- static_cast<int>(small_negative));
- EXPECT_EQ(saturated_cast<int>(small_positive),
- static_cast<int>(small_positive));
- EXPECT_EQ(saturated_cast<unsigned>(small_negative), static_cast<unsigned>(0));
- EXPECT_EQ(saturated_cast<int>(double_small), static_cast<int>(double_small));
- EXPECT_EQ(saturated_cast<int>(double_large), numeric_limits<int>::max());
- EXPECT_EQ(saturated_cast<float>(double_large), double_infinity);
- EXPECT_EQ(saturated_cast<float>(-double_large), -double_infinity);
- EXPECT_EQ(numeric_limits<int>::lowest(),
- saturated_cast<int>(double_small_int));
- EXPECT_EQ(numeric_limits<int>::max(), saturated_cast<int>(double_large_int));
-
- // Test the saturated cast overrides.
- using FloatLimits = numeric_limits<float>;
- using IntLimits = numeric_limits<int>;
- EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(FloatLimits::quiet_NaN())));
- EXPECT_EQ(CastTest1<int>::max(),
- (saturated_cast<int, CastTest1>(FloatLimits::infinity())));
- EXPECT_EQ(CastTest1<int>::max(),
- (saturated_cast<int, CastTest1>(FloatLimits::max())));
- EXPECT_EQ(CastTest1<int>::max(),
- (saturated_cast<int, CastTest1>(float(IntLimits::max()))));
- EXPECT_EQ(CastTest1<int>::lowest(),
- (saturated_cast<int, CastTest1>(-FloatLimits::infinity())));
- EXPECT_EQ(CastTest1<int>::lowest(),
- (saturated_cast<int, CastTest1>(FloatLimits::lowest())));
- EXPECT_EQ(0, (saturated_cast<int, CastTest1>(0.0)));
- EXPECT_EQ(1, (saturated_cast<int, CastTest1>(1.0)));
- EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(-1.0)));
- EXPECT_EQ(0, (saturated_cast<int, CastTest1>(0)));
- EXPECT_EQ(1, (saturated_cast<int, CastTest1>(1)));
- EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(-1)));
- EXPECT_EQ(CastTest1<int>::lowest(),
- (saturated_cast<int, CastTest1>(float(IntLimits::lowest()))));
- EXPECT_EQ(11, (saturated_cast<int, CastTest2>(FloatLimits::quiet_NaN())));
- EXPECT_EQ(10, (saturated_cast<int, CastTest2>(FloatLimits::infinity())));
- EXPECT_EQ(10, (saturated_cast<int, CastTest2>(FloatLimits::max())));
- EXPECT_EQ(1, (saturated_cast<int, CastTest2>(-FloatLimits::infinity())));
- EXPECT_EQ(1, (saturated_cast<int, CastTest2>(FloatLimits::lowest())));
- EXPECT_EQ(1, (saturated_cast<int, CastTest2>(0U)));
-
- float not_a_number = std::numeric_limits<float>::infinity() -
- std::numeric_limits<float>::infinity();
- EXPECT_TRUE(std::isnan(not_a_number));
- EXPECT_EQ(0, saturated_cast<int>(not_a_number));
-
- // Test the CheckedNumeric value extractions functions.
- auto int8_min = MakeCheckedNum(numeric_limits<int8_t>::lowest());
- auto int8_max = MakeCheckedNum(numeric_limits<int8_t>::max());
- auto double_max = MakeCheckedNum(numeric_limits<double>::max());
- static_assert(
- std::is_same<int16_t,
- decltype(int8_min.ValueOrDie<int16_t>())::type>::value,
- "ValueOrDie returning incorrect type.");
- static_assert(
- std::is_same<int16_t,
- decltype(int8_min.ValueOrDefault<int16_t>(0))::type>::value,
- "ValueOrDefault returning incorrect type.");
- EXPECT_FALSE(IsValidForType<uint8_t>(int8_min));
- EXPECT_TRUE(IsValidForType<uint8_t>(int8_max));
- EXPECT_EQ(static_cast<int>(numeric_limits<int8_t>::lowest()),
- ValueOrDieForType<int>(int8_min));
- EXPECT_TRUE(IsValidForType<uint32_t>(int8_max));
- EXPECT_EQ(static_cast<int>(numeric_limits<int8_t>::max()),
- ValueOrDieForType<int>(int8_max));
- EXPECT_EQ(0, ValueOrDefaultForType<int>(double_max, 0));
- uint8_t uint8_dest = 0;
- int16_t int16_dest = 0;
- double double_dest = 0;
- EXPECT_TRUE(int8_max.AssignIfValid(&uint8_dest));
- EXPECT_EQ(static_cast<uint8_t>(numeric_limits<int8_t>::max()), uint8_dest);
- EXPECT_FALSE(int8_min.AssignIfValid(&uint8_dest));
- EXPECT_TRUE(int8_max.AssignIfValid(&int16_dest));
- EXPECT_EQ(static_cast<int16_t>(numeric_limits<int8_t>::max()), int16_dest);
- EXPECT_TRUE(int8_min.AssignIfValid(&int16_dest));
- EXPECT_EQ(static_cast<int16_t>(numeric_limits<int8_t>::lowest()), int16_dest);
- EXPECT_FALSE(double_max.AssignIfValid(&uint8_dest));
- EXPECT_FALSE(double_max.AssignIfValid(&int16_dest));
- EXPECT_TRUE(double_max.AssignIfValid(&double_dest));
- EXPECT_EQ(numeric_limits<double>::max(), double_dest);
- EXPECT_EQ(1, checked_cast<int>(StrictNumeric<int>(1)));
- EXPECT_EQ(1, saturated_cast<int>(StrictNumeric<int>(1)));
- EXPECT_EQ(1, strict_cast<int>(StrictNumeric<int>(1)));
-
- enum class EnumTest { kOne = 1 };
- EXPECT_EQ(1, checked_cast<int>(EnumTest::kOne));
- EXPECT_EQ(1, saturated_cast<int>(EnumTest::kOne));
- EXPECT_EQ(1, strict_cast<int>(EnumTest::kOne));
-}
-
-TEST(SafeNumerics, IsValueInRangeForNumericType) {
- EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(0));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(1));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(2));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(-1));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(0xffffffffu));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0xffffffff)));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0x100000000)));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0x100000001)));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(
- std::numeric_limits<int32_t>::lowest()));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(
- std::numeric_limits<int64_t>::lowest()));
-
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(0));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(1));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(2));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(-1));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(0x7fffffff));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(0x7fffffffu));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(0x80000000u));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(0xffffffffu));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(INT64_C(0x80000000)));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(INT64_C(0xffffffff)));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(INT64_C(0x100000000)));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(
- std::numeric_limits<int32_t>::lowest()));
- EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(
- static_cast<int64_t>(std::numeric_limits<int32_t>::lowest())));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(
- static_cast<int64_t>(std::numeric_limits<int32_t>::lowest()) - 1));
- EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(
- std::numeric_limits<int64_t>::lowest()));
-
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(0));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(1));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(2));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(-1));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(0xffffffffu));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(UINT64_C(0xffffffff)));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(UINT64_C(0x100000000)));
- EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(UINT64_C(0x100000001)));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(
- std::numeric_limits<int32_t>::lowest()));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(INT64_C(-1)));
- EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(
- std::numeric_limits<int64_t>::lowest()));
-
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(1));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(2));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(-1));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0x7fffffff));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0x7fffffffu));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0x80000000u));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0xffffffffu));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(INT64_C(0x80000000)));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(INT64_C(0xffffffff)));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(INT64_C(0x100000000)));
- EXPECT_TRUE(
- IsValueInRangeForNumericType<int64_t>(INT64_C(0x7fffffffffffffff)));
- EXPECT_TRUE(
- IsValueInRangeForNumericType<int64_t>(UINT64_C(0x7fffffffffffffff)));
- EXPECT_FALSE(
- IsValueInRangeForNumericType<int64_t>(UINT64_C(0x8000000000000000)));
- EXPECT_FALSE(
- IsValueInRangeForNumericType<int64_t>(UINT64_C(0xffffffffffffffff)));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(
- std::numeric_limits<int32_t>::lowest()));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(
- static_cast<int64_t>(std::numeric_limits<int32_t>::lowest())));
- EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(
- std::numeric_limits<int64_t>::lowest()));
-}
-
-TEST(SafeNumerics, CompoundNumericOperations) {
- CheckedNumeric<int> a = 1;
- CheckedNumeric<int> b = 2;
- CheckedNumeric<int> c = 3;
- CheckedNumeric<int> d = 4;
- a += b;
- EXPECT_EQ(3, a.ValueOrDie());
- a -= c;
- EXPECT_EQ(0, a.ValueOrDie());
- d /= b;
- EXPECT_EQ(2, d.ValueOrDie());
- d *= d;
- EXPECT_EQ(4, d.ValueOrDie());
-
- CheckedNumeric<int> too_large = std::numeric_limits<int>::max();
- EXPECT_TRUE(too_large.IsValid());
- too_large += d;
- EXPECT_FALSE(too_large.IsValid());
- too_large -= d;
- EXPECT_FALSE(too_large.IsValid());
- too_large /= d;
- EXPECT_FALSE(too_large.IsValid());
-}
-
-TEST(SafeNumerics, VariadicNumericOperations) {
- { // Synthetic scope to avoid variable naming collisions.
- auto a = CheckAdd(1, 2UL, MakeCheckedNum(3LL), 4).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(a)::type>(10), a);
- auto b = CheckSub(MakeCheckedNum(20.0), 2UL, 4).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(b)::type>(14.0), b);
- auto c = CheckMul(20.0, MakeCheckedNum(1), 5, 3UL).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(c)::type>(300.0), c);
- auto d = CheckDiv(20.0, 2.0, MakeCheckedNum(5LL), -4).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(d)::type>(-.5), d);
- auto e = CheckMod(MakeCheckedNum(20), 3).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(e)::type>(2), e);
- auto f = CheckLsh(1, MakeCheckedNum(2)).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(f)::type>(4), f);
- auto g = CheckRsh(4, MakeCheckedNum(2)).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(g)::type>(1), g);
- auto h = CheckRsh(CheckAdd(1, 1, 1, 1), CheckSub(4, 2)).ValueOrDie();
- EXPECT_EQ(static_cast<decltype(h)::type>(1), h);
- }
-
- {
- auto a = ClampAdd(1, 2UL, MakeClampedNum(3LL), 4);
- EXPECT_EQ(static_cast<decltype(a)::type>(10), a);
- auto b = ClampSub(MakeClampedNum(20.0), 2UL, 4);
- EXPECT_EQ(static_cast<decltype(b)::type>(14.0), b);
- auto c = ClampMul(20.0, MakeClampedNum(1), 5, 3UL);
- EXPECT_EQ(static_cast<decltype(c)::type>(300.0), c);
- auto d = ClampDiv(20.0, 2.0, MakeClampedNum(5LL), -4);
- EXPECT_EQ(static_cast<decltype(d)::type>(-.5), d);
- auto e = ClampMod(MakeClampedNum(20), 3);
- EXPECT_EQ(static_cast<decltype(e)::type>(2), e);
- auto f = ClampLsh(1, MakeClampedNum(2U));
- EXPECT_EQ(static_cast<decltype(f)::type>(4), f);
- auto g = ClampRsh(4, MakeClampedNum(2U));
- EXPECT_EQ(static_cast<decltype(g)::type>(1), g);
- auto h = ClampRsh(ClampAdd(1, 1, 1, 1), ClampSub(4U, 2));
- EXPECT_EQ(static_cast<decltype(h)::type>(1), h);
- }
-}
-
-#if defined(__clang__)
-#pragma clang diagnostic pop // -Winteger-overflow
-#endif
-
-} // namespace internal
-} // namespace base
diff --git a/base/sampling_heap_profiler/sampling_heap_profiler_unittest.cc b/base/sampling_heap_profiler/sampling_heap_profiler_unittest.cc
deleted file mode 100644
index d3bef90..0000000
--- a/base/sampling_heap_profiler/sampling_heap_profiler_unittest.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2018 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 "base/sampling_heap_profiler/sampling_heap_profiler.h"
-
-#include <stdlib.h>
-#include <cinttypes>
-
-#include "base/allocator/allocator_shim.h"
-#include "base/debug/alias.h"
-#include "base/threading/simple_thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class SamplingHeapProfilerTest : public ::testing::Test {
-#if defined(OS_MACOSX)
- void SetUp() override { allocator::InitializeAllocatorShim(); }
-#endif
-};
-
-class SamplesCollector : public SamplingHeapProfiler::SamplesObserver {
- public:
- explicit SamplesCollector(size_t watch_size) : watch_size_(watch_size) {}
-
- void SampleAdded(uint32_t id, size_t size, size_t) override {
- if (sample_added || size != watch_size_)
- return;
- sample_id_ = id;
- sample_added = true;
- }
-
- void SampleRemoved(uint32_t id) override {
- if (id == sample_id_)
- sample_removed = true;
- }
-
- bool sample_added = false;
- bool sample_removed = false;
-
- private:
- size_t watch_size_;
- uint32_t sample_id_ = 0;
-};
-
-TEST_F(SamplingHeapProfilerTest, CollectSamples) {
- SamplingHeapProfiler::InitTLSSlot();
- SamplesCollector collector(10000);
- SamplingHeapProfiler* profiler = SamplingHeapProfiler::GetInstance();
- profiler->SuppressRandomnessForTest(true);
- profiler->SetSamplingInterval(1024);
- profiler->Start();
- profiler->AddSamplesObserver(&collector);
- void* volatile p = malloc(10000);
- free(p);
- profiler->Stop();
- profiler->RemoveSamplesObserver(&collector);
- CHECK(collector.sample_added);
- CHECK(collector.sample_removed);
-}
-
-const int kNumberOfAllocations = 10000;
-
-NOINLINE void Allocate1() {
- void* p = malloc(400);
- base::debug::Alias(&p);
-}
-
-NOINLINE void Allocate2() {
- void* p = malloc(700);
- base::debug::Alias(&p);
-}
-
-NOINLINE void Allocate3() {
- void* p = malloc(20480);
- base::debug::Alias(&p);
-}
-
-class MyThread1 : public SimpleThread {
- public:
- MyThread1() : SimpleThread("MyThread1") {}
- void Run() override {
- for (int i = 0; i < kNumberOfAllocations; ++i)
- Allocate1();
- }
-};
-
-class MyThread2 : public SimpleThread {
- public:
- MyThread2() : SimpleThread("MyThread2") {}
- void Run() override {
- for (int i = 0; i < kNumberOfAllocations; ++i)
- Allocate2();
- }
-};
-
-void CheckAllocationPattern(void (*allocate_callback)()) {
- SamplingHeapProfiler::InitTLSSlot();
- SamplingHeapProfiler* profiler = SamplingHeapProfiler::GetInstance();
- profiler->SuppressRandomnessForTest(false);
- profiler->SetSamplingInterval(10240);
- base::TimeTicks t0 = base::TimeTicks::Now();
- std::map<size_t, size_t> sums;
- const int iterations = 40;
- for (int i = 0; i < iterations; ++i) {
- uint32_t id = profiler->Start();
- allocate_callback();
- std::vector<SamplingHeapProfiler::Sample> samples =
- profiler->GetSamples(id);
- profiler->Stop();
- std::map<size_t, size_t> buckets;
- for (auto& sample : samples) {
- buckets[sample.size] += sample.total;
- }
- for (auto& it : buckets) {
- if (it.first != 400 && it.first != 700 && it.first != 20480)
- continue;
- sums[it.first] += it.second;
- printf("%zu,", it.second);
- }
- printf("\n");
- }
-
- printf("Time taken %" PRIu64 "ms\n",
- (base::TimeTicks::Now() - t0).InMilliseconds());
-
- for (auto sum : sums) {
- intptr_t expected = sum.first * kNumberOfAllocations;
- intptr_t actual = sum.second / iterations;
- printf("%zu:\tmean: %zu\trelative error: %.2f%%\n", sum.first, actual,
- 100. * (actual - expected) / expected);
- }
-}
-
-// Manual tests to check precision of the sampling profiler.
-// Yes, they do leak lots of memory.
-
-TEST_F(SamplingHeapProfilerTest, DISABLED_ParallelLargeSmallStats) {
- CheckAllocationPattern([]() {
- SimpleThread* t1 = new MyThread1();
- SimpleThread* t2 = new MyThread2();
- t1->Start();
- t2->Start();
- for (int i = 0; i < kNumberOfAllocations; ++i)
- Allocate3();
- t1->Join();
- t2->Join();
- });
-}
-
-TEST_F(SamplingHeapProfilerTest, DISABLED_SequentialLargeSmallStats) {
- CheckAllocationPattern([]() {
- for (int i = 0; i < kNumberOfAllocations; ++i) {
- Allocate1();
- Allocate2();
- Allocate3();
- }
- });
-}
-
-} // namespace
-} // namespace base
diff --git a/base/scoped_clear_errno_unittest.cc b/base/scoped_clear_errno_unittest.cc
deleted file mode 100644
index 8afb33e..0000000
--- a/base/scoped_clear_errno_unittest.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-// 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 <errno.h>
-
-#include "base/scoped_clear_errno.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(ScopedClearErrno, TestNoError) {
- errno = 1;
- {
- ScopedClearErrno clear_error;
- EXPECT_EQ(0, errno);
- }
- EXPECT_EQ(1, errno);
-}
-
-TEST(ScopedClearErrno, TestError) {
- errno = 1;
- {
- ScopedClearErrno clear_error;
- errno = 2;
- }
- EXPECT_EQ(2, errno);
-}
-
-} // namespace base
diff --git a/base/scoped_generic_unittest.cc b/base/scoped_generic_unittest.cc
deleted file mode 100644
index 5a6abfb..0000000
--- a/base/scoped_generic_unittest.cc
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2014 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 "base/scoped_generic.h"
-
-#include <utility>
-#include <vector>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-struct IntTraits {
- IntTraits(std::vector<int>* freed) : freed_ints(freed) {}
-
- static int InvalidValue() {
- return -1;
- }
- void Free(int value) {
- freed_ints->push_back(value);
- }
-
- std::vector<int>* freed_ints;
-};
-
-typedef ScopedGeneric<int, IntTraits> ScopedInt;
-
-} // namespace
-
-TEST(ScopedGenericTest, ScopedGeneric) {
- std::vector<int> values_freed;
- IntTraits traits(&values_freed);
-
- // Invalid case, delete should not be called.
- {
- ScopedInt a(IntTraits::InvalidValue(), traits);
- }
- EXPECT_TRUE(values_freed.empty());
-
- // Simple deleting case.
- static const int kFirst = 0;
- {
- ScopedInt a(kFirst, traits);
- }
- ASSERT_EQ(1u, values_freed.size());
- ASSERT_EQ(kFirst, values_freed[0]);
- values_freed.clear();
-
- // Release should return the right value and leave the object empty.
- {
- ScopedInt a(kFirst, traits);
- EXPECT_EQ(kFirst, a.release());
-
- ScopedInt b(IntTraits::InvalidValue(), traits);
- EXPECT_EQ(IntTraits::InvalidValue(), b.release());
- }
- ASSERT_TRUE(values_freed.empty());
-
- // Reset should free the old value, then the new one should go away when
- // it goes out of scope.
- static const int kSecond = 1;
- {
- ScopedInt b(kFirst, traits);
- b.reset(kSecond);
- ASSERT_EQ(1u, values_freed.size());
- ASSERT_EQ(kFirst, values_freed[0]);
- }
- ASSERT_EQ(2u, values_freed.size());
- ASSERT_EQ(kSecond, values_freed[1]);
- values_freed.clear();
-
- // Swap.
- {
- ScopedInt a(kFirst, traits);
- ScopedInt b(kSecond, traits);
- a.swap(b);
- EXPECT_TRUE(values_freed.empty()); // Nothing should be freed.
- EXPECT_EQ(kSecond, a.get());
- EXPECT_EQ(kFirst, b.get());
- }
- // Values should be deleted in the opposite order.
- ASSERT_EQ(2u, values_freed.size());
- EXPECT_EQ(kFirst, values_freed[0]);
- EXPECT_EQ(kSecond, values_freed[1]);
- values_freed.clear();
-
- // Move constructor.
- {
- ScopedInt a(kFirst, traits);
- ScopedInt b(std::move(a));
- EXPECT_TRUE(values_freed.empty()); // Nothing should be freed.
- ASSERT_EQ(IntTraits::InvalidValue(), a.get());
- ASSERT_EQ(kFirst, b.get());
- }
-
- ASSERT_EQ(1u, values_freed.size());
- ASSERT_EQ(kFirst, values_freed[0]);
- values_freed.clear();
-
- // Move assign.
- {
- ScopedInt a(kFirst, traits);
- ScopedInt b(kSecond, traits);
- b = std::move(a);
- ASSERT_EQ(1u, values_freed.size());
- EXPECT_EQ(kSecond, values_freed[0]);
- ASSERT_EQ(IntTraits::InvalidValue(), a.get());
- ASSERT_EQ(kFirst, b.get());
- }
-
- ASSERT_EQ(2u, values_freed.size());
- EXPECT_EQ(kFirst, values_freed[1]);
- values_freed.clear();
-}
-
-TEST(ScopedGenericTest, Operators) {
- std::vector<int> values_freed;
- IntTraits traits(&values_freed);
-
- static const int kFirst = 0;
- static const int kSecond = 1;
- {
- ScopedInt a(kFirst, traits);
- EXPECT_TRUE(a == kFirst);
- EXPECT_FALSE(a != kFirst);
- EXPECT_FALSE(a == kSecond);
- EXPECT_TRUE(a != kSecond);
-
- EXPECT_TRUE(kFirst == a);
- EXPECT_FALSE(kFirst != a);
- EXPECT_FALSE(kSecond == a);
- EXPECT_TRUE(kSecond != a);
- }
-
- // is_valid().
- {
- ScopedInt a(kFirst, traits);
- EXPECT_TRUE(a.is_valid());
- a.reset();
- EXPECT_FALSE(a.is_valid());
- }
-}
-
-// Cheesy manual "no compile" test for manually validating changes.
-#if 0
-TEST(ScopedGenericTest, NoCompile) {
- // Assignment shouldn't work.
- /*{
- ScopedInt a(kFirst, traits);
- ScopedInt b(a);
- }*/
-
- // Comparison shouldn't work.
- /*{
- ScopedInt a(kFirst, traits);
- ScopedInt b(kFirst, traits);
- if (a == b) {
- }
- }*/
-
- // Implicit conversion to bool shouldn't work.
- /*{
- ScopedInt a(kFirst, traits);
- bool result = a;
- }*/
-}
-#endif
-
-} // namespace base
diff --git a/base/scoped_native_library_unittest.cc b/base/scoped_native_library_unittest.cc
deleted file mode 100644
index 261e9d1..0000000
--- a/base/scoped_native_library_unittest.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (c) 2011 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 "base/scoped_native_library.h"
-
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include "base/files/file_path.h"
-#include "base/strings/utf_string_conversions.h"
-#endif
-
-namespace base {
-
-// Tests whether or not a function pointer retrieved via ScopedNativeLibrary
-// is available only in a scope.
-TEST(ScopedNativeLibrary, Basic) {
-#if defined(OS_WIN)
- // Get the pointer to DirectDrawCreate() from "ddraw.dll" and verify it
- // is valid only in this scope.
- // FreeLibrary() doesn't actually unload a DLL until its reference count
- // becomes zero, i.e. function pointer is still valid if the DLL used
- // in this test is also used by another part of this executable.
- // So, this test uses "ddraw.dll", which is not used by Chrome at all but
- // installed on all versions of Windows.
- const char kFunctionName[] = "DirectDrawCreate";
- NativeLibrary native_library;
- {
- FilePath path(FilePath::FromUTF8Unsafe(GetNativeLibraryName("ddraw")));
- native_library = LoadNativeLibrary(path, nullptr);
- ScopedNativeLibrary library(native_library);
- EXPECT_TRUE(library.is_valid());
- EXPECT_EQ(native_library, library.get());
- FARPROC test_function =
- reinterpret_cast<FARPROC>(library.GetFunctionPointer(kFunctionName));
- EXPECT_EQ(0, IsBadCodePtr(test_function));
- EXPECT_EQ(
- GetFunctionPointerFromNativeLibrary(native_library, kFunctionName),
- test_function);
- }
- EXPECT_FALSE(
- GetFunctionPointerFromNativeLibrary(native_library, kFunctionName));
-#endif
-}
-
-} // namespace base
diff --git a/base/security_unittest.cc b/base/security_unittest.cc
deleted file mode 100644
index 9a3bc27..0000000
--- a/base/security_unittest.cc
+++ /dev/null
@@ -1,172 +0,0 @@
-// 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 <fcntl.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <limits>
-#include <memory>
-
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/memory/free_deleter.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include <sys/mman.h>
-#include <unistd.h>
-#endif
-
-using std::nothrow;
-using std::numeric_limits;
-
-namespace {
-
-// This function acts as a compiler optimization barrier. We use it to
-// prevent the compiler from making an expression a compile-time constant.
-// We also use it so that the compiler doesn't discard certain return values
-// as something we don't need (see the comment with calloc below).
-template <typename Type>
-NOINLINE Type HideValueFromCompiler(volatile Type value) {
-#if defined(__GNUC__)
- // In a GCC compatible compiler (GCC or Clang), make this compiler barrier
- // more robust than merely using "volatile".
- __asm__ volatile ("" : "+r" (value));
-#endif // __GNUC__
- return value;
-}
-
-// TCmalloc, currently supported only by Linux/CrOS, supports malloc limits.
-// - NO_TCMALLOC (should be defined if compiled with use_allocator!="tcmalloc")
-// - ADDRESS_SANITIZER it has its own memory allocator
-#if defined(OS_LINUX) && !defined(NO_TCMALLOC) && !defined(ADDRESS_SANITIZER)
-#define MALLOC_OVERFLOW_TEST(function) function
-#else
-#define MALLOC_OVERFLOW_TEST(function) DISABLED_##function
-#endif
-
-// There are platforms where these tests are known to fail. We would like to
-// be able to easily check the status on the bots, but marking tests as
-// FAILS_ is too clunky.
-void OverflowTestsSoftExpectTrue(bool overflow_detected) {
- if (!overflow_detected) {
-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_MACOSX)
- // Sadly, on Linux, Android, and OSX we don't have a good story yet. Don't
- // fail the test, but report.
- printf("Platform has overflow: %s\n",
- !overflow_detected ? "yes." : "no.");
-#else
- // Otherwise, fail the test. (Note: EXPECT are ok in subfunctions, ASSERT
- // aren't).
- EXPECT_TRUE(overflow_detected);
-#endif
- }
-}
-
-#if defined(OS_IOS) || defined(OS_FUCHSIA) || defined(ADDRESS_SANITIZER) || \
- defined(THREAD_SANITIZER) || defined(MEMORY_SANITIZER)
-#define MAYBE_NewOverflow DISABLED_NewOverflow
-#else
-#define MAYBE_NewOverflow NewOverflow
-#endif
-// Test array[TooBig][X] and array[X][TooBig] allocations for int overflows.
-// IOS doesn't honor nothrow, so disable the test there.
-// TODO(https://crbug.com/828229): Fuchsia SDK exports an incorrect new[] that
-// gets picked up in Debug/component builds, breaking this test.
-// Disabled under XSan because asan aborts when new returns nullptr,
-// https://bugs.chromium.org/p/chromium/issues/detail?id=690271#c15
-TEST(SecurityTest, MAYBE_NewOverflow) {
- const size_t kArraySize = 4096;
- // We want something "dynamic" here, so that the compiler doesn't
- // immediately reject crazy arrays.
- const size_t kDynamicArraySize = HideValueFromCompiler(kArraySize);
- const size_t kMaxSizeT = std::numeric_limits<size_t>::max();
- const size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
- const size_t kDynamicArraySize2 = HideValueFromCompiler(kArraySize2);
- {
- std::unique_ptr<char[][kArraySize]> array_pointer(
- new (nothrow) char[kDynamicArraySize2][kArraySize]);
- // Prevent clang from optimizing away the whole test.
- char* volatile p = reinterpret_cast<char*>(array_pointer.get());
- OverflowTestsSoftExpectTrue(!p);
- }
- // On windows, the compiler prevents static array sizes of more than
- // 0x7fffffff (error C2148).
-#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
- ALLOW_UNUSED_LOCAL(kDynamicArraySize);
-#else
- {
- std::unique_ptr<char[][kArraySize2]> array_pointer(
- new (nothrow) char[kDynamicArraySize][kArraySize2]);
- // Prevent clang from optimizing away the whole test.
- char* volatile p = reinterpret_cast<char*>(array_pointer.get());
- OverflowTestsSoftExpectTrue(!p);
- }
-#endif // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
-}
-
-#if defined(OS_LINUX) && defined(__x86_64__)
-// Check if ptr1 and ptr2 are separated by less than size chars.
-bool ArePointersToSameArea(void* ptr1, void* ptr2, size_t size) {
- ptrdiff_t ptr_diff = reinterpret_cast<char*>(std::max(ptr1, ptr2)) -
- reinterpret_cast<char*>(std::min(ptr1, ptr2));
- return static_cast<size_t>(ptr_diff) <= size;
-}
-
-// Check if TCMalloc uses an underlying random memory allocator.
-TEST(SecurityTest, MALLOC_OVERFLOW_TEST(RandomMemoryAllocations)) {
- size_t kPageSize = 4096; // We support x86_64 only.
- // Check that malloc() returns an address that is neither the kernel's
- // un-hinted mmap area, nor the current brk() area. The first malloc() may
- // not be at a random address because TCMalloc will first exhaust any memory
- // that it has allocated early on, before starting the sophisticated
- // allocators.
- void* default_mmap_heap_address =
- mmap(nullptr, kPageSize, PROT_READ | PROT_WRITE,
- MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
- ASSERT_NE(default_mmap_heap_address,
- static_cast<void*>(MAP_FAILED));
- ASSERT_EQ(munmap(default_mmap_heap_address, kPageSize), 0);
- void* brk_heap_address = sbrk(0);
- ASSERT_NE(brk_heap_address, reinterpret_cast<void*>(-1));
- ASSERT_TRUE(brk_heap_address != nullptr);
- // 1 MB should get us past what TCMalloc pre-allocated before initializing
- // the sophisticated allocators.
- size_t kAllocSize = 1<<20;
- std::unique_ptr<char, base::FreeDeleter> ptr(
- static_cast<char*>(malloc(kAllocSize)));
- ASSERT_TRUE(ptr != nullptr);
- // If two pointers are separated by less than 512MB, they are considered
- // to be in the same area.
- // Our random pointer could be anywhere within 0x3fffffffffff (46bits),
- // and we are checking that it's not withing 1GB (30 bits) from two
- // addresses (brk and mmap heap). We have roughly one chance out of
- // 2^15 to flake.
- const size_t kAreaRadius = 1<<29;
- bool in_default_mmap_heap = ArePointersToSameArea(
- ptr.get(), default_mmap_heap_address, kAreaRadius);
- EXPECT_FALSE(in_default_mmap_heap);
-
- bool in_default_brk_heap = ArePointersToSameArea(
- ptr.get(), brk_heap_address, kAreaRadius);
- EXPECT_FALSE(in_default_brk_heap);
-
- // In the implementation, we always mask our random addresses with
- // kRandomMask, so we use it as an additional detection mechanism.
- const uintptr_t kRandomMask = 0x3fffffffffffULL;
- bool impossible_random_address =
- reinterpret_cast<uintptr_t>(ptr.get()) & ~kRandomMask;
- EXPECT_FALSE(impossible_random_address);
-}
-
-#endif // defined(OS_LINUX) && defined(__x86_64__)
-
-} // namespace
diff --git a/base/sequence_checker_unittest.cc b/base/sequence_checker_unittest.cc
deleted file mode 100644
index 8d44f3e..0000000
--- a/base/sequence_checker_unittest.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright 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 "base/sequence_checker.h"
-
-#include <stddef.h>
-
-#include <memory>
-#include <string>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback_forward.h"
-#include "base/macros.h"
-#include "base/sequence_token.h"
-#include "base/single_thread_task_runner.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/simple_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// Runs a callback on another thread.
-class RunCallbackThread : public SimpleThread {
- public:
- explicit RunCallbackThread(const Closure& callback)
- : SimpleThread("RunCallbackThread"), callback_(callback) {
- Start();
- Join();
- }
-
- private:
- // SimpleThread:
- void Run() override { callback_.Run(); }
-
- const Closure callback_;
-
- DISALLOW_COPY_AND_ASSIGN(RunCallbackThread);
-};
-
-void ExpectCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
- ASSERT_TRUE(sequence_checker);
-
- // This should bind |sequence_checker| to the current sequence if it wasn't
- // already bound to a sequence.
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
-
- // Since |sequence_checker| is now bound to the current sequence, another call
- // to CalledOnValidSequence() should return true.
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
-}
-
-void ExpectCalledOnValidSequenceWithSequenceToken(
- SequenceCheckerImpl* sequence_checker,
- SequenceToken sequence_token) {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(sequence_token);
- ExpectCalledOnValidSequence(sequence_checker);
-}
-
-void ExpectNotCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
- ASSERT_TRUE(sequence_checker);
- EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
-}
-
-} // namespace
-
-TEST(SequenceCheckerTest, CallsAllowedOnSameThreadNoSequenceToken) {
- SequenceCheckerImpl sequence_checker;
- EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
-}
-
-TEST(SequenceCheckerTest, CallsAllowedOnSameThreadSameSequenceToken) {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- SequenceCheckerImpl sequence_checker;
- EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
-}
-
-TEST(SequenceCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) {
- SequenceCheckerImpl sequence_checker;
- RunCallbackThread thread(
- Bind(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker)));
-}
-
-TEST(SequenceCheckerTest, CallsAllowedOnDifferentThreadsSameSequenceToken) {
- const SequenceToken sequence_token(SequenceToken::Create());
-
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(sequence_token);
- SequenceCheckerImpl sequence_checker;
- EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
-
- RunCallbackThread thread(Bind(&ExpectCalledOnValidSequenceWithSequenceToken,
- Unretained(&sequence_checker), sequence_token));
-}
-
-TEST(SequenceCheckerTest, CallsDisallowedOnSameThreadDifferentSequenceToken) {
- std::unique_ptr<SequenceCheckerImpl> sequence_checker;
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- sequence_checker.reset(new SequenceCheckerImpl);
- }
-
- {
- // Different SequenceToken.
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
- }
-
- // No SequenceToken.
- EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
-}
-
-TEST(SequenceCheckerTest, DetachFromSequence) {
- std::unique_ptr<SequenceCheckerImpl> sequence_checker;
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- sequence_checker.reset(new SequenceCheckerImpl);
- }
-
- sequence_checker->DetachFromSequence();
-
- {
- // Verify that CalledOnValidSequence() returns true when called with
- // a different sequence token after a call to DetachFromSequence().
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
- }
-}
-
-TEST(SequenceCheckerTest, DetachFromSequenceNoSequenceToken) {
- SequenceCheckerImpl sequence_checker;
- sequence_checker.DetachFromSequence();
-
- // Verify that CalledOnValidSequence() returns true when called on a
- // different thread after a call to DetachFromSequence().
- RunCallbackThread thread(
- Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)));
-
- EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
-}
-
-TEST(SequenceCheckerMacroTest, Macros) {
- auto scope = std::make_unique<ScopedSetSequenceTokenForCurrentThread>(
- SequenceToken::Create());
- SEQUENCE_CHECKER(my_sequence_checker);
-
- // Don't expect a DCHECK death when a SequenceChecker is used on the right
- // sequence.
- DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
-
- scope.reset();
-
-#if DCHECK_IS_ON()
- // Expect DCHECK death when used on a different sequence.
- EXPECT_DCHECK_DEATH({
- DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
- });
-#else
- // Happily no-ops on non-dcheck builds.
- DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
-#endif
-
- DETACH_FROM_SEQUENCE(my_sequence_checker);
-
- // Don't expect a DCHECK death when a SequenceChecker is used for the first
- // time after having been detached.
- DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
-}
-
-} // namespace base
diff --git a/base/sequence_token_unittest.cc b/base/sequence_token_unittest.cc
deleted file mode 100644
index 2ed6878..0000000
--- a/base/sequence_token_unittest.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2016 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 "base/sequence_token.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(SequenceTokenTest, IsValid) {
- EXPECT_FALSE(SequenceToken().IsValid());
- EXPECT_TRUE(SequenceToken::Create().IsValid());
-}
-
-TEST(SequenceTokenTest, OperatorEquals) {
- const SequenceToken invalid_a;
- const SequenceToken invalid_b;
- const SequenceToken valid_a = SequenceToken::Create();
- const SequenceToken valid_b = SequenceToken::Create();
-
- EXPECT_FALSE(invalid_a == invalid_a);
- EXPECT_FALSE(invalid_a == invalid_b);
- EXPECT_FALSE(invalid_a == valid_a);
- EXPECT_FALSE(invalid_a == valid_b);
-
- EXPECT_FALSE(valid_a == invalid_a);
- EXPECT_FALSE(valid_a == invalid_b);
- EXPECT_EQ(valid_a, valid_a);
- EXPECT_FALSE(valid_a == valid_b);
-}
-
-TEST(SequenceTokenTest, OperatorNotEquals) {
- const SequenceToken invalid_a;
- const SequenceToken invalid_b;
- const SequenceToken valid_a = SequenceToken::Create();
- const SequenceToken valid_b = SequenceToken::Create();
-
- EXPECT_NE(invalid_a, invalid_a);
- EXPECT_NE(invalid_a, invalid_b);
- EXPECT_NE(invalid_a, valid_a);
- EXPECT_NE(invalid_a, valid_b);
-
- EXPECT_NE(valid_a, invalid_a);
- EXPECT_NE(valid_a, invalid_b);
- EXPECT_FALSE(valid_a != valid_a);
- EXPECT_NE(valid_a, valid_b);
-}
-
-TEST(SequenceTokenTest, GetForCurrentThread) {
- const SequenceToken token = SequenceToken::Create();
-
- EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(token);
- EXPECT_TRUE(SequenceToken::GetForCurrentThread().IsValid());
- EXPECT_EQ(token, SequenceToken::GetForCurrentThread());
- }
-
- EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
-}
-
-TEST(SequenceTokenTest, ToInternalValue) {
- const SequenceToken token1 = SequenceToken::Create();
- const SequenceToken token2 = SequenceToken::Create();
-
- // Confirm that internal values are unique.
- EXPECT_NE(token1.ToInternalValue(), token2.ToInternalValue());
-}
-
-// Expect a default-constructed TaskToken to be invalid and not equal to
-// another invalid TaskToken.
-TEST(TaskTokenTest, InvalidDefaultConstructed) {
- EXPECT_FALSE(TaskToken().IsValid());
- EXPECT_NE(TaskToken(), TaskToken());
-}
-
-// Expect a TaskToken returned by TaskToken::GetForCurrentThread() outside the
-// scope of a ScopedSetSequenceTokenForCurrentThread to be invalid.
-TEST(TaskTokenTest, InvalidOutsideScope) {
- EXPECT_FALSE(TaskToken::GetForCurrentThread().IsValid());
-}
-
-// Expect an invalid TaskToken not to be equal with a valid TaskToken.
-TEST(TaskTokenTest, ValidNotEqualsInvalid) {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- TaskToken valid = TaskToken::GetForCurrentThread();
- TaskToken invalid;
- EXPECT_NE(valid, invalid);
-}
-
-// Expect TaskTokens returned by TaskToken::GetForCurrentThread() in the scope
-// of the same ScopedSetSequenceTokenForCurrentThread instance to be
-// valid and equal with each other.
-TEST(TaskTokenTest, EqualInSameScope) {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
-
- const TaskToken token_a = TaskToken::GetForCurrentThread();
- const TaskToken token_b = TaskToken::GetForCurrentThread();
-
- EXPECT_TRUE(token_a.IsValid());
- EXPECT_TRUE(token_b.IsValid());
- EXPECT_EQ(token_a, token_b);
-}
-
-// Expect TaskTokens returned by TaskToken::GetForCurrentThread() in the scope
-// of different ScopedSetSequenceTokenForCurrentThread instances to be
-// valid but not equal to each other.
-TEST(TaskTokenTest, NotEqualInDifferentScopes) {
- TaskToken token_a;
- TaskToken token_b;
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- token_a = TaskToken::GetForCurrentThread();
- }
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- token_b = TaskToken::GetForCurrentThread();
- }
-
- EXPECT_TRUE(token_a.IsValid());
- EXPECT_TRUE(token_b.IsValid());
- EXPECT_NE(token_a, token_b);
-}
-
-} // namespace base
diff --git a/base/sequenced_task_runner_unittest.cc b/base/sequenced_task_runner_unittest.cc
deleted file mode 100644
index 4dcc7e5..0000000
--- a/base/sequenced_task_runner_unittest.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2016 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 "base/sequenced_task_runner.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/gtest_prod_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class FlagOnDelete {
- public:
- FlagOnDelete(bool* deleted,
- scoped_refptr<SequencedTaskRunner> expected_deletion_sequence)
- : deleted_(deleted),
- expected_deletion_sequence_(std::move(expected_deletion_sequence)) {}
-
- private:
- friend class DeleteHelper<FlagOnDelete>;
- FRIEND_TEST_ALL_PREFIXES(SequencedTaskRunnerTest,
- OnTaskRunnerDeleterTargetStoppedEarly);
-
- ~FlagOnDelete() {
- EXPECT_FALSE(*deleted_);
- *deleted_ = true;
- if (expected_deletion_sequence_)
- EXPECT_TRUE(expected_deletion_sequence_->RunsTasksInCurrentSequence());
- }
-
- bool* deleted_;
- const scoped_refptr<SequencedTaskRunner> expected_deletion_sequence_;
-
- DISALLOW_COPY_AND_ASSIGN(FlagOnDelete);
-};
-
-class SequencedTaskRunnerTest : public testing::Test {
- protected:
- SequencedTaskRunnerTest() : foreign_thread_("foreign") {}
-
- void SetUp() override {
- main_runner_ = message_loop_.task_runner();
-
- foreign_thread_.Start();
- foreign_runner_ = foreign_thread_.task_runner();
- }
-
- scoped_refptr<SequencedTaskRunner> main_runner_;
- scoped_refptr<SequencedTaskRunner> foreign_runner_;
-
- Thread foreign_thread_;
-
- private:
- MessageLoop message_loop_;
-
- DISALLOW_COPY_AND_ASSIGN(SequencedTaskRunnerTest);
-};
-
-using SequenceBoundUniquePtr =
- std::unique_ptr<FlagOnDelete, OnTaskRunnerDeleter>;
-
-TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterOnMainThread) {
- bool deleted_on_main_thread = false;
- SequenceBoundUniquePtr ptr(
- new FlagOnDelete(&deleted_on_main_thread, main_runner_),
- OnTaskRunnerDeleter(main_runner_));
- EXPECT_FALSE(deleted_on_main_thread);
- foreign_runner_->PostTask(
- FROM_HERE, BindOnce([](SequenceBoundUniquePtr) {}, std::move(ptr)));
-
- {
- RunLoop run_loop;
- foreign_runner_->PostTaskAndReply(FROM_HERE, BindOnce([] {}),
- run_loop.QuitClosure());
- run_loop.Run();
- }
- EXPECT_TRUE(deleted_on_main_thread);
-}
-
-TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterTargetStoppedEarly) {
- bool deleted_on_main_thread = false;
- FlagOnDelete* raw = new FlagOnDelete(&deleted_on_main_thread, main_runner_);
- SequenceBoundUniquePtr ptr(raw, OnTaskRunnerDeleter(foreign_runner_));
- EXPECT_FALSE(deleted_on_main_thread);
-
- // Stopping the target ahead of deleting |ptr| should make its
- // OnTaskRunnerDeleter no-op.
- foreign_thread_.Stop();
- ptr = nullptr;
- EXPECT_FALSE(deleted_on_main_thread);
-
- delete raw;
- EXPECT_TRUE(deleted_on_main_thread);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/sha1_unittest.cc b/base/sha1_unittest.cc
deleted file mode 100644
index ea9cf63..0000000
--- a/base/sha1_unittest.cc
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) 2011 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 "base/sha1.h"
-
-#include <stddef.h>
-
-#include <string>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-TEST(SHA1Test, Test1) {
- // Example A.1 from FIPS 180-2: one-block message.
- std::string input = "abc";
-
- int expected[] = { 0xa9, 0x99, 0x3e, 0x36,
- 0x47, 0x06, 0x81, 0x6a,
- 0xba, 0x3e, 0x25, 0x71,
- 0x78, 0x50, 0xc2, 0x6c,
- 0x9c, 0xd0, 0xd8, 0x9d };
-
- std::string output = base::SHA1HashString(input);
- for (size_t i = 0; i < base::kSHA1Length; i++)
- EXPECT_EQ(expected[i], output[i] & 0xFF);
-}
-
-TEST(SHA1Test, Test2) {
- // Example A.2 from FIPS 180-2: multi-block message.
- std::string input =
- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
-
- int expected[] = { 0x84, 0x98, 0x3e, 0x44,
- 0x1c, 0x3b, 0xd2, 0x6e,
- 0xba, 0xae, 0x4a, 0xa1,
- 0xf9, 0x51, 0x29, 0xe5,
- 0xe5, 0x46, 0x70, 0xf1 };
-
- std::string output = base::SHA1HashString(input);
- for (size_t i = 0; i < base::kSHA1Length; i++)
- EXPECT_EQ(expected[i], output[i] & 0xFF);
-}
-
-TEST(SHA1Test, Test3) {
- // Example A.3 from FIPS 180-2: long message.
- std::string input(1000000, 'a');
-
- int expected[] = { 0x34, 0xaa, 0x97, 0x3c,
- 0xd4, 0xc4, 0xda, 0xa4,
- 0xf6, 0x1e, 0xeb, 0x2b,
- 0xdb, 0xad, 0x27, 0x31,
- 0x65, 0x34, 0x01, 0x6f };
-
- std::string output = base::SHA1HashString(input);
- for (size_t i = 0; i < base::kSHA1Length; i++)
- EXPECT_EQ(expected[i], output[i] & 0xFF);
-}
-
-TEST(SHA1Test, Test1Bytes) {
- // Example A.1 from FIPS 180-2: one-block message.
- std::string input = "abc";
- unsigned char output[base::kSHA1Length];
-
- unsigned char expected[] = { 0xa9, 0x99, 0x3e, 0x36,
- 0x47, 0x06, 0x81, 0x6a,
- 0xba, 0x3e, 0x25, 0x71,
- 0x78, 0x50, 0xc2, 0x6c,
- 0x9c, 0xd0, 0xd8, 0x9d };
-
- base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
- input.length(), output);
- for (size_t i = 0; i < base::kSHA1Length; i++)
- EXPECT_EQ(expected[i], output[i]);
-}
-
-TEST(SHA1Test, Test2Bytes) {
- // Example A.2 from FIPS 180-2: multi-block message.
- std::string input =
- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
- unsigned char output[base::kSHA1Length];
-
- unsigned char expected[] = { 0x84, 0x98, 0x3e, 0x44,
- 0x1c, 0x3b, 0xd2, 0x6e,
- 0xba, 0xae, 0x4a, 0xa1,
- 0xf9, 0x51, 0x29, 0xe5,
- 0xe5, 0x46, 0x70, 0xf1 };
-
- base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
- input.length(), output);
- for (size_t i = 0; i < base::kSHA1Length; i++)
- EXPECT_EQ(expected[i], output[i]);
-}
-
-TEST(SHA1Test, Test3Bytes) {
- // Example A.3 from FIPS 180-2: long message.
- std::string input(1000000, 'a');
- unsigned char output[base::kSHA1Length];
-
- unsigned char expected[] = { 0x34, 0xaa, 0x97, 0x3c,
- 0xd4, 0xc4, 0xda, 0xa4,
- 0xf6, 0x1e, 0xeb, 0x2b,
- 0xdb, 0xad, 0x27, 0x31,
- 0x65, 0x34, 0x01, 0x6f };
-
- base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
- input.length(), output);
- for (size_t i = 0; i < base::kSHA1Length; i++)
- EXPECT_EQ(expected[i], output[i]);
-}
diff --git a/base/stl_util_unittest.cc b/base/stl_util_unittest.cc
deleted file mode 100644
index f13f881..0000000
--- a/base/stl_util_unittest.cc
+++ /dev/null
@@ -1,612 +0,0 @@
-// Copyright 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.
-
-#include "base/stl_util.h"
-
-#include <array>
-#include <deque>
-#include <forward_list>
-#include <functional>
-#include <initializer_list>
-#include <iterator>
-#include <list>
-#include <map>
-#include <queue>
-#include <set>
-#include <stack>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "base/containers/queue.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-// Used as test case to ensure the various base::STLXxx functions don't require
-// more than operators "<" and "==" on values stored in containers.
-class ComparableValue {
- public:
- explicit ComparableValue(int value) : value_(value) {}
-
- bool operator==(const ComparableValue& rhs) const {
- return value_ == rhs.value_;
- }
-
- bool operator<(const ComparableValue& rhs) const {
- return value_ < rhs.value_;
- }
-
- private:
- int value_;
-};
-
-template <typename Container>
-void RunEraseTest() {
- const std::pair<Container, Container> test_data[] = {
- {Container(), Container()}, {{1, 2, 3}, {1, 3}}, {{1, 2, 3, 2}, {1, 3}}};
-
- for (auto test_case : test_data) {
- base::Erase(test_case.first, 2);
- EXPECT_EQ(test_case.second, test_case.first);
- }
-}
-
-// This test is written for containers of std::pair<int, int> to support maps.
-template <typename Container>
-void RunEraseIfTest() {
- struct {
- Container input;
- Container erase_even;
- Container erase_odd;
- } test_data[] = {
- {Container(), Container(), Container()},
- {{{1, 1}, {2, 2}, {3, 3}}, {{1, 1}, {3, 3}}, {{2, 2}}},
- {{{1, 1}, {2, 2}, {3, 3}, {4, 4}}, {{1, 1}, {3, 3}}, {{2, 2}, {4, 4}}},
- };
-
- for (auto test_case : test_data) {
- base::EraseIf(test_case.input, [](const std::pair<int, int>& elem) {
- return !(elem.first & 1);
- });
- EXPECT_EQ(test_case.erase_even, test_case.input);
- }
-
- for (auto test_case : test_data) {
- base::EraseIf(test_case.input, [](const std::pair<int, int>& elem) {
- return elem.first & 1;
- });
- EXPECT_EQ(test_case.erase_odd, test_case.input);
- }
-}
-
-struct CustomIntHash {
- size_t operator()(int elem) const { return std::hash<int>()(elem) + 1; }
-};
-
-struct HashByFirst {
- size_t operator()(const std::pair<int, int>& elem) const {
- return std::hash<int>()(elem.first);
- }
-};
-
-} // namespace
-
-namespace base {
-namespace {
-
-TEST(STLUtilTest, Size) {
- {
- std::vector<int> vector = {1, 2, 3, 4, 5};
- static_assert(
- std::is_same<decltype(base::size(vector)),
- decltype(vector.size())>::value,
- "base::size(vector) should have the same type as vector.size()");
- EXPECT_EQ(vector.size(), base::size(vector));
- }
-
- {
- std::string empty_str;
- static_assert(
- std::is_same<decltype(base::size(empty_str)),
- decltype(empty_str.size())>::value,
- "base::size(empty_str) should have the same type as empty_str.size()");
- EXPECT_EQ(0u, base::size(empty_str));
- }
-
- {
- std::array<int, 4> array = {{1, 2, 3, 4}};
- static_assert(
- std::is_same<decltype(base::size(array)),
- decltype(array.size())>::value,
- "base::size(array) should have the same type as array.size()");
- static_assert(base::size(array) == array.size(),
- "base::size(array) should be equal to array.size()");
- }
-
- {
- int array[] = {1, 2, 3};
- static_assert(std::is_same<size_t, decltype(base::size(array))>::value,
- "base::size(array) should be of type size_t");
- static_assert(3u == base::size(array), "base::size(array) should be 3");
- }
-}
-
-TEST(STLUtilTest, Empty) {
- {
- std::vector<int> vector;
- static_assert(
- std::is_same<decltype(base::empty(vector)),
- decltype(vector.empty())>::value,
- "base::empty(vector) should have the same type as vector.empty()");
- EXPECT_EQ(vector.empty(), base::empty(vector));
- }
-
- {
- std::array<int, 4> array = {{1, 2, 3, 4}};
- static_assert(
- std::is_same<decltype(base::empty(array)),
- decltype(array.empty())>::value,
- "base::empty(array) should have the same type as array.empty()");
- static_assert(base::empty(array) == array.empty(),
- "base::empty(array) should be equal to array.empty()");
- }
-
- {
- int array[] = {1, 2, 3};
- static_assert(std::is_same<bool, decltype(base::empty(array))>::value,
- "base::empty(array) should be of type bool");
- static_assert(!base::empty(array), "base::empty(array) should be false");
- }
-
- {
- constexpr std::initializer_list<int> il;
- static_assert(std::is_same<bool, decltype(base::empty(il))>::value,
- "base::empty(il) should be of type bool");
- static_assert(base::empty(il), "base::empty(il) should be true");
- }
-}
-
-TEST(STLUtilTest, Data) {
- {
- std::vector<int> vector = {1, 2, 3, 4, 5};
- static_assert(
- std::is_same<decltype(base::data(vector)),
- decltype(vector.data())>::value,
- "base::data(vector) should have the same type as vector.data()");
- EXPECT_EQ(vector.data(), base::data(vector));
- }
-
- {
- const std::string cstr = "const string";
- static_assert(
- std::is_same<decltype(base::data(cstr)), decltype(cstr.data())>::value,
- "base::data(cstr) should have the same type as cstr.data()");
-
- EXPECT_EQ(cstr.data(), base::data(cstr));
- }
-
- {
- std::string str = "mutable string";
- static_assert(std::is_same<decltype(base::data(str)), char*>::value,
- "base::data(str) should be of type char*");
- EXPECT_EQ(str.data(), base::data(str));
- }
-
- {
- std::string empty_str;
- static_assert(std::is_same<decltype(base::data(empty_str)), char*>::value,
- "base::data(empty_str) should be of type char*");
- EXPECT_EQ(empty_str.data(), base::data(empty_str));
- }
-
- {
- std::array<int, 4> array = {{1, 2, 3, 4}};
- static_assert(
- std::is_same<decltype(base::data(array)),
- decltype(array.data())>::value,
- "base::data(array) should have the same type as array.data()");
- // std::array::data() is not constexpr prior to C++17, hence the runtime
- // check.
- EXPECT_EQ(array.data(), base::data(array));
- }
-
- {
- constexpr int array[] = {1, 2, 3};
- static_assert(std::is_same<const int*, decltype(base::data(array))>::value,
- "base::data(array) should be of type const int*");
- static_assert(array == base::data(array),
- "base::data(array) should be array");
- }
-
- {
- constexpr std::initializer_list<int> il;
- static_assert(
- std::is_same<decltype(il.begin()), decltype(base::data(il))>::value,
- "base::data(il) should have the same type as il.begin()");
- static_assert(il.begin() == base::data(il),
- "base::data(il) should be equal to il.begin()");
- }
-}
-
-TEST(STLUtilTest, GetUnderlyingContainer) {
- {
- std::queue<int> queue({1, 2, 3, 4, 5});
- static_assert(std::is_same<decltype(GetUnderlyingContainer(queue)),
- const std::deque<int>&>::value,
- "GetUnderlyingContainer(queue) should be of type deque");
- EXPECT_THAT(GetUnderlyingContainer(queue),
- testing::ElementsAre(1, 2, 3, 4, 5));
- }
-
- {
- std::queue<int> queue;
- EXPECT_THAT(GetUnderlyingContainer(queue), testing::ElementsAre());
- }
-
- {
- base::queue<int> queue({1, 2, 3, 4, 5});
- static_assert(
- std::is_same<decltype(GetUnderlyingContainer(queue)),
- const base::circular_deque<int>&>::value,
- "GetUnderlyingContainer(queue) should be of type circular_deque");
- EXPECT_THAT(GetUnderlyingContainer(queue),
- testing::ElementsAre(1, 2, 3, 4, 5));
- }
-
- {
- std::vector<int> values = {1, 2, 3, 4, 5};
- std::priority_queue<int> queue(values.begin(), values.end());
- static_assert(std::is_same<decltype(GetUnderlyingContainer(queue)),
- const std::vector<int>&>::value,
- "GetUnderlyingContainer(queue) should be of type vector");
- EXPECT_THAT(GetUnderlyingContainer(queue),
- testing::UnorderedElementsAre(1, 2, 3, 4, 5));
- }
-
- {
- std::stack<int> stack({1, 2, 3, 4, 5});
- static_assert(std::is_same<decltype(GetUnderlyingContainer(stack)),
- const std::deque<int>&>::value,
- "GetUnderlyingContainer(stack) should be of type deque");
- EXPECT_THAT(GetUnderlyingContainer(stack),
- testing::ElementsAre(1, 2, 3, 4, 5));
- }
-}
-
-TEST(STLUtilTest, STLIsSorted) {
- {
- std::set<int> set;
- set.insert(24);
- set.insert(1);
- set.insert(12);
- EXPECT_TRUE(STLIsSorted(set));
- }
-
- {
- std::set<ComparableValue> set;
- set.insert(ComparableValue(24));
- set.insert(ComparableValue(1));
- set.insert(ComparableValue(12));
- EXPECT_TRUE(STLIsSorted(set));
- }
-
- {
- std::vector<int> vector;
- vector.push_back(1);
- vector.push_back(1);
- vector.push_back(4);
- vector.push_back(64);
- vector.push_back(12432);
- EXPECT_TRUE(STLIsSorted(vector));
- vector.back() = 1;
- EXPECT_FALSE(STLIsSorted(vector));
- }
-}
-
-TEST(STLUtilTest, STLSetDifference) {
- std::set<int> a1;
- a1.insert(1);
- a1.insert(2);
- a1.insert(3);
- a1.insert(4);
-
- std::set<int> a2;
- a2.insert(3);
- a2.insert(4);
- a2.insert(5);
- a2.insert(6);
- a2.insert(7);
-
- {
- std::set<int> difference;
- difference.insert(1);
- difference.insert(2);
- EXPECT_EQ(difference, STLSetDifference<std::set<int> >(a1, a2));
- }
-
- {
- std::set<int> difference;
- difference.insert(5);
- difference.insert(6);
- difference.insert(7);
- EXPECT_EQ(difference, STLSetDifference<std::set<int> >(a2, a1));
- }
-
- {
- std::vector<int> difference;
- difference.push_back(1);
- difference.push_back(2);
- EXPECT_EQ(difference, STLSetDifference<std::vector<int> >(a1, a2));
- }
-
- {
- std::vector<int> difference;
- difference.push_back(5);
- difference.push_back(6);
- difference.push_back(7);
- EXPECT_EQ(difference, STLSetDifference<std::vector<int> >(a2, a1));
- }
-}
-
-TEST(STLUtilTest, STLSetUnion) {
- std::set<int> a1;
- a1.insert(1);
- a1.insert(2);
- a1.insert(3);
- a1.insert(4);
-
- std::set<int> a2;
- a2.insert(3);
- a2.insert(4);
- a2.insert(5);
- a2.insert(6);
- a2.insert(7);
-
- {
- std::set<int> result;
- result.insert(1);
- result.insert(2);
- result.insert(3);
- result.insert(4);
- result.insert(5);
- result.insert(6);
- result.insert(7);
- EXPECT_EQ(result, STLSetUnion<std::set<int> >(a1, a2));
- }
-
- {
- std::set<int> result;
- result.insert(1);
- result.insert(2);
- result.insert(3);
- result.insert(4);
- result.insert(5);
- result.insert(6);
- result.insert(7);
- EXPECT_EQ(result, STLSetUnion<std::set<int> >(a2, a1));
- }
-
- {
- std::vector<int> result;
- result.push_back(1);
- result.push_back(2);
- result.push_back(3);
- result.push_back(4);
- result.push_back(5);
- result.push_back(6);
- result.push_back(7);
- EXPECT_EQ(result, STLSetUnion<std::vector<int> >(a1, a2));
- }
-
- {
- std::vector<int> result;
- result.push_back(1);
- result.push_back(2);
- result.push_back(3);
- result.push_back(4);
- result.push_back(5);
- result.push_back(6);
- result.push_back(7);
- EXPECT_EQ(result, STLSetUnion<std::vector<int> >(a2, a1));
- }
-}
-
-TEST(STLUtilTest, STLSetIntersection) {
- std::set<int> a1;
- a1.insert(1);
- a1.insert(2);
- a1.insert(3);
- a1.insert(4);
-
- std::set<int> a2;
- a2.insert(3);
- a2.insert(4);
- a2.insert(5);
- a2.insert(6);
- a2.insert(7);
-
- {
- std::set<int> result;
- result.insert(3);
- result.insert(4);
- EXPECT_EQ(result, STLSetIntersection<std::set<int> >(a1, a2));
- }
-
- {
- std::set<int> result;
- result.insert(3);
- result.insert(4);
- EXPECT_EQ(result, STLSetIntersection<std::set<int> >(a2, a1));
- }
-
- {
- std::vector<int> result;
- result.push_back(3);
- result.push_back(4);
- EXPECT_EQ(result, STLSetIntersection<std::vector<int> >(a1, a2));
- }
-
- {
- std::vector<int> result;
- result.push_back(3);
- result.push_back(4);
- EXPECT_EQ(result, STLSetIntersection<std::vector<int> >(a2, a1));
- }
-}
-
-TEST(STLUtilTest, STLIncludes) {
- std::set<int> a1;
- a1.insert(1);
- a1.insert(2);
- a1.insert(3);
- a1.insert(4);
-
- std::set<int> a2;
- a2.insert(3);
- a2.insert(4);
-
- std::set<int> a3;
- a3.insert(3);
- a3.insert(4);
- a3.insert(5);
-
- EXPECT_TRUE(STLIncludes<std::set<int> >(a1, a2));
- EXPECT_FALSE(STLIncludes<std::set<int> >(a1, a3));
- EXPECT_FALSE(STLIncludes<std::set<int> >(a2, a1));
- EXPECT_FALSE(STLIncludes<std::set<int> >(a2, a3));
- EXPECT_FALSE(STLIncludes<std::set<int> >(a3, a1));
- EXPECT_TRUE(STLIncludes<std::set<int> >(a3, a2));
-}
-
-TEST(Erase, String) {
- const std::pair<std::string, std::string> test_data[] = {
- {"", ""}, {"abc", "bc"}, {"abca", "bc"},
- };
-
- for (auto test_case : test_data) {
- Erase(test_case.first, 'a');
- EXPECT_EQ(test_case.second, test_case.first);
- }
-
- for (auto test_case : test_data) {
- EraseIf(test_case.first, [](char elem) { return elem < 'b'; });
- EXPECT_EQ(test_case.second, test_case.first);
- }
-}
-
-TEST(Erase, String16) {
- std::pair<base::string16, base::string16> test_data[] = {
- {base::string16(), base::string16()},
- {UTF8ToUTF16("abc"), UTF8ToUTF16("bc")},
- {UTF8ToUTF16("abca"), UTF8ToUTF16("bc")},
- };
-
- const base::string16 letters = UTF8ToUTF16("ab");
- for (auto test_case : test_data) {
- Erase(test_case.first, letters[0]);
- EXPECT_EQ(test_case.second, test_case.first);
- }
-
- for (auto test_case : test_data) {
- EraseIf(test_case.first, [&](short elem) { return elem < letters[1]; });
- EXPECT_EQ(test_case.second, test_case.first);
- }
-}
-
-TEST(Erase, Deque) {
- RunEraseTest<std::deque<int>>();
- RunEraseIfTest<std::deque<std::pair<int, int>>>();
-}
-
-TEST(Erase, Vector) {
- RunEraseTest<std::vector<int>>();
- RunEraseIfTest<std::vector<std::pair<int, int>>>();
-}
-
-TEST(Erase, ForwardList) {
- RunEraseTest<std::forward_list<int>>();
- RunEraseIfTest<std::forward_list<std::pair<int, int>>>();
-}
-
-TEST(Erase, List) {
- RunEraseTest<std::list<int>>();
- RunEraseIfTest<std::list<std::pair<int, int>>>();
-}
-
-TEST(Erase, Map) {
- RunEraseIfTest<std::map<int, int>>();
- RunEraseIfTest<std::map<int, int, std::greater<int>>>();
-}
-
-TEST(Erase, Multimap) {
- RunEraseIfTest<std::multimap<int, int>>();
- RunEraseIfTest<std::multimap<int, int, std::greater<int>>>();
-}
-
-TEST(Erase, Set) {
- RunEraseIfTest<std::set<std::pair<int, int>>>();
- RunEraseIfTest<
- std::set<std::pair<int, int>, std::greater<std::pair<int, int>>>>();
-}
-
-TEST(Erase, Multiset) {
- RunEraseIfTest<std::multiset<std::pair<int, int>>>();
- RunEraseIfTest<
- std::multiset<std::pair<int, int>, std::greater<std::pair<int, int>>>>();
-}
-
-TEST(Erase, UnorderedMap) {
- RunEraseIfTest<std::unordered_map<int, int>>();
- RunEraseIfTest<std::unordered_map<int, int, CustomIntHash>>();
-}
-
-TEST(Erase, UnorderedMultimap) {
- RunEraseIfTest<std::unordered_multimap<int, int>>();
- RunEraseIfTest<std::unordered_multimap<int, int, CustomIntHash>>();
-}
-
-TEST(Erase, UnorderedSet) {
- RunEraseIfTest<std::unordered_set<std::pair<int, int>, HashByFirst>>();
-}
-
-TEST(Erase, UnorderedMultiset) {
- RunEraseIfTest<std::unordered_multiset<std::pair<int, int>, HashByFirst>>();
-}
-
-TEST(Erase, IsNotIn) {
- // Should keep both '2' but only one '4', like std::set_intersection.
- std::vector<int> lhs = {0, 2, 2, 4, 4, 4, 6, 8, 10};
- std::vector<int> rhs = {1, 2, 2, 4, 5, 6, 7};
- std::vector<int> expected = {2, 2, 4, 6};
- EraseIf(lhs, IsNotIn<std::vector<int>>(rhs));
- EXPECT_EQ(expected, lhs);
-}
-
-TEST(ContainsValue, OrdinaryArrays) {
- const char allowed_chars[] = {'a', 'b', 'c', 'd'};
- EXPECT_TRUE(ContainsValue(allowed_chars, 'a'));
- EXPECT_FALSE(ContainsValue(allowed_chars, 'z'));
- EXPECT_FALSE(ContainsValue(allowed_chars, 0));
-
- const char allowed_chars_including_nul[] = "abcd";
- EXPECT_TRUE(ContainsValue(allowed_chars_including_nul, 0));
-}
-
-TEST(STLUtilTest, OptionalOrNullptr) {
- Optional<float> optional;
- EXPECT_EQ(nullptr, base::OptionalOrNullptr(optional));
-
- optional = 0.1f;
- EXPECT_EQ(&optional.value(), base::OptionalOrNullptr(optional));
- EXPECT_NE(nullptr, base::OptionalOrNullptr(optional));
-}
-
-} // namespace
-} // namespace base
diff --git a/base/strings/char_traits_unittest.cc b/base/strings/char_traits_unittest.cc
deleted file mode 100644
index 31c421b..0000000
--- a/base/strings/char_traits_unittest.cc
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2018 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 "base/strings/char_traits.h"
-#include "base/strings/string16.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(CharTraitsTest, CharCompare) {
- static_assert(CharTraits<char>::compare("abc", "def", 3) == -1, "");
- static_assert(CharTraits<char>::compare("def", "def", 3) == 0, "");
- static_assert(CharTraits<char>::compare("ghi", "def", 3) == 1, "");
-}
-
-TEST(CharTraitsTest, CharLength) {
- static_assert(CharTraits<char>::length("") == 0, "");
- static_assert(CharTraits<char>::length("abc") == 3, "");
-}
-
-TEST(CharTraitsTest, Char16TCompare) {
- static_assert(CharTraits<char16_t>::compare(u"abc", u"def", 3) == -1, "");
- static_assert(CharTraits<char16_t>::compare(u"def", u"def", 3) == 0, "");
- static_assert(CharTraits<char16_t>::compare(u"ghi", u"def", 3) == 1, "");
-}
-
-TEST(CharTraitsTest, Char16TLength) {
- static_assert(CharTraits<char16_t>::length(u"abc") == 3, "");
-}
-
-} // namespace base
diff --git a/base/strings/nullable_string16_unittest.cc b/base/strings/nullable_string16_unittest.cc
deleted file mode 100644
index f02fdce..0000000
--- a/base/strings/nullable_string16_unittest.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 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 "base/strings/nullable_string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(NullableString16Test, DefaultConstructor) {
- NullableString16 s;
- EXPECT_TRUE(s.is_null());
- EXPECT_EQ(string16(), s.string());
-}
-
-TEST(NullableString16Test, Equals) {
- NullableString16 a(ASCIIToUTF16("hello"), false);
- NullableString16 b(ASCIIToUTF16("hello"), false);
- EXPECT_EQ(a, b);
-}
-
-TEST(NullableString16Test, NotEquals) {
- NullableString16 a(ASCIIToUTF16("hello"), false);
- NullableString16 b(ASCIIToUTF16("world"), false);
- EXPECT_NE(a, b);
-}
-
-TEST(NullableString16Test, NotEqualsNull) {
- NullableString16 a(ASCIIToUTF16("hello"), false);
- NullableString16 b;
- EXPECT_NE(a, b);
-}
-
-} // namespace base
diff --git a/base/strings/pattern_unittest.cc b/base/strings/pattern_unittest.cc
deleted file mode 100644
index 8ec5495..0000000
--- a/base/strings/pattern_unittest.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2015 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 "base/strings/pattern.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(StringUtilTest, MatchPatternTest) {
- EXPECT_TRUE(MatchPattern("www.google.com", "*.com"));
- EXPECT_TRUE(MatchPattern("www.google.com", "*"));
- EXPECT_FALSE(MatchPattern("www.google.com", "www*.g*.org"));
- EXPECT_TRUE(MatchPattern("Hello", "H?l?o"));
- EXPECT_FALSE(MatchPattern("www.google.com", "http://*)"));
- EXPECT_FALSE(MatchPattern("www.msn.com", "*.COM"));
- EXPECT_TRUE(MatchPattern("Hello*1234", "He??o\\*1*"));
- EXPECT_FALSE(MatchPattern("", "*.*"));
- EXPECT_TRUE(MatchPattern("", "*"));
- EXPECT_TRUE(MatchPattern("", "?"));
- EXPECT_TRUE(MatchPattern("", ""));
- EXPECT_FALSE(MatchPattern("Hello", ""));
- EXPECT_TRUE(MatchPattern("Hello*", "Hello*"));
- EXPECT_TRUE(MatchPattern("abcd", "*???"));
- EXPECT_FALSE(MatchPattern("abcd", "???"));
- EXPECT_TRUE(MatchPattern("abcb", "a*b"));
- EXPECT_FALSE(MatchPattern("abcb", "a?b"));
-
- // Test UTF8 matching.
- EXPECT_TRUE(MatchPattern("heart: \xe2\x99\xa0", "*\xe2\x99\xa0"));
- EXPECT_TRUE(MatchPattern("heart: \xe2\x99\xa0.", "heart: ?."));
- EXPECT_TRUE(MatchPattern("hearts: \xe2\x99\xa0\xe2\x99\xa0", "*"));
- // Invalid sequences should be handled as a single invalid character.
- EXPECT_TRUE(MatchPattern("invalid: \xef\xbf\xbe", "invalid: ?"));
- // If the pattern has invalid characters, it shouldn't match anything.
- EXPECT_FALSE(MatchPattern("\xf4\x90\x80\x80", "\xf4\x90\x80\x80"));
-
- // Test UTF16 character matching.
- EXPECT_TRUE(MatchPattern(UTF8ToUTF16("www.google.com"),
- UTF8ToUTF16("*.com")));
- EXPECT_TRUE(MatchPattern(UTF8ToUTF16("Hello*1234"),
- UTF8ToUTF16("He??o\\*1*")));
-
- // Some test cases that might cause naive implementations to exhibit
- // exponential run time or fail.
- EXPECT_TRUE(MatchPattern("Hello", "He********************************o"));
- EXPECT_TRUE(MatchPattern("123456789012345678", "?????????????????*"));
- EXPECT_TRUE(MatchPattern("aaaaaaaaaaab", "a*a*a*a*a*a*a*a*a*a*a*b"));
-}
-
-} // namespace base
diff --git a/base/strings/safe_sprintf_unittest.cc b/base/strings/safe_sprintf_unittest.cc
deleted file mode 100644
index 4a0948b..0000000
--- a/base/strings/safe_sprintf_unittest.cc
+++ /dev/null
@@ -1,765 +0,0 @@
-// Copyright 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 "base/strings/safe_sprintf.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <limits>
-#include <memory>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Death tests on Android are currently very flaky. No need to add more flaky
-// tests, as they just make it hard to spot real problems.
-// TODO(markus): See if the restrictions on Android can eventually be lifted.
-#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-#define ALLOW_DEATH_TEST
-#endif
-
-namespace base {
-namespace strings {
-
-TEST(SafeSPrintfTest, Empty) {
- char buf[2] = { 'X', 'X' };
-
- // Negative buffer size should always result in an error.
- EXPECT_EQ(-1, SafeSNPrintf(buf, static_cast<size_t>(-1), ""));
- EXPECT_EQ('X', buf[0]);
- EXPECT_EQ('X', buf[1]);
-
- // Zero buffer size should always result in an error.
- EXPECT_EQ(-1, SafeSNPrintf(buf, 0, ""));
- EXPECT_EQ('X', buf[0]);
- EXPECT_EQ('X', buf[1]);
-
- // A one-byte buffer should always print a single NUL byte.
- EXPECT_EQ(0, SafeSNPrintf(buf, 1, ""));
- EXPECT_EQ(0, buf[0]);
- EXPECT_EQ('X', buf[1]);
- buf[0] = 'X';
-
- // A larger buffer should leave the trailing bytes unchanged.
- EXPECT_EQ(0, SafeSNPrintf(buf, 2, ""));
- EXPECT_EQ(0, buf[0]);
- EXPECT_EQ('X', buf[1]);
- buf[0] = 'X';
-
- // The same test using SafeSPrintf() instead of SafeSNPrintf().
- EXPECT_EQ(0, SafeSPrintf(buf, ""));
- EXPECT_EQ(0, buf[0]);
- EXPECT_EQ('X', buf[1]);
- buf[0] = 'X';
-}
-
-TEST(SafeSPrintfTest, NoArguments) {
- // Output a text message that doesn't require any substitutions. This
- // is roughly equivalent to calling strncpy() (but unlike strncpy(), it does
- // always add a trailing NUL; it always deduplicates '%' characters).
- static const char text[] = "hello world";
- char ref[20], buf[20];
- memset(ref, 'X', sizeof(ref));
- memcpy(buf, ref, sizeof(buf));
-
- // A negative buffer size should always result in an error.
- EXPECT_EQ(-1, SafeSNPrintf(buf, static_cast<size_t>(-1), text));
- EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
-
- // Zero buffer size should always result in an error.
- EXPECT_EQ(-1, SafeSNPrintf(buf, 0, text));
- EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
-
- // A one-byte buffer should always print a single NUL byte.
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1, SafeSNPrintf(buf, 1, text));
- EXPECT_EQ(0, buf[0]);
- EXPECT_TRUE(!memcmp(buf+1, ref+1, sizeof(buf)-1));
- memcpy(buf, ref, sizeof(buf));
-
- // A larger (but limited) buffer should always leave the trailing bytes
- // unchanged.
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1, SafeSNPrintf(buf, 2, text));
- EXPECT_EQ(text[0], buf[0]);
- EXPECT_EQ(0, buf[1]);
- EXPECT_TRUE(!memcmp(buf+2, ref+2, sizeof(buf)-2));
- memcpy(buf, ref, sizeof(buf));
-
- // A unrestricted buffer length should always leave the trailing bytes
- // unchanged.
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1,
- SafeSNPrintf(buf, sizeof(buf), text));
- EXPECT_EQ(std::string(text), std::string(buf));
- EXPECT_TRUE(!memcmp(buf + sizeof(text), ref + sizeof(text),
- sizeof(buf) - sizeof(text)));
- memcpy(buf, ref, sizeof(buf));
-
- // The same test using SafeSPrintf() instead of SafeSNPrintf().
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1, SafeSPrintf(buf, text));
- EXPECT_EQ(std::string(text), std::string(buf));
- EXPECT_TRUE(!memcmp(buf + sizeof(text), ref + sizeof(text),
- sizeof(buf) - sizeof(text)));
- memcpy(buf, ref, sizeof(buf));
-
- // Check for deduplication of '%' percent characters.
- EXPECT_EQ(1, SafeSPrintf(buf, "%%"));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%%%"));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%X"));
- EXPECT_EQ(3, SafeSPrintf(buf, "%%%%X"));
-#if defined(NDEBUG)
- EXPECT_EQ(1, SafeSPrintf(buf, "%"));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%%"));
- EXPECT_EQ(2, SafeSPrintf(buf, "%X"));
- EXPECT_EQ(3, SafeSPrintf(buf, "%%%X"));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, "%"), "src.1. == '%'");
- EXPECT_DEATH(SafeSPrintf(buf, "%%%"), "src.1. == '%'");
- EXPECT_DEATH(SafeSPrintf(buf, "%X"), "src.1. == '%'");
- EXPECT_DEATH(SafeSPrintf(buf, "%%%X"), "src.1. == '%'");
-#endif
-}
-
-TEST(SafeSPrintfTest, OneArgument) {
- // Test basic single-argument single-character substitution.
- const char text[] = "hello world";
- const char fmt[] = "hello%cworld";
- char ref[20], buf[20];
- memset(ref, 'X', sizeof(buf));
- memcpy(buf, ref, sizeof(buf));
-
- // A negative buffer size should always result in an error.
- EXPECT_EQ(-1, SafeSNPrintf(buf, static_cast<size_t>(-1), fmt, ' '));
- EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
-
- // Zero buffer size should always result in an error.
- EXPECT_EQ(-1, SafeSNPrintf(buf, 0, fmt, ' '));
- EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
-
- // A one-byte buffer should always print a single NUL byte.
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1,
- SafeSNPrintf(buf, 1, fmt, ' '));
- EXPECT_EQ(0, buf[0]);
- EXPECT_TRUE(!memcmp(buf+1, ref+1, sizeof(buf)-1));
- memcpy(buf, ref, sizeof(buf));
-
- // A larger (but limited) buffer should always leave the trailing bytes
- // unchanged.
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1,
- SafeSNPrintf(buf, 2, fmt, ' '));
- EXPECT_EQ(text[0], buf[0]);
- EXPECT_EQ(0, buf[1]);
- EXPECT_TRUE(!memcmp(buf+2, ref+2, sizeof(buf)-2));
- memcpy(buf, ref, sizeof(buf));
-
- // A unrestricted buffer length should always leave the trailing bytes
- // unchanged.
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1,
- SafeSNPrintf(buf, sizeof(buf), fmt, ' '));
- EXPECT_EQ(std::string(text), std::string(buf));
- EXPECT_TRUE(!memcmp(buf + sizeof(text), ref + sizeof(text),
- sizeof(buf) - sizeof(text)));
- memcpy(buf, ref, sizeof(buf));
-
- // The same test using SafeSPrintf() instead of SafeSNPrintf().
- EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1, SafeSPrintf(buf, fmt, ' '));
- EXPECT_EQ(std::string(text), std::string(buf));
- EXPECT_TRUE(!memcmp(buf + sizeof(text), ref + sizeof(text),
- sizeof(buf) - sizeof(text)));
- memcpy(buf, ref, sizeof(buf));
-
- // Check for deduplication of '%' percent characters.
- EXPECT_EQ(1, SafeSPrintf(buf, "%%", 0));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%%%", 0));
- EXPECT_EQ(2, SafeSPrintf(buf, "%Y", 0));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%Y", 0));
- EXPECT_EQ(3, SafeSPrintf(buf, "%%%Y", 0));
- EXPECT_EQ(3, SafeSPrintf(buf, "%%%%Y", 0));
-#if defined(NDEBUG)
- EXPECT_EQ(1, SafeSPrintf(buf, "%", 0));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%%", 0));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, "%", 0), "ch");
- EXPECT_DEATH(SafeSPrintf(buf, "%%%", 0), "ch");
-#endif
-}
-
-TEST(SafeSPrintfTest, MissingArg) {
-#if defined(NDEBUG)
- char buf[20];
- EXPECT_EQ(3, SafeSPrintf(buf, "%c%c", 'A'));
- EXPECT_EQ("A%c", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- char buf[20];
- EXPECT_DEATH(SafeSPrintf(buf, "%c%c", 'A'), "cur_arg < max_args");
-#endif
-}
-
-TEST(SafeSPrintfTest, ASANFriendlyBufferTest) {
- // Print into a buffer that is sized exactly to size. ASAN can verify that
- // nobody attempts to write past the end of the buffer.
- // There is a more complicated test in PrintLongString() that covers a lot
- // more edge case, but it is also harder to debug in case of a failure.
- const char kTestString[] = "This is a test";
- std::unique_ptr<char[]> buf(new char[sizeof(kTestString)]);
- EXPECT_EQ(static_cast<ssize_t>(sizeof(kTestString) - 1),
- SafeSNPrintf(buf.get(), sizeof(kTestString), kTestString));
- EXPECT_EQ(std::string(kTestString), std::string(buf.get()));
- EXPECT_EQ(static_cast<ssize_t>(sizeof(kTestString) - 1),
- SafeSNPrintf(buf.get(), sizeof(kTestString), "%s", kTestString));
- EXPECT_EQ(std::string(kTestString), std::string(buf.get()));
-}
-
-TEST(SafeSPrintfTest, NArgs) {
- // Pre-C++11 compilers have a different code path, that can only print
- // up to ten distinct arguments.
- // We test both SafeSPrintf() and SafeSNPrintf(). This makes sure we don't
- // have typos in the copy-n-pasted code that is needed to deal with various
- // numbers of arguments.
- char buf[12];
- EXPECT_EQ(1, SafeSPrintf(buf, "%c", 1));
- EXPECT_EQ("\1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%c%c", 1, 2));
- EXPECT_EQ("\1\2", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%c%c%c", 1, 2, 3));
- EXPECT_EQ("\1\2\3", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%c%c%c%c", 1, 2, 3, 4));
- EXPECT_EQ("\1\2\3\4", std::string(buf));
- EXPECT_EQ(5, SafeSPrintf(buf, "%c%c%c%c%c", 1, 2, 3, 4, 5));
- EXPECT_EQ("\1\2\3\4\5", std::string(buf));
- EXPECT_EQ(6, SafeSPrintf(buf, "%c%c%c%c%c%c", 1, 2, 3, 4, 5, 6));
- EXPECT_EQ("\1\2\3\4\5\6", std::string(buf));
- EXPECT_EQ(7, SafeSPrintf(buf, "%c%c%c%c%c%c%c", 1, 2, 3, 4, 5, 6, 7));
- EXPECT_EQ("\1\2\3\4\5\6\7", std::string(buf));
- EXPECT_EQ(8, SafeSPrintf(buf, "%c%c%c%c%c%c%c%c", 1, 2, 3, 4, 5, 6, 7, 8));
- EXPECT_EQ("\1\2\3\4\5\6\7\10", std::string(buf));
- EXPECT_EQ(9, SafeSPrintf(buf, "%c%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8, 9));
- EXPECT_EQ("\1\2\3\4\5\6\7\10\11", std::string(buf));
- EXPECT_EQ(10, SafeSPrintf(buf, "%c%c%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-
- // Repeat all the tests with SafeSNPrintf() instead of SafeSPrintf().
- EXPECT_EQ("\1\2\3\4\5\6\7\10\11\12", std::string(buf));
- EXPECT_EQ(1, SafeSNPrintf(buf, 11, "%c", 1));
- EXPECT_EQ("\1", std::string(buf));
- EXPECT_EQ(2, SafeSNPrintf(buf, 11, "%c%c", 1, 2));
- EXPECT_EQ("\1\2", std::string(buf));
- EXPECT_EQ(3, SafeSNPrintf(buf, 11, "%c%c%c", 1, 2, 3));
- EXPECT_EQ("\1\2\3", std::string(buf));
- EXPECT_EQ(4, SafeSNPrintf(buf, 11, "%c%c%c%c", 1, 2, 3, 4));
- EXPECT_EQ("\1\2\3\4", std::string(buf));
- EXPECT_EQ(5, SafeSNPrintf(buf, 11, "%c%c%c%c%c", 1, 2, 3, 4, 5));
- EXPECT_EQ("\1\2\3\4\5", std::string(buf));
- EXPECT_EQ(6, SafeSNPrintf(buf, 11, "%c%c%c%c%c%c", 1, 2, 3, 4, 5, 6));
- EXPECT_EQ("\1\2\3\4\5\6", std::string(buf));
- EXPECT_EQ(7, SafeSNPrintf(buf, 11, "%c%c%c%c%c%c%c", 1, 2, 3, 4, 5, 6, 7));
- EXPECT_EQ("\1\2\3\4\5\6\7", std::string(buf));
- EXPECT_EQ(8, SafeSNPrintf(buf, 11, "%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8));
- EXPECT_EQ("\1\2\3\4\5\6\7\10", std::string(buf));
- EXPECT_EQ(9, SafeSNPrintf(buf, 11, "%c%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8, 9));
- EXPECT_EQ("\1\2\3\4\5\6\7\10\11", std::string(buf));
- EXPECT_EQ(10, SafeSNPrintf(buf, 11, "%c%c%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
- EXPECT_EQ("\1\2\3\4\5\6\7\10\11\12", std::string(buf));
-
- EXPECT_EQ(11, SafeSPrintf(buf, "%c%c%c%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
- EXPECT_EQ("\1\2\3\4\5\6\7\10\11\12\13", std::string(buf));
- EXPECT_EQ(11, SafeSNPrintf(buf, 12, "%c%c%c%c%c%c%c%c%c%c%c",
- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
- EXPECT_EQ("\1\2\3\4\5\6\7\10\11\12\13", std::string(buf));
-}
-
-TEST(SafeSPrintfTest, DataTypes) {
- char buf[40];
-
- // Bytes
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (uint8_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%d", (uint8_t)-1));
- EXPECT_EQ("255", std::string(buf));
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (int8_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%d", (int8_t)-1));
- EXPECT_EQ("-1", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%d", (int8_t)-128));
- EXPECT_EQ("-128", std::string(buf));
-
- // Half-words
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (uint16_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(5, SafeSPrintf(buf, "%d", (uint16_t)-1));
- EXPECT_EQ("65535", std::string(buf));
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (int16_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%d", (int16_t)-1));
- EXPECT_EQ("-1", std::string(buf));
- EXPECT_EQ(6, SafeSPrintf(buf, "%d", (int16_t)-32768));
- EXPECT_EQ("-32768", std::string(buf));
-
- // Words
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (uint32_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(10, SafeSPrintf(buf, "%d", (uint32_t)-1));
- EXPECT_EQ("4294967295", std::string(buf));
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (int32_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%d", (int32_t)-1));
- EXPECT_EQ("-1", std::string(buf));
- // Work-around for an limitation of C90
- EXPECT_EQ(11, SafeSPrintf(buf, "%d", (int32_t)-2147483647-1));
- EXPECT_EQ("-2147483648", std::string(buf));
-
- // Quads
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (uint64_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(20, SafeSPrintf(buf, "%d", (uint64_t)-1));
- EXPECT_EQ("18446744073709551615", std::string(buf));
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", (int64_t)1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%d", (int64_t)-1));
- EXPECT_EQ("-1", std::string(buf));
- // Work-around for an limitation of C90
- EXPECT_EQ(20, SafeSPrintf(buf, "%d", (int64_t)-9223372036854775807LL-1));
- EXPECT_EQ("-9223372036854775808", std::string(buf));
-
- // Strings (both const and mutable).
- EXPECT_EQ(4, SafeSPrintf(buf, "test"));
- EXPECT_EQ("test", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, buf));
- EXPECT_EQ("test", std::string(buf));
-
- // Pointer
- char addr[20];
- sprintf(addr, "0x%llX", (unsigned long long)(uintptr_t)buf);
- SafeSPrintf(buf, "%p", buf);
- EXPECT_EQ(std::string(addr), std::string(buf));
- SafeSPrintf(buf, "%p", (const char *)buf);
- EXPECT_EQ(std::string(addr), std::string(buf));
- sprintf(addr, "0x%llX", (unsigned long long)(uintptr_t)sprintf);
- SafeSPrintf(buf, "%p", sprintf);
- EXPECT_EQ(std::string(addr), std::string(buf));
-
- // Padding for pointers is a little more complicated because of the "0x"
- // prefix. Padding with '0' zeros is relatively straight-forward, but
- // padding with ' ' spaces requires more effort.
- sprintf(addr, "0x%017llX", (unsigned long long)(uintptr_t)buf);
- SafeSPrintf(buf, "%019p", buf);
- EXPECT_EQ(std::string(addr), std::string(buf));
- sprintf(addr, "0x%llX", (unsigned long long)(uintptr_t)buf);
- memset(addr, ' ',
- (char*)memmove(addr + sizeof(addr) - strlen(addr) - 1,
- addr, strlen(addr)+1) - addr);
- SafeSPrintf(buf, "%19p", buf);
- EXPECT_EQ(std::string(addr), std::string(buf));
-}
-
-namespace {
-void PrintLongString(char* buf, size_t sz) {
- // Output a reasonably complex expression into a limited-size buffer.
- // At least one byte is available for writing the NUL character.
- CHECK_GT(sz, static_cast<size_t>(0));
-
- // Allocate slightly more space, so that we can verify that SafeSPrintf()
- // never writes past the end of the buffer.
- std::unique_ptr<char[]> tmp(new char[sz + 2]);
- memset(tmp.get(), 'X', sz+2);
-
- // Use SafeSPrintf() to output a complex list of arguments:
- // - test padding and truncating %c single characters.
- // - test truncating %s simple strings.
- // - test mismatching arguments and truncating (for %d != %s).
- // - test zero-padding and truncating %x hexadecimal numbers.
- // - test outputting and truncating %d MININT.
- // - test outputting and truncating %p arbitrary pointer values.
- // - test outputting, padding and truncating NULL-pointer %s strings.
- char* out = tmp.get();
- size_t out_sz = sz;
- size_t len;
- for (std::unique_ptr<char[]> perfect_buf;;) {
- size_t needed =
- SafeSNPrintf(out, out_sz,
-#if defined(NDEBUG)
- "A%2cong %s: %d %010X %d %p%7s", 'l', "string", "",
-#else
- "A%2cong %s: %%d %010X %d %p%7s", 'l', "string",
-#endif
- 0xDEADBEEF, std::numeric_limits<intptr_t>::min(),
- PrintLongString, static_cast<char*>(nullptr)) +
- 1;
-
- // Various sanity checks:
- // The numbered of characters needed to print the full string should always
- // be bigger or equal to the bytes that have actually been output.
- len = strlen(tmp.get());
- CHECK_GE(needed, len+1);
-
- // The number of characters output should always fit into the buffer that
- // was passed into SafeSPrintf().
- CHECK_LT(len, out_sz);
-
- // The output is always terminated with a NUL byte (actually, this test is
- // always going to pass, as strlen() already verified this)
- EXPECT_FALSE(tmp[len]);
-
- // ASAN can check that we are not overwriting buffers, iff we make sure the
- // buffer is exactly the size that we are expecting to be written. After
- // running SafeSNPrintf() the first time, it is possible to compute the
- // correct buffer size for this test. So, allocate a second buffer and run
- // the exact same SafeSNPrintf() command again.
- if (!perfect_buf.get()) {
- out_sz = std::min(needed, sz);
- out = new char[out_sz];
- perfect_buf.reset(out);
- } else {
- break;
- }
- }
-
- // All trailing bytes are unchanged.
- for (size_t i = len+1; i < sz+2; ++i)
- EXPECT_EQ('X', tmp[i]);
-
- // The text that was generated by SafeSPrintf() should always match the
- // equivalent text generated by sprintf(). Please note that the format
- // string for sprintf() is not complicated, as it does not have the
- // benefit of getting type information from the C++ compiler.
- //
- // N.B.: It would be so much cleaner to use snprintf(). But unfortunately,
- // Visual Studio doesn't support this function, and the work-arounds
- // are all really awkward.
- char ref[256];
- CHECK_LE(sz, sizeof(ref));
- sprintf(ref, "A long string: %%d 00DEADBEEF %lld 0x%llX <NULL>",
- static_cast<long long>(std::numeric_limits<intptr_t>::min()),
- static_cast<unsigned long long>(
- reinterpret_cast<uintptr_t>(PrintLongString)));
- ref[sz-1] = '\000';
-
-#if defined(NDEBUG)
- const size_t kSSizeMax = std::numeric_limits<ssize_t>::max();
-#else
- const size_t kSSizeMax = internal::GetSafeSPrintfSSizeMaxForTest();
-#endif
-
- // Compare the output from SafeSPrintf() to the one from sprintf().
- EXPECT_EQ(std::string(ref).substr(0, kSSizeMax-1), std::string(tmp.get()));
-
- // We allocated a slightly larger buffer, so that we could perform some
- // extra sanity checks. Now that the tests have all passed, we copy the
- // data to the output buffer that the caller provided.
- memcpy(buf, tmp.get(), len+1);
-}
-
-#if !defined(NDEBUG)
-class ScopedSafeSPrintfSSizeMaxSetter {
- public:
- ScopedSafeSPrintfSSizeMaxSetter(size_t sz) {
- old_ssize_max_ = internal::GetSafeSPrintfSSizeMaxForTest();
- internal::SetSafeSPrintfSSizeMaxForTest(sz);
- }
-
- ~ScopedSafeSPrintfSSizeMaxSetter() {
- internal::SetSafeSPrintfSSizeMaxForTest(old_ssize_max_);
- }
-
- private:
- size_t old_ssize_max_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedSafeSPrintfSSizeMaxSetter);
-};
-#endif
-
-} // anonymous namespace
-
-TEST(SafeSPrintfTest, Truncation) {
- // We use PrintLongString() to print a complex long string and then
- // truncate to all possible lengths. This ends up exercising a lot of
- // different code paths in SafeSPrintf() and IToASCII(), as truncation can
- // happen in a lot of different states.
- char ref[256];
- PrintLongString(ref, sizeof(ref));
- for (size_t i = strlen(ref)+1; i; --i) {
- char buf[sizeof(ref)];
- PrintLongString(buf, i);
- EXPECT_EQ(std::string(ref, i - 1), std::string(buf));
- }
-
- // When compiling in debug mode, we have the ability to fake a small
- // upper limit for the maximum value that can be stored in an ssize_t.
- // SafeSPrintf() uses this upper limit to determine how many bytes it will
- // write to the buffer, even if the caller claimed a bigger buffer size.
- // Repeat the truncation test and verify that this other code path in
- // SafeSPrintf() works correctly, too.
-#if !defined(NDEBUG)
- for (size_t i = strlen(ref)+1; i > 1; --i) {
- ScopedSafeSPrintfSSizeMaxSetter ssize_max_setter(i);
- char buf[sizeof(ref)];
- PrintLongString(buf, sizeof(buf));
- EXPECT_EQ(std::string(ref, i - 1), std::string(buf));
- }
-
- // kSSizeMax is also used to constrain the maximum amount of padding, before
- // SafeSPrintf() detects an error in the format string.
- ScopedSafeSPrintfSSizeMaxSetter ssize_max_setter(100);
- char buf[256];
- EXPECT_EQ(99, SafeSPrintf(buf, "%99c", ' '));
- EXPECT_EQ(std::string(99, ' '), std::string(buf));
- *buf = '\000';
-#if defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, "%100c", ' '), "padding <= max_padding");
-#endif
- EXPECT_EQ(0, *buf);
-#endif
-}
-
-TEST(SafeSPrintfTest, Padding) {
- char buf[40], fmt[40];
-
- // Chars %c
- EXPECT_EQ(1, SafeSPrintf(buf, "%c", 'A'));
- EXPECT_EQ("A", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%2c", 'A'));
- EXPECT_EQ(" A", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%02c", 'A'));
- EXPECT_EQ(" A", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%-2c", 'A'));
- EXPECT_EQ("%-2c", std::string(buf));
- SafeSPrintf(fmt, "%%%dc", std::numeric_limits<ssize_t>::max() - 1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1, SafeSPrintf(buf, fmt, 'A'));
- SafeSPrintf(fmt, "%%%dc",
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, fmt, 'A'));
- EXPECT_EQ("%c", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, fmt, 'A'), "padding <= max_padding");
-#endif
-
- // Octal %o
- EXPECT_EQ(1, SafeSPrintf(buf, "%o", 1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%2o", 1));
- EXPECT_EQ(" 1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%02o", 1));
- EXPECT_EQ("01", std::string(buf));
- EXPECT_EQ(12, SafeSPrintf(buf, "%12o", -1));
- EXPECT_EQ(" 37777777777", std::string(buf));
- EXPECT_EQ(12, SafeSPrintf(buf, "%012o", -1));
- EXPECT_EQ("037777777777", std::string(buf));
- EXPECT_EQ(23, SafeSPrintf(buf, "%23o", -1LL));
- EXPECT_EQ(" 1777777777777777777777", std::string(buf));
- EXPECT_EQ(23, SafeSPrintf(buf, "%023o", -1LL));
- EXPECT_EQ("01777777777777777777777", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%2o", 0111));
- EXPECT_EQ("111", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%-2o", 1));
- EXPECT_EQ("%-2o", std::string(buf));
- SafeSPrintf(fmt, "%%%do", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, 1));
- EXPECT_EQ(" ", std::string(buf));
- SafeSPrintf(fmt, "%%0%do", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, 1));
- EXPECT_EQ("000", std::string(buf));
- SafeSPrintf(fmt, "%%%do",
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, fmt, 1));
- EXPECT_EQ("%o", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, fmt, 1), "padding <= max_padding");
-#endif
-
- // Decimals %d
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", 1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%2d", 1));
- EXPECT_EQ(" 1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%02d", 1));
- EXPECT_EQ("01", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%3d", -1));
- EXPECT_EQ(" -1", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%03d", -1));
- EXPECT_EQ("-01", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%2d", 111));
- EXPECT_EQ("111", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%2d", -111));
- EXPECT_EQ("-111", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%-2d", 1));
- EXPECT_EQ("%-2d", std::string(buf));
- SafeSPrintf(fmt, "%%%dd", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, 1));
- EXPECT_EQ(" ", std::string(buf));
- SafeSPrintf(fmt, "%%0%dd", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, 1));
- EXPECT_EQ("000", std::string(buf));
- SafeSPrintf(fmt, "%%%dd",
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, fmt, 1));
- EXPECT_EQ("%d", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, fmt, 1), "padding <= max_padding");
-#endif
-
- // Hex %X
- EXPECT_EQ(1, SafeSPrintf(buf, "%X", 1));
- EXPECT_EQ("1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%2X", 1));
- EXPECT_EQ(" 1", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%02X", 1));
- EXPECT_EQ("01", std::string(buf));
- EXPECT_EQ(9, SafeSPrintf(buf, "%9X", -1));
- EXPECT_EQ(" FFFFFFFF", std::string(buf));
- EXPECT_EQ(9, SafeSPrintf(buf, "%09X", -1));
- EXPECT_EQ("0FFFFFFFF", std::string(buf));
- EXPECT_EQ(17, SafeSPrintf(buf, "%17X", -1LL));
- EXPECT_EQ(" FFFFFFFFFFFFFFFF", std::string(buf));
- EXPECT_EQ(17, SafeSPrintf(buf, "%017X", -1LL));
- EXPECT_EQ("0FFFFFFFFFFFFFFFF", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%2X", 0x111));
- EXPECT_EQ("111", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%-2X", 1));
- EXPECT_EQ("%-2X", std::string(buf));
- SafeSPrintf(fmt, "%%%dX", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, 1));
- EXPECT_EQ(" ", std::string(buf));
- SafeSPrintf(fmt, "%%0%dX", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, 1));
- EXPECT_EQ("000", std::string(buf));
- SafeSPrintf(fmt, "%%%dX",
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, fmt, 1));
- EXPECT_EQ("%X", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, fmt, 1), "padding <= max_padding");
-#endif
-
- // Pointer %p
- EXPECT_EQ(3, SafeSPrintf(buf, "%p", (void*)1));
- EXPECT_EQ("0x1", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%4p", (void*)1));
- EXPECT_EQ(" 0x1", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%04p", (void*)1));
- EXPECT_EQ("0x01", std::string(buf));
- EXPECT_EQ(5, SafeSPrintf(buf, "%4p", (void*)0x111));
- EXPECT_EQ("0x111", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%-2p", (void*)1));
- EXPECT_EQ("%-2p", std::string(buf));
- SafeSPrintf(fmt, "%%%dp", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, (void*)1));
- EXPECT_EQ(" ", std::string(buf));
- SafeSPrintf(fmt, "%%0%dp", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, (void*)1));
- EXPECT_EQ("0x0", std::string(buf));
- SafeSPrintf(fmt, "%%%dp",
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, fmt, 1));
- EXPECT_EQ("%p", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, fmt, 1), "padding <= max_padding");
-#endif
-
- // String
- EXPECT_EQ(1, SafeSPrintf(buf, "%s", "A"));
- EXPECT_EQ("A", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%2s", "A"));
- EXPECT_EQ(" A", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%02s", "A"));
- EXPECT_EQ(" A", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%2s", "AAA"));
- EXPECT_EQ("AAA", std::string(buf));
- EXPECT_EQ(4, SafeSPrintf(buf, "%-2s", "A"));
- EXPECT_EQ("%-2s", std::string(buf));
- SafeSPrintf(fmt, "%%%ds", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, "A"));
- EXPECT_EQ(" ", std::string(buf));
- SafeSPrintf(fmt, "%%0%ds", std::numeric_limits<ssize_t>::max()-1);
- EXPECT_EQ(std::numeric_limits<ssize_t>::max()-1,
- SafeSNPrintf(buf, 4, fmt, "A"));
- EXPECT_EQ(" ", std::string(buf));
- SafeSPrintf(fmt, "%%%ds",
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, fmt, "A"));
- EXPECT_EQ("%s", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, fmt, "A"), "padding <= max_padding");
-#endif
-}
-
-TEST(SafeSPrintfTest, EmbeddedNul) {
- char buf[] = { 'X', 'X', 'X', 'X' };
- EXPECT_EQ(2, SafeSPrintf(buf, "%3c", 0));
- EXPECT_EQ(' ', buf[0]);
- EXPECT_EQ(' ', buf[1]);
- EXPECT_EQ(0, buf[2]);
- EXPECT_EQ('X', buf[3]);
-
- // Check handling of a NUL format character. N.B. this takes two different
- // code paths depending on whether we are actually passing arguments. If
- // we don't have any arguments, we are running in the fast-path code, that
- // looks (almost) like a strncpy().
-#if defined(NDEBUG)
- EXPECT_EQ(2, SafeSPrintf(buf, "%%%"));
- EXPECT_EQ("%%", std::string(buf));
- EXPECT_EQ(2, SafeSPrintf(buf, "%%%", 0));
- EXPECT_EQ("%%", std::string(buf));
-#elif defined(ALLOW_DEATH_TEST)
- EXPECT_DEATH(SafeSPrintf(buf, "%%%"), "src.1. == '%'");
- EXPECT_DEATH(SafeSPrintf(buf, "%%%", 0), "ch");
-#endif
-}
-
-TEST(SafeSPrintfTest, EmitNULL) {
- char buf[40];
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion-null"
-#endif
- EXPECT_EQ(1, SafeSPrintf(buf, "%d", NULL));
- EXPECT_EQ("0", std::string(buf));
- EXPECT_EQ(3, SafeSPrintf(buf, "%p", NULL));
- EXPECT_EQ("0x0", std::string(buf));
- EXPECT_EQ(6, SafeSPrintf(buf, "%s", NULL));
- EXPECT_EQ("<NULL>", std::string(buf));
-#if defined(__GCC__)
-#pragma GCC diagnostic pop
-#endif
-}
-
-TEST(SafeSPrintfTest, PointerSize) {
- // The internal data representation is a 64bit value, independent of the
- // native word size. We want to perform sign-extension for signed integers,
- // but we want to avoid doing so for pointer types. This could be a
- // problem on systems, where pointers are only 32bit. This tests verifies
- // that there is no such problem.
- char *str = reinterpret_cast<char *>(0x80000000u);
- void *ptr = str;
- char buf[40];
- EXPECT_EQ(10, SafeSPrintf(buf, "%p", str));
- EXPECT_EQ("0x80000000", std::string(buf));
- EXPECT_EQ(10, SafeSPrintf(buf, "%p", ptr));
- EXPECT_EQ("0x80000000", std::string(buf));
-}
-
-} // namespace strings
-} // namespace base
diff --git a/base/strings/strcat_unittest.cc b/base/strings/strcat_unittest.cc
deleted file mode 100644
index cf2db51..0000000
--- a/base/strings/strcat_unittest.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2017 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 "base/strings/strcat.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(StrCat, 8Bit) {
- EXPECT_EQ("", StrCat({""}));
- EXPECT_EQ("1", StrCat({"1"}));
- EXPECT_EQ("122", StrCat({"1", "22"}));
- EXPECT_EQ("122333", StrCat({"1", "22", "333"}));
- EXPECT_EQ("1223334444", StrCat({"1", "22", "333", "4444"}));
- EXPECT_EQ("122333444455555", StrCat({"1", "22", "333", "4444", "55555"}));
-}
-
-TEST(StrCat, 16Bit) {
- string16 arg1 = ASCIIToUTF16("1");
- string16 arg2 = ASCIIToUTF16("22");
- string16 arg3 = ASCIIToUTF16("333");
-
- EXPECT_EQ(ASCIIToUTF16(""), StrCat({string16()}));
- EXPECT_EQ(ASCIIToUTF16("1"), StrCat({arg1}));
- EXPECT_EQ(ASCIIToUTF16("122"), StrCat({arg1, arg2}));
- EXPECT_EQ(ASCIIToUTF16("122333"), StrCat({arg1, arg2, arg3}));
-}
-
-TEST(StrAppend, 8Bit) {
- std::string result;
-
- result = "foo";
- StrAppend(&result, {std::string()});
- EXPECT_EQ("foo", result);
-
- result = "foo";
- StrAppend(&result, {"1"});
- EXPECT_EQ("foo1", result);
-
- result = "foo";
- StrAppend(&result, {"1", "22", "333"});
- EXPECT_EQ("foo122333", result);
-}
-
-TEST(StrAppend, 16Bit) {
- string16 arg1 = ASCIIToUTF16("1");
- string16 arg2 = ASCIIToUTF16("22");
- string16 arg3 = ASCIIToUTF16("333");
-
- string16 result;
-
- result = ASCIIToUTF16("foo");
- StrAppend(&result, {string16()});
- EXPECT_EQ(ASCIIToUTF16("foo"), result);
-
- result = ASCIIToUTF16("foo");
- StrAppend(&result, {arg1});
- EXPECT_EQ(ASCIIToUTF16("foo1"), result);
-
- result = ASCIIToUTF16("foo");
- StrAppend(&result, {arg1, arg2, arg3});
- EXPECT_EQ(ASCIIToUTF16("foo122333"), result);
-}
-
-} // namespace base
diff --git a/base/strings/string16_unittest.cc b/base/strings/string16_unittest.cc
deleted file mode 100644
index 0d2ca80..0000000
--- a/base/strings/string16_unittest.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 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 <sstream>
-#include <unordered_set>
-
-#include "base/strings/string16.h"
-
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// We define a custom operator<< for string16 so we can use it with logging.
-// This tests that conversion.
-TEST(String16Test, OutputStream) {
- // Basic stream test.
- {
- std::ostringstream stream;
- stream << "Empty '" << string16() << "' standard '"
- << string16(ASCIIToUTF16("Hello, world")) << "'";
- EXPECT_STREQ("Empty '' standard 'Hello, world'",
- stream.str().c_str());
- }
-
- // Interesting edge cases.
- {
- // These should each get converted to the invalid character: EF BF BD.
- string16 initial_surrogate;
- initial_surrogate.push_back(0xd800);
- string16 final_surrogate;
- final_surrogate.push_back(0xdc00);
-
- // Old italic A = U+10300, will get converted to: F0 90 8C 80 'z'.
- string16 surrogate_pair;
- surrogate_pair.push_back(0xd800);
- surrogate_pair.push_back(0xdf00);
- surrogate_pair.push_back('z');
-
- // Will get converted to the invalid char + 's': EF BF BD 's'.
- string16 unterminated_surrogate;
- unterminated_surrogate.push_back(0xd800);
- unterminated_surrogate.push_back('s');
-
- std::ostringstream stream;
- stream << initial_surrogate << "," << final_surrogate << ","
- << surrogate_pair << "," << unterminated_surrogate;
-
- EXPECT_STREQ("\xef\xbf\xbd,\xef\xbf\xbd,\xf0\x90\x8c\x80z,\xef\xbf\xbds",
- stream.str().c_str());
- }
-}
-
-TEST(String16Test, Hash) {
- string16 str1 = ASCIIToUTF16("hello");
- string16 str2 = ASCIIToUTF16("world");
-
- std::unordered_set<string16> set;
-
- set.insert(str1);
- EXPECT_EQ(1u, set.count(str1));
- EXPECT_EQ(0u, set.count(str2));
-}
-
-} // namespace base
diff --git a/base/strings/string16_unittest.nc b/base/strings/string16_unittest.nc
deleted file mode 100644
index 5186a45..0000000
--- a/base/strings/string16_unittest.nc
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2017 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 is a "No Compile Test".
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/strings/string16.h"
-
-#if defined(NCTEST_NO_KOENIG_LOOKUP_FOR_STRING16) // [r"use of undeclared identifier 'ShouldNotBeFound'"]
-
-// base::string16 is declared as a typedef. It should not cause other functions
-// in base to be found via Argument-dependent lookup.
-
-namespace base {
-void ShouldNotBeFound(const base::string16& arg) {}
-}
-
-// Intentionally not in base:: namespace.
-void WontCompile() {
- base::string16 s;
- ShouldNotBeFound(s);
-}
-
-#endif
diff --git a/base/strings/string_number_conversions_unittest.cc b/base/strings/string_number_conversions_unittest.cc
deleted file mode 100644
index d969450..0000000
--- a/base/strings/string_number_conversions_unittest.cc
+++ /dev/null
@@ -1,905 +0,0 @@
-// 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.
-
-#include "base/strings/string_number_conversions.h"
-
-#include <errno.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include <cmath>
-#include <limits>
-
-#include "base/bit_cast.h"
-#include "base/format_macros.h"
-#include "base/macros.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-template <typename INT>
-struct NumberToStringTest {
- INT num;
- const char* sexpected;
- const char* uexpected;
-};
-
-} // namespace
-
-TEST(StringNumberConversionsTest, NumberToString) {
- static const NumberToStringTest<int> int_tests[] = {
- {0, "0", "0"},
- {-1, "-1", "4294967295"},
- {std::numeric_limits<int>::max(), "2147483647", "2147483647"},
- {std::numeric_limits<int>::min(), "-2147483648", "2147483648"},
- };
- static const NumberToStringTest<int64_t> int64_tests[] = {
- {0, "0", "0"},
- {-1, "-1", "18446744073709551615"},
- {
- std::numeric_limits<int64_t>::max(), "9223372036854775807",
- "9223372036854775807",
- },
- {std::numeric_limits<int64_t>::min(), "-9223372036854775808",
- "9223372036854775808"},
- };
-
- for (size_t i = 0; i < arraysize(int_tests); ++i) {
- const NumberToStringTest<int>& test = int_tests[i];
- EXPECT_EQ(NumberToString(test.num), test.sexpected);
- EXPECT_EQ(NumberToString16(test.num), UTF8ToUTF16(test.sexpected));
- EXPECT_EQ(NumberToString(static_cast<unsigned>(test.num)), test.uexpected);
- EXPECT_EQ(NumberToString16(static_cast<unsigned>(test.num)),
- UTF8ToUTF16(test.uexpected));
- }
- for (size_t i = 0; i < arraysize(int64_tests); ++i) {
- const NumberToStringTest<int64_t>& test = int64_tests[i];
- EXPECT_EQ(NumberToString(test.num), test.sexpected);
- EXPECT_EQ(NumberToString16(test.num), UTF8ToUTF16(test.sexpected));
- EXPECT_EQ(NumberToString(static_cast<uint64_t>(test.num)), test.uexpected);
- EXPECT_EQ(NumberToString16(static_cast<uint64_t>(test.num)),
- UTF8ToUTF16(test.uexpected));
- }
-}
-
-TEST(StringNumberConversionsTest, Uint64ToString) {
- static const struct {
- uint64_t input;
- std::string output;
- } cases[] = {
- {0, "0"},
- {42, "42"},
- {INT_MAX, "2147483647"},
- {std::numeric_limits<uint64_t>::max(), "18446744073709551615"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].output, NumberToString(cases[i].input));
-}
-
-TEST(StringNumberConversionsTest, SizeTToString) {
- size_t size_t_max = std::numeric_limits<size_t>::max();
- std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
-
- static const struct {
- size_t input;
- std::string output;
- } cases[] = {
- {0, "0"},
- {9, "9"},
- {42, "42"},
- {INT_MAX, "2147483647"},
- {2147483648U, "2147483648"},
-#if SIZE_MAX > 4294967295U
- {99999999999U, "99999999999"},
-#endif
- {size_t_max, size_t_max_string},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].output, NumberToString(cases[i].input));
-}
-
-TEST(StringNumberConversionsTest, StringToInt) {
- static const struct {
- std::string input;
- int output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"42\x99", 42, false},
- {"\x99" "42\x99", 0, false},
- {"-2147483648", INT_MIN, true},
- {"2147483647", INT_MAX, true},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", -273, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-2147483649", INT_MIN, false},
- {"-99999999999", INT_MIN, false},
- {"2147483648", INT_MAX, false},
- {"99999999999", INT_MAX, false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- int output = cases[i].output ^ 1; // Ensure StringToInt wrote something.
- EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = cases[i].output ^ 1; // Ensure StringToInt wrote something.
- EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- int output;
- EXPECT_FALSE(StringToInt(input_string, &output));
- EXPECT_EQ(6, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToInt(utf16_input, &output));
- EXPECT_EQ(6, output);
-
- output = 0;
- const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
- EXPECT_FALSE(StringToInt(string16(negative_wide_input), &output));
- EXPECT_EQ(0, output);
-}
-
-TEST(StringNumberConversionsTest, StringToUint) {
- static const struct {
- std::string input;
- unsigned output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"42\x99", 42, false},
- {"\x99" "42\x99", 0, false},
- {"-2147483648", 0, false},
- {"2147483647", INT_MAX, true},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", 0, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-2147483649", 0, false},
- {"-99999999999", 0, false},
- {"4294967295", UINT_MAX, true},
- {"4294967296", UINT_MAX, false},
- {"99999999999", UINT_MAX, false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- unsigned output =
- cases[i].output ^ 1; // Ensure StringToUint wrote something.
- EXPECT_EQ(cases[i].success, StringToUint(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = cases[i].output ^ 1; // Ensure StringToUint wrote something.
- EXPECT_EQ(cases[i].success, StringToUint(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- unsigned output;
- EXPECT_FALSE(StringToUint(input_string, &output));
- EXPECT_EQ(6U, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToUint(utf16_input, &output));
- EXPECT_EQ(6U, output);
-
- output = 0;
- const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
- EXPECT_FALSE(StringToUint(string16(negative_wide_input), &output));
- EXPECT_EQ(0U, output);
-}
-
-TEST(StringNumberConversionsTest, StringToInt64) {
- static const struct {
- std::string input;
- int64_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"-2147483648", INT_MIN, true},
- {"2147483647", INT_MAX, true},
- {"-2147483649", INT64_C(-2147483649), true},
- {"-99999999999", INT64_C(-99999999999), true},
- {"2147483648", INT64_C(2147483648), true},
- {"99999999999", INT64_C(99999999999), true},
- {"9223372036854775807", std::numeric_limits<int64_t>::max(), true},
- {"-9223372036854775808", std::numeric_limits<int64_t>::min(), true},
- {"09", 9, true},
- {"-09", -9, true},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"0x42", 0, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", -273, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-9223372036854775809", std::numeric_limits<int64_t>::min(), false},
- {"-99999999999999999999", std::numeric_limits<int64_t>::min(), false},
- {"9223372036854775808", std::numeric_limits<int64_t>::max(), false},
- {"99999999999999999999", std::numeric_limits<int64_t>::max(), false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- int64_t output = 0;
- EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- int64_t output;
- EXPECT_FALSE(StringToInt64(input_string, &output));
- EXPECT_EQ(6, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToInt64(utf16_input, &output));
- EXPECT_EQ(6, output);
-}
-
-TEST(StringNumberConversionsTest, StringToUint64) {
- static const struct {
- std::string input;
- uint64_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"-2147483648", 0, false},
- {"2147483647", INT_MAX, true},
- {"-2147483649", 0, false},
- {"-99999999999", 0, false},
- {"2147483648", UINT64_C(2147483648), true},
- {"99999999999", UINT64_C(99999999999), true},
- {"9223372036854775807", std::numeric_limits<int64_t>::max(), true},
- {"-9223372036854775808", 0, false},
- {"09", 9, true},
- {"-09", 0, false},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"0x42", 0, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", 0, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-9223372036854775809", 0, false},
- {"-99999999999999999999", 0, false},
- {"9223372036854775808", UINT64_C(9223372036854775808), true},
- {"99999999999999999999", std::numeric_limits<uint64_t>::max(), false},
- {"18446744073709551615", std::numeric_limits<uint64_t>::max(), true},
- {"18446744073709551616", std::numeric_limits<uint64_t>::max(), false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- uint64_t output = 0;
- EXPECT_EQ(cases[i].success, StringToUint64(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToUint64(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- uint64_t output;
- EXPECT_FALSE(StringToUint64(input_string, &output));
- EXPECT_EQ(6U, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToUint64(utf16_input, &output));
- EXPECT_EQ(6U, output);
-}
-
-TEST(StringNumberConversionsTest, StringToSizeT) {
- size_t size_t_max = std::numeric_limits<size_t>::max();
- std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
-
- static const struct {
- std::string input;
- size_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 42, true},
- {"-2147483648", 0, false},
- {"2147483647", INT_MAX, true},
- {"-2147483649", 0, false},
- {"-99999999999", 0, false},
- {"2147483648", 2147483648U, true},
-#if SIZE_MAX > 4294967295U
- {"99999999999", 99999999999U, true},
-#endif
- {"-9223372036854775808", 0, false},
- {"09", 9, true},
- {"-09", 0, false},
- {"", 0, false},
- {" 42", 42, false},
- {"42 ", 42, false},
- {"0x42", 0, false},
- {"\t\n\v\f\r 42", 42, false},
- {"blah42", 0, false},
- {"42blah", 42, false},
- {"blah42blah", 0, false},
- {"-273.15", 0, false},
- {"+98.6", 98, false},
- {"--123", 0, false},
- {"++123", 0, false},
- {"-+123", 0, false},
- {"+-123", 0, false},
- {"-", 0, false},
- {"-9223372036854775809", 0, false},
- {"-99999999999999999999", 0, false},
- {"999999999999999999999999", size_t_max, false},
- {size_t_max_string, size_t_max, true},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- size_t output = 0;
- EXPECT_EQ(cases[i].success, StringToSizeT(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToSizeT(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "6\06";
- std::string input_string(input, arraysize(input) - 1);
- size_t output;
- EXPECT_FALSE(StringToSizeT(input_string, &output));
- EXPECT_EQ(6U, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToSizeT(utf16_input, &output));
- EXPECT_EQ(6U, output);
-}
-
-TEST(StringNumberConversionsTest, HexStringToInt) {
- static const struct {
- std::string input;
- int64_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 66, true},
- {"-42", -66, true},
- {"+42", 66, true},
- {"7fffffff", INT_MAX, true},
- {"-80000000", INT_MIN, true},
- {"80000000", INT_MAX, false}, // Overflow test.
- {"-80000001", INT_MIN, false}, // Underflow test.
- {"0x42", 66, true},
- {"-0x42", -66, true},
- {"+0x42", 66, true},
- {"0x7fffffff", INT_MAX, true},
- {"-0x80000000", INT_MIN, true},
- {"-80000000", INT_MIN, true},
- {"80000000", INT_MAX, false}, // Overflow test.
- {"-80000001", INT_MIN, false}, // Underflow test.
- {"0x0f", 15, true},
- {"0f", 15, true},
- {" 45", 0x45, false},
- {"\t\n\v\f\r 0x45", 0x45, false},
- {" 45", 0x45, false},
- {"45 ", 0x45, false},
- {"45:", 0x45, false},
- {"efgh", 0xef, false},
- {"0xefgh", 0xef, false},
- {"hgfe", 0, false},
- {"-", 0, false},
- {"", 0, false},
- {"0x", 0, false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- int output = 0;
- EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "0xc0ffee\0" "9";
- std::string input_string(input, arraysize(input) - 1);
- int output;
- EXPECT_FALSE(HexStringToInt(input_string, &output));
- EXPECT_EQ(0xc0ffee, output);
-}
-
-TEST(StringNumberConversionsTest, HexStringToUInt) {
- static const struct {
- std::string input;
- uint32_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 0x42, true},
- {"-42", 0, false},
- {"+42", 0x42, true},
- {"7fffffff", INT_MAX, true},
- {"-80000000", 0, false},
- {"ffffffff", 0xffffffff, true},
- {"DeadBeef", 0xdeadbeef, true},
- {"0x42", 0x42, true},
- {"-0x42", 0, false},
- {"+0x42", 0x42, true},
- {"0x7fffffff", INT_MAX, true},
- {"-0x80000000", 0, false},
- {"0xffffffff", std::numeric_limits<uint32_t>::max(), true},
- {"0XDeadBeef", 0xdeadbeef, true},
- {"0x7fffffffffffffff", std::numeric_limits<uint32_t>::max(),
- false}, // Overflow test.
- {"-0x8000000000000000", 0, false},
- {"0x8000000000000000", std::numeric_limits<uint32_t>::max(),
- false}, // Overflow test.
- {"-0x8000000000000001", 0, false},
- {"0xFFFFFFFFFFFFFFFF", std::numeric_limits<uint32_t>::max(),
- false}, // Overflow test.
- {"FFFFFFFFFFFFFFFF", std::numeric_limits<uint32_t>::max(),
- false}, // Overflow test.
- {"0x0000000000000000", 0, true},
- {"0000000000000000", 0, true},
- {"1FFFFFFFFFFFFFFFF", std::numeric_limits<uint32_t>::max(),
- false}, // Overflow test.
- {"0x0f", 0x0f, true},
- {"0f", 0x0f, true},
- {" 45", 0x45, false},
- {"\t\n\v\f\r 0x45", 0x45, false},
- {" 45", 0x45, false},
- {"45 ", 0x45, false},
- {"45:", 0x45, false},
- {"efgh", 0xef, false},
- {"0xefgh", 0xef, false},
- {"hgfe", 0, false},
- {"-", 0, false},
- {"", 0, false},
- {"0x", 0, false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- uint32_t output = 0;
- EXPECT_EQ(cases[i].success, HexStringToUInt(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "0xc0ffee\0" "9";
- std::string input_string(input, arraysize(input) - 1);
- uint32_t output;
- EXPECT_FALSE(HexStringToUInt(input_string, &output));
- EXPECT_EQ(0xc0ffeeU, output);
-}
-
-TEST(StringNumberConversionsTest, HexStringToInt64) {
- static const struct {
- std::string input;
- int64_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 66, true},
- {"-42", -66, true},
- {"+42", 66, true},
- {"40acd88557b", INT64_C(4444444448123), true},
- {"7fffffff", INT_MAX, true},
- {"-80000000", INT_MIN, true},
- {"ffffffff", 0xffffffff, true},
- {"DeadBeef", 0xdeadbeef, true},
- {"0x42", 66, true},
- {"-0x42", -66, true},
- {"+0x42", 66, true},
- {"0x40acd88557b", INT64_C(4444444448123), true},
- {"0x7fffffff", INT_MAX, true},
- {"-0x80000000", INT_MIN, true},
- {"0xffffffff", 0xffffffff, true},
- {"0XDeadBeef", 0xdeadbeef, true},
- {"0x7fffffffffffffff", std::numeric_limits<int64_t>::max(), true},
- {"-0x8000000000000000", std::numeric_limits<int64_t>::min(), true},
- {"0x8000000000000000", std::numeric_limits<int64_t>::max(),
- false}, // Overflow test.
- {"-0x8000000000000001", std::numeric_limits<int64_t>::min(),
- false}, // Underflow test.
- {"0x0f", 15, true},
- {"0f", 15, true},
- {" 45", 0x45, false},
- {"\t\n\v\f\r 0x45", 0x45, false},
- {" 45", 0x45, false},
- {"45 ", 0x45, false},
- {"45:", 0x45, false},
- {"efgh", 0xef, false},
- {"0xefgh", 0xef, false},
- {"hgfe", 0, false},
- {"-", 0, false},
- {"", 0, false},
- {"0x", 0, false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- int64_t output = 0;
- EXPECT_EQ(cases[i].success, HexStringToInt64(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "0xc0ffee\0" "9";
- std::string input_string(input, arraysize(input) - 1);
- int64_t output;
- EXPECT_FALSE(HexStringToInt64(input_string, &output));
- EXPECT_EQ(0xc0ffee, output);
-}
-
-TEST(StringNumberConversionsTest, HexStringToUInt64) {
- static const struct {
- std::string input;
- uint64_t output;
- bool success;
- } cases[] = {
- {"0", 0, true},
- {"42", 66, true},
- {"-42", 0, false},
- {"+42", 66, true},
- {"40acd88557b", INT64_C(4444444448123), true},
- {"7fffffff", INT_MAX, true},
- {"-80000000", 0, false},
- {"ffffffff", 0xffffffff, true},
- {"DeadBeef", 0xdeadbeef, true},
- {"0x42", 66, true},
- {"-0x42", 0, false},
- {"+0x42", 66, true},
- {"0x40acd88557b", INT64_C(4444444448123), true},
- {"0x7fffffff", INT_MAX, true},
- {"-0x80000000", 0, false},
- {"0xffffffff", 0xffffffff, true},
- {"0XDeadBeef", 0xdeadbeef, true},
- {"0x7fffffffffffffff", std::numeric_limits<int64_t>::max(), true},
- {"-0x8000000000000000", 0, false},
- {"0x8000000000000000", UINT64_C(0x8000000000000000), true},
- {"-0x8000000000000001", 0, false},
- {"0xFFFFFFFFFFFFFFFF", std::numeric_limits<uint64_t>::max(), true},
- {"FFFFFFFFFFFFFFFF", std::numeric_limits<uint64_t>::max(), true},
- {"0x0000000000000000", 0, true},
- {"0000000000000000", 0, true},
- {"1FFFFFFFFFFFFFFFF", std::numeric_limits<uint64_t>::max(),
- false}, // Overflow test.
- {"0x0f", 15, true},
- {"0f", 15, true},
- {" 45", 0x45, false},
- {"\t\n\v\f\r 0x45", 0x45, false},
- {" 45", 0x45, false},
- {"45 ", 0x45, false},
- {"45:", 0x45, false},
- {"efgh", 0xef, false},
- {"0xefgh", 0xef, false},
- {"hgfe", 0, false},
- {"-", 0, false},
- {"", 0, false},
- {"0x", 0, false},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- uint64_t output = 0;
- EXPECT_EQ(cases[i].success, HexStringToUInt64(cases[i].input, &output));
- EXPECT_EQ(cases[i].output, output);
- }
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "0xc0ffee\0" "9";
- std::string input_string(input, arraysize(input) - 1);
- uint64_t output;
- EXPECT_FALSE(HexStringToUInt64(input_string, &output));
- EXPECT_EQ(0xc0ffeeU, output);
-}
-
-TEST(StringNumberConversionsTest, HexStringToBytes) {
- static const struct {
- const std::string input;
- const char* output;
- size_t output_len;
- bool success;
- } cases[] = {
- {"0", "", 0, false}, // odd number of characters fails
- {"00", "\0", 1, true},
- {"42", "\x42", 1, true},
- {"-42", "", 0, false}, // any non-hex value fails
- {"+42", "", 0, false},
- {"7fffffff", "\x7f\xff\xff\xff", 4, true},
- {"80000000", "\x80\0\0\0", 4, true},
- {"deadbeef", "\xde\xad\xbe\xef", 4, true},
- {"DeadBeef", "\xde\xad\xbe\xef", 4, true},
- {"0x42", "", 0, false}, // leading 0x fails (x is not hex)
- {"0f", "\xf", 1, true},
- {"45 ", "\x45", 1, false},
- {"efgh", "\xef", 1, false},
- {"", "", 0, false},
- {"0123456789ABCDEF", "\x01\x23\x45\x67\x89\xAB\xCD\xEF", 8, true},
- {"0123456789ABCDEF012345",
- "\x01\x23\x45\x67\x89\xAB\xCD\xEF\x01\x23\x45", 11, true},
- };
-
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- std::vector<uint8_t> output;
- std::vector<uint8_t> compare;
- EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) <<
- i << ": " << cases[i].input;
- for (size_t j = 0; j < cases[i].output_len; ++j)
- compare.push_back(static_cast<uint8_t>(cases[i].output[j]));
- ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
- EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
- i << ": " << cases[i].input;
- }
-}
-
-TEST(StringNumberConversionsTest, StringToDouble) {
- static const struct {
- std::string input;
- double output;
- bool success;
- } cases[] = {
- // Test different forms of zero.
- {"0", 0.0, true},
- {"+0", 0.0, true},
- {"-0", 0.0, true},
- {"0.0", 0.0, true},
- {"000000000000000000000000000000.0", 0.0, true},
- {"0.000000000000000000000000000", 0.0, true},
-
- // Test the answer.
- {"42", 42.0, true},
- {"-42", -42.0, true},
-
- // Test variances of an ordinary number.
- {"123.45", 123.45, true},
- {"-123.45", -123.45, true},
- {"+123.45", 123.45, true},
-
- // Test different forms of representation.
- {"2.99792458e8", 299792458.0, true},
- {"149597870.691E+3", 149597870691.0, true},
- {"6.", 6.0, true},
-
- // Test around the largest/smallest value that a double can represent.
- {"9e307", 9e307, true},
- {"1.7976e308", 1.7976e308, true},
- {"1.7977e308", HUGE_VAL, false},
- {"1.797693134862315807e+308", HUGE_VAL, true},
- {"1.797693134862315808e+308", HUGE_VAL, false},
- {"9e308", HUGE_VAL, false},
- {"9e309", HUGE_VAL, false},
- {"9e999", HUGE_VAL, false},
- {"9e1999", HUGE_VAL, false},
- {"9e19999", HUGE_VAL, false},
- {"9e99999999999999999999", HUGE_VAL, false},
- {"-9e307", -9e307, true},
- {"-1.7976e308", -1.7976e308, true},
- {"-1.7977e308", -HUGE_VAL, false},
- {"-1.797693134862315807e+308", -HUGE_VAL, true},
- {"-1.797693134862315808e+308", -HUGE_VAL, false},
- {"-9e308", -HUGE_VAL, false},
- {"-9e309", -HUGE_VAL, false},
- {"-9e999", -HUGE_VAL, false},
- {"-9e1999", -HUGE_VAL, false},
- {"-9e19999", -HUGE_VAL, false},
- {"-9e99999999999999999999", -HUGE_VAL, false},
-
- // Test more exponents.
- {"1e-2", 0.01, true},
- {"42 ", 42.0, false},
- {" 1e-2", 0.01, false},
- {"1e-2 ", 0.01, false},
- {"-1E-7", -0.0000001, true},
- {"01e02", 100, true},
- {"2.3e15", 2.3e15, true},
- {"100e-309", 100e-309, true},
-
- // Test some invalid cases.
- {"\t\n\v\f\r -123.45e2", -12345.0, false},
- {"+123 e4", 123.0, false},
- {"123e ", 123.0, false},
- {"123e", 123.0, false},
- {" 2.99", 2.99, false},
- {"1e3.4", 1000.0, false},
- {"nothing", 0.0, false},
- {"-", 0.0, false},
- {"+", 0.0, false},
- {"", 0.0, false},
-
- // crbug.org/588726
- {"-0.0010000000000000000000000000000000000000001e-256",
- -1.0000000000000001e-259, true},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- double output;
- errno = 1;
- EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
- if (cases[i].success)
- EXPECT_EQ(1, errno) << i; // confirm that errno is unchanged.
- EXPECT_DOUBLE_EQ(cases[i].output, output);
- }
-
- // One additional test to verify that conversion of numbers in strings with
- // embedded NUL characters. The NUL and extra data after it should be
- // interpreted as junk after the number.
- const char input[] = "3.14\0" "159";
- std::string input_string(input, arraysize(input) - 1);
- double output;
- EXPECT_FALSE(StringToDouble(input_string, &output));
- EXPECT_DOUBLE_EQ(3.14, output);
-}
-
-TEST(StringNumberConversionsTest, DoubleToString) {
- static const struct {
- double input;
- const char* expected;
- } cases[] = {
- {0.0, "0"},
- {1.25, "1.25"},
- {1.33518e+012, "1.33518e+12"},
- {1.33489e+012, "1.33489e+12"},
- {1.33505e+012, "1.33505e+12"},
- {1.33545e+009, "1335450000"},
- {1.33503e+009, "1335030000"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- EXPECT_EQ(cases[i].expected, NumberToString(cases[i].input));
- EXPECT_EQ(cases[i].expected, UTF16ToUTF8(NumberToString16(cases[i].input)));
- }
-
- // The following two values were seen in crashes in the wild.
- const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
- double input = 0;
- memcpy(&input, input_bytes, arraysize(input_bytes));
- EXPECT_EQ("1335179083776", NumberToString(input));
- const char input_bytes2[8] =
- {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'};
- input = 0;
- memcpy(&input, input_bytes2, arraysize(input_bytes2));
- EXPECT_EQ("1334890332160", NumberToString(input));
-}
-
-TEST(StringNumberConversionsTest, HexEncode) {
- std::string hex(HexEncode(nullptr, 0));
- EXPECT_EQ(hex.length(), 0U);
- unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
- hex = HexEncode(bytes, sizeof(bytes));
- EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
-}
-
-// Test cases of known-bad strtod conversions that motivated the use of dmg_fp.
-// See https://bugs.chromium.org/p/chromium/issues/detail?id=593512.
-TEST(StringNumberConversionsTest, StrtodFailures) {
- static const struct {
- const char* input;
- uint64_t expected;
- } cases[] = {
- // http://www.exploringbinary.com/incorrectly-rounded-conversions-in-visual-c-plus-plus/
- {"9214843084008499", 0x43405e6cec57761aULL},
- {"0.500000000000000166533453693773481063544750213623046875",
- 0x3fe0000000000002ULL},
- {"30078505129381147446200", 0x44997a3c7271b021ULL},
- {"1777820000000000000001", 0x4458180d5bad2e3eULL},
- {"0.500000000000000166547006220929549868969843373633921146392822265625",
- 0x3fe0000000000002ULL},
- {"0.50000000000000016656055874808561867439493653364479541778564453125",
- 0x3fe0000000000002ULL},
- {"0.3932922657273", 0x3fd92bb352c4623aULL},
-
- // http://www.exploringbinary.com/incorrectly-rounded-conversions-in-gcc-and-glibc/
- {"0.500000000000000166533453693773481063544750213623046875",
- 0x3fe0000000000002ULL},
- {"3.518437208883201171875e13", 0x42c0000000000002ULL},
- {"62.5364939768271845828", 0x404f44abd5aa7ca4ULL},
- {"8.10109172351e-10", 0x3e0bd5cbaef0fd0cULL},
- {"1.50000000000000011102230246251565404236316680908203125",
- 0x3ff8000000000000ULL},
- {"9007199254740991.4999999999999999999999999999999995",
- 0x433fffffffffffffULL},
-
- // http://www.exploringbinary.com/incorrect-decimal-to-floating-point-conversion-in-sqlite/
- {"1e-23", 0x3b282db34012b251ULL},
- {"8.533e+68", 0x4e3fa69165a8eea2ULL},
- {"4.1006e-184", 0x19dbe0d1c7ea60c9ULL},
- {"9.998e+307", 0x7fe1cc0a350ca87bULL},
- {"9.9538452227e-280", 0x0602117ae45cde43ULL},
- {"6.47660115e-260", 0x0a1fdd9e333badadULL},
- {"7.4e+47", 0x49e033d7eca0adefULL},
- {"5.92e+48", 0x4a1033d7eca0adefULL},
- {"7.35e+66", 0x4dd172b70eababa9ULL},
- {"8.32116e+55", 0x4b8b2628393e02cdULL},
- };
-
- for (const auto& test : cases) {
- double output;
- EXPECT_TRUE(StringToDouble(test.input, &output));
- EXPECT_EQ(bit_cast<uint64_t>(output), test.expected);
- }
-}
-
-} // namespace base
diff --git a/base/strings/string_piece_unittest.cc b/base/strings/string_piece_unittest.cc
deleted file mode 100644
index 17d0897..0000000
--- a/base/strings/string_piece_unittest.cc
+++ /dev/null
@@ -1,805 +0,0 @@
-// 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.
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-template <typename T>
-class CommonStringPieceTest : public ::testing::Test {
- public:
- static const T as_string(const char* input) {
- return T(input);
- }
- static const T& as_string(const T& input) {
- return input;
- }
-};
-
-template <>
-class CommonStringPieceTest<string16> : public ::testing::Test {
- public:
- static const string16 as_string(const char* input) {
- return ASCIIToUTF16(input);
- }
- static const string16 as_string(const std::string& input) {
- return ASCIIToUTF16(input);
- }
-};
-
-typedef ::testing::Types<std::string, string16> SupportedStringTypes;
-
-TYPED_TEST_CASE(CommonStringPieceTest, SupportedStringTypes);
-
-TYPED_TEST(CommonStringPieceTest, CheckComparisonOperators) {
-#define CMP_Y(op, x, y) \
- { \
- TypeParam lhs(TestFixture::as_string(x)); \
- TypeParam rhs(TestFixture::as_string(y)); \
- ASSERT_TRUE( (BasicStringPiece<TypeParam>((lhs.c_str())) op \
- BasicStringPiece<TypeParam>((rhs.c_str())))); \
- ASSERT_TRUE( (BasicStringPiece<TypeParam>((lhs.c_str())).compare( \
- BasicStringPiece<TypeParam>((rhs.c_str()))) op 0)); \
- }
-
-#define CMP_N(op, x, y) \
- { \
- TypeParam lhs(TestFixture::as_string(x)); \
- TypeParam rhs(TestFixture::as_string(y)); \
- ASSERT_FALSE( (BasicStringPiece<TypeParam>((lhs.c_str())) op \
- BasicStringPiece<TypeParam>((rhs.c_str())))); \
- ASSERT_FALSE( (BasicStringPiece<TypeParam>((lhs.c_str())).compare( \
- BasicStringPiece<TypeParam>((rhs.c_str()))) op 0)); \
- }
-
- CMP_Y(==, "", "");
- CMP_Y(==, "a", "a");
- CMP_Y(==, "aa", "aa");
- CMP_N(==, "a", "");
- CMP_N(==, "", "a");
- CMP_N(==, "a", "b");
- CMP_N(==, "a", "aa");
- CMP_N(==, "aa", "a");
-
- CMP_N(!=, "", "");
- CMP_N(!=, "a", "a");
- CMP_N(!=, "aa", "aa");
- CMP_Y(!=, "a", "");
- CMP_Y(!=, "", "a");
- CMP_Y(!=, "a", "b");
- CMP_Y(!=, "a", "aa");
- CMP_Y(!=, "aa", "a");
-
- CMP_Y(<, "a", "b");
- CMP_Y(<, "a", "aa");
- CMP_Y(<, "aa", "b");
- CMP_Y(<, "aa", "bb");
- CMP_N(<, "a", "a");
- CMP_N(<, "b", "a");
- CMP_N(<, "aa", "a");
- CMP_N(<, "b", "aa");
- CMP_N(<, "bb", "aa");
-
- CMP_Y(<=, "a", "a");
- CMP_Y(<=, "a", "b");
- CMP_Y(<=, "a", "aa");
- CMP_Y(<=, "aa", "b");
- CMP_Y(<=, "aa", "bb");
- CMP_N(<=, "b", "a");
- CMP_N(<=, "aa", "a");
- CMP_N(<=, "b", "aa");
- CMP_N(<=, "bb", "aa");
-
- CMP_N(>=, "a", "b");
- CMP_N(>=, "a", "aa");
- CMP_N(>=, "aa", "b");
- CMP_N(>=, "aa", "bb");
- CMP_Y(>=, "a", "a");
- CMP_Y(>=, "b", "a");
- CMP_Y(>=, "aa", "a");
- CMP_Y(>=, "b", "aa");
- CMP_Y(>=, "bb", "aa");
-
- CMP_N(>, "a", "a");
- CMP_N(>, "a", "b");
- CMP_N(>, "a", "aa");
- CMP_N(>, "aa", "b");
- CMP_N(>, "aa", "bb");
- CMP_Y(>, "b", "a");
- CMP_Y(>, "aa", "a");
- CMP_Y(>, "b", "aa");
- CMP_Y(>, "bb", "aa");
-
- std::string x;
- for (int i = 0; i < 256; i++) {
- x += 'a';
- std::string y = x;
- CMP_Y(==, x, y);
- for (int j = 0; j < i; j++) {
- std::string z = x;
- z[j] = 'b'; // Differs in position 'j'
- CMP_N(==, x, z);
- }
- }
-
-#undef CMP_Y
-#undef CMP_N
-}
-
-TYPED_TEST(CommonStringPieceTest, CheckSTL) {
- TypeParam alphabet(TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
- TypeParam abc(TestFixture::as_string("abc"));
- TypeParam xyz(TestFixture::as_string("xyz"));
- TypeParam foobar(TestFixture::as_string("foobar"));
-
- BasicStringPiece<TypeParam> a(alphabet);
- BasicStringPiece<TypeParam> b(abc);
- BasicStringPiece<TypeParam> c(xyz);
- BasicStringPiece<TypeParam> d(foobar);
- BasicStringPiece<TypeParam> e;
- TypeParam temp(TestFixture::as_string("123"));
- temp += static_cast<typename TypeParam::value_type>(0);
- temp += TestFixture::as_string("456");
- BasicStringPiece<TypeParam> f(temp);
-
- ASSERT_EQ(a[6], static_cast<typename TypeParam::value_type>('g'));
- ASSERT_EQ(b[0], static_cast<typename TypeParam::value_type>('a'));
- ASSERT_EQ(c[2], static_cast<typename TypeParam::value_type>('z'));
- ASSERT_EQ(f[3], static_cast<typename TypeParam::value_type>('\0'));
- ASSERT_EQ(f[5], static_cast<typename TypeParam::value_type>('5'));
-
- ASSERT_EQ(*d.data(), static_cast<typename TypeParam::value_type>('f'));
- ASSERT_EQ(d.data()[5], static_cast<typename TypeParam::value_type>('r'));
- ASSERT_EQ(e.data(), nullptr);
-
- ASSERT_EQ(*a.begin(), static_cast<typename TypeParam::value_type>('a'));
- ASSERT_EQ(*(b.begin() + 2), static_cast<typename TypeParam::value_type>('c'));
- ASSERT_EQ(*(c.end() - 1), static_cast<typename TypeParam::value_type>('z'));
-
- ASSERT_EQ(*a.rbegin(), static_cast<typename TypeParam::value_type>('z'));
- ASSERT_EQ(*(b.rbegin() + 2),
- static_cast<typename TypeParam::value_type>('a'));
- ASSERT_EQ(*(c.rend() - 1), static_cast<typename TypeParam::value_type>('x'));
- ASSERT_EQ(a.rbegin() + 26, a.rend());
-
- ASSERT_EQ(a.size(), 26U);
- ASSERT_EQ(b.size(), 3U);
- ASSERT_EQ(c.size(), 3U);
- ASSERT_EQ(d.size(), 6U);
- ASSERT_EQ(e.size(), 0U);
- ASSERT_EQ(f.size(), 7U);
-
- ASSERT_TRUE(!d.empty());
- ASSERT_TRUE(d.begin() != d.end());
- ASSERT_EQ(d.begin() + 6, d.end());
-
- ASSERT_TRUE(e.empty());
- ASSERT_EQ(e.begin(), e.end());
-
- d.clear();
- ASSERT_EQ(d.size(), 0U);
- ASSERT_TRUE(d.empty());
- ASSERT_EQ(d.data(), nullptr);
- ASSERT_EQ(d.begin(), d.end());
-
- ASSERT_GE(a.max_size(), a.capacity());
- ASSERT_GE(a.capacity(), a.size());
-}
-
-TYPED_TEST(CommonStringPieceTest, CheckFind) {
- typedef BasicStringPiece<TypeParam> Piece;
-
- TypeParam alphabet(TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
- TypeParam abc(TestFixture::as_string("abc"));
- TypeParam xyz(TestFixture::as_string("xyz"));
- TypeParam foobar(TestFixture::as_string("foobar"));
-
- BasicStringPiece<TypeParam> a(alphabet);
- BasicStringPiece<TypeParam> b(abc);
- BasicStringPiece<TypeParam> c(xyz);
- BasicStringPiece<TypeParam> d(foobar);
-
- d.clear();
- Piece e;
- TypeParam temp(TestFixture::as_string("123"));
- temp.push_back('\0');
- temp += TestFixture::as_string("456");
- Piece f(temp);
-
- typename TypeParam::value_type buf[4] = { '%', '%', '%', '%' };
- ASSERT_EQ(a.copy(buf, 4), 4U);
- ASSERT_EQ(buf[0], a[0]);
- ASSERT_EQ(buf[1], a[1]);
- ASSERT_EQ(buf[2], a[2]);
- ASSERT_EQ(buf[3], a[3]);
- ASSERT_EQ(a.copy(buf, 3, 7), 3U);
- ASSERT_EQ(buf[0], a[7]);
- ASSERT_EQ(buf[1], a[8]);
- ASSERT_EQ(buf[2], a[9]);
- ASSERT_EQ(buf[3], a[3]);
- ASSERT_EQ(c.copy(buf, 99), 3U);
- ASSERT_EQ(buf[0], c[0]);
- ASSERT_EQ(buf[1], c[1]);
- ASSERT_EQ(buf[2], c[2]);
- ASSERT_EQ(buf[3], a[3]);
-
- ASSERT_EQ(Piece::npos, TypeParam::npos);
-
- ASSERT_EQ(a.find(b), 0U);
- ASSERT_EQ(a.find(b, 1), Piece::npos);
- ASSERT_EQ(a.find(c), 23U);
- ASSERT_EQ(a.find(c, 9), 23U);
- ASSERT_EQ(a.find(c, Piece::npos), Piece::npos);
- ASSERT_EQ(b.find(c), Piece::npos);
- ASSERT_EQ(b.find(c, Piece::npos), Piece::npos);
- ASSERT_EQ(a.find(d), 0U);
- ASSERT_EQ(a.find(e), 0U);
- ASSERT_EQ(a.find(d, 12), 12U);
- ASSERT_EQ(a.find(e, 17), 17U);
- TypeParam not_found(TestFixture::as_string("xx not found bb"));
- Piece g(not_found);
- ASSERT_EQ(a.find(g), Piece::npos);
- // empty string nonsense
- ASSERT_EQ(d.find(b), Piece::npos);
- ASSERT_EQ(e.find(b), Piece::npos);
- ASSERT_EQ(d.find(b, 4), Piece::npos);
- ASSERT_EQ(e.find(b, 7), Piece::npos);
-
- size_t empty_search_pos = TypeParam().find(TypeParam());
- ASSERT_EQ(d.find(d), empty_search_pos);
- ASSERT_EQ(d.find(e), empty_search_pos);
- ASSERT_EQ(e.find(d), empty_search_pos);
- ASSERT_EQ(e.find(e), empty_search_pos);
- ASSERT_EQ(d.find(d, 4), std::string().find(std::string(), 4));
- ASSERT_EQ(d.find(e, 4), std::string().find(std::string(), 4));
- ASSERT_EQ(e.find(d, 4), std::string().find(std::string(), 4));
- ASSERT_EQ(e.find(e, 4), std::string().find(std::string(), 4));
-
- ASSERT_EQ(a.find('a'), 0U);
- ASSERT_EQ(a.find('c'), 2U);
- ASSERT_EQ(a.find('z'), 25U);
- ASSERT_EQ(a.find('$'), Piece::npos);
- ASSERT_EQ(a.find('\0'), Piece::npos);
- ASSERT_EQ(f.find('\0'), 3U);
- ASSERT_EQ(f.find('3'), 2U);
- ASSERT_EQ(f.find('5'), 5U);
- ASSERT_EQ(g.find('o'), 4U);
- ASSERT_EQ(g.find('o', 4), 4U);
- ASSERT_EQ(g.find('o', 5), 8U);
- ASSERT_EQ(a.find('b', 5), Piece::npos);
- // empty string nonsense
- ASSERT_EQ(d.find('\0'), Piece::npos);
- ASSERT_EQ(e.find('\0'), Piece::npos);
- ASSERT_EQ(d.find('\0', 4), Piece::npos);
- ASSERT_EQ(e.find('\0', 7), Piece::npos);
- ASSERT_EQ(d.find('x'), Piece::npos);
- ASSERT_EQ(e.find('x'), Piece::npos);
- ASSERT_EQ(d.find('x', 4), Piece::npos);
- ASSERT_EQ(e.find('x', 7), Piece::npos);
-
- ASSERT_EQ(a.rfind(b), 0U);
- ASSERT_EQ(a.rfind(b, 1), 0U);
- ASSERT_EQ(a.rfind(c), 23U);
- ASSERT_EQ(a.rfind(c, 22U), Piece::npos);
- ASSERT_EQ(a.rfind(c, 1U), Piece::npos);
- ASSERT_EQ(a.rfind(c, 0U), Piece::npos);
- ASSERT_EQ(b.rfind(c), Piece::npos);
- ASSERT_EQ(b.rfind(c, 0U), Piece::npos);
- ASSERT_EQ(a.rfind(d), static_cast<size_t>(a.as_string().rfind(TypeParam())));
- ASSERT_EQ(a.rfind(e), a.as_string().rfind(TypeParam()));
- ASSERT_EQ(a.rfind(d), static_cast<size_t>(TypeParam(a).rfind(TypeParam())));
- ASSERT_EQ(a.rfind(e), TypeParam(a).rfind(TypeParam()));
- ASSERT_EQ(a.rfind(d, 12), 12U);
- ASSERT_EQ(a.rfind(e, 17), 17U);
- ASSERT_EQ(a.rfind(g), Piece::npos);
- ASSERT_EQ(d.rfind(b), Piece::npos);
- ASSERT_EQ(e.rfind(b), Piece::npos);
- ASSERT_EQ(d.rfind(b, 4), Piece::npos);
- ASSERT_EQ(e.rfind(b, 7), Piece::npos);
- // empty string nonsense
- ASSERT_EQ(d.rfind(d, 4), std::string().rfind(std::string()));
- ASSERT_EQ(e.rfind(d, 7), std::string().rfind(std::string()));
- ASSERT_EQ(d.rfind(e, 4), std::string().rfind(std::string()));
- ASSERT_EQ(e.rfind(e, 7), std::string().rfind(std::string()));
- ASSERT_EQ(d.rfind(d), std::string().rfind(std::string()));
- ASSERT_EQ(e.rfind(d), std::string().rfind(std::string()));
- ASSERT_EQ(d.rfind(e), std::string().rfind(std::string()));
- ASSERT_EQ(e.rfind(e), std::string().rfind(std::string()));
-
- ASSERT_EQ(g.rfind('o'), 8U);
- ASSERT_EQ(g.rfind('q'), Piece::npos);
- ASSERT_EQ(g.rfind('o', 8), 8U);
- ASSERT_EQ(g.rfind('o', 7), 4U);
- ASSERT_EQ(g.rfind('o', 3), Piece::npos);
- ASSERT_EQ(f.rfind('\0'), 3U);
- ASSERT_EQ(f.rfind('\0', 12), 3U);
- ASSERT_EQ(f.rfind('3'), 2U);
- ASSERT_EQ(f.rfind('5'), 5U);
- // empty string nonsense
- ASSERT_EQ(d.rfind('o'), Piece::npos);
- ASSERT_EQ(e.rfind('o'), Piece::npos);
- ASSERT_EQ(d.rfind('o', 4), Piece::npos);
- ASSERT_EQ(e.rfind('o', 7), Piece::npos);
-
- TypeParam one_two_three_four(TestFixture::as_string("one,two:three;four"));
- TypeParam comma_colon(TestFixture::as_string(",:"));
- ASSERT_EQ(3U, Piece(one_two_three_four).find_first_of(comma_colon));
- ASSERT_EQ(a.find_first_of(b), 0U);
- ASSERT_EQ(a.find_first_of(b, 0), 0U);
- ASSERT_EQ(a.find_first_of(b, 1), 1U);
- ASSERT_EQ(a.find_first_of(b, 2), 2U);
- ASSERT_EQ(a.find_first_of(b, 3), Piece::npos);
- ASSERT_EQ(a.find_first_of(c), 23U);
- ASSERT_EQ(a.find_first_of(c, 23), 23U);
- ASSERT_EQ(a.find_first_of(c, 24), 24U);
- ASSERT_EQ(a.find_first_of(c, 25), 25U);
- ASSERT_EQ(a.find_first_of(c, 26), Piece::npos);
- ASSERT_EQ(g.find_first_of(b), 13U);
- ASSERT_EQ(g.find_first_of(c), 0U);
- ASSERT_EQ(a.find_first_of(f), Piece::npos);
- ASSERT_EQ(f.find_first_of(a), Piece::npos);
- // empty string nonsense
- ASSERT_EQ(a.find_first_of(d), Piece::npos);
- ASSERT_EQ(a.find_first_of(e), Piece::npos);
- ASSERT_EQ(d.find_first_of(b), Piece::npos);
- ASSERT_EQ(e.find_first_of(b), Piece::npos);
- ASSERT_EQ(d.find_first_of(d), Piece::npos);
- ASSERT_EQ(e.find_first_of(d), Piece::npos);
- ASSERT_EQ(d.find_first_of(e), Piece::npos);
- ASSERT_EQ(e.find_first_of(e), Piece::npos);
-
- ASSERT_EQ(a.find_first_not_of(b), 3U);
- ASSERT_EQ(a.find_first_not_of(c), 0U);
- ASSERT_EQ(b.find_first_not_of(a), Piece::npos);
- ASSERT_EQ(c.find_first_not_of(a), Piece::npos);
- ASSERT_EQ(f.find_first_not_of(a), 0U);
- ASSERT_EQ(a.find_first_not_of(f), 0U);
- ASSERT_EQ(a.find_first_not_of(d), 0U);
- ASSERT_EQ(a.find_first_not_of(e), 0U);
- // empty string nonsense
- ASSERT_EQ(d.find_first_not_of(a), Piece::npos);
- ASSERT_EQ(e.find_first_not_of(a), Piece::npos);
- ASSERT_EQ(d.find_first_not_of(d), Piece::npos);
- ASSERT_EQ(e.find_first_not_of(d), Piece::npos);
- ASSERT_EQ(d.find_first_not_of(e), Piece::npos);
- ASSERT_EQ(e.find_first_not_of(e), Piece::npos);
-
- TypeParam equals(TestFixture::as_string("===="));
- Piece h(equals);
- ASSERT_EQ(h.find_first_not_of('='), Piece::npos);
- ASSERT_EQ(h.find_first_not_of('=', 3), Piece::npos);
- ASSERT_EQ(h.find_first_not_of('\0'), 0U);
- ASSERT_EQ(g.find_first_not_of('x'), 2U);
- ASSERT_EQ(f.find_first_not_of('\0'), 0U);
- ASSERT_EQ(f.find_first_not_of('\0', 3), 4U);
- ASSERT_EQ(f.find_first_not_of('\0', 2), 2U);
- // empty string nonsense
- ASSERT_EQ(d.find_first_not_of('x'), Piece::npos);
- ASSERT_EQ(e.find_first_not_of('x'), Piece::npos);
- ASSERT_EQ(d.find_first_not_of('\0'), Piece::npos);
- ASSERT_EQ(e.find_first_not_of('\0'), Piece::npos);
-
- // Piece g("xx not found bb");
- TypeParam fifty_six(TestFixture::as_string("56"));
- Piece i(fifty_six);
- ASSERT_EQ(h.find_last_of(a), Piece::npos);
- ASSERT_EQ(g.find_last_of(a), g.size()-1);
- ASSERT_EQ(a.find_last_of(b), 2U);
- ASSERT_EQ(a.find_last_of(c), a.size()-1);
- ASSERT_EQ(f.find_last_of(i), 6U);
- ASSERT_EQ(a.find_last_of('a'), 0U);
- ASSERT_EQ(a.find_last_of('b'), 1U);
- ASSERT_EQ(a.find_last_of('z'), 25U);
- ASSERT_EQ(a.find_last_of('a', 5), 0U);
- ASSERT_EQ(a.find_last_of('b', 5), 1U);
- ASSERT_EQ(a.find_last_of('b', 0), Piece::npos);
- ASSERT_EQ(a.find_last_of('z', 25), 25U);
- ASSERT_EQ(a.find_last_of('z', 24), Piece::npos);
- ASSERT_EQ(f.find_last_of(i, 5), 5U);
- ASSERT_EQ(f.find_last_of(i, 6), 6U);
- ASSERT_EQ(f.find_last_of(a, 4), Piece::npos);
- // empty string nonsense
- ASSERT_EQ(f.find_last_of(d), Piece::npos);
- ASSERT_EQ(f.find_last_of(e), Piece::npos);
- ASSERT_EQ(f.find_last_of(d, 4), Piece::npos);
- ASSERT_EQ(f.find_last_of(e, 4), Piece::npos);
- ASSERT_EQ(d.find_last_of(d), Piece::npos);
- ASSERT_EQ(d.find_last_of(e), Piece::npos);
- ASSERT_EQ(e.find_last_of(d), Piece::npos);
- ASSERT_EQ(e.find_last_of(e), Piece::npos);
- ASSERT_EQ(d.find_last_of(f), Piece::npos);
- ASSERT_EQ(e.find_last_of(f), Piece::npos);
- ASSERT_EQ(d.find_last_of(d, 4), Piece::npos);
- ASSERT_EQ(d.find_last_of(e, 4), Piece::npos);
- ASSERT_EQ(e.find_last_of(d, 4), Piece::npos);
- ASSERT_EQ(e.find_last_of(e, 4), Piece::npos);
- ASSERT_EQ(d.find_last_of(f, 4), Piece::npos);
- ASSERT_EQ(e.find_last_of(f, 4), Piece::npos);
-
- ASSERT_EQ(a.find_last_not_of(b), a.size()-1);
- ASSERT_EQ(a.find_last_not_of(c), 22U);
- ASSERT_EQ(b.find_last_not_of(a), Piece::npos);
- ASSERT_EQ(b.find_last_not_of(b), Piece::npos);
- ASSERT_EQ(f.find_last_not_of(i), 4U);
- ASSERT_EQ(a.find_last_not_of(c, 24), 22U);
- ASSERT_EQ(a.find_last_not_of(b, 3), 3U);
- ASSERT_EQ(a.find_last_not_of(b, 2), Piece::npos);
- // empty string nonsense
- ASSERT_EQ(f.find_last_not_of(d), f.size()-1);
- ASSERT_EQ(f.find_last_not_of(e), f.size()-1);
- ASSERT_EQ(f.find_last_not_of(d, 4), 4U);
- ASSERT_EQ(f.find_last_not_of(e, 4), 4U);
- ASSERT_EQ(d.find_last_not_of(d), Piece::npos);
- ASSERT_EQ(d.find_last_not_of(e), Piece::npos);
- ASSERT_EQ(e.find_last_not_of(d), Piece::npos);
- ASSERT_EQ(e.find_last_not_of(e), Piece::npos);
- ASSERT_EQ(d.find_last_not_of(f), Piece::npos);
- ASSERT_EQ(e.find_last_not_of(f), Piece::npos);
- ASSERT_EQ(d.find_last_not_of(d, 4), Piece::npos);
- ASSERT_EQ(d.find_last_not_of(e, 4), Piece::npos);
- ASSERT_EQ(e.find_last_not_of(d, 4), Piece::npos);
- ASSERT_EQ(e.find_last_not_of(e, 4), Piece::npos);
- ASSERT_EQ(d.find_last_not_of(f, 4), Piece::npos);
- ASSERT_EQ(e.find_last_not_of(f, 4), Piece::npos);
-
- ASSERT_EQ(h.find_last_not_of('x'), h.size() - 1);
- ASSERT_EQ(h.find_last_not_of('='), Piece::npos);
- ASSERT_EQ(b.find_last_not_of('c'), 1U);
- ASSERT_EQ(h.find_last_not_of('x', 2), 2U);
- ASSERT_EQ(h.find_last_not_of('=', 2), Piece::npos);
- ASSERT_EQ(b.find_last_not_of('b', 1), 0U);
- // empty string nonsense
- ASSERT_EQ(d.find_last_not_of('x'), Piece::npos);
- ASSERT_EQ(e.find_last_not_of('x'), Piece::npos);
- ASSERT_EQ(d.find_last_not_of('\0'), Piece::npos);
- ASSERT_EQ(e.find_last_not_of('\0'), Piece::npos);
-
- ASSERT_EQ(a.substr(0, 3), b);
- ASSERT_EQ(a.substr(23), c);
- ASSERT_EQ(a.substr(23, 3), c);
- ASSERT_EQ(a.substr(23, 99), c);
- ASSERT_EQ(a.substr(0), a);
- ASSERT_EQ(a.substr(3, 2), TestFixture::as_string("de"));
- // empty string nonsense
- ASSERT_EQ(a.substr(99, 2), e);
- ASSERT_EQ(d.substr(99), e);
- ASSERT_EQ(d.substr(0, 99), e);
- ASSERT_EQ(d.substr(99, 99), e);
-}
-
-TYPED_TEST(CommonStringPieceTest, CheckCustom) {
- TypeParam foobar(TestFixture::as_string("foobar"));
- BasicStringPiece<TypeParam> a(foobar);
- TypeParam s1(TestFixture::as_string("123"));
- s1 += static_cast<typename TypeParam::value_type>('\0');
- s1 += TestFixture::as_string("456");
- BasicStringPiece<TypeParam> b(s1);
- BasicStringPiece<TypeParam> e;
- TypeParam s2;
-
- // remove_prefix
- BasicStringPiece<TypeParam> c(a);
- c.remove_prefix(3);
- ASSERT_EQ(c, TestFixture::as_string("bar"));
- c = a;
- c.remove_prefix(0);
- ASSERT_EQ(c, a);
- c.remove_prefix(c.size());
- ASSERT_EQ(c, e);
-
- // remove_suffix
- c = a;
- c.remove_suffix(3);
- ASSERT_EQ(c, TestFixture::as_string("foo"));
- c = a;
- c.remove_suffix(0);
- ASSERT_EQ(c, a);
- c.remove_suffix(c.size());
- ASSERT_EQ(c, e);
-
- // set
- c.set(foobar.c_str());
- ASSERT_EQ(c, a);
- c.set(foobar.c_str(), 6);
- ASSERT_EQ(c, a);
- c.set(foobar.c_str(), 0);
- ASSERT_EQ(c, e);
- c.set(foobar.c_str(), 7); // Note, has an embedded NULL
- ASSERT_NE(c, a);
-
- // as_string
- TypeParam s3(a.as_string().c_str(), 7); // Note, has an embedded NULL
- ASSERT_EQ(c, s3);
- TypeParam s4(e.as_string());
- ASSERT_TRUE(s4.empty());
-
- // operator STRING_TYPE()
- TypeParam s5(TypeParam(a).c_str(), 7); // Note, has an embedded NULL
- ASSERT_EQ(c, s5);
- TypeParam s6(e);
- ASSERT_TRUE(s6.empty());
-}
-
-TEST(StringPieceTest, CheckCustom) {
- StringPiece a("foobar");
- std::string s1("123");
- s1 += '\0';
- s1 += "456";
- StringPiece b(s1);
- StringPiece e;
- std::string s2;
-
- // CopyToString
- a.CopyToString(&s2);
- ASSERT_EQ(s2.size(), 6U);
- ASSERT_EQ(s2, "foobar");
- b.CopyToString(&s2);
- ASSERT_EQ(s2.size(), 7U);
- ASSERT_EQ(s1, s2);
- e.CopyToString(&s2);
- ASSERT_TRUE(s2.empty());
-
- // AppendToString
- s2.erase();
- a.AppendToString(&s2);
- ASSERT_EQ(s2.size(), 6U);
- ASSERT_EQ(s2, "foobar");
- a.AppendToString(&s2);
- ASSERT_EQ(s2.size(), 12U);
- ASSERT_EQ(s2, "foobarfoobar");
-
- // starts_with
- ASSERT_TRUE(a.starts_with(a));
- ASSERT_TRUE(a.starts_with("foo"));
- ASSERT_TRUE(a.starts_with(e));
- ASSERT_TRUE(b.starts_with(s1));
- ASSERT_TRUE(b.starts_with(b));
- ASSERT_TRUE(b.starts_with(e));
- ASSERT_TRUE(e.starts_with(""));
- ASSERT_TRUE(!a.starts_with(b));
- ASSERT_TRUE(!b.starts_with(a));
- ASSERT_TRUE(!e.starts_with(a));
-
- // ends with
- ASSERT_TRUE(a.ends_with(a));
- ASSERT_TRUE(a.ends_with("bar"));
- ASSERT_TRUE(a.ends_with(e));
- ASSERT_TRUE(b.ends_with(s1));
- ASSERT_TRUE(b.ends_with(b));
- ASSERT_TRUE(b.ends_with(e));
- ASSERT_TRUE(e.ends_with(""));
- ASSERT_TRUE(!a.ends_with(b));
- ASSERT_TRUE(!b.ends_with(a));
- ASSERT_TRUE(!e.ends_with(a));
-
- StringPiece c;
- c.set("foobar", 6);
- ASSERT_EQ(c, a);
- c.set("foobar", 0);
- ASSERT_EQ(c, e);
- c.set("foobar", 7);
- ASSERT_NE(c, a);
-}
-
-TYPED_TEST(CommonStringPieceTest, CheckNULL) {
- // we used to crash here, but now we don't.
- BasicStringPiece<TypeParam> s(nullptr);
- ASSERT_EQ(s.data(), nullptr);
- ASSERT_EQ(s.size(), 0U);
-
- s.set(nullptr);
- ASSERT_EQ(s.data(), nullptr);
- ASSERT_EQ(s.size(), 0U);
-
- TypeParam str(s);
- ASSERT_EQ(str.length(), 0U);
- ASSERT_EQ(str, TypeParam());
-
- str = s.as_string();
- ASSERT_EQ(str.length(), 0U);
- ASSERT_EQ(str, TypeParam());
-}
-
-TYPED_TEST(CommonStringPieceTest, CheckComparisons2) {
- TypeParam alphabet(TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
- TypeParam alphabet_z(TestFixture::as_string("abcdefghijklmnopqrstuvwxyzz"));
- TypeParam alphabet_y(TestFixture::as_string("abcdefghijklmnopqrstuvwxyy"));
- BasicStringPiece<TypeParam> abc(alphabet);
-
- // check comparison operations on strings longer than 4 bytes.
- ASSERT_EQ(abc, BasicStringPiece<TypeParam>(alphabet));
- ASSERT_EQ(abc.compare(BasicStringPiece<TypeParam>(alphabet)), 0);
-
- ASSERT_TRUE(abc < BasicStringPiece<TypeParam>(alphabet_z));
- ASSERT_LT(abc.compare(BasicStringPiece<TypeParam>(alphabet_z)), 0);
-
- ASSERT_TRUE(abc > BasicStringPiece<TypeParam>(alphabet_y));
- ASSERT_GT(abc.compare(BasicStringPiece<TypeParam>(alphabet_y)), 0);
-}
-
-// Test operations only supported by std::string version.
-TEST(StringPieceTest, CheckComparisons2) {
- StringPiece abc("abcdefghijklmnopqrstuvwxyz");
-
- // starts_with
- ASSERT_TRUE(abc.starts_with(abc));
- ASSERT_TRUE(abc.starts_with("abcdefghijklm"));
- ASSERT_TRUE(!abc.starts_with("abcdefguvwxyz"));
-
- // ends_with
- ASSERT_TRUE(abc.ends_with(abc));
- ASSERT_TRUE(!abc.ends_with("abcdefguvwxyz"));
- ASSERT_TRUE(abc.ends_with("nopqrstuvwxyz"));
-}
-
-TYPED_TEST(CommonStringPieceTest, StringCompareNotAmbiguous) {
- ASSERT_TRUE(TestFixture::as_string("hello").c_str() ==
- TestFixture::as_string("hello"));
- ASSERT_TRUE(TestFixture::as_string("hello").c_str() <
- TestFixture::as_string("world"));
-}
-
-TYPED_TEST(CommonStringPieceTest, HeterogenousStringPieceEquals) {
- TypeParam hello(TestFixture::as_string("hello"));
-
- ASSERT_EQ(BasicStringPiece<TypeParam>(hello), hello);
- ASSERT_EQ(hello.c_str(), BasicStringPiece<TypeParam>(hello));
-}
-
-// string16-specific stuff
-TEST(StringPiece16Test, CheckSTL) {
- // Check some non-ascii characters.
- string16 fifth(ASCIIToUTF16("123"));
- fifth.push_back(0x0000);
- fifth.push_back(0xd8c5);
- fifth.push_back(0xdffe);
- StringPiece16 f(fifth);
-
- ASSERT_EQ(f[3], '\0');
- ASSERT_EQ(f[5], static_cast<char16>(0xdffe));
-
- ASSERT_EQ(f.size(), 6U);
-}
-
-
-
-TEST(StringPiece16Test, CheckConversion) {
- // Make sure that we can convert from UTF8 to UTF16 and back. We use a two
- // byte character (G clef) to test this.
- ASSERT_EQ(
- UTF16ToUTF8(
- StringPiece16(UTF8ToUTF16("\xf0\x9d\x84\x9e")).as_string()),
- "\xf0\x9d\x84\x9e");
-}
-
-TYPED_TEST(CommonStringPieceTest, CheckConstructors) {
- TypeParam str(TestFixture::as_string("hello world"));
- TypeParam empty;
-
- ASSERT_EQ(str, BasicStringPiece<TypeParam>(str));
- ASSERT_EQ(str, BasicStringPiece<TypeParam>(str.c_str()));
- ASSERT_TRUE(TestFixture::as_string("hello") ==
- BasicStringPiece<TypeParam>(str.c_str(), 5));
- ASSERT_EQ(
- empty,
- BasicStringPiece<TypeParam>(
- str.c_str(),
- static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
- ASSERT_EQ(empty, BasicStringPiece<TypeParam>(nullptr));
- ASSERT_TRUE(
- empty ==
- BasicStringPiece<TypeParam>(
- nullptr,
- static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
- ASSERT_EQ(empty, BasicStringPiece<TypeParam>());
- ASSERT_EQ(str, BasicStringPiece<TypeParam>(str.begin(), str.end()));
- ASSERT_EQ(empty, BasicStringPiece<TypeParam>(str.begin(), str.begin()));
- ASSERT_EQ(empty, BasicStringPiece<TypeParam>(empty));
- ASSERT_EQ(empty, BasicStringPiece<TypeParam>(empty.begin(), empty.end()));
-}
-
-TEST(StringPieceTest, ConstexprCtor) {
- {
- constexpr StringPiece piece;
- std::ignore = piece;
- }
-
- {
- constexpr StringPiece piece("abc");
- std::ignore = piece;
- }
-
- {
- constexpr StringPiece piece("abc", 2);
- std::ignore = piece;
- }
-}
-
-TEST(StringPieceTest, ConstexprData) {
- {
- constexpr StringPiece piece;
- static_assert(piece.data() == nullptr, "");
- }
-
- {
- constexpr StringPiece piece("abc");
- static_assert(piece.data()[0] == 'a', "");
- static_assert(piece.data()[1] == 'b', "");
- static_assert(piece.data()[2] == 'c', "");
- }
-
- {
- constexpr StringPiece piece("def", 2);
- static_assert(piece.data()[0] == 'd', "");
- static_assert(piece.data()[1] == 'e', "");
- }
-}
-
-TEST(StringPieceTest, ConstexprSize) {
- {
- constexpr StringPiece piece;
- static_assert(piece.size() == 0, "");
- }
-
- {
- constexpr StringPiece piece("abc");
- static_assert(piece.size() == 3, "");
- }
-
- {
- constexpr StringPiece piece("def", 2);
- static_assert(piece.size() == 2, "");
- }
-}
-
-TEST(StringPieceTest, Compare) {
- constexpr StringPiece piece = "def";
-
- static_assert(piece.compare("ab") == 1, "");
- static_assert(piece.compare("abc") == 1, "");
- static_assert(piece.compare("abcd") == 1, "");
- static_assert(piece.compare("de") == 1, "");
- static_assert(piece.compare("def") == 0, "");
- static_assert(piece.compare("defg") == -1, "");
- static_assert(piece.compare("gh") == -1, "");
- static_assert(piece.compare("ghi") == -1, "");
- static_assert(piece.compare("ghij") == -1, "");
-}
-
-TEST(StringPieceTest, StartsWith) {
- constexpr StringPiece piece("abc");
-
- static_assert(piece.starts_with(""), "");
- static_assert(piece.starts_with("a"), "");
- static_assert(piece.starts_with("ab"), "");
- static_assert(piece.starts_with("abc"), "");
-
- static_assert(!piece.starts_with("b"), "");
- static_assert(!piece.starts_with("bc"), "");
-
- static_assert(!piece.starts_with("abcd"), "");
-}
-
-TEST(StringPieceTest, EndsWith) {
- constexpr StringPiece piece("abc");
-
- static_assert(piece.ends_with(""), "");
- static_assert(piece.ends_with("c"), "");
- static_assert(piece.ends_with("bc"), "");
- static_assert(piece.ends_with("abc"), "");
-
- static_assert(!piece.ends_with("a"), "");
- static_assert(!piece.ends_with("ab"), "");
-
- static_assert(!piece.ends_with("abcd"), "");
-}
-
-} // namespace base
diff --git a/base/strings/string_split_unittest.cc b/base/strings/string_split_unittest.cc
deleted file mode 100644
index bf09aa5..0000000
--- a/base/strings/string_split_unittest.cc
+++ /dev/null
@@ -1,386 +0,0 @@
-// 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.
-
-#include "base/strings/string_split.h"
-
-#include <stddef.h>
-
-#include "base/macros.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::ElementsAre;
-
-namespace base {
-
-class SplitStringIntoKeyValuePairsTest : public testing::Test {
- protected:
- base::StringPairs kv_pairs;
-};
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(),
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- EXPECT_TRUE(kv_pairs.empty());
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, MissingKeyValueDelimiter) {
- EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1,key2:value2",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_TRUE(kv_pairs[0].first.empty());
- EXPECT_TRUE(kv_pairs[0].second.empty());
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptyKeyWithKeyValueDelimiter) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs(":value1,key2:value2",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_TRUE(kv_pairs[0].first.empty());
- EXPECT_EQ("value1", kv_pairs[0].second);
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, TrailingAndLeadingPairDelimiter) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs(",key1:value1,key2:value2,",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ("key1", kv_pairs[0].first);
- EXPECT_EQ("value1", kv_pairs[0].second);
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptyPair) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ("key1", kv_pairs[0].first);
- EXPECT_EQ("value1", kv_pairs[0].second);
- EXPECT_EQ("key3", kv_pairs[1].first);
- EXPECT_EQ("value3", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptyValue) {
- EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1:,key2:value2",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ("key1", kv_pairs[0].first);
- EXPECT_EQ("", kv_pairs[0].second);
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, UntrimmedWhitespace) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1 : value1",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(1U, kv_pairs.size());
- EXPECT_EQ("key1 ", kv_pairs[0].first);
- EXPECT_EQ(" value1", kv_pairs[0].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, TrimmedWhitespace) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1 , key2:value2",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ("key1", kv_pairs[0].first);
- EXPECT_EQ("value1", kv_pairs[0].second);
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, MultipleKeyValueDelimiters) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:::value1,key2:value2",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ("key1", kv_pairs[0].first);
- EXPECT_EQ("value1", kv_pairs[0].second);
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, OnlySplitAtGivenSeparator) {
- std::string a("a ?!@#$%^&*()_+:/{}\\\t\nb");
- EXPECT_TRUE(SplitStringIntoKeyValuePairs(a + "X" + a + "Y" + a + "X" + a,
- 'X', // Key-value delimiter
- 'Y', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ(a, kv_pairs[0].first);
- EXPECT_EQ(a, kv_pairs[0].second);
- EXPECT_EQ(a, kv_pairs[1].first);
- EXPECT_EQ(a, kv_pairs[1].second);
-}
-
-
-TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) {
- EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1,key2:value2",
- ':', // Key-value delimiter
- ',', // Key-value pair delimiter
- &kv_pairs));
- ASSERT_EQ(2U, kv_pairs.size());
- EXPECT_EQ("key1", kv_pairs[0].first);
- EXPECT_EQ("va:ue1", kv_pairs[0].second);
- EXPECT_EQ("key2", kv_pairs[1].first);
- EXPECT_EQ("value2", kv_pairs[1].second);
-}
-
-TEST(SplitStringUsingSubstrTest, EmptyString) {
- std::vector<std::string> results = SplitStringUsingSubstr(
- std::string(), "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(1u, results.size());
- EXPECT_THAT(results, ElementsAre(""));
-}
-
-TEST(StringUtilTest, SplitString_Basics) {
- std::vector<std::string> r;
-
- r = SplitString(std::string(), ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- EXPECT_TRUE(r.empty());
-
- // Empty separator list
- r = SplitString("hello, world", "", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(1u, r.size());
- EXPECT_EQ("hello, world", r[0]);
-
- // Should split on any of the separators.
- r = SplitString("::,,;;", ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(7u, r.size());
- for (auto str : r)
- ASSERT_TRUE(str.empty());
-
- r = SplitString("red, green; blue:", ",:;", TRIM_WHITESPACE,
- SPLIT_WANT_NONEMPTY);
- ASSERT_EQ(3u, r.size());
- EXPECT_EQ("red", r[0]);
- EXPECT_EQ("green", r[1]);
- EXPECT_EQ("blue", r[2]);
-
- // Want to split a string along whitespace sequences.
- r = SplitString(" red green \tblue\n", " \t\n", TRIM_WHITESPACE,
- SPLIT_WANT_NONEMPTY);
- ASSERT_EQ(3u, r.size());
- EXPECT_EQ("red", r[0]);
- EXPECT_EQ("green", r[1]);
- EXPECT_EQ("blue", r[2]);
-
- // Weird case of splitting on spaces but not trimming.
- r = SplitString(" red ", " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(3u, r.size());
- EXPECT_EQ("", r[0]); // Before the first space.
- EXPECT_EQ("red", r[1]);
- EXPECT_EQ("", r[2]); // After the last space.
-}
-
-TEST(StringUtilTest, SplitString_WhitespaceAndResultType) {
- std::vector<std::string> r;
-
- // Empty input handling.
- r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- EXPECT_TRUE(r.empty());
- r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
- EXPECT_TRUE(r.empty());
-
- // Input string is space and we're trimming.
- r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(1u, r.size());
- EXPECT_EQ("", r[0]);
- r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
- EXPECT_TRUE(r.empty());
-
- // Test all 4 combinations of flags on ", ,".
- r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(3u, r.size());
- EXPECT_EQ("", r[0]);
- EXPECT_EQ(" ", r[1]);
- EXPECT_EQ("", r[2]);
- r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
- ASSERT_EQ(1u, r.size());
- ASSERT_EQ(" ", r[0]);
- r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(3u, r.size());
- EXPECT_EQ("", r[0]);
- EXPECT_EQ("", r[1]);
- EXPECT_EQ("", r[2]);
- r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
- ASSERT_TRUE(r.empty());
-}
-
-TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) {
- std::vector<std::string> results = SplitStringUsingSubstr(
- "alongwordwithnodelimiter", "DELIMITER", TRIM_WHITESPACE,
- SPLIT_WANT_ALL);
- ASSERT_EQ(1u, results.size());
- EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter"));
-}
-
-TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) {
- std::vector<std::string> results = SplitStringUsingSubstr(
- "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree",
- "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(6u, results.size());
- EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three"));
-}
-
-TEST(SplitStringUsingSubstrTest, ConsecutiveDelimitersSkipped) {
- std::vector<std::string> results = SplitStringUsingSubstr(
- "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro",
- "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(7u, results.size());
- EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro"));
-}
-
-TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) {
- std::vector<std::string> results = SplitStringUsingSubstr(
- "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
- "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(7u, results.size());
- EXPECT_THAT(
- results, ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, StringWithNoDelimiter) {
- std::vector<base::StringPiece> results =
- SplitStringPieceUsingSubstr("alongwordwithnodelimiter", "DELIMITER",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(1u, results.size());
- EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter"));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, LeadingDelimitersSkipped) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree", "DELIMITER",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(6u, results.size());
- EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three"));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, ConsecutiveDelimitersSkipped) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro",
- "DELIMITER", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(7u, results.size());
- EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro"));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, TrailingDelimitersSkipped) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
- "DELIMITER", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(7u, results.size());
- EXPECT_THAT(results,
- ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, KeepWhitespace) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "un DELIMITERdeux\tDELIMITERtrois\nDELIMITERquatre", "DELIMITER",
- base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(4u, results.size());
- EXPECT_THAT(results, ElementsAre("un ", "deux\t", "trois\n", "quatre"));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, TrimWhitespace) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "un DELIMITERdeux\tDELIMITERtrois\nDELIMITERquatre", "DELIMITER",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(4u, results.size());
- EXPECT_THAT(results, ElementsAre("un", "deux", "trois", "quatre"));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, SplitWantAll) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "unDELIMITERdeuxDELIMITERtroisDELIMITERDELIMITER", "DELIMITER",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(5u, results.size());
- EXPECT_THAT(results, ElementsAre("un", "deux", "trois", "", ""));
-}
-
-TEST(SplitStringPieceUsingSubstrTest, SplitWantNonEmpty) {
- std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
- "unDELIMITERdeuxDELIMITERtroisDELIMITERDELIMITER", "DELIMITER",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
- ASSERT_EQ(3u, results.size());
- EXPECT_THAT(results, ElementsAre("un", "deux", "trois"));
-}
-
-TEST(StringSplitTest, StringSplitKeepWhitespace) {
- std::vector<std::string> r;
-
- r = SplitString(" ", "*", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
- ASSERT_EQ(1U, r.size());
- EXPECT_EQ(r[0], " ");
-
- r = SplitString("\t \ta\t ", "\t", base::KEEP_WHITESPACE,
- base::SPLIT_WANT_ALL);
- ASSERT_EQ(4U, r.size());
- EXPECT_EQ(r[0], "");
- EXPECT_EQ(r[1], " ");
- EXPECT_EQ(r[2], "a");
- EXPECT_EQ(r[3], " ");
-
- r = SplitString("\ta\t\nb\tcc", "\n", base::KEEP_WHITESPACE,
- base::SPLIT_WANT_ALL);
- ASSERT_EQ(2U, r.size());
- EXPECT_EQ(r[0], "\ta\t");
- EXPECT_EQ(r[1], "b\tcc");
-}
-
-TEST(StringSplitTest, SplitStringAlongWhitespace) {
- struct TestData {
- const char* input;
- const size_t expected_result_count;
- const char* output1;
- const char* output2;
- } data[] = {
- { "a", 1, "a", "" },
- { " ", 0, "", "" },
- { " a", 1, "a", "" },
- { " ab ", 1, "ab", "" },
- { " ab c", 2, "ab", "c" },
- { " ab c ", 2, "ab", "c" },
- { " ab cd", 2, "ab", "cd" },
- { " ab cd ", 2, "ab", "cd" },
- { " \ta\t", 1, "a", "" },
- { " b\ta\t", 2, "b", "a" },
- { " b\tat", 2, "b", "at" },
- { "b\tat", 2, "b", "at" },
- { "b\t at", 2, "b", "at" },
- };
- for (size_t i = 0; i < arraysize(data); ++i) {
- std::vector<std::string> results = base::SplitString(
- data[i].input, kWhitespaceASCII, base::KEEP_WHITESPACE,
- base::SPLIT_WANT_NONEMPTY);
- ASSERT_EQ(data[i].expected_result_count, results.size());
- if (data[i].expected_result_count > 0)
- ASSERT_EQ(data[i].output1, results[0]);
- if (data[i].expected_result_count > 1)
- ASSERT_EQ(data[i].output2, results[1]);
- }
-}
-
-} // namespace base
diff --git a/base/strings/string_tokenizer_unittest.cc b/base/strings/string_tokenizer_unittest.cc
deleted file mode 100644
index d391845..0000000
--- a/base/strings/string_tokenizer_unittest.cc
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright (c) 2006-2008 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 "base/strings/string_tokenizer.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-using std::string;
-
-namespace base {
-
-namespace {
-
-TEST(StringTokenizerTest, Simple) {
- string input = "this is a test";
- StringTokenizer t(input, " ");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("this"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("is"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("a"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("test"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, Reset) {
- string input = "this is a test";
- StringTokenizer t(input, " ");
-
- for (int i = 0; i < 2; ++i) {
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("this"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("is"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("a"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("test"), t.token());
-
- EXPECT_FALSE(t.GetNext());
- t.Reset();
- }
-}
-
-TEST(StringTokenizerTest, RetDelims) {
- string input = "this is a test";
- StringTokenizer t(input, " ");
- t.set_options(StringTokenizer::RETURN_DELIMS);
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("this"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string(" "), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("is"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string(" "), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("a"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string(" "), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("test"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, ManyDelims) {
- string input = "this: is, a-test";
- StringTokenizer t(input, ": ,-");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("this"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("is"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("a"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("test"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, ParseHeader) {
- string input = "Content-Type: text/html ; charset=UTF-8";
- StringTokenizer t(input, ": ;=");
- t.set_options(StringTokenizer::RETURN_DELIMS);
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_FALSE(t.token_is_delim());
- EXPECT_EQ(string("Content-Type"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_TRUE(t.token_is_delim());
- EXPECT_EQ(string(":"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_TRUE(t.token_is_delim());
- EXPECT_EQ(string(" "), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_FALSE(t.token_is_delim());
- EXPECT_EQ(string("text/html"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_TRUE(t.token_is_delim());
- EXPECT_EQ(string(" "), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_TRUE(t.token_is_delim());
- EXPECT_EQ(string(";"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_TRUE(t.token_is_delim());
- EXPECT_EQ(string(" "), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_FALSE(t.token_is_delim());
- EXPECT_EQ(string("charset"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_TRUE(t.token_is_delim());
- EXPECT_EQ(string("="), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_FALSE(t.token_is_delim());
- EXPECT_EQ(string("UTF-8"), t.token());
-
- EXPECT_FALSE(t.GetNext());
- EXPECT_FALSE(t.token_is_delim());
-}
-
-TEST(StringTokenizerTest, ParseQuotedString) {
- string input = "foo bar 'hello world' baz";
- StringTokenizer t(input, " ");
- t.set_quote_chars("'");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("foo"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("bar"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("'hello world'"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("baz"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, ParseQuotedString_Malformed) {
- string input = "bar 'hello wo";
- StringTokenizer t(input, " ");
- t.set_quote_chars("'");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("bar"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("'hello wo"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, ParseQuotedString_Multiple) {
- string input = "bar 'hel\"lo\" wo' baz\"";
- StringTokenizer t(input, " ");
- t.set_quote_chars("'\"");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("bar"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("'hel\"lo\" wo'"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("baz\""), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, ParseQuotedString_EscapedQuotes) {
- string input = "foo 'don\\'t do that'";
- StringTokenizer t(input, " ");
- t.set_quote_chars("'");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("foo"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("'don\\'t do that'"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-TEST(StringTokenizerTest, ParseQuotedString_EscapedQuotes2) {
- string input = "foo='a, b', bar";
- StringTokenizer t(input, ", ");
- t.set_quote_chars("'");
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("foo='a, b'"), t.token());
-
- EXPECT_TRUE(t.GetNext());
- EXPECT_EQ(string("bar"), t.token());
-
- EXPECT_FALSE(t.GetNext());
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
deleted file mode 100644
index 509889e..0000000
--- a/base/strings/string_util_unittest.cc
+++ /dev/null
@@ -1,1379 +0,0 @@
-// Copyright 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 "base/strings/string_util.h"
-
-#include <math.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::ElementsAre;
-
-namespace base {
-
-static const struct trim_case {
- const wchar_t* input;
- const TrimPositions positions;
- const wchar_t* output;
- const TrimPositions return_value;
-} trim_cases[] = {
- {L" Google Video ", TRIM_LEADING, L"Google Video ", TRIM_LEADING},
- {L" Google Video ", TRIM_TRAILING, L" Google Video", TRIM_TRAILING},
- {L" Google Video ", TRIM_ALL, L"Google Video", TRIM_ALL},
- {L"Google Video", TRIM_ALL, L"Google Video", TRIM_NONE},
- {L"", TRIM_ALL, L"", TRIM_NONE},
- {L" ", TRIM_LEADING, L"", TRIM_LEADING},
- {L" ", TRIM_TRAILING, L"", TRIM_TRAILING},
- {L" ", TRIM_ALL, L"", TRIM_ALL},
- {L"\t\rTest String\n", TRIM_ALL, L"Test String", TRIM_ALL},
- {L"\x2002Test String\x00A0\x3000", TRIM_ALL, L"Test String", TRIM_ALL},
-};
-
-static const struct trim_case_ascii {
- const char* input;
- const TrimPositions positions;
- const char* output;
- const TrimPositions return_value;
-} trim_cases_ascii[] = {
- {" Google Video ", TRIM_LEADING, "Google Video ", TRIM_LEADING},
- {" Google Video ", TRIM_TRAILING, " Google Video", TRIM_TRAILING},
- {" Google Video ", TRIM_ALL, "Google Video", TRIM_ALL},
- {"Google Video", TRIM_ALL, "Google Video", TRIM_NONE},
- {"", TRIM_ALL, "", TRIM_NONE},
- {" ", TRIM_LEADING, "", TRIM_LEADING},
- {" ", TRIM_TRAILING, "", TRIM_TRAILING},
- {" ", TRIM_ALL, "", TRIM_ALL},
- {"\t\rTest String\n", TRIM_ALL, "Test String", TRIM_ALL},
-};
-
-namespace {
-
-// Helper used to test TruncateUTF8ToByteSize.
-bool Truncated(const std::string& input,
- const size_t byte_size,
- std::string* output) {
- size_t prev = input.length();
- TruncateUTF8ToByteSize(input, byte_size, output);
- return prev != output->length();
-}
-
-} // namespace
-
-TEST(StringUtilTest, TruncateUTF8ToByteSize) {
- std::string output;
-
- // Empty strings and invalid byte_size arguments
- EXPECT_FALSE(Truncated(std::string(), 0, &output));
- EXPECT_EQ(output, "");
- EXPECT_TRUE(Truncated("\xe1\x80\xbf", 0, &output));
- EXPECT_EQ(output, "");
- EXPECT_FALSE(Truncated("\xe1\x80\xbf", static_cast<size_t>(-1), &output));
- EXPECT_FALSE(Truncated("\xe1\x80\xbf", 4, &output));
-
- // Testing the truncation of valid UTF8 correctly
- EXPECT_TRUE(Truncated("abc", 2, &output));
- EXPECT_EQ(output, "ab");
- EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 2, &output));
- EXPECT_EQ(output.compare("\xc2\x81"), 0);
- EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 3, &output));
- EXPECT_EQ(output.compare("\xc2\x81"), 0);
- EXPECT_FALSE(Truncated("\xc2\x81\xc2\x81", 4, &output));
- EXPECT_EQ(output.compare("\xc2\x81\xc2\x81"), 0);
-
- {
- const char array[] = "\x00\x00\xc2\x81\xc2\x81";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\x00\x00\xc2\x81", 4)), 0);
- }
-
- {
- const char array[] = "\x00\xc2\x81\xc2\x81";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\x00\xc2\x81", 3)), 0);
- }
-
- // Testing invalid UTF8
- EXPECT_TRUE(Truncated("\xed\xa0\x80\xed\xbf\xbf", 6, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xed\xa0\x8f", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xed\xbf\xbf", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // Testing invalid UTF8 mixed with valid UTF8
- EXPECT_FALSE(Truncated("\xe1\x80\xbf", 3, &output));
- EXPECT_EQ(output.compare("\xe1\x80\xbf"), 0);
- EXPECT_FALSE(Truncated("\xf1\x80\xa0\xbf", 4, &output));
- EXPECT_EQ(output.compare("\xf1\x80\xa0\xbf"), 0);
- EXPECT_FALSE(Truncated("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf",
- 10, &output));
- EXPECT_EQ(output.compare("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"), 0);
- EXPECT_TRUE(Truncated("a\xc2\x81\xe1\x80\xbf\xf1""a""\x80\xa0",
- 10, &output));
- EXPECT_EQ(output.compare("a\xc2\x81\xe1\x80\xbf\xf1""a"), 0);
- EXPECT_FALSE(Truncated("\xef\xbb\xbf" "abc", 6, &output));
- EXPECT_EQ(output.compare("\xef\xbb\xbf" "abc"), 0);
-
- // Overlong sequences
- EXPECT_TRUE(Truncated("\xc0\x80", 2, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xc1\x80\xc1\x81", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xe0\x80\x80", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xe0\x82\x80", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xe0\x9f\xbf", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x80\x80\x8D", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x80\x82\x91", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x80\xa0\x80", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x8f\xbb\xbf", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf8\x80\x80\x80\xbf", 5, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xfc\x80\x80\x80\xa0\xa5", 6, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // Beyond U+10FFFF (the upper limit of Unicode codespace)
- EXPECT_TRUE(Truncated("\xf4\x90\x80\x80", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf8\xa0\xbf\x80\xbf", 5, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xfc\x9c\xbf\x80\xbf\x80", 6, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // BOMs in UTF-16(BE|LE) and UTF-32(BE|LE)
- EXPECT_TRUE(Truncated("\xfe\xff", 2, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xff\xfe", 2, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- {
- const char array[] = "\x00\x00\xfe\xff";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\x00\x00", 2)), 0);
- }
-
- // Variants on the previous test
- {
- const char array[] = "\xff\xfe\x00\x00";
- const std::string array_string(array, 4);
- EXPECT_FALSE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\xff\xfe\x00\x00", 4)), 0);
- }
- {
- const char array[] = "\xff\x00\x00\xfe";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\xff\x00\x00", 3)), 0);
- }
-
- // Non-characters : U+xxFFF[EF] where xx is 0x00 through 0x10 and <FDD0,FDEF>
- EXPECT_TRUE(Truncated("\xef\xbf\xbe", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x8f\xbf\xbe", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf3\xbf\xbf\xbf", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xef\xb7\x90", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xef\xb7\xaf", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // Strings in legacy encodings that are valid in UTF-8, but
- // are invalid as UTF-8 in real data.
- EXPECT_TRUE(Truncated("caf\xe9", 4, &output));
- EXPECT_EQ(output.compare("caf"), 0);
- EXPECT_TRUE(Truncated("\xb0\xa1\xb0\xa2", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_FALSE(Truncated("\xa7\x41\xa6\x6e", 4, &output));
- EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
- EXPECT_TRUE(Truncated("\xa7\x41\xa6\x6e\xd9\xee\xe4\xee", 7,
- &output));
- EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
-
- // Testing using the same string as input and output.
- EXPECT_FALSE(Truncated(output, 4, &output));
- EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
- EXPECT_TRUE(Truncated(output, 3, &output));
- EXPECT_EQ(output.compare("\xa7\x41"), 0);
-
- // "abc" with U+201[CD] in windows-125[0-8]
- EXPECT_TRUE(Truncated("\x93" "abc\x94", 5, &output));
- EXPECT_EQ(output.compare("\x93" "abc"), 0);
-
- // U+0639 U+064E U+0644 U+064E in ISO-8859-6
- EXPECT_TRUE(Truncated("\xd9\xee\xe4\xee", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
- EXPECT_TRUE(Truncated("\xe3\xe5\xe9\xdC", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
-}
-
-TEST(StringUtilTest, TrimWhitespace) {
- string16 output; // Allow contents to carry over to next testcase
- for (size_t i = 0; i < arraysize(trim_cases); ++i) {
- const trim_case& value = trim_cases[i];
- EXPECT_EQ(value.return_value,
- TrimWhitespace(WideToUTF16(value.input), value.positions,
- &output));
- EXPECT_EQ(WideToUTF16(value.output), output);
- }
-
- // Test that TrimWhitespace() can take the same string for input and output
- output = ASCIIToUTF16(" This is a test \r\n");
- EXPECT_EQ(TRIM_ALL, TrimWhitespace(output, TRIM_ALL, &output));
- EXPECT_EQ(ASCIIToUTF16("This is a test"), output);
-
- // Once more, but with a string of whitespace
- output = ASCIIToUTF16(" \r\n");
- EXPECT_EQ(TRIM_ALL, TrimWhitespace(output, TRIM_ALL, &output));
- EXPECT_EQ(string16(), output);
-
- std::string output_ascii;
- for (size_t i = 0; i < arraysize(trim_cases_ascii); ++i) {
- const trim_case_ascii& value = trim_cases_ascii[i];
- EXPECT_EQ(value.return_value,
- TrimWhitespaceASCII(value.input, value.positions, &output_ascii));
- EXPECT_EQ(value.output, output_ascii);
- }
-}
-
-static const struct collapse_case {
- const wchar_t* input;
- const bool trim;
- const wchar_t* output;
-} collapse_cases[] = {
- {L" Google Video ", false, L"Google Video"},
- {L"Google Video", false, L"Google Video"},
- {L"", false, L""},
- {L" ", false, L""},
- {L"\t\rTest String\n", false, L"Test String"},
- {L"\x2002Test String\x00A0\x3000", false, L"Test String"},
- {L" Test \n \t String ", false, L"Test String"},
- {L"\x2002Test\x1680 \x2028 \tString\x00A0\x3000", false, L"Test String"},
- {L" Test String", false, L"Test String"},
- {L"Test String ", false, L"Test String"},
- {L"Test String", false, L"Test String"},
- {L"", true, L""},
- {L"\n", true, L""},
- {L" \r ", true, L""},
- {L"\nFoo", true, L"Foo"},
- {L"\r Foo ", true, L"Foo"},
- {L" Foo bar ", true, L"Foo bar"},
- {L" \tFoo bar \n", true, L"Foo bar"},
- {L" a \r b\n c \r\n d \t\re \t f \n ", true, L"abcde f"},
-};
-
-TEST(StringUtilTest, CollapseWhitespace) {
- for (size_t i = 0; i < arraysize(collapse_cases); ++i) {
- const collapse_case& value = collapse_cases[i];
- EXPECT_EQ(WideToUTF16(value.output),
- CollapseWhitespace(WideToUTF16(value.input), value.trim));
- }
-}
-
-static const struct collapse_case_ascii {
- const char* input;
- const bool trim;
- const char* output;
-} collapse_cases_ascii[] = {
- {" Google Video ", false, "Google Video"},
- {"Google Video", false, "Google Video"},
- {"", false, ""},
- {" ", false, ""},
- {"\t\rTest String\n", false, "Test String"},
- {" Test \n \t String ", false, "Test String"},
- {" Test String", false, "Test String"},
- {"Test String ", false, "Test String"},
- {"Test String", false, "Test String"},
- {"", true, ""},
- {"\n", true, ""},
- {" \r ", true, ""},
- {"\nFoo", true, "Foo"},
- {"\r Foo ", true, "Foo"},
- {" Foo bar ", true, "Foo bar"},
- {" \tFoo bar \n", true, "Foo bar"},
- {" a \r b\n c \r\n d \t\re \t f \n ", true, "abcde f"},
-};
-
-TEST(StringUtilTest, CollapseWhitespaceASCII) {
- for (size_t i = 0; i < arraysize(collapse_cases_ascii); ++i) {
- const collapse_case_ascii& value = collapse_cases_ascii[i];
- EXPECT_EQ(value.output, CollapseWhitespaceASCII(value.input, value.trim));
- }
-}
-
-TEST(StringUtilTest, IsStringUTF8) {
- EXPECT_TRUE(IsStringUTF8("abc"));
- EXPECT_TRUE(IsStringUTF8("\xc2\x81"));
- EXPECT_TRUE(IsStringUTF8("\xe1\x80\xbf"));
- EXPECT_TRUE(IsStringUTF8("\xf1\x80\xa0\xbf"));
- EXPECT_TRUE(IsStringUTF8("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"));
- EXPECT_TRUE(IsStringUTF8("\xef\xbb\xbf" "abc")); // UTF-8 BOM
-
- // surrogate code points
- EXPECT_FALSE(IsStringUTF8("\xed\xa0\x80\xed\xbf\xbf"));
- EXPECT_FALSE(IsStringUTF8("\xed\xa0\x8f"));
- EXPECT_FALSE(IsStringUTF8("\xed\xbf\xbf"));
-
- // overlong sequences
- EXPECT_FALSE(IsStringUTF8("\xc0\x80")); // U+0000
- EXPECT_FALSE(IsStringUTF8("\xc1\x80\xc1\x81")); // "AB"
- EXPECT_FALSE(IsStringUTF8("\xe0\x80\x80")); // U+0000
- EXPECT_FALSE(IsStringUTF8("\xe0\x82\x80")); // U+0080
- EXPECT_FALSE(IsStringUTF8("\xe0\x9f\xbf")); // U+07ff
- EXPECT_FALSE(IsStringUTF8("\xf0\x80\x80\x8D")); // U+000D
- EXPECT_FALSE(IsStringUTF8("\xf0\x80\x82\x91")); // U+0091
- EXPECT_FALSE(IsStringUTF8("\xf0\x80\xa0\x80")); // U+0800
- EXPECT_FALSE(IsStringUTF8("\xf0\x8f\xbb\xbf")); // U+FEFF (BOM)
- EXPECT_FALSE(IsStringUTF8("\xf8\x80\x80\x80\xbf")); // U+003F
- EXPECT_FALSE(IsStringUTF8("\xfc\x80\x80\x80\xa0\xa5")); // U+00A5
-
- // Beyond U+10FFFF (the upper limit of Unicode codespace)
- EXPECT_FALSE(IsStringUTF8("\xf4\x90\x80\x80")); // U+110000
- EXPECT_FALSE(IsStringUTF8("\xf8\xa0\xbf\x80\xbf")); // 5 bytes
- EXPECT_FALSE(IsStringUTF8("\xfc\x9c\xbf\x80\xbf\x80")); // 6 bytes
-
- // BOMs in UTF-16(BE|LE) and UTF-32(BE|LE)
- EXPECT_FALSE(IsStringUTF8("\xfe\xff"));
- EXPECT_FALSE(IsStringUTF8("\xff\xfe"));
- EXPECT_FALSE(IsStringUTF8(std::string("\x00\x00\xfe\xff", 4)));
- EXPECT_FALSE(IsStringUTF8("\xff\xfe\x00\x00"));
-
- // Non-characters : U+xxFFF[EF] where xx is 0x00 through 0x10 and <FDD0,FDEF>
- EXPECT_FALSE(IsStringUTF8("\xef\xbf\xbe")); // U+FFFE)
- EXPECT_FALSE(IsStringUTF8("\xf0\x8f\xbf\xbe")); // U+1FFFE
- EXPECT_FALSE(IsStringUTF8("\xf3\xbf\xbf\xbf")); // U+10FFFF
- EXPECT_FALSE(IsStringUTF8("\xef\xb7\x90")); // U+FDD0
- EXPECT_FALSE(IsStringUTF8("\xef\xb7\xaf")); // U+FDEF
- // Strings in legacy encodings. We can certainly make up strings
- // in a legacy encoding that are valid in UTF-8, but in real data,
- // most of them are invalid as UTF-8.
- EXPECT_FALSE(IsStringUTF8("caf\xe9")); // cafe with U+00E9 in ISO-8859-1
- EXPECT_FALSE(IsStringUTF8("\xb0\xa1\xb0\xa2")); // U+AC00, U+AC001 in EUC-KR
- EXPECT_FALSE(IsStringUTF8("\xa7\x41\xa6\x6e")); // U+4F60 U+597D in Big5
- // "abc" with U+201[CD] in windows-125[0-8]
- EXPECT_FALSE(IsStringUTF8("\x93" "abc\x94"));
- // U+0639 U+064E U+0644 U+064E in ISO-8859-6
- EXPECT_FALSE(IsStringUTF8("\xd9\xee\xe4\xee"));
- // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
- EXPECT_FALSE(IsStringUTF8("\xe3\xe5\xe9\xdC"));
-
- // Check that we support Embedded Nulls. The first uses the canonical UTF-8
- // representation, and the second uses a 2-byte sequence. The second version
- // is invalid UTF-8 since UTF-8 states that the shortest encoding for a
- // given codepoint must be used.
- static const char kEmbeddedNull[] = "embedded\0null";
- EXPECT_TRUE(IsStringUTF8(
- std::string(kEmbeddedNull, sizeof(kEmbeddedNull))));
- EXPECT_FALSE(IsStringUTF8("embedded\xc0\x80U+0000"));
-}
-
-TEST(StringUtilTest, IsStringASCII) {
- static char char_ascii[] =
- "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
- static char16 char16_ascii[] = {
- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A',
- 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6',
- '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F', 0 };
- static std::wstring wchar_ascii(
- L"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF");
-
- // Test a variety of the fragment start positions and lengths in order to make
- // sure that bit masking in IsStringASCII works correctly.
- // Also, test that a non-ASCII character will be detected regardless of its
- // position inside the string.
- {
- const size_t string_length = arraysize(char_ascii) - 1;
- for (size_t offset = 0; offset < 8; ++offset) {
- for (size_t len = 0, max_len = string_length - offset; len < max_len;
- ++len) {
- EXPECT_TRUE(IsStringASCII(StringPiece(char_ascii + offset, len)));
- for (size_t char_pos = offset; char_pos < len; ++char_pos) {
- char_ascii[char_pos] |= '\x80';
- EXPECT_FALSE(IsStringASCII(StringPiece(char_ascii + offset, len)));
- char_ascii[char_pos] &= ~'\x80';
- }
- }
- }
- }
-
- {
- const size_t string_length = arraysize(char16_ascii) - 1;
- for (size_t offset = 0; offset < 4; ++offset) {
- for (size_t len = 0, max_len = string_length - offset; len < max_len;
- ++len) {
- EXPECT_TRUE(IsStringASCII(StringPiece16(char16_ascii + offset, len)));
- for (size_t char_pos = offset; char_pos < len; ++char_pos) {
- char16_ascii[char_pos] |= 0x80;
- EXPECT_FALSE(
- IsStringASCII(StringPiece16(char16_ascii + offset, len)));
- char16_ascii[char_pos] &= ~0x80;
- // Also test when the upper half is non-zero.
- char16_ascii[char_pos] |= 0x100;
- EXPECT_FALSE(
- IsStringASCII(StringPiece16(char16_ascii + offset, len)));
- char16_ascii[char_pos] &= ~0x100;
- }
- }
- }
- }
-
- {
- const size_t string_length = wchar_ascii.length();
- for (size_t len = 0; len < string_length; ++len) {
- EXPECT_TRUE(IsStringASCII(wchar_ascii.substr(0, len)));
- for (size_t char_pos = 0; char_pos < len; ++char_pos) {
- wchar_ascii[char_pos] |= 0x80;
- EXPECT_FALSE(
- IsStringASCII(wchar_ascii.substr(0, len)));
- wchar_ascii[char_pos] &= ~0x80;
- wchar_ascii[char_pos] |= 0x100;
- EXPECT_FALSE(
- IsStringASCII(wchar_ascii.substr(0, len)));
- wchar_ascii[char_pos] &= ~0x100;
-#if defined(WCHAR_T_IS_UTF32)
- wchar_ascii[char_pos] |= 0x10000;
- EXPECT_FALSE(
- IsStringASCII(wchar_ascii.substr(0, len)));
- wchar_ascii[char_pos] &= ~0x10000;
-#endif // WCHAR_T_IS_UTF32
- }
- }
- }
-}
-
-TEST(StringUtilTest, ConvertASCII) {
- static const char* const char_cases[] = {
- "Google Video",
- "Hello, world\n",
- "0123ABCDwxyz \a\b\t\r\n!+,.~"
- };
-
- static const wchar_t* const wchar_cases[] = {
- L"Google Video",
- L"Hello, world\n",
- L"0123ABCDwxyz \a\b\t\r\n!+,.~"
- };
-
- for (size_t i = 0; i < arraysize(char_cases); ++i) {
- EXPECT_TRUE(IsStringASCII(char_cases[i]));
- string16 utf16 = ASCIIToUTF16(char_cases[i]);
- EXPECT_EQ(WideToUTF16(wchar_cases[i]), utf16);
-
- std::string ascii = UTF16ToASCII(WideToUTF16(wchar_cases[i]));
- EXPECT_EQ(char_cases[i], ascii);
- }
-
- EXPECT_FALSE(IsStringASCII("Google \x80Video"));
-
- // Convert empty strings.
- string16 empty16;
- std::string empty;
- EXPECT_EQ(empty, UTF16ToASCII(empty16));
- EXPECT_EQ(empty16, ASCIIToUTF16(empty));
-
- // Convert strings with an embedded NUL character.
- const char chars_with_nul[] = "test\0string";
- const int length_with_nul = arraysize(chars_with_nul) - 1;
- std::string string_with_nul(chars_with_nul, length_with_nul);
- string16 string16_with_nul = ASCIIToUTF16(string_with_nul);
- EXPECT_EQ(static_cast<string16::size_type>(length_with_nul),
- string16_with_nul.length());
- std::string narrow_with_nul = UTF16ToASCII(string16_with_nul);
- EXPECT_EQ(static_cast<std::string::size_type>(length_with_nul),
- narrow_with_nul.length());
- EXPECT_EQ(0, string_with_nul.compare(narrow_with_nul));
-}
-
-TEST(StringUtilTest, ToLowerASCII) {
- EXPECT_EQ('c', ToLowerASCII('C'));
- EXPECT_EQ('c', ToLowerASCII('c'));
- EXPECT_EQ('2', ToLowerASCII('2'));
-
- EXPECT_EQ(static_cast<char16>('c'), ToLowerASCII(static_cast<char16>('C')));
- EXPECT_EQ(static_cast<char16>('c'), ToLowerASCII(static_cast<char16>('c')));
- EXPECT_EQ(static_cast<char16>('2'), ToLowerASCII(static_cast<char16>('2')));
-
- EXPECT_EQ("cc2", ToLowerASCII("Cc2"));
- EXPECT_EQ(ASCIIToUTF16("cc2"), ToLowerASCII(ASCIIToUTF16("Cc2")));
-}
-
-TEST(StringUtilTest, ToUpperASCII) {
- EXPECT_EQ('C', ToUpperASCII('C'));
- EXPECT_EQ('C', ToUpperASCII('c'));
- EXPECT_EQ('2', ToUpperASCII('2'));
-
- EXPECT_EQ(static_cast<char16>('C'), ToUpperASCII(static_cast<char16>('C')));
- EXPECT_EQ(static_cast<char16>('C'), ToUpperASCII(static_cast<char16>('c')));
- EXPECT_EQ(static_cast<char16>('2'), ToUpperASCII(static_cast<char16>('2')));
-
- EXPECT_EQ("CC2", ToUpperASCII("Cc2"));
- EXPECT_EQ(ASCIIToUTF16("CC2"), ToUpperASCII(ASCIIToUTF16("Cc2")));
-}
-
-TEST(StringUtilTest, LowerCaseEqualsASCII) {
- static const struct {
- const char* src_a;
- const char* dst;
- } lowercase_cases[] = {
- { "FoO", "foo" },
- { "foo", "foo" },
- { "FOO", "foo" },
- };
-
- for (size_t i = 0; i < arraysize(lowercase_cases); ++i) {
- EXPECT_TRUE(LowerCaseEqualsASCII(ASCIIToUTF16(lowercase_cases[i].src_a),
- lowercase_cases[i].dst));
- EXPECT_TRUE(LowerCaseEqualsASCII(lowercase_cases[i].src_a,
- lowercase_cases[i].dst));
- }
-}
-
-TEST(StringUtilTest, FormatBytesUnlocalized) {
- static const struct {
- int64_t bytes;
- const char* expected;
- } cases[] = {
- // Expected behavior: we show one post-decimal digit when we have
- // under two pre-decimal digits, except in cases where it makes no
- // sense (zero or bytes).
- // Since we switch units once we cross the 1000 mark, this keeps
- // the display of file sizes or bytes consistently around three
- // digits.
- {0, "0 B"},
- {512, "512 B"},
- {1024*1024, "1.0 MB"},
- {1024*1024*1024, "1.0 GB"},
- {10LL*1024*1024*1024, "10.0 GB"},
- {99LL*1024*1024*1024, "99.0 GB"},
- {105LL*1024*1024*1024, "105 GB"},
- {105LL*1024*1024*1024 + 500LL*1024*1024, "105 GB"},
- {~(1LL << 63), "8192 PB"},
-
- {99*1024 + 103, "99.1 kB"},
- {1024*1024 + 103, "1.0 MB"},
- {1024*1024 + 205 * 1024, "1.2 MB"},
- {1024*1024*1024 + (927 * 1024*1024), "1.9 GB"},
- {10LL*1024*1024*1024, "10.0 GB"},
- {100LL*1024*1024*1024, "100 GB"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- EXPECT_EQ(ASCIIToUTF16(cases[i].expected),
- FormatBytesUnlocalized(cases[i].bytes));
- }
-}
-TEST(StringUtilTest, ReplaceSubstringsAfterOffset) {
- static const struct {
- StringPiece str;
- size_t start_offset;
- StringPiece find_this;
- StringPiece replace_with;
- StringPiece expected;
- } cases[] = {
- {"aaa", 0, "", "b", "aaa"},
- {"aaa", 1, "", "b", "aaa"},
- {"aaa", 0, "a", "b", "bbb"},
- {"aaa", 0, "aa", "b", "ba"},
- {"aaa", 0, "aa", "bbb", "bbba"},
- {"aaaaa", 0, "aa", "b", "bba"},
- {"ababaaababa", 0, "aba", "", "baaba"},
- {"ababaaababa", 0, "aba", "_", "_baa_ba"},
- {"ababaaababa", 0, "aba", "__", "__baa__ba"},
- {"ababaaababa", 0, "aba", "___", "___baa___ba"},
- {"ababaaababa", 0, "aba", "____", "____baa____ba"},
- {"ababaaababa", 0, "aba", "_____", "_____baa_____ba"},
- {"abb", 0, "ab", "a", "ab"},
- {"Removing some substrings inging", 0, "ing", "", "Remov some substrs "},
- {"Not found", 0, "x", "0", "Not found"},
- {"Not found again", 5, "x", "0", "Not found again"},
- {" Making it much longer ", 0, " ", "Four score and seven years ago",
- "Four score and seven years agoMakingFour score and seven years agoit"
- "Four score and seven years agomuchFour score and seven years agolonger"
- "Four score and seven years ago"},
- {" Making it much much much much shorter ", 0,
- "Making it much much much much shorter", "", " "},
- {"so much much much much much very much much much shorter", 0, "much ",
- "", "so very shorter"},
- {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
- {"Replace me only me once", 9, "me ", "", "Replace me only once"},
- {"abababab", 2, "ab", "c", "abccc"},
- {"abababab", 1, "ab", "c", "abccc"},
- {"abababab", 1, "aba", "c", "abcbab"},
- };
-
- // base::string16 variant
- for (const auto& scenario : cases) {
- string16 str = ASCIIToUTF16(scenario.str);
- ReplaceSubstringsAfterOffset(&str, scenario.start_offset,
- ASCIIToUTF16(scenario.find_this),
- ASCIIToUTF16(scenario.replace_with));
- EXPECT_EQ(ASCIIToUTF16(scenario.expected), str);
- }
-
- // std::string with insufficient capacity: expansion must realloc the buffer.
- for (const auto& scenario : cases) {
- std::string str = scenario.str.as_string();
- str.shrink_to_fit(); // This is nonbinding, but it's the best we've got.
- ReplaceSubstringsAfterOffset(&str, scenario.start_offset,
- scenario.find_this, scenario.replace_with);
- EXPECT_EQ(scenario.expected, str);
- }
-
- // std::string with ample capacity: should be possible to grow in-place.
- for (const auto& scenario : cases) {
- std::string str = scenario.str.as_string();
- str.reserve(std::max(scenario.str.length(), scenario.expected.length()) *
- 2);
-
- ReplaceSubstringsAfterOffset(&str, scenario.start_offset,
- scenario.find_this, scenario.replace_with);
- EXPECT_EQ(scenario.expected, str);
- }
-}
-
-TEST(StringUtilTest, ReplaceFirstSubstringAfterOffset) {
- static const struct {
- const char* str;
- string16::size_type start_offset;
- const char* find_this;
- const char* replace_with;
- const char* expected;
- } cases[] = {
- {"aaa", 0, "a", "b", "baa"},
- {"abb", 0, "ab", "a", "ab"},
- {"Removing some substrings inging", 0, "ing", "",
- "Remov some substrings inging"},
- {"Not found", 0, "x", "0", "Not found"},
- {"Not found again", 5, "x", "0", "Not found again"},
- {" Making it much longer ", 0, " ", "Four score and seven years ago",
- "Four score and seven years agoMaking it much longer "},
- {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
- {"Replace me only me once", 4, "me ", "", "Replace only me once"},
- {"abababab", 2, "ab", "c", "abcabab"},
- };
-
- for (size_t i = 0; i < arraysize(cases); i++) {
- string16 str = ASCIIToUTF16(cases[i].str);
- ReplaceFirstSubstringAfterOffset(&str, cases[i].start_offset,
- ASCIIToUTF16(cases[i].find_this),
- ASCIIToUTF16(cases[i].replace_with));
- EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
- }
-}
-
-TEST(StringUtilTest, HexDigitToInt) {
- EXPECT_EQ(0, HexDigitToInt('0'));
- EXPECT_EQ(1, HexDigitToInt('1'));
- EXPECT_EQ(2, HexDigitToInt('2'));
- EXPECT_EQ(3, HexDigitToInt('3'));
- EXPECT_EQ(4, HexDigitToInt('4'));
- EXPECT_EQ(5, HexDigitToInt('5'));
- EXPECT_EQ(6, HexDigitToInt('6'));
- EXPECT_EQ(7, HexDigitToInt('7'));
- EXPECT_EQ(8, HexDigitToInt('8'));
- EXPECT_EQ(9, HexDigitToInt('9'));
- EXPECT_EQ(10, HexDigitToInt('A'));
- EXPECT_EQ(11, HexDigitToInt('B'));
- EXPECT_EQ(12, HexDigitToInt('C'));
- EXPECT_EQ(13, HexDigitToInt('D'));
- EXPECT_EQ(14, HexDigitToInt('E'));
- EXPECT_EQ(15, HexDigitToInt('F'));
-
- // Verify the lower case as well.
- EXPECT_EQ(10, HexDigitToInt('a'));
- EXPECT_EQ(11, HexDigitToInt('b'));
- EXPECT_EQ(12, HexDigitToInt('c'));
- EXPECT_EQ(13, HexDigitToInt('d'));
- EXPECT_EQ(14, HexDigitToInt('e'));
- EXPECT_EQ(15, HexDigitToInt('f'));
-}
-
-TEST(StringUtilTest, JoinString) {
- std::string separator(", ");
- std::vector<std::string> parts;
- EXPECT_EQ(std::string(), JoinString(parts, separator));
-
- parts.push_back(std::string());
- EXPECT_EQ(std::string(), JoinString(parts, separator));
- parts.clear();
-
- parts.push_back("a");
- EXPECT_EQ("a", JoinString(parts, separator));
-
- parts.push_back("b");
- parts.push_back("c");
- EXPECT_EQ("a, b, c", JoinString(parts, separator));
-
- parts.push_back(std::string());
- EXPECT_EQ("a, b, c, ", JoinString(parts, separator));
- parts.push_back(" ");
- EXPECT_EQ("a|b|c|| ", JoinString(parts, "|"));
-}
-
-TEST(StringUtilTest, JoinString16) {
- string16 separator = ASCIIToUTF16(", ");
- std::vector<string16> parts;
- EXPECT_EQ(string16(), JoinString(parts, separator));
-
- parts.push_back(string16());
- EXPECT_EQ(string16(), JoinString(parts, separator));
- parts.clear();
-
- parts.push_back(ASCIIToUTF16("a"));
- EXPECT_EQ(ASCIIToUTF16("a"), JoinString(parts, separator));
-
- parts.push_back(ASCIIToUTF16("b"));
- parts.push_back(ASCIIToUTF16("c"));
- EXPECT_EQ(ASCIIToUTF16("a, b, c"), JoinString(parts, separator));
-
- parts.push_back(ASCIIToUTF16(""));
- EXPECT_EQ(ASCIIToUTF16("a, b, c, "), JoinString(parts, separator));
- parts.push_back(ASCIIToUTF16(" "));
- EXPECT_EQ(ASCIIToUTF16("a|b|c|| "), JoinString(parts, ASCIIToUTF16("|")));
-}
-
-TEST(StringUtilTest, JoinStringPiece) {
- std::string separator(", ");
- std::vector<StringPiece> parts;
- EXPECT_EQ(std::string(), JoinString(parts, separator));
-
- // Test empty first part (https://crbug.com/698073).
- parts.push_back(StringPiece());
- EXPECT_EQ(std::string(), JoinString(parts, separator));
- parts.clear();
-
- parts.push_back("a");
- EXPECT_EQ("a", JoinString(parts, separator));
-
- parts.push_back("b");
- parts.push_back("c");
- EXPECT_EQ("a, b, c", JoinString(parts, separator));
-
- parts.push_back(StringPiece());
- EXPECT_EQ("a, b, c, ", JoinString(parts, separator));
- parts.push_back(" ");
- EXPECT_EQ("a|b|c|| ", JoinString(parts, "|"));
-}
-
-TEST(StringUtilTest, JoinStringPiece16) {
- string16 separator = ASCIIToUTF16(", ");
- std::vector<StringPiece16> parts;
- EXPECT_EQ(string16(), JoinString(parts, separator));
-
- // Test empty first part (https://crbug.com/698073).
- parts.push_back(StringPiece16());
- EXPECT_EQ(string16(), JoinString(parts, separator));
- parts.clear();
-
- const string16 kA = ASCIIToUTF16("a");
- parts.push_back(kA);
- EXPECT_EQ(ASCIIToUTF16("a"), JoinString(parts, separator));
-
- const string16 kB = ASCIIToUTF16("b");
- parts.push_back(kB);
- const string16 kC = ASCIIToUTF16("c");
- parts.push_back(kC);
- EXPECT_EQ(ASCIIToUTF16("a, b, c"), JoinString(parts, separator));
-
- parts.push_back(StringPiece16());
- EXPECT_EQ(ASCIIToUTF16("a, b, c, "), JoinString(parts, separator));
- const string16 kSpace = ASCIIToUTF16(" ");
- parts.push_back(kSpace);
- EXPECT_EQ(ASCIIToUTF16("a|b|c|| "), JoinString(parts, ASCIIToUTF16("|")));
-}
-
-TEST(StringUtilTest, JoinStringInitializerList) {
- std::string separator(", ");
- EXPECT_EQ(std::string(), JoinString({}, separator));
-
- // Test empty first part (https://crbug.com/698073).
- EXPECT_EQ(std::string(), JoinString({StringPiece()}, separator));
-
- // With const char*s.
- EXPECT_EQ("a", JoinString({"a"}, separator));
- EXPECT_EQ("a, b, c", JoinString({"a", "b", "c"}, separator));
- EXPECT_EQ("a, b, c, ", JoinString({"a", "b", "c", StringPiece()}, separator));
- EXPECT_EQ("a|b|c|| ", JoinString({"a", "b", "c", StringPiece(), " "}, "|"));
-
- // With std::strings.
- const std::string kA = "a";
- const std::string kB = "b";
- EXPECT_EQ("a, b", JoinString({kA, kB}, separator));
-
- // With StringPieces.
- const StringPiece kPieceA = kA;
- const StringPiece kPieceB = kB;
- EXPECT_EQ("a, b", JoinString({kPieceA, kPieceB}, separator));
-}
-
-TEST(StringUtilTest, JoinStringInitializerList16) {
- string16 separator = ASCIIToUTF16(", ");
- EXPECT_EQ(string16(), JoinString({}, separator));
-
- // Test empty first part (https://crbug.com/698073).
- EXPECT_EQ(string16(), JoinString({StringPiece16()}, separator));
-
- // With string16s.
- const string16 kA = ASCIIToUTF16("a");
- EXPECT_EQ(ASCIIToUTF16("a"), JoinString({kA}, separator));
-
- const string16 kB = ASCIIToUTF16("b");
- const string16 kC = ASCIIToUTF16("c");
- EXPECT_EQ(ASCIIToUTF16("a, b, c"), JoinString({kA, kB, kC}, separator));
-
- EXPECT_EQ(ASCIIToUTF16("a, b, c, "),
- JoinString({kA, kB, kC, StringPiece16()}, separator));
- const string16 kSpace = ASCIIToUTF16(" ");
- EXPECT_EQ(
- ASCIIToUTF16("a|b|c|| "),
- JoinString({kA, kB, kC, StringPiece16(), kSpace}, ASCIIToUTF16("|")));
-
- // With StringPiece16s.
- const StringPiece16 kPieceA = kA;
- const StringPiece16 kPieceB = kB;
- EXPECT_EQ(ASCIIToUTF16("a, b"), JoinString({kPieceA, kPieceB}, separator));
-}
-
-TEST(StringUtilTest, StartsWith) {
- EXPECT_TRUE(StartsWith("javascript:url", "javascript",
- base::CompareCase::SENSITIVE));
- EXPECT_FALSE(StartsWith("JavaScript:url", "javascript",
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(StartsWith("javascript:url", "javascript",
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(StartsWith("JavaScript:url", "javascript",
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(StartsWith("java", "javascript", base::CompareCase::SENSITIVE));
- EXPECT_FALSE(StartsWith("java", "javascript",
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(StartsWith(std::string(), "javascript",
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(StartsWith(std::string(), "javascript",
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(StartsWith("java", std::string(),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(StartsWith("java", std::string(), base::CompareCase::SENSITIVE));
-
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
- ASCIIToUTF16("javascript"),
- base::CompareCase::SENSITIVE));
- EXPECT_FALSE(StartsWith(ASCIIToUTF16("JavaScript:url"),
- ASCIIToUTF16("javascript"),
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
- ASCIIToUTF16("javascript"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("JavaScript:url"),
- ASCIIToUTF16("javascript"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"), ASCIIToUTF16("javascript"),
- base::CompareCase::SENSITIVE));
- EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"), ASCIIToUTF16("javascript"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"),
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(),
- base::CompareCase::SENSITIVE));
-}
-
-TEST(StringUtilTest, EndsWith) {
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), ASCIIToUTF16(".plugin"),
- base::CompareCase::SENSITIVE));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.Plugin"), ASCIIToUTF16(".plugin"),
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), ASCIIToUTF16(".plugin"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.Plugin"), ASCIIToUTF16(".plugin"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"),
- base::CompareCase::SENSITIVE));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"), ASCIIToUTF16(".plugin"),
- base::CompareCase::SENSITIVE));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"), ASCIIToUTF16(".plugin"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"),
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(),
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"), ASCIIToUTF16(".plugin"),
- base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"), ASCIIToUTF16(".plugin"),
- base::CompareCase::SENSITIVE));
- EXPECT_TRUE(
- EndsWith(string16(), string16(), base::CompareCase::INSENSITIVE_ASCII));
- EXPECT_TRUE(EndsWith(string16(), string16(), base::CompareCase::SENSITIVE));
-}
-
-TEST(StringUtilTest, GetStringFWithOffsets) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("1"));
- subst.push_back(ASCIIToUTF16("2"));
- std::vector<size_t> offsets;
-
- ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $1. Your number is $2."),
- subst,
- &offsets);
- EXPECT_EQ(2U, offsets.size());
- EXPECT_EQ(7U, offsets[0]);
- EXPECT_EQ(25U, offsets[1]);
- offsets.clear();
-
- ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $2. Your number is $1."),
- subst,
- &offsets);
- EXPECT_EQ(2U, offsets.size());
- EXPECT_EQ(25U, offsets[0]);
- EXPECT_EQ(7U, offsets[1]);
- offsets.clear();
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersTooFew) {
- // Test whether replacestringplaceholders works as expected when there
- // are fewer inputs than outputs.
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("9a"));
- subst.push_back(ASCIIToUTF16("8b"));
- subst.push_back(ASCIIToUTF16("7c"));
-
- string16 formatted =
- ReplaceStringPlaceholders(
- ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$1g,$2h,$3i"), subst, nullptr);
-
- EXPECT_EQ(ASCIIToUTF16("9aa,8bb,7cc,d,e,f,9ag,8bh,7ci"), formatted);
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholders) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("9a"));
- subst.push_back(ASCIIToUTF16("8b"));
- subst.push_back(ASCIIToUTF16("7c"));
- subst.push_back(ASCIIToUTF16("6d"));
- subst.push_back(ASCIIToUTF16("5e"));
- subst.push_back(ASCIIToUTF16("4f"));
- subst.push_back(ASCIIToUTF16("3g"));
- subst.push_back(ASCIIToUTF16("2h"));
- subst.push_back(ASCIIToUTF16("1i"));
-
- string16 formatted =
- ReplaceStringPlaceholders(
- ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i"), subst, nullptr);
-
- EXPECT_EQ(ASCIIToUTF16("9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii"), formatted);
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersNetExpansionWithContraction) {
- // In this test, some of the substitutions are shorter than the placeholders,
- // but overall the string gets longer.
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("9a____"));
- subst.push_back(ASCIIToUTF16("B"));
- subst.push_back(ASCIIToUTF16("7c___"));
- subst.push_back(ASCIIToUTF16("d"));
- subst.push_back(ASCIIToUTF16("5e____"));
- subst.push_back(ASCIIToUTF16("F"));
- subst.push_back(ASCIIToUTF16("3g___"));
- subst.push_back(ASCIIToUTF16("h"));
- subst.push_back(ASCIIToUTF16("1i_____"));
-
- string16 original = ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i");
- string16 expected =
- ASCIIToUTF16("9a____a,Bb,7c___c,dd,5e____e,Ff,3g___g,hh,1i_____i");
-
- EXPECT_EQ(expected, ReplaceStringPlaceholders(original, subst, nullptr));
-
- std::vector<size_t> offsets;
- EXPECT_EQ(expected, ReplaceStringPlaceholders(original, subst, &offsets));
- std::vector<size_t> expected_offsets = {0, 8, 11, 18, 21, 29, 32, 39, 42};
- EXPECT_EQ(offsets.size(), subst.size());
- EXPECT_EQ(expected_offsets, offsets);
- for (size_t i = 0; i < offsets.size(); i++) {
- EXPECT_EQ(expected.substr(expected_offsets[i], subst[i].length()),
- subst[i]);
- }
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersNetContractionWithExpansion) {
- // In this test, some of the substitutions are longer than the placeholders,
- // but overall the string gets smaller. Additionally, the placeholders appear
- // in a permuted order.
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("z"));
- subst.push_back(ASCIIToUTF16("y"));
- subst.push_back(ASCIIToUTF16("XYZW"));
- subst.push_back(ASCIIToUTF16("x"));
- subst.push_back(ASCIIToUTF16("w"));
-
- string16 formatted =
- ReplaceStringPlaceholders(ASCIIToUTF16("$3_$4$2$1$5"), subst, nullptr);
-
- EXPECT_EQ(ASCIIToUTF16("XYZW_xyzw"), formatted);
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersOneDigit) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("1a"));
- string16 formatted =
- ReplaceStringPlaceholders(ASCIIToUTF16(" $16 "), subst, nullptr);
- EXPECT_EQ(ASCIIToUTF16(" 1a6 "), formatted);
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersInvalidPlaceholder) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("1a"));
- string16 formatted =
- ReplaceStringPlaceholders(ASCIIToUTF16("+$-+$A+$1+"), subst, nullptr);
- EXPECT_EQ(ASCIIToUTF16("+++1a+"), formatted);
-}
-
-TEST(StringUtilTest, StdStringReplaceStringPlaceholders) {
- std::vector<std::string> subst;
- subst.push_back("9a");
- subst.push_back("8b");
- subst.push_back("7c");
- subst.push_back("6d");
- subst.push_back("5e");
- subst.push_back("4f");
- subst.push_back("3g");
- subst.push_back("2h");
- subst.push_back("1i");
-
- std::string formatted =
- ReplaceStringPlaceholders(
- "$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i", subst, nullptr);
-
- EXPECT_EQ("9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii", formatted);
-}
-
-TEST(StringUtilTest, StdStringReplaceStringPlaceholdersMultipleMatches) {
- std::vector<std::string> subst;
- subst.push_back("4"); // Referenced twice.
- subst.push_back("?"); // Unreferenced.
- subst.push_back("!"); // Unreferenced.
- subst.push_back("16"); // Referenced once.
-
- std::string original = "$1 * $1 == $4";
- std::string expected = "4 * 4 == 16";
- EXPECT_EQ(expected, ReplaceStringPlaceholders(original, subst, nullptr));
- std::vector<size_t> offsets;
- EXPECT_EQ(expected, ReplaceStringPlaceholders(original, subst, &offsets));
- std::vector<size_t> expected_offsets = {0, 4, 9};
- EXPECT_EQ(expected_offsets, offsets);
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersConsecutiveDollarSigns) {
- std::vector<std::string> subst;
- subst.push_back("a");
- subst.push_back("b");
- subst.push_back("c");
- EXPECT_EQ(ReplaceStringPlaceholders("$$1 $$$2 $$$$3", subst, nullptr),
- "$1 $$2 $$$3");
-}
-
-TEST(StringUtilTest, LcpyTest) {
- // Test the normal case where we fit in our buffer.
- {
- char dst[10];
- wchar_t wdst[10];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
- }
-
- // Test dst_size == 0, nothing should be written to |dst| and we should
- // have the equivalent of strlen(src).
- {
- char dst[2] = {1, 2};
- wchar_t wdst[2] = {1, 2};
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", 0));
- EXPECT_EQ(1, dst[0]);
- EXPECT_EQ(2, dst[1]);
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", 0));
- EXPECT_EQ(static_cast<wchar_t>(1), wdst[0]);
- EXPECT_EQ(static_cast<wchar_t>(2), wdst[1]);
- }
-
- // Test the case were we _just_ competely fit including the null.
- {
- char dst[8];
- wchar_t wdst[8];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
- }
-
- // Test the case were we we are one smaller, so we can't fit the null.
- {
- char dst[7];
- wchar_t wdst[7];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "abcdef", 7));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"abcdef", sizeof(wchar_t) * 7));
- }
-
- // Test the case were we are just too small.
- {
- char dst[3];
- wchar_t wdst[3];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "ab", 3));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"ab", sizeof(wchar_t) * 3));
- }
-}
-
-TEST(StringUtilTest, WprintfFormatPortabilityTest) {
- static const struct {
- const wchar_t* input;
- bool portable;
- } cases[] = {
- { L"%ls", true },
- { L"%s", false },
- { L"%S", false },
- { L"%lS", false },
- { L"Hello, %s", false },
- { L"%lc", true },
- { L"%c", false },
- { L"%C", false },
- { L"%lC", false },
- { L"%ls %s", false },
- { L"%s %ls", false },
- { L"%s %ls %s", false },
- { L"%f", true },
- { L"%f %F", false },
- { L"%d %D", false },
- { L"%o %O", false },
- { L"%u %U", false },
- { L"%f %d %o %u", true },
- { L"%-8d (%02.1f%)", true },
- { L"% 10s", false },
- { L"% 10ls", true }
- };
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].portable, IsWprintfFormatPortable(cases[i].input));
-}
-
-TEST(StringUtilTest, RemoveChars) {
- const char kRemoveChars[] = "-/+*";
- std::string input = "A-+bc/d!*";
- EXPECT_TRUE(RemoveChars(input, kRemoveChars, &input));
- EXPECT_EQ("Abcd!", input);
-
- // No characters match kRemoveChars.
- EXPECT_FALSE(RemoveChars(input, kRemoveChars, &input));
- EXPECT_EQ("Abcd!", input);
-
- // Empty string.
- input.clear();
- EXPECT_FALSE(RemoveChars(input, kRemoveChars, &input));
- EXPECT_EQ(std::string(), input);
-}
-
-TEST(StringUtilTest, ReplaceChars) {
- struct TestData {
- const char* input;
- const char* replace_chars;
- const char* replace_with;
- const char* output;
- bool result;
- } cases[] = {
- {"", "", "", "", false},
- {"t", "t", "t", "t", true},
- {"a", "b", "c", "a", false},
- {"b", "b", "c", "c", true},
- {"bob", "b", "p", "pop", true},
- {"bob", "o", "i", "bib", true},
- {"test", "", "", "test", false},
- {"test", "", "!", "test", false},
- {"test", "z", "!", "test", false},
- {"test", "e", "!", "t!st", true},
- {"test", "e", "!?", "t!?st", true},
- {"test", "ez", "!", "t!st", true},
- {"test", "zed", "!?", "t!?st", true},
- {"test", "t", "!?", "!?es!?", true},
- {"test", "et", "!>", "!>!>s!>", true},
- {"test", "zest", "!", "!!!!", true},
- {"test", "szt", "!", "!e!!", true},
- {"test", "t", "test", "testestest", true},
- {"tetst", "t", "test", "testeteststest", true},
- {"ttttttt", "t", "-", "-------", true},
- {"aAaAaAAaAAa", "A", "", "aaaaa", true},
- {"xxxxxxxxxx", "x", "", "", true},
- {"xxxxxxxxxx", "x", "x", "xxxxxxxxxx", true},
- {"xxxxxxxxxx", "x", "y-", "y-y-y-y-y-y-y-y-y-y-", true},
- {"xxxxxxxxxx", "x", "xy", "xyxyxyxyxyxyxyxyxyxy", true},
- {"xxxxxxxxxx", "x", "zyx", "zyxzyxzyxzyxzyxzyxzyxzyxzyxzyx", true},
- {"xaxxaxxxaxxxax", "x", "xy", "xyaxyxyaxyxyxyaxyxyxyaxy", true},
- {"-xaxxaxxxaxxxax-", "x", "xy", "-xyaxyxyaxyxyxyaxyxyxyaxy-", true},
- };
-
- for (const TestData& scenario : cases) {
- // Test with separate output and input vars.
- std::string output;
- bool result = ReplaceChars(scenario.input, scenario.replace_chars,
- scenario.replace_with, &output);
- EXPECT_EQ(scenario.result, result) << scenario.input;
- EXPECT_EQ(scenario.output, output);
- }
-
- for (const TestData& scenario : cases) {
- // Test with an input/output var of limited capacity.
- std::string input_output = scenario.input;
- input_output.shrink_to_fit();
- bool result = ReplaceChars(input_output, scenario.replace_chars,
- scenario.replace_with, &input_output);
- EXPECT_EQ(scenario.result, result) << scenario.input;
- EXPECT_EQ(scenario.output, input_output);
- }
-
- for (const TestData& scenario : cases) {
- // Test with an input/output var of ample capacity; should
- // not realloc.
- std::string input_output = scenario.input;
- input_output.reserve(strlen(scenario.output) * 2);
- const void* original_buffer = input_output.data();
- bool result = ReplaceChars(input_output, scenario.replace_chars,
- scenario.replace_with, &input_output);
- EXPECT_EQ(scenario.result, result) << scenario.input;
- EXPECT_EQ(scenario.output, input_output);
- EXPECT_EQ(original_buffer, input_output.data());
- }
-}
-
-TEST(StringUtilTest, ContainsOnlyChars) {
- // Providing an empty list of characters should return false but for the empty
- // string.
- EXPECT_TRUE(ContainsOnlyChars(std::string(), std::string()));
- EXPECT_FALSE(ContainsOnlyChars("Hello", std::string()));
-
- EXPECT_TRUE(ContainsOnlyChars(std::string(), "1234"));
- EXPECT_TRUE(ContainsOnlyChars("1", "1234"));
- EXPECT_TRUE(ContainsOnlyChars("1", "4321"));
- EXPECT_TRUE(ContainsOnlyChars("123", "4321"));
- EXPECT_FALSE(ContainsOnlyChars("123a", "4321"));
-
- EXPECT_TRUE(ContainsOnlyChars(std::string(), kWhitespaceASCII));
- EXPECT_TRUE(ContainsOnlyChars(" ", kWhitespaceASCII));
- EXPECT_TRUE(ContainsOnlyChars("\t", kWhitespaceASCII));
- EXPECT_TRUE(ContainsOnlyChars("\t \r \n ", kWhitespaceASCII));
- EXPECT_FALSE(ContainsOnlyChars("a", kWhitespaceASCII));
- EXPECT_FALSE(ContainsOnlyChars("\thello\r \n ", kWhitespaceASCII));
-
- EXPECT_TRUE(ContainsOnlyChars(string16(), kWhitespaceUTF16));
- EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16(" "), kWhitespaceUTF16));
- EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16("\t"), kWhitespaceUTF16));
- EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16("\t \r \n "), kWhitespaceUTF16));
- EXPECT_FALSE(ContainsOnlyChars(ASCIIToUTF16("a"), kWhitespaceUTF16));
- EXPECT_FALSE(ContainsOnlyChars(ASCIIToUTF16("\thello\r \n "),
- kWhitespaceUTF16));
-}
-
-TEST(StringUtilTest, CompareCaseInsensitiveASCII) {
- EXPECT_EQ(0, CompareCaseInsensitiveASCII("", ""));
- EXPECT_EQ(0, CompareCaseInsensitiveASCII("Asdf", "aSDf"));
-
- // Differing lengths.
- EXPECT_EQ(-1, CompareCaseInsensitiveASCII("Asdf", "aSDfA"));
- EXPECT_EQ(1, CompareCaseInsensitiveASCII("AsdfA", "aSDf"));
-
- // Differing values.
- EXPECT_EQ(-1, CompareCaseInsensitiveASCII("AsdfA", "aSDfb"));
- EXPECT_EQ(1, CompareCaseInsensitiveASCII("Asdfb", "aSDfA"));
-}
-
-TEST(StringUtilTest, EqualsCaseInsensitiveASCII) {
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("", ""));
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("Asdf", "aSDF"));
- EXPECT_FALSE(EqualsCaseInsensitiveASCII("bsdf", "aSDF"));
- EXPECT_FALSE(EqualsCaseInsensitiveASCII("Asdf", "aSDFz"));
-}
-
-TEST(StringUtilTest, IsUnicodeWhitespace) {
- // NOT unicode white space.
- EXPECT_FALSE(IsUnicodeWhitespace(L'\0'));
- EXPECT_FALSE(IsUnicodeWhitespace(L'A'));
- EXPECT_FALSE(IsUnicodeWhitespace(L'0'));
- EXPECT_FALSE(IsUnicodeWhitespace(L'.'));
- EXPECT_FALSE(IsUnicodeWhitespace(L';'));
- EXPECT_FALSE(IsUnicodeWhitespace(L'\x4100'));
-
- // Actual unicode whitespace.
- EXPECT_TRUE(IsUnicodeWhitespace(L' '));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\xa0'));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\x3000'));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\t'));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\r'));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\v'));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\f'));
- EXPECT_TRUE(IsUnicodeWhitespace(L'\n'));
-}
-
-class WriteIntoTest : public testing::Test {
- protected:
- static void WritesCorrectly(size_t num_chars) {
- std::string buffer;
- char kOriginal[] = "supercali";
- strncpy(WriteInto(&buffer, num_chars + 1), kOriginal, num_chars);
- // Using std::string(buffer.c_str()) instead of |buffer| truncates the
- // string at the first \0.
- EXPECT_EQ(std::string(kOriginal,
- std::min(num_chars, arraysize(kOriginal) - 1)),
- std::string(buffer.c_str()));
- EXPECT_EQ(num_chars, buffer.size());
- }
-};
-
-TEST_F(WriteIntoTest, WriteInto) {
- // Validate that WriteInto reserves enough space and
- // sizes a string correctly.
- WritesCorrectly(1);
- WritesCorrectly(2);
- WritesCorrectly(5000);
-
- // Validate that WriteInto doesn't modify other strings
- // when using a Copy-on-Write implementation.
- const char kLive[] = "live";
- const char kDead[] = "dead";
- const std::string live = kLive;
- std::string dead = live;
- strncpy(WriteInto(&dead, 5), kDead, 4);
- EXPECT_EQ(kDead, dead);
- EXPECT_EQ(4u, dead.size());
- EXPECT_EQ(kLive, live);
- EXPECT_EQ(4u, live.size());
-}
-
-} // namespace base
diff --git a/base/strings/stringize_macros_unittest.cc b/base/strings/stringize_macros_unittest.cc
deleted file mode 100644
index d7f9e56..0000000
--- a/base/strings/stringize_macros_unittest.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2010 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 "base/strings/stringize_macros.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Macros as per documentation in header file.
-#define PREPROCESSOR_UTIL_UNITTEST_A FOO
-#define PREPROCESSOR_UTIL_UNITTEST_B(x) myobj->FunctionCall(x)
-#define PREPROCESSOR_UTIL_UNITTEST_C "foo"
-
-TEST(StringizeTest, Ansi) {
- EXPECT_STREQ(
- "PREPROCESSOR_UTIL_UNITTEST_A",
- STRINGIZE_NO_EXPANSION(PREPROCESSOR_UTIL_UNITTEST_A));
- EXPECT_STREQ(
- "PREPROCESSOR_UTIL_UNITTEST_B(y)",
- STRINGIZE_NO_EXPANSION(PREPROCESSOR_UTIL_UNITTEST_B(y)));
- EXPECT_STREQ(
- "PREPROCESSOR_UTIL_UNITTEST_C",
- STRINGIZE_NO_EXPANSION(PREPROCESSOR_UTIL_UNITTEST_C));
-
- EXPECT_STREQ("FOO", STRINGIZE(PREPROCESSOR_UTIL_UNITTEST_A));
- EXPECT_STREQ("myobj->FunctionCall(y)",
- STRINGIZE(PREPROCESSOR_UTIL_UNITTEST_B(y)));
- EXPECT_STREQ("\"foo\"", STRINGIZE(PREPROCESSOR_UTIL_UNITTEST_C));
-}
diff --git a/base/strings/stringprintf_unittest.cc b/base/strings/stringprintf_unittest.cc
deleted file mode 100644
index 02cd349..0000000
--- a/base/strings/stringprintf_unittest.cc
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright 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 "base/strings/stringprintf.h"
-
-#include <errno.h>
-#include <stddef.h>
-
-#include "base/macros.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// A helper for the StringAppendV test that follows.
-//
-// Just forwards its args to StringAppendV.
-static void StringAppendVTestHelper(std::string* out, const char* format, ...) {
- va_list ap;
- va_start(ap, format);
- StringAppendV(out, format, ap);
- va_end(ap);
-}
-
-} // namespace
-
-TEST(StringPrintfTest, StringPrintfEmpty) {
- EXPECT_EQ("", StringPrintf("%s", ""));
-}
-
-TEST(StringPrintfTest, StringPrintfMisc) {
- EXPECT_EQ("123hello w", StringPrintf("%3d%2s %1c", 123, "hello", 'w'));
-#if defined(OS_WIN)
- EXPECT_EQ(L"123hello w", StringPrintf(L"%3d%2ls %1lc", 123, L"hello", 'w'));
-#endif
-}
-
-TEST(StringPrintfTest, StringAppendfEmptyString) {
- std::string value("Hello");
- StringAppendF(&value, "%s", "");
- EXPECT_EQ("Hello", value);
-
-#if defined(OS_WIN)
- std::wstring valuew(L"Hello");
- StringAppendF(&valuew, L"%ls", L"");
- EXPECT_EQ(L"Hello", valuew);
-#endif
-}
-
-TEST(StringPrintfTest, StringAppendfString) {
- std::string value("Hello");
- StringAppendF(&value, " %s", "World");
- EXPECT_EQ("Hello World", value);
-
-#if defined(OS_WIN)
- std::wstring valuew(L"Hello");
- StringAppendF(&valuew, L" %ls", L"World");
- EXPECT_EQ(L"Hello World", valuew);
-#endif
-}
-
-TEST(StringPrintfTest, StringAppendfInt) {
- std::string value("Hello");
- StringAppendF(&value, " %d", 123);
- EXPECT_EQ("Hello 123", value);
-
-#if defined(OS_WIN)
- std::wstring valuew(L"Hello");
- StringAppendF(&valuew, L" %d", 123);
- EXPECT_EQ(L"Hello 123", valuew);
-#endif
-}
-
-// Make sure that lengths exactly around the initial buffer size are handled
-// correctly.
-TEST(StringPrintfTest, StringPrintfBounds) {
- const int kSrcLen = 1026;
- char src[kSrcLen];
- for (size_t i = 0; i < arraysize(src); i++)
- src[i] = 'A';
-
- wchar_t srcw[kSrcLen];
- for (size_t i = 0; i < arraysize(srcw); i++)
- srcw[i] = 'A';
-
- for (int i = 1; i < 3; i++) {
- src[kSrcLen - i] = 0;
- std::string out;
- SStringPrintf(&out, "%s", src);
- EXPECT_STREQ(src, out.c_str());
-
-#if defined(OS_WIN)
- srcw[kSrcLen - i] = 0;
- std::wstring outw;
- SStringPrintf(&outw, L"%ls", srcw);
- EXPECT_STREQ(srcw, outw.c_str());
-#endif
- }
-}
-
-// Test very large sprintfs that will cause the buffer to grow.
-TEST(StringPrintfTest, Grow) {
- char src[1026];
- for (size_t i = 0; i < arraysize(src); i++)
- src[i] = 'A';
- src[1025] = 0;
-
- const char fmt[] = "%sB%sB%sB%sB%sB%sB%s";
-
- std::string out;
- SStringPrintf(&out, fmt, src, src, src, src, src, src, src);
-
- const int kRefSize = 320000;
- char* ref = new char[kRefSize];
-#if defined(OS_WIN)
- sprintf_s(ref, kRefSize, fmt, src, src, src, src, src, src, src);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- snprintf(ref, kRefSize, fmt, src, src, src, src, src, src, src);
-#endif
-
- EXPECT_STREQ(ref, out.c_str());
- delete[] ref;
-}
-
-TEST(StringPrintfTest, StringAppendV) {
- std::string out;
- StringAppendVTestHelper(&out, "%d foo %s", 1, "bar");
- EXPECT_EQ("1 foo bar", out);
-}
-
-// Test the boundary condition for the size of the string_util's
-// internal buffer.
-TEST(StringPrintfTest, GrowBoundary) {
- const int kStringUtilBufLen = 1024;
- // Our buffer should be one larger than the size of StringAppendVT's stack
- // buffer.
- // And need extra one for NULL-terminator.
- const int kBufLen = kStringUtilBufLen + 1 + 1;
- char src[kBufLen];
- for (int i = 0; i < kBufLen - 1; ++i)
- src[i] = 'a';
- src[kBufLen - 1] = 0;
-
- std::string out;
- SStringPrintf(&out, "%s", src);
-
- EXPECT_STREQ(src, out.c_str());
-}
-
-#if defined(OS_WIN)
-// vswprintf in Visual Studio 2013 fails when given U+FFFF. This tests that the
-// failure case is gracefuly handled. In Visual Studio 2015 the bad character
-// is passed through.
-TEST(StringPrintfTest, Invalid) {
- wchar_t invalid[2];
- invalid[0] = 0xffff;
- invalid[1] = 0;
-
- std::wstring out;
- SStringPrintf(&out, L"%ls", invalid);
-#if _MSC_VER >= 1900
- EXPECT_STREQ(invalid, out.c_str());
-#else
- EXPECT_STREQ(L"", out.c_str());
-#endif
-}
-#endif
-
-// Test that StringPrintf and StringAppendV do not change errno.
-TEST(StringPrintfTest, StringPrintfErrno) {
- errno = 1;
- EXPECT_EQ("", StringPrintf("%s", ""));
- EXPECT_EQ(1, errno);
- std::string out;
- StringAppendVTestHelper(&out, "%d foo %s", 1, "bar");
- EXPECT_EQ(1, errno);
-}
-
-} // namespace base
diff --git a/base/strings/sys_string_conversions_unittest.cc b/base/strings/sys_string_conversions_unittest.cc
deleted file mode 100644
index 0f4eddd..0000000
--- a/base/strings/sys_string_conversions_unittest.cc
+++ /dev/null
@@ -1,196 +0,0 @@
-// Copyright (c) 2011 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 <stddef.h>
-
-#include <string>
-
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/test/scoped_locale.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#ifdef WCHAR_T_IS_UTF32
-static const std::wstring kSysWideOldItalicLetterA = L"\x10300";
-#else
-static const std::wstring kSysWideOldItalicLetterA = L"\xd800\xdf00";
-#endif
-
-namespace base {
-
-TEST(SysStrings, SysWideToUTF8) {
- EXPECT_EQ("Hello, world", SysWideToUTF8(L"Hello, world"));
- EXPECT_EQ("\xe4\xbd\xa0\xe5\xa5\xbd", SysWideToUTF8(L"\x4f60\x597d"));
-
- // >16 bits
- EXPECT_EQ("\xF0\x90\x8C\x80", SysWideToUTF8(kSysWideOldItalicLetterA));
-
- // Error case. When Windows finds a UTF-16 character going off the end of
- // a string, it just converts that literal value to UTF-8, even though this
- // is invalid.
- //
- // This is what XP does, but Vista has different behavior, so we don't bother
- // verifying it:
- // EXPECT_EQ("\xE4\xBD\xA0\xED\xA0\x80zyxw",
- // SysWideToUTF8(L"\x4f60\xd800zyxw"));
-
- // Test embedded NULLs.
- std::wstring wide_null(L"a");
- wide_null.push_back(0);
- wide_null.push_back('b');
-
- std::string expected_null("a");
- expected_null.push_back(0);
- expected_null.push_back('b');
-
- EXPECT_EQ(expected_null, SysWideToUTF8(wide_null));
-}
-
-TEST(SysStrings, SysUTF8ToWide) {
- EXPECT_EQ(L"Hello, world", SysUTF8ToWide("Hello, world"));
- EXPECT_EQ(L"\x4f60\x597d", SysUTF8ToWide("\xe4\xbd\xa0\xe5\xa5\xbd"));
- // >16 bits
- EXPECT_EQ(kSysWideOldItalicLetterA, SysUTF8ToWide("\xF0\x90\x8C\x80"));
-
- // Error case. When Windows finds an invalid UTF-8 character, it just skips
- // it. This seems weird because it's inconsistent with the reverse conversion.
- //
- // This is what XP does, but Vista has different behavior, so we don't bother
- // verifying it:
- // EXPECT_EQ(L"\x4f60zyxw", SysUTF8ToWide("\xe4\xbd\xa0\xe5\xa5zyxw"));
-
- // Test embedded NULLs.
- std::string utf8_null("a");
- utf8_null.push_back(0);
- utf8_null.push_back('b');
-
- std::wstring expected_null(L"a");
- expected_null.push_back(0);
- expected_null.push_back('b');
-
- EXPECT_EQ(expected_null, SysUTF8ToWide(utf8_null));
-}
-
-#if defined(OS_LINUX) // Tests depend on setting a specific Linux locale.
-
-TEST(SysStrings, SysWideToNativeMB) {
-#if !defined(SYSTEM_NATIVE_UTF8)
- ScopedLocale locale("en_US.UTF-8");
-#endif
- EXPECT_EQ("Hello, world", SysWideToNativeMB(L"Hello, world"));
- EXPECT_EQ("\xe4\xbd\xa0\xe5\xa5\xbd", SysWideToNativeMB(L"\x4f60\x597d"));
-
- // >16 bits
- EXPECT_EQ("\xF0\x90\x8C\x80", SysWideToNativeMB(kSysWideOldItalicLetterA));
-
- // Error case. When Windows finds a UTF-16 character going off the end of
- // a string, it just converts that literal value to UTF-8, even though this
- // is invalid.
- //
- // This is what XP does, but Vista has different behavior, so we don't bother
- // verifying it:
- // EXPECT_EQ("\xE4\xBD\xA0\xED\xA0\x80zyxw",
- // SysWideToNativeMB(L"\x4f60\xd800zyxw"));
-
- // Test embedded NULLs.
- std::wstring wide_null(L"a");
- wide_null.push_back(0);
- wide_null.push_back('b');
-
- std::string expected_null("a");
- expected_null.push_back(0);
- expected_null.push_back('b');
-
- EXPECT_EQ(expected_null, SysWideToNativeMB(wide_null));
-}
-
-// We assume the test is running in a UTF8 locale.
-TEST(SysStrings, SysNativeMBToWide) {
-#if !defined(SYSTEM_NATIVE_UTF8)
- ScopedLocale locale("en_US.UTF-8");
-#endif
- EXPECT_EQ(L"Hello, world", SysNativeMBToWide("Hello, world"));
- EXPECT_EQ(L"\x4f60\x597d", SysNativeMBToWide("\xe4\xbd\xa0\xe5\xa5\xbd"));
- // >16 bits
- EXPECT_EQ(kSysWideOldItalicLetterA, SysNativeMBToWide("\xF0\x90\x8C\x80"));
-
- // Error case. When Windows finds an invalid UTF-8 character, it just skips
- // it. This seems weird because it's inconsistent with the reverse conversion.
- //
- // This is what XP does, but Vista has different behavior, so we don't bother
- // verifying it:
- // EXPECT_EQ(L"\x4f60zyxw", SysNativeMBToWide("\xe4\xbd\xa0\xe5\xa5zyxw"));
-
- // Test embedded NULLs.
- std::string utf8_null("a");
- utf8_null.push_back(0);
- utf8_null.push_back('b');
-
- std::wstring expected_null(L"a");
- expected_null.push_back(0);
- expected_null.push_back('b');
-
- EXPECT_EQ(expected_null, SysNativeMBToWide(utf8_null));
-}
-
-static const wchar_t* const kConvertRoundtripCases[] = {
- L"Google Video",
- // "网页 图片 资讯更多 »"
- L"\x7f51\x9875\x0020\x56fe\x7247\x0020\x8d44\x8baf\x66f4\x591a\x0020\x00bb",
- // "Παγκόσμιος Ιστός"
- L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
- L"\x03bf\x03c2\x0020\x0399\x03c3\x03c4\x03cc\x03c2",
- // "Поиск страниц на русском"
- L"\x041f\x043e\x0438\x0441\x043a\x0020\x0441\x0442"
- L"\x0440\x0430\x043d\x0438\x0446\x0020\x043d\x0430"
- L"\x0020\x0440\x0443\x0441\x0441\x043a\x043e\x043c",
- // "전체서비스"
- L"\xc804\xccb4\xc11c\xbe44\xc2a4",
-
- // Test characters that take more than 16 bits. This will depend on whether
- // wchar_t is 16 or 32 bits.
-#if defined(WCHAR_T_IS_UTF16)
- L"\xd800\xdf00",
- // ????? (Mathematical Alphanumeric Symbols (U+011d40 - U+011d44 : A,B,C,D,E)
- L"\xd807\xdd40\xd807\xdd41\xd807\xdd42\xd807\xdd43\xd807\xdd44",
-#elif defined(WCHAR_T_IS_UTF32)
- L"\x10300",
- // ????? (Mathematical Alphanumeric Symbols (U+011d40 - U+011d44 : A,B,C,D,E)
- L"\x11d40\x11d41\x11d42\x11d43\x11d44",
-#endif
-};
-
-
-TEST(SysStrings, SysNativeMBAndWide) {
-#if !defined(SYSTEM_NATIVE_UTF8)
- ScopedLocale locale("en_US.UTF-8");
-#endif
- for (size_t i = 0; i < arraysize(kConvertRoundtripCases); ++i) {
- std::wstring wide = kConvertRoundtripCases[i];
- std::wstring trip = SysNativeMBToWide(SysWideToNativeMB(wide));
- EXPECT_EQ(wide.size(), trip.size());
- EXPECT_EQ(wide, trip);
- }
-
- // We assume our test is running in UTF-8, so double check through ICU.
- for (size_t i = 0; i < arraysize(kConvertRoundtripCases); ++i) {
- std::wstring wide = kConvertRoundtripCases[i];
- std::wstring trip = SysNativeMBToWide(WideToUTF8(wide));
- EXPECT_EQ(wide.size(), trip.size());
- EXPECT_EQ(wide, trip);
- }
-
- for (size_t i = 0; i < arraysize(kConvertRoundtripCases); ++i) {
- std::wstring wide = kConvertRoundtripCases[i];
- std::wstring trip = UTF8ToWide(SysWideToNativeMB(wide));
- EXPECT_EQ(wide.size(), trip.size());
- EXPECT_EQ(wide, trip);
- }
-}
-#endif // OS_LINUX
-
-} // namespace base
diff --git a/base/strings/utf_offset_string_conversions_unittest.cc b/base/strings/utf_offset_string_conversions_unittest.cc
deleted file mode 100644
index c5ce647..0000000
--- a/base/strings/utf_offset_string_conversions_unittest.cc
+++ /dev/null
@@ -1,300 +0,0 @@
-// Copyright (c) 2011 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 <stddef.h>
-
-#include <algorithm>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/utf_offset_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-static const size_t kNpos = string16::npos;
-
-} // namespace
-
-TEST(UTFOffsetStringConversionsTest, AdjustOffset) {
- struct UTF8ToUTF16Case {
- const char* utf8;
- size_t input_offset;
- size_t output_offset;
- } utf8_to_utf16_cases[] = {
- {"", 0, 0},
- {"", kNpos, kNpos},
- {"\xe4\xbd\xa0\xe5\xa5\xbd", 1, kNpos},
- {"\xe4\xbd\xa0\xe5\xa5\xbd", 3, 1},
- {"\xed\xb0\x80z", 3, 3},
- {"A\xF0\x90\x8C\x80z", 1, 1},
- {"A\xF0\x90\x8C\x80z", 2, kNpos},
- {"A\xF0\x90\x8C\x80z", 5, 3},
- {"A\xF0\x90\x8C\x80z", 6, 4},
- {"A\xF0\x90\x8C\x80z", kNpos, kNpos},
- };
- for (size_t i = 0; i < arraysize(utf8_to_utf16_cases); ++i) {
- const size_t offset = utf8_to_utf16_cases[i].input_offset;
- std::vector<size_t> offsets;
- offsets.push_back(offset);
- UTF8ToUTF16AndAdjustOffsets(utf8_to_utf16_cases[i].utf8, &offsets);
- EXPECT_EQ(utf8_to_utf16_cases[i].output_offset, offsets[0]);
- }
-
- struct UTF16ToUTF8Case {
- char16 utf16[10];
- size_t input_offset;
- size_t output_offset;
- } utf16_to_utf8_cases[] = {
- {{}, 0, 0},
- // Converted to 3-byte utf-8 sequences
- {{0x5909, 0x63DB}, 3, kNpos},
- {{0x5909, 0x63DB}, 2, 6},
- {{0x5909, 0x63DB}, 1, 3},
- {{0x5909, 0x63DB}, 0, 0},
- // Converted to 2-byte utf-8 sequences
- {{'A', 0x00bc, 0x00be, 'z'}, 1, 1},
- {{'A', 0x00bc, 0x00be, 'z'}, 2, 3},
- {{'A', 0x00bc, 0x00be, 'z'}, 3, 5},
- {{'A', 0x00bc, 0x00be, 'z'}, 4, 6},
- // Surrogate pair
- {{'A', 0xd800, 0xdf00, 'z'}, 1, 1},
- {{'A', 0xd800, 0xdf00, 'z'}, 2, kNpos},
- {{'A', 0xd800, 0xdf00, 'z'}, 3, 5},
- {{'A', 0xd800, 0xdf00, 'z'}, 4, 6},
- };
- for (size_t i = 0; i < arraysize(utf16_to_utf8_cases); ++i) {
- size_t offset = utf16_to_utf8_cases[i].input_offset;
- std::vector<size_t> offsets;
- offsets.push_back(offset);
- UTF16ToUTF8AndAdjustOffsets(utf16_to_utf8_cases[i].utf16, &offsets);
- EXPECT_EQ(utf16_to_utf8_cases[i].output_offset, offsets[0]) << i;
- }
-}
-
-TEST(UTFOffsetStringConversionsTest, LimitOffsets) {
- const OffsetAdjuster::Adjustments kNoAdjustments;
- const size_t kLimit = 10;
- const size_t kItems = 20;
- std::vector<size_t> size_ts;
- for (size_t t = 0; t < kItems; ++t) {
- size_ts.push_back(t);
- OffsetAdjuster::AdjustOffset(kNoAdjustments, &size_ts.back(), kLimit);
- }
- size_t unlimited_count = 0;
- for (std::vector<size_t>::iterator ti = size_ts.begin(); ti != size_ts.end();
- ++ti) {
- if (*ti != kNpos)
- ++unlimited_count;
- }
- EXPECT_EQ(11U, unlimited_count);
-
- // Reverse the values in the vector and try again.
- size_ts.clear();
- for (size_t t = kItems; t > 0; --t) {
- size_ts.push_back(t - 1);
- OffsetAdjuster::AdjustOffset(kNoAdjustments, &size_ts.back(), kLimit);
- }
- unlimited_count = 0;
- for (std::vector<size_t>::iterator ti = size_ts.begin(); ti != size_ts.end();
- ++ti) {
- if (*ti != kNpos)
- ++unlimited_count;
- }
- EXPECT_EQ(11U, unlimited_count);
-}
-
-TEST(UTFOffsetStringConversionsTest, AdjustOffsets) {
- // Imagine we have strings as shown in the following cases where the
- // X's represent encoded characters.
- // 1: abcXXXdef ==> abcXdef
- {
- std::vector<size_t> offsets;
- for (size_t t = 0; t <= 9; ++t)
- offsets.push_back(t);
- OffsetAdjuster::Adjustments adjustments;
- adjustments.push_back(OffsetAdjuster::Adjustment(3, 3, 1));
- OffsetAdjuster::AdjustOffsets(adjustments, &offsets);
- size_t expected_1[] = {0, 1, 2, 3, kNpos, kNpos, 4, 5, 6, 7};
- EXPECT_EQ(offsets.size(), arraysize(expected_1));
- for (size_t i = 0; i < arraysize(expected_1); ++i)
- EXPECT_EQ(expected_1[i], offsets[i]);
- }
-
- // 2: XXXaXXXXbcXXXXXXXdefXXX ==> XaXXbcXXXXdefX
- {
- std::vector<size_t> offsets;
- for (size_t t = 0; t <= 23; ++t)
- offsets.push_back(t);
- OffsetAdjuster::Adjustments adjustments;
- adjustments.push_back(OffsetAdjuster::Adjustment(0, 3, 1));
- adjustments.push_back(OffsetAdjuster::Adjustment(4, 4, 2));
- adjustments.push_back(OffsetAdjuster::Adjustment(10, 7, 4));
- adjustments.push_back(OffsetAdjuster::Adjustment(20, 3, 1));
- OffsetAdjuster::AdjustOffsets(adjustments, &offsets);
- size_t expected_2[] = {
- 0, kNpos, kNpos, 1, 2, kNpos, kNpos, kNpos, 4, 5, 6, kNpos, kNpos, kNpos,
- kNpos, kNpos, kNpos, 10, 11, 12, 13, kNpos, kNpos, 14
- };
- EXPECT_EQ(offsets.size(), arraysize(expected_2));
- for (size_t i = 0; i < arraysize(expected_2); ++i)
- EXPECT_EQ(expected_2[i], offsets[i]);
- }
-
- // 3: XXXaXXXXbcdXXXeXX ==> aXXXXbcdXXXe
- {
- std::vector<size_t> offsets;
- for (size_t t = 0; t <= 17; ++t)
- offsets.push_back(t);
- OffsetAdjuster::Adjustments adjustments;
- adjustments.push_back(OffsetAdjuster::Adjustment(0, 3, 0));
- adjustments.push_back(OffsetAdjuster::Adjustment(4, 4, 4));
- adjustments.push_back(OffsetAdjuster::Adjustment(11, 3, 3));
- adjustments.push_back(OffsetAdjuster::Adjustment(15, 2, 0));
- OffsetAdjuster::AdjustOffsets(adjustments, &offsets);
- size_t expected_3[] = {
- 0, kNpos, kNpos, 0, 1, kNpos, kNpos, kNpos, 5, 6, 7, 8, kNpos, kNpos, 11,
- 12, kNpos, 12
- };
- EXPECT_EQ(offsets.size(), arraysize(expected_3));
- for (size_t i = 0; i < arraysize(expected_3); ++i)
- EXPECT_EQ(expected_3[i], offsets[i]);
- }
-}
-
-TEST(UTFOffsetStringConversionsTest, UnadjustOffsets) {
- // Imagine we have strings as shown in the following cases where the
- // X's represent encoded characters.
- // 1: abcXXXdef ==> abcXdef
- {
- std::vector<size_t> offsets;
- for (size_t t = 0; t <= 7; ++t)
- offsets.push_back(t);
- OffsetAdjuster::Adjustments adjustments;
- adjustments.push_back(OffsetAdjuster::Adjustment(3, 3, 1));
- OffsetAdjuster::UnadjustOffsets(adjustments, &offsets);
- size_t expected_1[] = {0, 1, 2, 3, 6, 7, 8, 9};
- EXPECT_EQ(offsets.size(), arraysize(expected_1));
- for (size_t i = 0; i < arraysize(expected_1); ++i)
- EXPECT_EQ(expected_1[i], offsets[i]);
- }
-
- // 2: XXXaXXXXbcXXXXXXXdefXXX ==> XaXXbcXXXXdefX
- {
- std::vector<size_t> offsets;
- for (size_t t = 0; t <= 14; ++t)
- offsets.push_back(t);
- OffsetAdjuster::Adjustments adjustments;
- adjustments.push_back(OffsetAdjuster::Adjustment(0, 3, 1));
- adjustments.push_back(OffsetAdjuster::Adjustment(4, 4, 2));
- adjustments.push_back(OffsetAdjuster::Adjustment(10, 7, 4));
- adjustments.push_back(OffsetAdjuster::Adjustment(20, 3, 1));
- OffsetAdjuster::UnadjustOffsets(adjustments, &offsets);
- size_t expected_2[] = {
- 0, 3, 4, kNpos, 8, 9, 10, kNpos, kNpos, kNpos, 17, 18, 19, 20, 23
- };
- EXPECT_EQ(offsets.size(), arraysize(expected_2));
- for (size_t i = 0; i < arraysize(expected_2); ++i)
- EXPECT_EQ(expected_2[i], offsets[i]);
- }
-
- // 3: XXXaXXXXbcdXXXeXX ==> aXXXXbcdXXXe
- {
- std::vector<size_t> offsets;
- for (size_t t = 0; t <= 12; ++t)
- offsets.push_back(t);
- OffsetAdjuster::Adjustments adjustments;
- adjustments.push_back(OffsetAdjuster::Adjustment(0, 3, 0));
- adjustments.push_back(OffsetAdjuster::Adjustment(4, 4, 4));
- adjustments.push_back(OffsetAdjuster::Adjustment(11, 3, 3));
- adjustments.push_back(OffsetAdjuster::Adjustment(15, 2, 0));
- OffsetAdjuster::UnadjustOffsets(adjustments, &offsets);
- size_t expected_3[] = {
- 0, // this could just as easily be 3
- 4, kNpos, kNpos, kNpos, 8, 9, 10, 11, kNpos, kNpos, 14,
- 15 // this could just as easily be 17
- };
- EXPECT_EQ(offsets.size(), arraysize(expected_3));
- for (size_t i = 0; i < arraysize(expected_3); ++i)
- EXPECT_EQ(expected_3[i], offsets[i]);
- }
-}
-
-// MergeSequentialAdjustments is used by net/base/escape.{h,cc} and
-// net/base/net_util.{h,cc}. The two tests EscapeTest.AdjustOffset and
-// NetUtilTest.FormatUrlWithOffsets test its behavior extensively. This
-// is simply a short, additional test.
-TEST(UTFOffsetStringConversionsTest, MergeSequentialAdjustments) {
- // Pretend the input string is "abcdefghijklmnopqrstuvwxyz".
-
- // Set up |first_adjustments| to
- // - remove the leading "a"
- // - combine the "bc" into one character (call it ".")
- // - remove the "f"
- // - remove the "tuv"
- // The resulting string should be ".deghijklmnopqrswxyz".
- OffsetAdjuster::Adjustments first_adjustments;
- first_adjustments.push_back(OffsetAdjuster::Adjustment(0, 1, 0));
- first_adjustments.push_back(OffsetAdjuster::Adjustment(1, 2, 1));
- first_adjustments.push_back(OffsetAdjuster::Adjustment(5, 1, 0));
- first_adjustments.push_back(OffsetAdjuster::Adjustment(19, 3, 0));
-
- // Set up |adjustments_on_adjusted_string| to
- // - combine the "." character that replaced "bc" with "d" into one character
- // (call it "?")
- // - remove the "egh"
- // - expand the "i" into two characters (call them "12")
- // - combine the "jkl" into one character (call it "@")
- // - expand the "z" into two characters (call it "34")
- // The resulting string should be "?12@mnopqrswxy34".
- OffsetAdjuster::Adjustments adjustments_on_adjusted_string;
- adjustments_on_adjusted_string.push_back(OffsetAdjuster::Adjustment(
- 0, 2, 1));
- adjustments_on_adjusted_string.push_back(OffsetAdjuster::Adjustment(
- 2, 3, 0));
- adjustments_on_adjusted_string.push_back(OffsetAdjuster::Adjustment(
- 5, 1, 2));
- adjustments_on_adjusted_string.push_back(OffsetAdjuster::Adjustment(
- 6, 3, 1));
- adjustments_on_adjusted_string.push_back(OffsetAdjuster::Adjustment(
- 19, 1, 2));
-
- // Now merge the adjustments and check the results.
- OffsetAdjuster::MergeSequentialAdjustments(first_adjustments,
- &adjustments_on_adjusted_string);
- // The merged adjustments should look like
- // - combine abcd into "?"
- // - note: it's also reasonable for the Merge function to instead produce
- // two adjustments instead of this, one to remove a and another to
- // combine bcd into "?". This test verifies the current behavior.
- // - remove efgh
- // - expand i into "12"
- // - combine jkl into "@"
- // - remove tuv
- // - expand z into "34"
- ASSERT_EQ(6u, adjustments_on_adjusted_string.size());
- EXPECT_EQ(0u, adjustments_on_adjusted_string[0].original_offset);
- EXPECT_EQ(4u, adjustments_on_adjusted_string[0].original_length);
- EXPECT_EQ(1u, adjustments_on_adjusted_string[0].output_length);
- EXPECT_EQ(4u, adjustments_on_adjusted_string[1].original_offset);
- EXPECT_EQ(4u, adjustments_on_adjusted_string[1].original_length);
- EXPECT_EQ(0u, adjustments_on_adjusted_string[1].output_length);
- EXPECT_EQ(8u, adjustments_on_adjusted_string[2].original_offset);
- EXPECT_EQ(1u, adjustments_on_adjusted_string[2].original_length);
- EXPECT_EQ(2u, adjustments_on_adjusted_string[2].output_length);
- EXPECT_EQ(9u, adjustments_on_adjusted_string[3].original_offset);
- EXPECT_EQ(3u, adjustments_on_adjusted_string[3].original_length);
- EXPECT_EQ(1u, adjustments_on_adjusted_string[3].output_length);
- EXPECT_EQ(19u, adjustments_on_adjusted_string[4].original_offset);
- EXPECT_EQ(3u, adjustments_on_adjusted_string[4].original_length);
- EXPECT_EQ(0u, adjustments_on_adjusted_string[4].output_length);
- EXPECT_EQ(25u, adjustments_on_adjusted_string[5].original_offset);
- EXPECT_EQ(1u, adjustments_on_adjusted_string[5].original_length);
- EXPECT_EQ(2u, adjustments_on_adjusted_string[5].output_length);
-}
-
-} // namespace base
diff --git a/base/strings/utf_string_conversions_unittest.cc b/base/strings/utf_string_conversions_unittest.cc
deleted file mode 100644
index ce776c8..0000000
--- a/base/strings/utf_string_conversions_unittest.cc
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright (c) 2010 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 <stddef.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-const wchar_t* const kConvertRoundtripCases[] = {
- L"Google Video",
- // "网页 图片 资讯更多 »"
- L"\x7f51\x9875\x0020\x56fe\x7247\x0020\x8d44\x8baf\x66f4\x591a\x0020\x00bb",
- // "Παγκόσμιος Ιστός"
- L"\x03a0\x03b1\x03b3\x03ba\x03cc\x03c3\x03bc\x03b9"
- L"\x03bf\x03c2\x0020\x0399\x03c3\x03c4\x03cc\x03c2",
- // "Поиск страниц на русском"
- L"\x041f\x043e\x0438\x0441\x043a\x0020\x0441\x0442"
- L"\x0440\x0430\x043d\x0438\x0446\x0020\x043d\x0430"
- L"\x0020\x0440\x0443\x0441\x0441\x043a\x043e\x043c",
- // "전체서비스"
- L"\xc804\xccb4\xc11c\xbe44\xc2a4",
-
- // Test characters that take more than 16 bits. This will depend on whether
- // wchar_t is 16 or 32 bits.
-#if defined(WCHAR_T_IS_UTF16)
- L"\xd800\xdf00",
- // ????? (Mathematical Alphanumeric Symbols (U+011d40 - U+011d44 : A,B,C,D,E)
- L"\xd807\xdd40\xd807\xdd41\xd807\xdd42\xd807\xdd43\xd807\xdd44",
-#elif defined(WCHAR_T_IS_UTF32)
- L"\x10300",
- // ????? (Mathematical Alphanumeric Symbols (U+011d40 - U+011d44 : A,B,C,D,E)
- L"\x11d40\x11d41\x11d42\x11d43\x11d44",
-#endif
-};
-
-} // namespace
-
-TEST(UTFStringConversionsTest, ConvertUTF8AndWide) {
- // we round-trip all the wide strings through UTF-8 to make sure everything
- // agrees on the conversion. This uses the stream operators to test them
- // simultaneously.
- for (size_t i = 0; i < arraysize(kConvertRoundtripCases); ++i) {
- std::ostringstream utf8;
- utf8 << WideToUTF8(kConvertRoundtripCases[i]);
- std::wostringstream wide;
- wide << UTF8ToWide(utf8.str());
-
- EXPECT_EQ(kConvertRoundtripCases[i], wide.str());
- }
-}
-
-TEST(UTFStringConversionsTest, ConvertUTF8AndWideEmptyString) {
- // An empty std::wstring should be converted to an empty std::string,
- // and vice versa.
- std::wstring wempty;
- std::string empty;
- EXPECT_EQ(empty, WideToUTF8(wempty));
- EXPECT_EQ(wempty, UTF8ToWide(empty));
-}
-
-TEST(UTFStringConversionsTest, ConvertUTF8ToWide) {
- struct UTF8ToWideCase {
- const char* utf8;
- const wchar_t* wide;
- bool success;
- } convert_cases[] = {
- // Regular UTF-8 input.
- {"\xe4\xbd\xa0\xe5\xa5\xbd", L"\x4f60\x597d", true},
- // Non-character is passed through.
- {"\xef\xbf\xbfHello", L"\xffffHello", true},
- // Truncated UTF-8 sequence.
- {"\xe4\xa0\xe5\xa5\xbd", L"\xfffd\x597d", false},
- // Truncated off the end.
- {"\xe5\xa5\xbd\xe4\xa0", L"\x597d\xfffd", false},
- // Non-shortest-form UTF-8.
- {"\xf0\x84\xbd\xa0\xe5\xa5\xbd", L"\xfffd\xfffd\xfffd\xfffd\x597d", false},
- // This UTF-8 character decodes to a UTF-16 surrogate, which is illegal.
- {"\xed\xb0\x80", L"\xfffd\xfffd\xfffd", false},
- // Non-BMP characters. The second is a non-character regarded as valid.
- // The result will either be in UTF-16 or UTF-32.
-#if defined(WCHAR_T_IS_UTF16)
- {"A\xF0\x90\x8C\x80z", L"A\xd800\xdf00z", true},
- {"A\xF4\x8F\xBF\xBEz", L"A\xdbff\xdffez", true},
-#elif defined(WCHAR_T_IS_UTF32)
- {"A\xF0\x90\x8C\x80z", L"A\x10300z", true},
- {"A\xF4\x8F\xBF\xBEz", L"A\x10fffez", true},
-#endif
- };
-
- for (size_t i = 0; i < arraysize(convert_cases); i++) {
- std::wstring converted;
- EXPECT_EQ(convert_cases[i].success,
- UTF8ToWide(convert_cases[i].utf8,
- strlen(convert_cases[i].utf8),
- &converted));
- std::wstring expected(convert_cases[i].wide);
- EXPECT_EQ(expected, converted);
- }
-
- // Manually test an embedded NULL.
- std::wstring converted;
- EXPECT_TRUE(UTF8ToWide("\00Z\t", 3, &converted));
- ASSERT_EQ(3U, converted.length());
- EXPECT_EQ(static_cast<wchar_t>(0), converted[0]);
- EXPECT_EQ('Z', converted[1]);
- EXPECT_EQ('\t', converted[2]);
-
- // Make sure that conversion replaces, not appends.
- EXPECT_TRUE(UTF8ToWide("B", 1, &converted));
- ASSERT_EQ(1U, converted.length());
- EXPECT_EQ('B', converted[0]);
-}
-
-#if defined(WCHAR_T_IS_UTF16)
-// This test is only valid when wchar_t == UTF-16.
-TEST(UTFStringConversionsTest, ConvertUTF16ToUTF8) {
- struct WideToUTF8Case {
- const wchar_t* utf16;
- const char* utf8;
- bool success;
- } convert_cases[] = {
- // Regular UTF-16 input.
- {L"\x4f60\x597d", "\xe4\xbd\xa0\xe5\xa5\xbd", true},
- // Test a non-BMP character.
- {L"\xd800\xdf00", "\xF0\x90\x8C\x80", true},
- // Non-characters are passed through.
- {L"\xffffHello", "\xEF\xBF\xBFHello", true},
- {L"\xdbff\xdffeHello", "\xF4\x8F\xBF\xBEHello", true},
- // The first character is a truncated UTF-16 character.
- {L"\xd800\x597d", "\xef\xbf\xbd\xe5\xa5\xbd", false},
- // Truncated at the end.
- {L"\x597d\xd800", "\xe5\xa5\xbd\xef\xbf\xbd", false},
- };
-
- for (const auto& test : convert_cases) {
- std::string converted;
- EXPECT_EQ(test.success,
- WideToUTF8(test.utf16, wcslen(test.utf16), &converted));
- std::string expected(test.utf8);
- EXPECT_EQ(expected, converted);
- }
-}
-
-#elif defined(WCHAR_T_IS_UTF32)
-// This test is only valid when wchar_t == UTF-32.
-TEST(UTFStringConversionsTest, ConvertUTF32ToUTF8) {
- struct WideToUTF8Case {
- const wchar_t* utf32;
- const char* utf8;
- bool success;
- } convert_cases[] = {
- // Regular 16-bit input.
- {L"\x4f60\x597d", "\xe4\xbd\xa0\xe5\xa5\xbd", true},
- // Test a non-BMP character.
- {L"A\x10300z", "A\xF0\x90\x8C\x80z", true},
- // Non-characters are passed through.
- {L"\xffffHello", "\xEF\xBF\xBFHello", true},
- {L"\x10fffeHello", "\xF4\x8F\xBF\xBEHello", true},
- // Invalid Unicode code points.
- {L"\xfffffffHello", "\xEF\xBF\xBDHello", false},
- // The first character is a truncated UTF-16 character.
- {L"\xd800\x597d", "\xef\xbf\xbd\xe5\xa5\xbd", false},
- {L"\xdc01Hello", "\xef\xbf\xbdHello", false},
- };
-
- for (const auto& test : convert_cases) {
- std::string converted;
- EXPECT_EQ(test.success,
- WideToUTF8(test.utf32, wcslen(test.utf32), &converted));
- std::string expected(test.utf8);
- EXPECT_EQ(expected, converted);
- }
-}
-#endif // defined(WCHAR_T_IS_UTF32)
-
-TEST(UTFStringConversionsTest, ConvertMultiString) {
- static char16 multi16[] = {
- 'f', 'o', 'o', '\0',
- 'b', 'a', 'r', '\0',
- 'b', 'a', 'z', '\0',
- '\0'
- };
- static char multi[] = {
- 'f', 'o', 'o', '\0',
- 'b', 'a', 'r', '\0',
- 'b', 'a', 'z', '\0',
- '\0'
- };
- string16 multistring16;
- memcpy(WriteInto(&multistring16, arraysize(multi16)), multi16,
- sizeof(multi16));
- EXPECT_EQ(arraysize(multi16) - 1, multistring16.length());
- std::string expected;
- memcpy(WriteInto(&expected, arraysize(multi)), multi, sizeof(multi));
- EXPECT_EQ(arraysize(multi) - 1, expected.length());
- const std::string& converted = UTF16ToUTF8(multistring16);
- EXPECT_EQ(arraysize(multi) - 1, converted.length());
- EXPECT_EQ(expected, converted);
-}
-
-} // namespace base
diff --git a/base/supports_user_data_unittest.cc b/base/supports_user_data_unittest.cc
deleted file mode 100644
index 2e0a724..0000000
--- a/base/supports_user_data_unittest.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2014 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 "base/supports_user_data.h"
-
-#include <vector>
-
-#include "base/memory/ptr_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-struct TestSupportsUserData : public SupportsUserData {};
-
-struct UsesItself : public SupportsUserData::Data {
- UsesItself(SupportsUserData* supports_user_data, const void* key)
- : supports_user_data_(supports_user_data),
- key_(key) {
- }
-
- ~UsesItself() override {
- EXPECT_EQ(nullptr, supports_user_data_->GetUserData(key_));
- }
-
- SupportsUserData* supports_user_data_;
- const void* key_;
-};
-
-TEST(SupportsUserDataTest, ClearWorksRecursively) {
- TestSupportsUserData supports_user_data;
- char key = 0;
- supports_user_data.SetUserData(
- &key, std::make_unique<UsesItself>(&supports_user_data, &key));
- // Destruction of supports_user_data runs the actual test.
-}
-
-} // namespace
-} // namespace base
diff --git a/base/sync_socket_unittest.cc b/base/sync_socket_unittest.cc
deleted file mode 100644
index fdcd9a1..0000000
--- a/base/sync_socket_unittest.cc
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 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 "base/sync_socket.h"
-
-#include "base/macros.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-constexpr TimeDelta kReceiveTimeout = base::TimeDelta::FromMilliseconds(750);
-
-class HangingReceiveThread : public DelegateSimpleThread::Delegate {
- public:
- explicit HangingReceiveThread(SyncSocket* socket, bool with_timeout)
- : socket_(socket),
- thread_(this, "HangingReceiveThread"),
- with_timeout_(with_timeout),
- started_event_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- done_event_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {
- thread_.Start();
- }
-
- ~HangingReceiveThread() override = default;
-
- void Run() override {
- int data = 0;
- ASSERT_EQ(socket_->Peek(), 0u);
-
- started_event_.Signal();
-
- if (with_timeout_) {
- ASSERT_EQ(0u, socket_->ReceiveWithTimeout(&data, sizeof(data),
- kReceiveTimeout));
- } else {
- ASSERT_EQ(0u, socket_->Receive(&data, sizeof(data)));
- }
-
- done_event_.Signal();
- }
-
- void Stop() {
- thread_.Join();
- }
-
- WaitableEvent* started_event() { return &started_event_; }
- WaitableEvent* done_event() { return &done_event_; }
-
- private:
- SyncSocket* socket_;
- DelegateSimpleThread thread_;
- bool with_timeout_;
- WaitableEvent started_event_;
- WaitableEvent done_event_;
-
- DISALLOW_COPY_AND_ASSIGN(HangingReceiveThread);
-};
-
-// Tests sending data between two SyncSockets. Uses ASSERT() and thus will exit
-// early upon failure. Callers should use ASSERT_NO_FATAL_FAILURE() if testing
-// continues after return.
-void SendReceivePeek(SyncSocket* socket_a, SyncSocket* socket_b) {
- int received = 0;
- const int kSending = 123;
- static_assert(sizeof(kSending) == sizeof(received), "invalid data size");
-
- ASSERT_EQ(0u, socket_a->Peek());
- ASSERT_EQ(0u, socket_b->Peek());
-
- // Verify |socket_a| can send to |socket_a| and |socket_a| can Receive from
- // |socket_a|.
- ASSERT_EQ(sizeof(kSending), socket_a->Send(&kSending, sizeof(kSending)));
- ASSERT_EQ(sizeof(kSending), socket_b->Peek());
- ASSERT_EQ(sizeof(kSending), socket_b->Receive(&received, sizeof(kSending)));
- ASSERT_EQ(kSending, received);
-
- ASSERT_EQ(0u, socket_a->Peek());
- ASSERT_EQ(0u, socket_b->Peek());
-
- // Now verify the reverse.
- received = 0;
- ASSERT_EQ(sizeof(kSending), socket_b->Send(&kSending, sizeof(kSending)));
- ASSERT_EQ(sizeof(kSending), socket_a->Peek());
- ASSERT_EQ(sizeof(kSending), socket_a->Receive(&received, sizeof(kSending)));
- ASSERT_EQ(kSending, received);
-
- ASSERT_EQ(0u, socket_a->Peek());
- ASSERT_EQ(0u, socket_b->Peek());
-
- ASSERT_TRUE(socket_a->Close());
- ASSERT_TRUE(socket_b->Close());
-}
-
-} // namespace
-
-class SyncSocketTest : public testing::Test {
- public:
- void SetUp() override {
- ASSERT_TRUE(SyncSocket::CreatePair(&socket_a_, &socket_b_));
- }
-
- protected:
- SyncSocket socket_a_;
- SyncSocket socket_b_;
-};
-
-TEST_F(SyncSocketTest, NormalSendReceivePeek) {
- SendReceivePeek(&socket_a_, &socket_b_);
-}
-
-TEST_F(SyncSocketTest, ClonedSendReceivePeek) {
- SyncSocket socket_c(socket_a_.Release());
- SyncSocket socket_d(socket_b_.Release());
- SendReceivePeek(&socket_c, &socket_d);
-};
-
-class CancelableSyncSocketTest : public testing::Test {
- public:
- void SetUp() override {
- ASSERT_TRUE(CancelableSyncSocket::CreatePair(&socket_a_, &socket_b_));
- }
-
- protected:
- CancelableSyncSocket socket_a_;
- CancelableSyncSocket socket_b_;
-};
-
-TEST_F(CancelableSyncSocketTest, NormalSendReceivePeek) {
- SendReceivePeek(&socket_a_, &socket_b_);
-}
-
-TEST_F(CancelableSyncSocketTest, ClonedSendReceivePeek) {
- CancelableSyncSocket socket_c(socket_a_.Release());
- CancelableSyncSocket socket_d(socket_b_.Release());
- SendReceivePeek(&socket_c, &socket_d);
-}
-
-TEST_F(CancelableSyncSocketTest, ShutdownCancelsReceive) {
- HangingReceiveThread thread(&socket_b_, /* with_timeout = */ false);
-
- // Wait for the thread to be started. Note that this doesn't guarantee that
- // Receive() is called before Shutdown().
- thread.started_event()->Wait();
-
- EXPECT_TRUE(socket_b_.Shutdown());
- EXPECT_TRUE(thread.done_event()->TimedWait(kReceiveTimeout));
-
- thread.Stop();
-}
-
-TEST_F(CancelableSyncSocketTest, ShutdownCancelsReceiveWithTimeout) {
- HangingReceiveThread thread(&socket_b_, /* with_timeout = */ true);
-
- // Wait for the thread to be started. Note that this doesn't guarantee that
- // Receive() is called before Shutdown().
- thread.started_event()->Wait();
-
- EXPECT_TRUE(socket_b_.Shutdown());
- EXPECT_TRUE(thread.done_event()->TimedWait(kReceiveTimeout));
-
- thread.Stop();
-}
-
-TEST_F(CancelableSyncSocketTest, ReceiveAfterShutdown) {
- socket_a_.Shutdown();
- int data = 0;
- EXPECT_EQ(0u, socket_a_.Receive(&data, sizeof(data)));
-}
-
-TEST_F(CancelableSyncSocketTest, ReceiveWithTimeoutAfterShutdown) {
- socket_a_.Shutdown();
- TimeTicks start = TimeTicks::Now();
- int data = 0;
- EXPECT_EQ(0u,
- socket_a_.ReceiveWithTimeout(&data, sizeof(data), kReceiveTimeout));
-
- // Ensure the receive didn't just timeout.
- EXPECT_LT(TimeTicks::Now() - start, kReceiveTimeout);
-}
-
-} // namespace base
diff --git a/base/synchronization/atomic_flag_unittest.cc b/base/synchronization/atomic_flag_unittest.cc
deleted file mode 100644
index 1a3da7f..0000000
--- a/base/synchronization/atomic_flag_unittest.cc
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) 2011 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 "base/synchronization/atomic_flag.h"
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-void ExpectSetFlagDeath(AtomicFlag* flag) {
- ASSERT_TRUE(flag);
- EXPECT_DCHECK_DEATH(flag->Set());
-}
-
-// Busy waits (to explicitly avoid using synchronization constructs that would
-// defeat the purpose of testing atomics) until |tested_flag| is set and then
-// verifies that non-atomic |*expected_after_flag| is true and sets |*done_flag|
-// before returning if it's non-null.
-void BusyWaitUntilFlagIsSet(AtomicFlag* tested_flag, bool* expected_after_flag,
- AtomicFlag* done_flag) {
- while (!tested_flag->IsSet())
- PlatformThread::YieldCurrentThread();
-
- EXPECT_TRUE(*expected_after_flag);
- if (done_flag)
- done_flag->Set();
-}
-
-} // namespace
-
-TEST(AtomicFlagTest, SimpleSingleThreadedTest) {
- AtomicFlag flag;
- ASSERT_FALSE(flag.IsSet());
- flag.Set();
- ASSERT_TRUE(flag.IsSet());
-}
-
-TEST(AtomicFlagTest, DoubleSetTest) {
- AtomicFlag flag;
- ASSERT_FALSE(flag.IsSet());
- flag.Set();
- ASSERT_TRUE(flag.IsSet());
- flag.Set();
- ASSERT_TRUE(flag.IsSet());
-}
-
-TEST(AtomicFlagTest, ReadFromDifferentThread) {
- // |tested_flag| is the one being tested below.
- AtomicFlag tested_flag;
- // |expected_after_flag| is used to confirm that sequential consistency is
- // obtained around |tested_flag|.
- bool expected_after_flag = false;
- // |reset_flag| is used to confirm the test flows as intended without using
- // synchronization constructs which would defeat the purpose of exercising
- // atomics.
- AtomicFlag reset_flag;
-
- Thread thread("AtomicFlagTest.ReadFromDifferentThread");
- ASSERT_TRUE(thread.Start());
- thread.task_runner()->PostTask(FROM_HERE,
- BindOnce(&BusyWaitUntilFlagIsSet, &tested_flag,
- &expected_after_flag, &reset_flag));
-
- // To verify that IsSet() fetches the flag's value from memory every time it
- // is called (not just the first time that it is called on a thread), sleep
- // before setting the flag.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(20));
-
- // |expected_after_flag| is used to verify that all memory operations
- // performed before |tested_flag| is Set() are visible to threads that can see
- // IsSet().
- expected_after_flag = true;
- tested_flag.Set();
-
- // Sleep again to give the busy loop time to observe the flag and verify
- // expectations.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(20));
-
- // Use |reset_flag| to confirm that the above completed (which the rest of
- // this test assumes).
- while (!reset_flag.IsSet())
- PlatformThread::YieldCurrentThread();
-
- tested_flag.UnsafeResetForTesting();
- EXPECT_FALSE(tested_flag.IsSet());
- expected_after_flag = false;
-
- // Perform the same test again after the controlled UnsafeResetForTesting(),
- // |thread| is guaranteed to be synchronized past the
- // |UnsafeResetForTesting()| call when the task runs per the implicit
- // synchronization in the post task mechanism.
- thread.task_runner()->PostTask(FROM_HERE,
- BindOnce(&BusyWaitUntilFlagIsSet, &tested_flag,
- &expected_after_flag, nullptr));
-
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(20));
-
- expected_after_flag = true;
- tested_flag.Set();
-
- // The |thread|'s destructor will block until the posted task completes, so
- // the test will time out if it fails to see the flag be set.
-}
-
-TEST(AtomicFlagTest, SetOnDifferentSequenceDeathTest) {
- // Checks that Set() can't be called from another sequence after being called
- // on this one. AtomicFlag should die on a DCHECK if Set() is called again
- // from another sequence.
-
- // Note: flag must be declared before the Thread so that its destructor runs
- // later. Otherwise there's a race between destructing flag and running
- // ExpectSetFlagDeath.
- AtomicFlag flag;
-
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
- Thread t("AtomicFlagTest.SetOnDifferentThreadDeathTest");
- ASSERT_TRUE(t.Start());
- EXPECT_TRUE(t.WaitUntilThreadStarted());
-
- flag.Set();
- t.task_runner()->PostTask(FROM_HERE, BindOnce(&ExpectSetFlagDeath, &flag));
-}
-
-} // namespace base
diff --git a/base/synchronization/condition_variable_unittest.cc b/base/synchronization/condition_variable_unittest.cc
deleted file mode 100644
index 929060a..0000000
--- a/base/synchronization/condition_variable_unittest.cc
+++ /dev/null
@@ -1,768 +0,0 @@
-// 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.
-
-// Multi-threaded tests of ConditionVariable class.
-
-#include "base/synchronization/condition_variable.h"
-
-#include <time.h>
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/spin_wait.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_collision_warner.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-namespace base {
-
-namespace {
-//------------------------------------------------------------------------------
-// Define our test class, with several common variables.
-//------------------------------------------------------------------------------
-
-class ConditionVariableTest : public PlatformTest {
- public:
- const TimeDelta kZeroMs;
- const TimeDelta kTenMs;
- const TimeDelta kThirtyMs;
- const TimeDelta kFortyFiveMs;
- const TimeDelta kSixtyMs;
- const TimeDelta kOneHundredMs;
-
- ConditionVariableTest()
- : kZeroMs(TimeDelta::FromMilliseconds(0)),
- kTenMs(TimeDelta::FromMilliseconds(10)),
- kThirtyMs(TimeDelta::FromMilliseconds(30)),
- kFortyFiveMs(TimeDelta::FromMilliseconds(45)),
- kSixtyMs(TimeDelta::FromMilliseconds(60)),
- kOneHundredMs(TimeDelta::FromMilliseconds(100)) {
- }
-};
-
-//------------------------------------------------------------------------------
-// Define a class that will control activities an several multi-threaded tests.
-// The general structure of multi-threaded tests is that a test case will
-// construct an instance of a WorkQueue. The WorkQueue will spin up some
-// threads and control them throughout their lifetime, as well as maintaining
-// a central repository of the work thread's activity. Finally, the WorkQueue
-// will command the the worker threads to terminate. At that point, the test
-// cases will validate that the WorkQueue has records showing that the desired
-// activities were performed.
-//------------------------------------------------------------------------------
-
-// Callers are responsible for synchronizing access to the following class.
-// The WorkQueue::lock_, as accessed via WorkQueue::lock(), should be used for
-// all synchronized access.
-class WorkQueue : public PlatformThread::Delegate {
- public:
- explicit WorkQueue(int thread_count);
- ~WorkQueue() override;
-
- // PlatformThread::Delegate interface.
- void ThreadMain() override;
-
- //----------------------------------------------------------------------------
- // Worker threads only call the following methods.
- // They should use the lock to get exclusive access.
- int GetThreadId(); // Get an ID assigned to a thread..
- bool EveryIdWasAllocated() const; // Indicates that all IDs were handed out.
- TimeDelta GetAnAssignment(int thread_id); // Get a work task duration.
- void WorkIsCompleted(int thread_id);
-
- int task_count() const;
- bool allow_help_requests() const; // Workers can signal more workers.
- bool shutdown() const; // Check if shutdown has been requested.
-
- void thread_shutting_down();
-
-
- //----------------------------------------------------------------------------
- // Worker threads can call them but not needed to acquire a lock.
- Lock* lock();
-
- ConditionVariable* work_is_available();
- ConditionVariable* all_threads_have_ids();
- ConditionVariable* no_more_tasks();
-
- //----------------------------------------------------------------------------
- // The rest of the methods are for use by the controlling master thread (the
- // test case code).
- void ResetHistory();
- int GetMinCompletionsByWorkerThread() const;
- int GetMaxCompletionsByWorkerThread() const;
- int GetNumThreadsTakingAssignments() const;
- int GetNumThreadsCompletingTasks() const;
- int GetNumberOfCompletedTasks() const;
-
- void SetWorkTime(TimeDelta delay);
- void SetTaskCount(int count);
- void SetAllowHelp(bool allow);
-
- // The following must be called without locking, and will spin wait until the
- // threads are all in a wait state.
- void SpinUntilAllThreadsAreWaiting();
- void SpinUntilTaskCountLessThan(int task_count);
-
- // Caller must acquire lock before calling.
- void SetShutdown();
-
- // Compares the |shutdown_task_count_| to the |thread_count| and returns true
- // if they are equal. This check will acquire the |lock_| so the caller
- // should not hold the lock when calling this method.
- bool ThreadSafeCheckShutdown(int thread_count);
-
- private:
- // Both worker threads and controller use the following to synchronize.
- Lock lock_;
- ConditionVariable work_is_available_; // To tell threads there is work.
-
- // Conditions to notify the controlling process (if it is interested).
- ConditionVariable all_threads_have_ids_; // All threads are running.
- ConditionVariable no_more_tasks_; // Task count is zero.
-
- const int thread_count_;
- int waiting_thread_count_;
- std::unique_ptr<PlatformThreadHandle[]> thread_handles_;
- std::vector<int> assignment_history_; // Number of assignment per worker.
- std::vector<int> completion_history_; // Number of completions per worker.
- int thread_started_counter_; // Used to issue unique id to workers.
- int shutdown_task_count_; // Number of tasks told to shutdown
- int task_count_; // Number of assignment tasks waiting to be processed.
- TimeDelta worker_delay_; // Time each task takes to complete.
- bool allow_help_requests_; // Workers can signal more workers.
- bool shutdown_; // Set when threads need to terminate.
-
- DFAKE_MUTEX(locked_methods_);
-};
-
-//------------------------------------------------------------------------------
-// The next section contains the actual tests.
-//------------------------------------------------------------------------------
-
-TEST_F(ConditionVariableTest, StartupShutdownTest) {
- Lock lock;
-
- // First try trivial startup/shutdown.
- {
- ConditionVariable cv1(&lock);
- } // Call for cv1 destruction.
-
- // Exercise with at least a few waits.
- ConditionVariable cv(&lock);
-
- lock.Acquire();
- cv.TimedWait(kTenMs); // Wait for 10 ms.
- cv.TimedWait(kTenMs); // Wait for 10 ms.
- lock.Release();
-
- lock.Acquire();
- cv.TimedWait(kTenMs); // Wait for 10 ms.
- cv.TimedWait(kTenMs); // Wait for 10 ms.
- cv.TimedWait(kTenMs); // Wait for 10 ms.
- lock.Release();
-} // Call for cv destruction.
-
-TEST_F(ConditionVariableTest, TimeoutTest) {
- Lock lock;
- ConditionVariable cv(&lock);
- lock.Acquire();
-
- TimeTicks start = TimeTicks::Now();
- const TimeDelta WAIT_TIME = TimeDelta::FromMilliseconds(300);
- // Allow for clocking rate granularity.
- const TimeDelta FUDGE_TIME = TimeDelta::FromMilliseconds(50);
-
- cv.TimedWait(WAIT_TIME + FUDGE_TIME);
- TimeDelta duration = TimeTicks::Now() - start;
- // We can't use EXPECT_GE here as the TimeDelta class does not support the
- // required stream conversion.
- EXPECT_TRUE(duration >= WAIT_TIME);
-
- lock.Release();
-}
-
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
-const int kDiscontinuitySeconds = 2;
-
-void BackInTime(Lock* lock) {
- AutoLock auto_lock(*lock);
-
- timeval tv;
- gettimeofday(&tv, nullptr);
- tv.tv_sec -= kDiscontinuitySeconds;
- settimeofday(&tv, nullptr);
-}
-
-// Tests that TimedWait ignores changes to the system clock.
-// Test is disabled by default, because it needs to run as root to muck with the
-// system clock.
-// http://crbug.com/293736
-TEST_F(ConditionVariableTest, DISABLED_TimeoutAcrossSetTimeOfDay) {
- timeval tv;
- gettimeofday(&tv, nullptr);
- tv.tv_sec += kDiscontinuitySeconds;
- if (settimeofday(&tv, nullptr) < 0) {
- PLOG(ERROR) << "Could not set time of day. Run as root?";
- return;
- }
-
- Lock lock;
- ConditionVariable cv(&lock);
- lock.Acquire();
-
- Thread thread("Helper");
- thread.Start();
- thread.task_runner()->PostTask(FROM_HERE, base::BindOnce(&BackInTime, &lock));
-
- TimeTicks start = TimeTicks::Now();
- const TimeDelta kWaitTime = TimeDelta::FromMilliseconds(300);
- // Allow for clocking rate granularity.
- const TimeDelta kFudgeTime = TimeDelta::FromMilliseconds(50);
-
- cv.TimedWait(kWaitTime + kFudgeTime);
- TimeDelta duration = TimeTicks::Now() - start;
-
- thread.Stop();
- // We can't use EXPECT_GE here as the TimeDelta class does not support the
- // required stream conversion.
- EXPECT_TRUE(duration >= kWaitTime);
- EXPECT_TRUE(duration <= TimeDelta::FromSeconds(kDiscontinuitySeconds));
-
- lock.Release();
-}
-#endif
-
-
-// Suddenly got flaky on Win, see http://crbug.com/10607 (starting at
-// comment #15).
-#if defined(OS_WIN)
-#define MAYBE_MultiThreadConsumerTest DISABLED_MultiThreadConsumerTest
-#else
-#define MAYBE_MultiThreadConsumerTest MultiThreadConsumerTest
-#endif
-// Test serial task servicing, as well as two parallel task servicing methods.
-TEST_F(ConditionVariableTest, MAYBE_MultiThreadConsumerTest) {
- const int kThreadCount = 10;
- WorkQueue queue(kThreadCount); // Start the threads.
-
- const int kTaskCount = 10; // Number of tasks in each mini-test here.
-
- Time start_time; // Used to time task processing.
-
- {
- base::AutoLock auto_lock(*queue.lock());
- while (!queue.EveryIdWasAllocated())
- queue.all_threads_have_ids()->Wait();
- }
-
- // If threads aren't in a wait state, they may start to gobble up tasks in
- // parallel, short-circuiting (breaking) this test.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- // Since we have no tasks yet, all threads should be waiting by now.
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(0, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(0, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_EQ(0, queue.GetMaxCompletionsByWorkerThread());
- EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
- EXPECT_EQ(0, queue.GetNumberOfCompletedTasks());
-
- // Set up to make each task include getting help from another worker, so
- // so that the work gets done in paralell.
- queue.ResetHistory();
- queue.SetTaskCount(kTaskCount);
- queue.SetWorkTime(kThirtyMs);
- queue.SetAllowHelp(true);
-
- start_time = Time::Now();
- }
-
- queue.work_is_available()->Signal(); // But each worker can signal another.
- // Wait till we at least start to handle tasks (and we're not all waiting).
- queue.SpinUntilTaskCountLessThan(kTaskCount);
- // Wait to allow the all workers to get done.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- // Wait until all work tasks have at least been assigned.
- base::AutoLock auto_lock(*queue.lock());
- while (queue.task_count())
- queue.no_more_tasks()->Wait();
-
- // To avoid racy assumptions, we'll just assert that at least 2 threads
- // did work. We know that the first worker should have gone to sleep, and
- // hence a second worker should have gotten an assignment.
- EXPECT_LE(2, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(kTaskCount, queue.GetNumberOfCompletedTasks());
-
- // Try to ask all workers to help, and only a few will do the work.
- queue.ResetHistory();
- queue.SetTaskCount(3);
- queue.SetWorkTime(kThirtyMs);
- queue.SetAllowHelp(false);
- }
- queue.work_is_available()->Broadcast(); // Make them all try.
- // Wait till we at least start to handle tasks (and we're not all waiting).
- queue.SpinUntilTaskCountLessThan(3);
- // Wait to allow the 3 workers to get done.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
- EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
- EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
-
- // Set up to make each task get help from another worker.
- queue.ResetHistory();
- queue.SetTaskCount(3);
- queue.SetWorkTime(kThirtyMs);
- queue.SetAllowHelp(true); // Allow (unnecessary) help requests.
- }
- queue.work_is_available()->Broadcast(); // Signal all threads.
- // Wait till we at least start to handle tasks (and we're not all waiting).
- queue.SpinUntilTaskCountLessThan(3);
- // Wait to allow the 3 workers to get done.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
- EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
- EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
-
- // Set up to make each task get help from another worker.
- queue.ResetHistory();
- queue.SetTaskCount(20); // 2 tasks per thread.
- queue.SetWorkTime(kThirtyMs);
- queue.SetAllowHelp(true);
- }
- queue.work_is_available()->Signal(); // But each worker can signal another.
- // Wait till we at least start to handle tasks (and we're not all waiting).
- queue.SpinUntilTaskCountLessThan(20);
- // Wait to allow the 10 workers to get done.
- queue.SpinUntilAllThreadsAreWaiting(); // Should take about 60 ms.
-
- {
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
-
- // Same as last test, but with Broadcast().
- queue.ResetHistory();
- queue.SetTaskCount(20); // 2 tasks per thread.
- queue.SetWorkTime(kThirtyMs);
- queue.SetAllowHelp(true);
- }
- queue.work_is_available()->Broadcast();
- // Wait till we at least start to handle tasks (and we're not all waiting).
- queue.SpinUntilTaskCountLessThan(20);
- // Wait to allow the 10 workers to get done.
- queue.SpinUntilAllThreadsAreWaiting(); // Should take about 60 ms.
-
- {
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
-
- queue.SetShutdown();
- }
- queue.work_is_available()->Broadcast(); // Force check for shutdown.
-
- SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(1),
- queue.ThreadSafeCheckShutdown(kThreadCount));
-}
-
-TEST_F(ConditionVariableTest, LargeFastTaskTest) {
- const int kThreadCount = 200;
- WorkQueue queue(kThreadCount); // Start the threads.
-
- Lock private_lock; // Used locally for master to wait.
- base::AutoLock private_held_lock(private_lock);
- ConditionVariable private_cv(&private_lock);
-
- {
- base::AutoLock auto_lock(*queue.lock());
- while (!queue.EveryIdWasAllocated())
- queue.all_threads_have_ids()->Wait();
- }
-
- // Wait a bit more to allow threads to reach their wait state.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- // Since we have no tasks, all threads should be waiting by now.
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(0, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(0, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_EQ(0, queue.GetMaxCompletionsByWorkerThread());
- EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
- EXPECT_EQ(0, queue.GetNumberOfCompletedTasks());
-
- // Set up to make all workers do (an average of) 20 tasks.
- queue.ResetHistory();
- queue.SetTaskCount(20 * kThreadCount);
- queue.SetWorkTime(kFortyFiveMs);
- queue.SetAllowHelp(false);
- }
- queue.work_is_available()->Broadcast(); // Start up all threads.
- // Wait until we've handed out all tasks.
- {
- base::AutoLock auto_lock(*queue.lock());
- while (queue.task_count() != 0)
- queue.no_more_tasks()->Wait();
- }
-
- // Wait till the last of the tasks complete.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- // With Broadcast(), every thread should have participated.
- // but with racing.. they may not all have done equal numbers of tasks.
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(kThreadCount, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(kThreadCount, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_LE(20, queue.GetMaxCompletionsByWorkerThread());
- EXPECT_EQ(20 * kThreadCount, queue.GetNumberOfCompletedTasks());
-
- // Set up to make all workers do (an average of) 4 tasks.
- queue.ResetHistory();
- queue.SetTaskCount(kThreadCount * 4);
- queue.SetWorkTime(kFortyFiveMs);
- queue.SetAllowHelp(true); // Might outperform Broadcast().
- }
- queue.work_is_available()->Signal(); // Start up one thread.
-
- // Wait until we've handed out all tasks
- {
- base::AutoLock auto_lock(*queue.lock());
- while (queue.task_count() != 0)
- queue.no_more_tasks()->Wait();
- }
-
- // Wait till the last of the tasks complete.
- queue.SpinUntilAllThreadsAreWaiting();
-
- {
- // With Signal(), every thread should have participated.
- // but with racing.. they may not all have done four tasks.
- base::AutoLock auto_lock(*queue.lock());
- EXPECT_EQ(kThreadCount, queue.GetNumThreadsTakingAssignments());
- EXPECT_EQ(kThreadCount, queue.GetNumThreadsCompletingTasks());
- EXPECT_EQ(0, queue.task_count());
- EXPECT_LE(4, queue.GetMaxCompletionsByWorkerThread());
- EXPECT_EQ(4 * kThreadCount, queue.GetNumberOfCompletedTasks());
-
- queue.SetShutdown();
- }
- queue.work_is_available()->Broadcast(); // Force check for shutdown.
-
- // Wait for shutdowns to complete.
- SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(1),
- queue.ThreadSafeCheckShutdown(kThreadCount));
-}
-
-//------------------------------------------------------------------------------
-// Finally we provide the implementation for the methods in the WorkQueue class.
-//------------------------------------------------------------------------------
-
-WorkQueue::WorkQueue(int thread_count)
- : lock_(),
- work_is_available_(&lock_),
- all_threads_have_ids_(&lock_),
- no_more_tasks_(&lock_),
- thread_count_(thread_count),
- waiting_thread_count_(0),
- thread_handles_(new PlatformThreadHandle[thread_count]),
- assignment_history_(thread_count),
- completion_history_(thread_count),
- thread_started_counter_(0),
- shutdown_task_count_(0),
- task_count_(0),
- allow_help_requests_(false),
- shutdown_(false) {
- EXPECT_GE(thread_count_, 1);
- ResetHistory();
- SetTaskCount(0);
- SetWorkTime(TimeDelta::FromMilliseconds(30));
-
- for (int i = 0; i < thread_count_; ++i) {
- PlatformThreadHandle pth;
- EXPECT_TRUE(PlatformThread::Create(0, this, &pth));
- thread_handles_[i] = pth;
- }
-}
-
-WorkQueue::~WorkQueue() {
- {
- base::AutoLock auto_lock(lock_);
- SetShutdown();
- }
- work_is_available_.Broadcast(); // Tell them all to terminate.
-
- for (int i = 0; i < thread_count_; ++i) {
- PlatformThread::Join(thread_handles_[i]);
- }
- EXPECT_EQ(0, waiting_thread_count_);
-}
-
-int WorkQueue::GetThreadId() {
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- DCHECK(!EveryIdWasAllocated());
- return thread_started_counter_++; // Give out Unique IDs.
-}
-
-bool WorkQueue::EveryIdWasAllocated() const {
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- return thread_count_ == thread_started_counter_;
-}
-
-TimeDelta WorkQueue::GetAnAssignment(int thread_id) {
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- DCHECK_LT(0, task_count_);
- assignment_history_[thread_id]++;
- if (0 == --task_count_) {
- no_more_tasks_.Signal();
- }
- return worker_delay_;
-}
-
-void WorkQueue::WorkIsCompleted(int thread_id) {
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- completion_history_[thread_id]++;
-}
-
-int WorkQueue::task_count() const {
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- return task_count_;
-}
-
-bool WorkQueue::allow_help_requests() const {
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- return allow_help_requests_;
-}
-
-bool WorkQueue::shutdown() const {
- lock_.AssertAcquired();
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- return shutdown_;
-}
-
-// Because this method is called from the test's main thread we need to actually
-// take the lock. Threads will call the thread_shutting_down() method with the
-// lock already acquired.
-bool WorkQueue::ThreadSafeCheckShutdown(int thread_count) {
- bool all_shutdown;
- base::AutoLock auto_lock(lock_);
- {
- // Declare in scope so DFAKE is guranteed to be destroyed before AutoLock.
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- all_shutdown = (shutdown_task_count_ == thread_count);
- }
- return all_shutdown;
-}
-
-void WorkQueue::thread_shutting_down() {
- lock_.AssertAcquired();
- DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
- shutdown_task_count_++;
-}
-
-Lock* WorkQueue::lock() {
- return &lock_;
-}
-
-ConditionVariable* WorkQueue::work_is_available() {
- return &work_is_available_;
-}
-
-ConditionVariable* WorkQueue::all_threads_have_ids() {
- return &all_threads_have_ids_;
-}
-
-ConditionVariable* WorkQueue::no_more_tasks() {
- return &no_more_tasks_;
-}
-
-void WorkQueue::ResetHistory() {
- for (int i = 0; i < thread_count_; ++i) {
- assignment_history_[i] = 0;
- completion_history_[i] = 0;
- }
-}
-
-int WorkQueue::GetMinCompletionsByWorkerThread() const {
- int minumum = completion_history_[0];
- for (int i = 0; i < thread_count_; ++i)
- minumum = std::min(minumum, completion_history_[i]);
- return minumum;
-}
-
-int WorkQueue::GetMaxCompletionsByWorkerThread() const {
- int maximum = completion_history_[0];
- for (int i = 0; i < thread_count_; ++i)
- maximum = std::max(maximum, completion_history_[i]);
- return maximum;
-}
-
-int WorkQueue::GetNumThreadsTakingAssignments() const {
- int count = 0;
- for (int i = 0; i < thread_count_; ++i)
- if (assignment_history_[i])
- count++;
- return count;
-}
-
-int WorkQueue::GetNumThreadsCompletingTasks() const {
- int count = 0;
- for (int i = 0; i < thread_count_; ++i)
- if (completion_history_[i])
- count++;
- return count;
-}
-
-int WorkQueue::GetNumberOfCompletedTasks() const {
- int total = 0;
- for (int i = 0; i < thread_count_; ++i)
- total += completion_history_[i];
- return total;
-}
-
-void WorkQueue::SetWorkTime(TimeDelta delay) {
- worker_delay_ = delay;
-}
-
-void WorkQueue::SetTaskCount(int count) {
- task_count_ = count;
-}
-
-void WorkQueue::SetAllowHelp(bool allow) {
- allow_help_requests_ = allow;
-}
-
-void WorkQueue::SetShutdown() {
- lock_.AssertAcquired();
- shutdown_ = true;
-}
-
-void WorkQueue::SpinUntilAllThreadsAreWaiting() {
- while (true) {
- {
- base::AutoLock auto_lock(lock_);
- if (waiting_thread_count_ == thread_count_)
- break;
- }
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
- }
-}
-
-void WorkQueue::SpinUntilTaskCountLessThan(int task_count) {
- while (true) {
- {
- base::AutoLock auto_lock(lock_);
- if (task_count_ < task_count)
- break;
- }
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
- }
-}
-
-
-//------------------------------------------------------------------------------
-// Define the standard worker task. Several tests will spin out many of these
-// threads.
-//------------------------------------------------------------------------------
-
-// The multithread tests involve several threads with a task to perform as
-// directed by an instance of the class WorkQueue.
-// The task is to:
-// a) Check to see if there are more tasks (there is a task counter).
-// a1) Wait on condition variable if there are no tasks currently.
-// b) Call a function to see what should be done.
-// c) Do some computation based on the number of milliseconds returned in (b).
-// d) go back to (a).
-
-// WorkQueue::ThreadMain() implements the above task for all threads.
-// It calls the controlling object to tell the creator about progress, and to
-// ask about tasks.
-
-void WorkQueue::ThreadMain() {
- int thread_id;
- {
- base::AutoLock auto_lock(lock_);
- thread_id = GetThreadId();
- if (EveryIdWasAllocated())
- all_threads_have_ids()->Signal(); // Tell creator we're ready.
- }
-
- Lock private_lock; // Used to waste time on "our work".
- while (1) { // This is the main consumer loop.
- TimeDelta work_time;
- bool could_use_help;
- {
- base::AutoLock auto_lock(lock_);
- while (0 == task_count() && !shutdown()) {
- ++waiting_thread_count_;
- work_is_available()->Wait();
- --waiting_thread_count_;
- }
- if (shutdown()) {
- // Ack the notification of a shutdown message back to the controller.
- thread_shutting_down();
- return; // Terminate.
- }
- // Get our task duration from the queue.
- work_time = GetAnAssignment(thread_id);
- could_use_help = (task_count() > 0) && allow_help_requests();
- } // Release lock
-
- // Do work (outside of locked region.
- if (could_use_help)
- work_is_available()->Signal(); // Get help from other threads.
-
- if (work_time > TimeDelta::FromMilliseconds(0)) {
- // We could just sleep(), but we'll instead further exercise the
- // condition variable class, and do a timed wait.
- base::AutoLock auto_lock(private_lock);
- ConditionVariable private_cv(&private_lock);
- private_cv.TimedWait(work_time); // Unsynchronized waiting.
- }
-
- {
- base::AutoLock auto_lock(lock_);
- // Send notification that we completed our "work."
- WorkIsCompleted(thread_id);
- }
- }
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/synchronization/lock_unittest.cc b/base/synchronization/lock_unittest.cc
deleted file mode 100644
index 1e2f998..0000000
--- a/base/synchronization/lock_unittest.cc
+++ /dev/null
@@ -1,257 +0,0 @@
-// 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.
-
-#include "base/synchronization/lock.h"
-
-#include <stdlib.h>
-
-#include "base/compiler_specific.h"
-#include "base/debug/activity_tracker.h"
-#include "base/macros.h"
-#include "base/threading/platform_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// Basic test to make sure that Acquire()/Release()/Try() don't crash ----------
-
-class BasicLockTestThread : public PlatformThread::Delegate {
- public:
- explicit BasicLockTestThread(Lock* lock) : lock_(lock), acquired_(0) {}
-
- void ThreadMain() override {
- for (int i = 0; i < 10; i++) {
- lock_->Acquire();
- acquired_++;
- lock_->Release();
- }
- for (int i = 0; i < 10; i++) {
- lock_->Acquire();
- acquired_++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
- lock_->Release();
- }
- for (int i = 0; i < 10; i++) {
- if (lock_->Try()) {
- acquired_++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
- lock_->Release();
- }
- }
- }
-
- int acquired() const { return acquired_; }
-
- private:
- Lock* lock_;
- int acquired_;
-
- DISALLOW_COPY_AND_ASSIGN(BasicLockTestThread);
-};
-
-TEST(LockTest, Basic) {
- Lock lock;
- BasicLockTestThread thread(&lock);
- PlatformThreadHandle handle;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-
- int acquired = 0;
- for (int i = 0; i < 5; i++) {
- lock.Acquire();
- acquired++;
- lock.Release();
- }
- for (int i = 0; i < 10; i++) {
- lock.Acquire();
- acquired++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
- lock.Release();
- }
- for (int i = 0; i < 10; i++) {
- if (lock.Try()) {
- acquired++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
- lock.Release();
- }
- }
- for (int i = 0; i < 5; i++) {
- lock.Acquire();
- acquired++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20));
- lock.Release();
- }
-
- PlatformThread::Join(handle);
-
- EXPECT_GE(acquired, 20);
- EXPECT_GE(thread.acquired(), 20);
-}
-
-// Test that Try() works as expected -------------------------------------------
-
-class TryLockTestThread : public PlatformThread::Delegate {
- public:
- explicit TryLockTestThread(Lock* lock) : lock_(lock), got_lock_(false) {}
-
- void ThreadMain() override {
- got_lock_ = lock_->Try();
- if (got_lock_)
- lock_->Release();
- }
-
- bool got_lock() const { return got_lock_; }
-
- private:
- Lock* lock_;
- bool got_lock_;
-
- DISALLOW_COPY_AND_ASSIGN(TryLockTestThread);
-};
-
-TEST(LockTest, TryLock) {
- Lock lock;
-
- ASSERT_TRUE(lock.Try());
- // We now have the lock....
-
- // This thread will not be able to get the lock.
- {
- TryLockTestThread thread(&lock);
- PlatformThreadHandle handle;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-
- PlatformThread::Join(handle);
-
- ASSERT_FALSE(thread.got_lock());
- }
-
- lock.Release();
-
- // This thread will....
- {
- TryLockTestThread thread(&lock);
- PlatformThreadHandle handle;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-
- PlatformThread::Join(handle);
-
- ASSERT_TRUE(thread.got_lock());
- // But it released it....
- ASSERT_TRUE(lock.Try());
- }
-
- lock.Release();
-}
-
-TEST(LockTest, TryTrackedLock) {
- // Enable the activity tracker.
- debug::GlobalActivityTracker::CreateWithLocalMemory(64 << 10, 0, "", 3, 0);
-
- Lock lock;
-
- ASSERT_TRUE(lock.Try());
- // We now have the lock....
-
- // This thread will not be able to get the lock.
- {
- TryLockTestThread thread(&lock);
- PlatformThreadHandle handle;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-
- PlatformThread::Join(handle);
-
- ASSERT_FALSE(thread.got_lock());
- }
-
- lock.Release();
-
- // This thread will....
- {
- TryLockTestThread thread(&lock);
- PlatformThreadHandle handle;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-
- PlatformThread::Join(handle);
-
- ASSERT_TRUE(thread.got_lock());
- // But it released it....
- ASSERT_TRUE(lock.Try());
- }
-
- lock.Release();
- debug::GlobalActivityTracker::ReleaseForTesting();
-}
-
-// Tests that locks actually exclude -------------------------------------------
-
-class MutexLockTestThread : public PlatformThread::Delegate {
- public:
- MutexLockTestThread(Lock* lock, int* value) : lock_(lock), value_(value) {}
-
- // Static helper which can also be called from the main thread.
- static void DoStuff(Lock* lock, int* value) {
- for (int i = 0; i < 40; i++) {
- lock->Acquire();
- int v = *value;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 10));
- *value = v + 1;
- lock->Release();
- }
- }
-
- void ThreadMain() override { DoStuff(lock_, value_); }
-
- private:
- Lock* lock_;
- int* value_;
-
- DISALLOW_COPY_AND_ASSIGN(MutexLockTestThread);
-};
-
-TEST(LockTest, MutexTwoThreads) {
- Lock lock;
- int value = 0;
-
- MutexLockTestThread thread(&lock, &value);
- PlatformThreadHandle handle;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-
- MutexLockTestThread::DoStuff(&lock, &value);
-
- PlatformThread::Join(handle);
-
- EXPECT_EQ(2 * 40, value);
-}
-
-TEST(LockTest, MutexFourThreads) {
- Lock lock;
- int value = 0;
-
- MutexLockTestThread thread1(&lock, &value);
- MutexLockTestThread thread2(&lock, &value);
- MutexLockTestThread thread3(&lock, &value);
- PlatformThreadHandle handle1;
- PlatformThreadHandle handle2;
- PlatformThreadHandle handle3;
-
- ASSERT_TRUE(PlatformThread::Create(0, &thread1, &handle1));
- ASSERT_TRUE(PlatformThread::Create(0, &thread2, &handle2));
- ASSERT_TRUE(PlatformThread::Create(0, &thread3, &handle3));
-
- MutexLockTestThread::DoStuff(&lock, &value);
-
- PlatformThread::Join(handle1);
- PlatformThread::Join(handle2);
- PlatformThread::Join(handle3);
-
- EXPECT_EQ(4 * 40, value);
-}
-
-} // namespace base
diff --git a/base/synchronization/waitable_event_unittest.cc b/base/synchronization/waitable_event_unittest.cc
deleted file mode 100644
index 9c981d8..0000000
--- a/base/synchronization/waitable_event_unittest.cc
+++ /dev/null
@@ -1,274 +0,0 @@
-// 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.
-
-#include "base/synchronization/waitable_event.h"
-
-#include <stddef.h>
-
-#include <algorithm>
-
-#include "base/compiler_specific.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(WaitableEventTest, ManualBasics) {
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- EXPECT_FALSE(event.IsSignaled());
-
- event.Signal();
- EXPECT_TRUE(event.IsSignaled());
- EXPECT_TRUE(event.IsSignaled());
-
- event.Reset();
- EXPECT_FALSE(event.IsSignaled());
- EXPECT_FALSE(event.TimedWait(TimeDelta::FromMilliseconds(10)));
-
- event.Signal();
- event.Wait();
- EXPECT_TRUE(event.TimedWait(TimeDelta::FromMilliseconds(10)));
-}
-
-TEST(WaitableEventTest, ManualInitiallySignaled) {
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::SIGNALED);
-
- EXPECT_TRUE(event.IsSignaled());
- EXPECT_TRUE(event.IsSignaled());
-
- event.Reset();
-
- EXPECT_FALSE(event.IsSignaled());
- EXPECT_FALSE(event.IsSignaled());
-
- event.Signal();
-
- event.Wait();
- EXPECT_TRUE(event.IsSignaled());
- EXPECT_TRUE(event.IsSignaled());
-}
-
-TEST(WaitableEventTest, AutoBasics) {
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- EXPECT_FALSE(event.IsSignaled());
-
- event.Signal();
- EXPECT_TRUE(event.IsSignaled());
- EXPECT_FALSE(event.IsSignaled());
-
- event.Reset();
- EXPECT_FALSE(event.IsSignaled());
- EXPECT_FALSE(event.TimedWait(TimeDelta::FromMilliseconds(10)));
-
- event.Signal();
- event.Wait();
- EXPECT_FALSE(event.TimedWait(TimeDelta::FromMilliseconds(10)));
-
- event.Signal();
- EXPECT_TRUE(event.TimedWait(TimeDelta::FromMilliseconds(10)));
-}
-
-TEST(WaitableEventTest, AutoInitiallySignaled) {
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::SIGNALED);
-
- EXPECT_TRUE(event.IsSignaled());
- EXPECT_FALSE(event.IsSignaled());
-
- event.Signal();
-
- EXPECT_TRUE(event.IsSignaled());
- EXPECT_FALSE(event.IsSignaled());
-}
-
-TEST(WaitableEventTest, WaitManyShortcut) {
- WaitableEvent* ev[5];
- for (unsigned i = 0; i < 5; ++i) {
- ev[i] = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- }
-
- ev[3]->Signal();
- EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 3u);
-
- ev[3]->Signal();
- EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 3u);
-
- ev[4]->Signal();
- EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 4u);
-
- ev[0]->Signal();
- EXPECT_EQ(WaitableEvent::WaitMany(ev, 5), 0u);
-
- for (unsigned i = 0; i < 5; ++i)
- delete ev[i];
-}
-
-TEST(WaitableEventTest, WaitManyLeftToRight) {
- WaitableEvent* ev[5];
- for (size_t i = 0; i < 5; ++i) {
- ev[i] = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- }
-
- // Test for consistent left-to-right return behavior across all permutations
- // of the input array. This is to verify that only the indices -- and not
- // the WaitableEvents' addresses -- are relevant in determining who wins when
- // multiple events are signaled.
-
- std::sort(ev, ev + 5);
- do {
- ev[0]->Signal();
- ev[1]->Signal();
- EXPECT_EQ(0u, WaitableEvent::WaitMany(ev, 5));
-
- ev[2]->Signal();
- EXPECT_EQ(1u, WaitableEvent::WaitMany(ev, 5));
- EXPECT_EQ(2u, WaitableEvent::WaitMany(ev, 5));
-
- ev[3]->Signal();
- ev[4]->Signal();
- ev[0]->Signal();
- EXPECT_EQ(0u, WaitableEvent::WaitMany(ev, 5));
- EXPECT_EQ(3u, WaitableEvent::WaitMany(ev, 5));
- ev[2]->Signal();
- EXPECT_EQ(2u, WaitableEvent::WaitMany(ev, 5));
- EXPECT_EQ(4u, WaitableEvent::WaitMany(ev, 5));
- } while (std::next_permutation(ev, ev + 5));
-
- for (size_t i = 0; i < 5; ++i)
- delete ev[i];
-}
-
-class WaitableEventSignaler : public PlatformThread::Delegate {
- public:
- WaitableEventSignaler(TimeDelta delay, WaitableEvent* event)
- : delay_(delay),
- event_(event) {
- }
-
- void ThreadMain() override {
- PlatformThread::Sleep(delay_);
- event_->Signal();
- }
-
- private:
- const TimeDelta delay_;
- WaitableEvent* event_;
-};
-
-// Tests that a WaitableEvent can be safely deleted when |Wait| is done without
-// additional synchronization.
-TEST(WaitableEventTest, WaitAndDelete) {
- WaitableEvent* ev =
- new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEventSignaler signaler(TimeDelta::FromMilliseconds(10), ev);
- PlatformThreadHandle thread;
- PlatformThread::Create(0, &signaler, &thread);
-
- ev->Wait();
- delete ev;
-
- PlatformThread::Join(thread);
-}
-
-// Tests that a WaitableEvent can be safely deleted when |WaitMany| is done
-// without additional synchronization.
-TEST(WaitableEventTest, WaitMany) {
- WaitableEvent* ev[5];
- for (unsigned i = 0; i < 5; ++i) {
- ev[i] = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- }
-
- WaitableEventSignaler signaler(TimeDelta::FromMilliseconds(10), ev[2]);
- PlatformThreadHandle thread;
- PlatformThread::Create(0, &signaler, &thread);
-
- size_t index = WaitableEvent::WaitMany(ev, 5);
-
- for (unsigned i = 0; i < 5; ++i)
- delete ev[i];
-
- PlatformThread::Join(thread);
- EXPECT_EQ(2u, index);
-}
-
-// Tests that using TimeDelta::Max() on TimedWait() is not the same as passing
-// a timeout of 0. (crbug.com/465948)
-TEST(WaitableEventTest, TimedWait) {
- WaitableEvent* ev =
- new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- TimeDelta thread_delay = TimeDelta::FromMilliseconds(10);
- WaitableEventSignaler signaler(thread_delay, ev);
- PlatformThreadHandle thread;
- TimeTicks start = TimeTicks::Now();
- PlatformThread::Create(0, &signaler, &thread);
-
- EXPECT_TRUE(ev->TimedWait(TimeDelta::Max()));
- EXPECT_GE(TimeTicks::Now() - start, thread_delay);
- delete ev;
-
- PlatformThread::Join(thread);
-}
-
-// Tests that a sub-ms TimedWait doesn't time out promptly.
-TEST(WaitableEventTest, SubMsTimedWait) {
- WaitableEvent ev(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- TimeDelta delay = TimeDelta::FromMicroseconds(900);
- TimeTicks start_time = TimeTicks::Now();
- ev.TimedWait(delay);
- EXPECT_GE(TimeTicks::Now() - start_time, delay);
-}
-
-// Tests that TimedWaitUntil can be safely used with various end_time deadline
-// values.
-TEST(WaitableEventTest, TimedWaitUntil) {
- WaitableEvent ev(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- TimeTicks start_time(TimeTicks::Now());
- TimeDelta delay = TimeDelta::FromMilliseconds(10);
-
- // Should be OK to wait for the current time or time in the past.
- // That should end promptly and be equivalent to IsSignalled.
- EXPECT_FALSE(ev.TimedWaitUntil(start_time));
- EXPECT_FALSE(ev.TimedWaitUntil(start_time - delay));
-
- // Should be OK to wait for zero TimeTicks().
- EXPECT_FALSE(ev.TimedWaitUntil(TimeTicks()));
-
- // Waiting for a time in the future shouldn't end before the deadline
- // if the event isn't signalled.
- EXPECT_FALSE(ev.TimedWaitUntil(start_time + delay));
- EXPECT_GE(TimeTicks::Now() - start_time, delay);
-
- // Test that passing TimeTicks::Max to TimedWaitUntil is valid and isn't
- // the same as passing TimeTicks(). Also verifies that signaling event
- // ends the wait promptly.
- WaitableEventSignaler signaler(delay, &ev);
- PlatformThreadHandle thread;
- start_time = TimeTicks::Now();
- PlatformThread::Create(0, &signaler, &thread);
-
- EXPECT_TRUE(ev.TimedWaitUntil(TimeTicks::Max()));
- EXPECT_GE(TimeTicks::Now() - start_time, delay);
-
- PlatformThread::Join(thread);
-}
-
-} // namespace base
diff --git a/base/synchronization/waitable_event_watcher_unittest.cc b/base/synchronization/waitable_event_watcher_unittest.cc
deleted file mode 100644
index bdb45a3..0000000
--- a/base/synchronization/waitable_event_watcher_unittest.cc
+++ /dev/null
@@ -1,429 +0,0 @@
-// 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.
-
-#include "base/synchronization/waitable_event_watcher.h"
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// The message loops on which each waitable event timer should be tested.
-const MessageLoop::Type testing_message_loops[] = {
- MessageLoop::TYPE_DEFAULT,
- MessageLoop::TYPE_IO,
-#if !defined(OS_IOS) // iOS does not allow direct running of the UI loop.
- MessageLoop::TYPE_UI,
-#endif
-};
-
-void QuitWhenSignaled(WaitableEvent* event) {
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-class DecrementCountContainer {
- public:
- explicit DecrementCountContainer(int* counter) : counter_(counter) {}
- void OnWaitableEventSignaled(WaitableEvent* object) {
- // NOTE: |object| may be already deleted.
- --(*counter_);
- }
-
- private:
- int* counter_;
-};
-
-} // namespace
-
-class WaitableEventWatcherTest
- : public testing::TestWithParam<MessageLoop::Type> {};
-
-TEST_P(WaitableEventWatcherTest, BasicSignalManual) {
- MessageLoop message_loop(GetParam());
-
- // A manual-reset event that is not yet signaled.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEventWatcher watcher;
- watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
-
- event.Signal();
-
- RunLoop().Run();
-
- EXPECT_TRUE(event.IsSignaled());
-}
-
-TEST_P(WaitableEventWatcherTest, BasicSignalAutomatic) {
- MessageLoop message_loop(GetParam());
-
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEventWatcher watcher;
- watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
-
- event.Signal();
-
- RunLoop().Run();
-
- // The WaitableEventWatcher consumes the event signal.
- EXPECT_FALSE(event.IsSignaled());
-}
-
-TEST_P(WaitableEventWatcherTest, BasicCancel) {
- MessageLoop message_loop(GetParam());
-
- // A manual-reset event that is not yet signaled.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEventWatcher watcher;
-
- watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
-
- watcher.StopWatching();
-}
-
-TEST_P(WaitableEventWatcherTest, CancelAfterSet) {
- MessageLoop message_loop(GetParam());
-
- // A manual-reset event that is not yet signaled.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEventWatcher watcher;
-
- int counter = 1;
- DecrementCountContainer delegate(&counter);
- WaitableEventWatcher::EventCallback callback = BindOnce(
- &DecrementCountContainer::OnWaitableEventSignaled, Unretained(&delegate));
- watcher.StartWatching(&event, std::move(callback),
- SequencedTaskRunnerHandle::Get());
-
- event.Signal();
-
- // Let the background thread do its business
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
-
- watcher.StopWatching();
-
- RunLoop().RunUntilIdle();
-
- // Our delegate should not have fired.
- EXPECT_EQ(1, counter);
-}
-
-TEST_P(WaitableEventWatcherTest, OutlivesMessageLoop) {
- // Simulate a MessageLoop that dies before an WaitableEventWatcher. This
- // ordinarily doesn't happen when people use the Thread class, but it can
- // happen when people use the Singleton pattern or atexit.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- {
- std::unique_ptr<WaitableEventWatcher> watcher;
- {
- MessageLoop message_loop(GetParam());
- watcher = std::make_unique<WaitableEventWatcher>();
-
- watcher->StartWatching(&event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
- }
- }
-}
-
-TEST_P(WaitableEventWatcherTest, SignaledAtStartManual) {
- MessageLoop message_loop(GetParam());
-
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::SIGNALED);
-
- WaitableEventWatcher watcher;
- watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
-
- RunLoop().Run();
-
- EXPECT_TRUE(event.IsSignaled());
-}
-
-TEST_P(WaitableEventWatcherTest, SignaledAtStartAutomatic) {
- MessageLoop message_loop(GetParam());
-
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::SIGNALED);
-
- WaitableEventWatcher watcher;
- watcher.StartWatching(&event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
-
- RunLoop().Run();
-
- // The watcher consumes the event signal.
- EXPECT_FALSE(event.IsSignaled());
-}
-
-TEST_P(WaitableEventWatcherTest, StartWatchingInCallback) {
- MessageLoop message_loop(GetParam());
-
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEventWatcher watcher;
- watcher.StartWatching(
- &event,
- BindOnce(
- [](WaitableEventWatcher* watcher, WaitableEvent* event) {
- // |event| is manual, so the second watcher will run
- // immediately.
- watcher->StartWatching(event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
- },
- &watcher),
- SequencedTaskRunnerHandle::Get());
-
- event.Signal();
-
- RunLoop().Run();
-}
-
-TEST_P(WaitableEventWatcherTest, MultipleWatchersManual) {
- MessageLoop message_loop(GetParam());
-
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- int counter1 = 0;
- int counter2 = 0;
-
- auto callback = [](RunLoop* run_loop, int* counter, WaitableEvent* event) {
- ++(*counter);
- run_loop->QuitWhenIdle();
- };
-
- RunLoop run_loop;
-
- WaitableEventWatcher watcher1;
- watcher1.StartWatching(
- &event, BindOnce(callback, Unretained(&run_loop), Unretained(&counter1)),
- SequencedTaskRunnerHandle::Get());
-
- WaitableEventWatcher watcher2;
- watcher2.StartWatching(
- &event, BindOnce(callback, Unretained(&run_loop), Unretained(&counter2)),
- SequencedTaskRunnerHandle::Get());
-
- event.Signal();
- run_loop.Run();
-
- EXPECT_EQ(1, counter1);
- EXPECT_EQ(1, counter2);
- EXPECT_TRUE(event.IsSignaled());
-}
-
-// Tests that only one async waiter gets called back for an auto-reset event.
-TEST_P(WaitableEventWatcherTest, MultipleWatchersAutomatic) {
- MessageLoop message_loop(GetParam());
-
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- int counter1 = 0;
- int counter2 = 0;
-
- auto callback = [](RunLoop** run_loop, int* counter, WaitableEvent* event) {
- ++(*counter);
- (*run_loop)->QuitWhenIdle();
- };
-
- // The same RunLoop instance cannot be Run more than once, and it is
- // undefined which watcher will get called back first. Have the callback
- // dereference this pointer to quit the loop, which will be updated on each
- // Run.
- RunLoop* current_run_loop;
-
- WaitableEventWatcher watcher1;
- watcher1.StartWatching(
- &event,
- BindOnce(callback, Unretained(¤t_run_loop), Unretained(&counter1)),
- SequencedTaskRunnerHandle::Get());
-
- WaitableEventWatcher watcher2;
- watcher2.StartWatching(
- &event,
- BindOnce(callback, Unretained(¤t_run_loop), Unretained(&counter2)),
- SequencedTaskRunnerHandle::Get());
-
- event.Signal();
- {
- RunLoop run_loop;
- current_run_loop = &run_loop;
- run_loop.Run();
- }
-
- // Only one of the waiters should have been signaled.
- EXPECT_TRUE((counter1 == 1) ^ (counter2 == 1));
-
- EXPECT_FALSE(event.IsSignaled());
-
- event.Signal();
- {
- RunLoop run_loop;
- current_run_loop = &run_loop;
- run_loop.Run();
- }
-
- EXPECT_FALSE(event.IsSignaled());
-
- // The other watcher should have been signaled.
- EXPECT_EQ(1, counter1);
- EXPECT_EQ(1, counter2);
-}
-
-// To help detect errors around deleting WaitableEventWatcher, an additional
-// bool parameter is used to test sleeping between watching and deletion.
-class WaitableEventWatcherDeletionTest
- : public testing::TestWithParam<std::tuple<MessageLoop::Type, bool>> {};
-
-TEST_P(WaitableEventWatcherDeletionTest, DeleteUnder) {
- MessageLoop::Type message_loop_type;
- bool delay_after_delete;
- std::tie(message_loop_type, delay_after_delete) = GetParam();
-
- // Delete the WaitableEvent out from under the Watcher. This is explictly
- // allowed by the interface.
-
- MessageLoop message_loop(message_loop_type);
-
- {
- WaitableEventWatcher watcher;
-
- auto* event = new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- watcher.StartWatching(event, BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
-
- if (delay_after_delete) {
- // On Windows that sleep() improves the chance to catch some problems.
- // It postpones the dtor |watcher| (which immediately cancel the waiting)
- // and gives some time to run to a created background thread.
- // Unfortunately, that thread is under OS control and we can't
- // manipulate it directly.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
- }
-
- delete event;
- }
-}
-
-TEST_P(WaitableEventWatcherDeletionTest, SignalAndDelete) {
- MessageLoop::Type message_loop_type;
- bool delay_after_delete;
- std::tie(message_loop_type, delay_after_delete) = GetParam();
-
- // Signal and immediately delete the WaitableEvent out from under the Watcher.
-
- MessageLoop message_loop(message_loop_type);
-
- {
- WaitableEventWatcher watcher;
-
- auto event = std::make_unique<WaitableEvent>(
- WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- watcher.StartWatching(event.get(), BindOnce(&QuitWhenSignaled),
- SequencedTaskRunnerHandle::Get());
- event->Signal();
- event.reset();
-
- if (delay_after_delete) {
- // On Windows that sleep() improves the chance to catch some problems.
- // It postpones the dtor |watcher| (which immediately cancel the waiting)
- // and gives some time to run to a created background thread.
- // Unfortunately, that thread is under OS control and we can't
- // manipulate it directly.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(30));
- }
-
- // Wait for the watcher callback.
- RunLoop().Run();
- }
-}
-
-// Tests deleting the WaitableEventWatcher between signaling the event and
-// when the callback should be run.
-TEST_P(WaitableEventWatcherDeletionTest, DeleteWatcherBeforeCallback) {
- MessageLoop::Type message_loop_type;
- bool delay_after_delete;
- std::tie(message_loop_type, delay_after_delete) = GetParam();
-
- MessageLoop message_loop(message_loop_type);
- scoped_refptr<SingleThreadTaskRunner> task_runner =
- message_loop.task_runner();
-
- // Flag used to esnure that the |watcher_callback| never runs.
- bool did_callback = false;
-
- WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- auto watcher = std::make_unique<WaitableEventWatcher>();
-
- // Queue up a series of tasks:
- // 1. StartWatching the WaitableEvent
- // 2. Signal the event (which will result in another task getting posted to
- // the |task_runner|)
- // 3. Delete the WaitableEventWatcher
- // 4. WaitableEventWatcher callback should run (from #2)
-
- WaitableEventWatcher::EventCallback watcher_callback = BindOnce(
- [](bool* did_callback, WaitableEvent*) {
- *did_callback = true;
- },
- Unretained(&did_callback));
-
- task_runner->PostTask(
- FROM_HERE, BindOnce(IgnoreResult(&WaitableEventWatcher::StartWatching),
- Unretained(watcher.get()), Unretained(&event),
- std::move(watcher_callback), task_runner));
- task_runner->PostTask(FROM_HERE,
- BindOnce(&WaitableEvent::Signal, Unretained(&event)));
- task_runner->DeleteSoon(FROM_HERE, std::move(watcher));
- if (delay_after_delete) {
- task_runner->PostTask(FROM_HERE, BindOnce(&PlatformThread::Sleep,
- TimeDelta::FromMilliseconds(30)));
- }
-
- RunLoop().RunUntilIdle();
-
- EXPECT_FALSE(did_callback);
-}
-
-INSTANTIATE_TEST_CASE_P(,
- WaitableEventWatcherTest,
- testing::ValuesIn(testing_message_loops));
-
-INSTANTIATE_TEST_CASE_P(
- ,
- WaitableEventWatcherDeletionTest,
- testing::Combine(testing::ValuesIn(testing_message_loops),
- testing::Bool()));
-
-} // namespace base
diff --git a/base/sys_byteorder_unittest.cc b/base/sys_byteorder_unittest.cc
deleted file mode 100644
index f5bad31..0000000
--- a/base/sys_byteorder_unittest.cc
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) 2016 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 "base/sys_byteorder.h"
-
-#include <stdint.h>
-
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-const uint16_t k16BitTestData = 0xaabb;
-const uint16_t k16BitSwappedTestData = 0xbbaa;
-const uint32_t k32BitTestData = 0xaabbccdd;
-const uint32_t k32BitSwappedTestData = 0xddccbbaa;
-const uint64_t k64BitTestData = 0xaabbccdd44332211;
-const uint64_t k64BitSwappedTestData = 0x11223344ddccbbaa;
-
-} // namespace
-
-TEST(ByteOrderTest, ByteSwap16) {
- uint16_t swapped = base::ByteSwap(k16BitTestData);
- EXPECT_EQ(k16BitSwappedTestData, swapped);
- uint16_t reswapped = base::ByteSwap(swapped);
- EXPECT_EQ(k16BitTestData, reswapped);
-}
-
-TEST(ByteOrderTest, ByteSwap32) {
- uint32_t swapped = base::ByteSwap(k32BitTestData);
- EXPECT_EQ(k32BitSwappedTestData, swapped);
- uint32_t reswapped = base::ByteSwap(swapped);
- EXPECT_EQ(k32BitTestData, reswapped);
-}
-
-TEST(ByteOrderTest, ByteSwap64) {
- uint64_t swapped = base::ByteSwap(k64BitTestData);
- EXPECT_EQ(k64BitSwappedTestData, swapped);
- uint64_t reswapped = base::ByteSwap(swapped);
- EXPECT_EQ(k64BitTestData, reswapped);
-}
-
-TEST(ByteOrderTest, ByteSwapUintPtrT) {
-#if defined(ARCH_CPU_64_BITS)
- const uintptr_t test_data = static_cast<uintptr_t>(k64BitTestData);
- const uintptr_t swapped_test_data =
- static_cast<uintptr_t>(k64BitSwappedTestData);
-#elif defined(ARCH_CPU_32_BITS)
- const uintptr_t test_data = static_cast<uintptr_t>(k32BitTestData);
- const uintptr_t swapped_test_data =
- static_cast<uintptr_t>(k32BitSwappedTestData);
-#else
-#error architecture not supported
-#endif
-
- uintptr_t swapped = base::ByteSwapUintPtrT(test_data);
- EXPECT_EQ(swapped_test_data, swapped);
- uintptr_t reswapped = base::ByteSwapUintPtrT(swapped);
- EXPECT_EQ(test_data, reswapped);
-}
-
-TEST(ByteOrderTest, ByteSwapToLE16) {
- uint16_t le = base::ByteSwapToLE16(k16BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k16BitTestData, le);
-#else
- EXPECT_EQ(k16BitSwappedTestData, le);
-#endif
-}
-
-TEST(ByteOrderTest, ByteSwapToLE32) {
- uint32_t le = base::ByteSwapToLE32(k32BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k32BitTestData, le);
-#else
- EXPECT_EQ(k32BitSwappedTestData, le);
-#endif
-}
-
-TEST(ByteOrderTest, ByteSwapToLE64) {
- uint64_t le = base::ByteSwapToLE64(k64BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k64BitTestData, le);
-#else
- EXPECT_EQ(k64BitSwappedTestData, le);
-#endif
-}
-
-TEST(ByteOrderTest, NetToHost16) {
- uint16_t h = base::NetToHost16(k16BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k16BitSwappedTestData, h);
-#else
- EXPECT_EQ(k16BitTestData, h);
-#endif
-}
-
-TEST(ByteOrderTest, NetToHost32) {
- uint32_t h = base::NetToHost32(k32BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k32BitSwappedTestData, h);
-#else
- EXPECT_EQ(k32BitTestData, h);
-#endif
-}
-
-TEST(ByteOrderTest, NetToHost64) {
- uint64_t h = base::NetToHost64(k64BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k64BitSwappedTestData, h);
-#else
- EXPECT_EQ(k64BitTestData, h);
-#endif
-}
-
-TEST(ByteOrderTest, HostToNet16) {
- uint16_t n = base::HostToNet16(k16BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k16BitSwappedTestData, n);
-#else
- EXPECT_EQ(k16BitTestData, n);
-#endif
-}
-
-TEST(ByteOrderTest, HostToNet32) {
- uint32_t n = base::HostToNet32(k32BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k32BitSwappedTestData, n);
-#else
- EXPECT_EQ(k32BitTestData, n);
-#endif
-}
-
-TEST(ByteOrderTest, HostToNet64) {
- uint64_t n = base::HostToNet64(k64BitTestData);
-#if defined(ARCH_CPU_LITTLE_ENDIAN)
- EXPECT_EQ(k64BitSwappedTestData, n);
-#else
- EXPECT_EQ(k64BitTestData, n);
-#endif
-}
diff --git a/base/sys_info_unittest.cc b/base/sys_info_unittest.cc
deleted file mode 100644
index 7b2c458..0000000
--- a/base/sys_info_unittest.cc
+++ /dev/null
@@ -1,212 +0,0 @@
-// 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.
-
-#include <stdint.h>
-
-#include "base/environment.h"
-#include "base/files/file_util.h"
-#include "base/process/process_metrics.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/sys_info.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-namespace base {
-
-using SysInfoTest = PlatformTest;
-
-TEST_F(SysInfoTest, NumProcs) {
- // We aren't actually testing that it's correct, just that it's sane.
- EXPECT_GE(SysInfo::NumberOfProcessors(), 1);
-}
-
-TEST_F(SysInfoTest, AmountOfMem) {
- // We aren't actually testing that it's correct, just that it's sane.
- EXPECT_GT(SysInfo::AmountOfPhysicalMemory(), 0);
- EXPECT_GT(SysInfo::AmountOfPhysicalMemoryMB(), 0);
- // The maxmimal amount of virtual memory can be zero which means unlimited.
- EXPECT_GE(SysInfo::AmountOfVirtualMemory(), 0);
-}
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#if defined(OS_LINUX)
-#define MAYBE_AmountOfAvailablePhysicalMemory \
- DISABLED_AmountOfAvailablePhysicalMemory
-#else
-#define MAYBE_AmountOfAvailablePhysicalMemory AmountOfAvailablePhysicalMemory
-#endif // defined(OS_LINUX)
-TEST_F(SysInfoTest, MAYBE_AmountOfAvailablePhysicalMemory) {
- // Note: info is in _K_bytes.
- SystemMemoryInfoKB info;
- ASSERT_TRUE(GetSystemMemoryInfo(&info));
- EXPECT_GT(info.free, 0);
-
- if (info.available != 0) {
- // If there is MemAvailable from kernel.
- EXPECT_LT(info.available, info.total);
- const int64_t amount = SysInfo::AmountOfAvailablePhysicalMemory(info);
- // We aren't actually testing that it's correct, just that it's sane.
- EXPECT_GT(amount, static_cast<int64_t>(info.free) * 1024);
- EXPECT_LT(amount / 1024, info.available);
- // Simulate as if there is no MemAvailable.
- info.available = 0;
- }
-
- // There is no MemAvailable. Check the fallback logic.
- const int64_t amount = SysInfo::AmountOfAvailablePhysicalMemory(info);
- // We aren't actually testing that it's correct, just that it's sane.
- EXPECT_GT(amount, static_cast<int64_t>(info.free) * 1024);
- EXPECT_LT(amount / 1024, info.total);
-}
-#endif // defined(OS_LINUX) || defined(OS_ANDROID)
-
-TEST_F(SysInfoTest, AmountOfFreeDiskSpace) {
- // We aren't actually testing that it's correct, just that it's sane.
- FilePath tmp_path;
- ASSERT_TRUE(GetTempDir(&tmp_path));
- EXPECT_GE(SysInfo::AmountOfFreeDiskSpace(tmp_path), 0) << tmp_path.value();
-}
-
-TEST_F(SysInfoTest, AmountOfTotalDiskSpace) {
- // We aren't actually testing that it's correct, just that it's sane.
- FilePath tmp_path;
- ASSERT_TRUE(GetTempDir(&tmp_path));
- EXPECT_GT(SysInfo::AmountOfTotalDiskSpace(tmp_path), 0) << tmp_path.value();
-}
-
-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
-TEST_F(SysInfoTest, OperatingSystemVersionNumbers) {
- int32_t os_major_version = -1;
- int32_t os_minor_version = -1;
- int32_t os_bugfix_version = -1;
- SysInfo::OperatingSystemVersionNumbers(&os_major_version,
- &os_minor_version,
- &os_bugfix_version);
- EXPECT_GT(os_major_version, -1);
- EXPECT_GT(os_minor_version, -1);
- EXPECT_GT(os_bugfix_version, -1);
-}
-#endif
-
-TEST_F(SysInfoTest, Uptime) {
- TimeDelta up_time_1 = SysInfo::Uptime();
- // UpTime() is implemented internally using TimeTicks::Now(), which documents
- // system resolution as being 1-15ms. Sleep a little longer than that.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(20));
- TimeDelta up_time_2 = SysInfo::Uptime();
- EXPECT_GT(up_time_1.InMicroseconds(), 0);
- EXPECT_GT(up_time_2.InMicroseconds(), up_time_1.InMicroseconds());
-}
-
-#if defined(OS_MACOSX)
-TEST_F(SysInfoTest, HardwareModelNameFormatMacAndiOS) {
- std::string hardware_model = SysInfo::HardwareModelName();
- ASSERT_FALSE(hardware_model.empty());
- // Check that the model is of the expected format "Foo,Bar" where "Bar" is
- // a number.
- std::vector<StringPiece> pieces =
- SplitStringPiece(hardware_model, ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- ASSERT_EQ(2u, pieces.size()) << hardware_model;
- int value;
- EXPECT_TRUE(StringToInt(pieces[1], &value)) << hardware_model;
-}
-#endif
-
-#if defined(OS_CHROMEOS)
-
-TEST_F(SysInfoTest, GoogleChromeOSVersionNumbers) {
- int32_t os_major_version = -1;
- int32_t os_minor_version = -1;
- int32_t os_bugfix_version = -1;
- const char kLsbRelease[] =
- "FOO=1234123.34.5\n"
- "CHROMEOS_RELEASE_VERSION=1.2.3.4\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease, Time());
- SysInfo::OperatingSystemVersionNumbers(&os_major_version,
- &os_minor_version,
- &os_bugfix_version);
- EXPECT_EQ(1, os_major_version);
- EXPECT_EQ(2, os_minor_version);
- EXPECT_EQ(3, os_bugfix_version);
-}
-
-TEST_F(SysInfoTest, GoogleChromeOSVersionNumbersFirst) {
- int32_t os_major_version = -1;
- int32_t os_minor_version = -1;
- int32_t os_bugfix_version = -1;
- const char kLsbRelease[] =
- "CHROMEOS_RELEASE_VERSION=1.2.3.4\n"
- "FOO=1234123.34.5\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease, Time());
- SysInfo::OperatingSystemVersionNumbers(&os_major_version,
- &os_minor_version,
- &os_bugfix_version);
- EXPECT_EQ(1, os_major_version);
- EXPECT_EQ(2, os_minor_version);
- EXPECT_EQ(3, os_bugfix_version);
-}
-
-TEST_F(SysInfoTest, GoogleChromeOSNoVersionNumbers) {
- int32_t os_major_version = -1;
- int32_t os_minor_version = -1;
- int32_t os_bugfix_version = -1;
- const char kLsbRelease[] = "FOO=1234123.34.5\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease, Time());
- SysInfo::OperatingSystemVersionNumbers(&os_major_version,
- &os_minor_version,
- &os_bugfix_version);
- EXPECT_EQ(0, os_major_version);
- EXPECT_EQ(0, os_minor_version);
- EXPECT_EQ(0, os_bugfix_version);
-}
-
-TEST_F(SysInfoTest, GoogleChromeOSLsbReleaseTime) {
- const char kLsbRelease[] = "CHROMEOS_RELEASE_VERSION=1.2.3.4";
- // Use a fake time that can be safely displayed as a string.
- const Time lsb_release_time(Time::FromDoubleT(12345.6));
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease, lsb_release_time);
- Time parsed_lsb_release_time = SysInfo::GetLsbReleaseTime();
- EXPECT_DOUBLE_EQ(lsb_release_time.ToDoubleT(),
- parsed_lsb_release_time.ToDoubleT());
-}
-
-TEST_F(SysInfoTest, IsRunningOnChromeOS) {
- SysInfo::SetChromeOSVersionInfoForTest("", Time());
- EXPECT_FALSE(SysInfo::IsRunningOnChromeOS());
-
- const char kLsbRelease1[] =
- "CHROMEOS_RELEASE_NAME=Non Chrome OS\n"
- "CHROMEOS_RELEASE_VERSION=1.2.3.4\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease1, Time());
- EXPECT_FALSE(SysInfo::IsRunningOnChromeOS());
-
- const char kLsbRelease2[] =
- "CHROMEOS_RELEASE_NAME=Chrome OS\n"
- "CHROMEOS_RELEASE_VERSION=1.2.3.4\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease2, Time());
- EXPECT_TRUE(SysInfo::IsRunningOnChromeOS());
-
- const char kLsbRelease3[] =
- "CHROMEOS_RELEASE_NAME=Chromium OS\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease3, Time());
- EXPECT_TRUE(SysInfo::IsRunningOnChromeOS());
-}
-
-TEST_F(SysInfoTest, GetStrippedReleaseBoard) {
- const char* kLsbRelease1 = "CHROMEOS_RELEASE_BOARD=Glimmer\n";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease1, Time());
- EXPECT_EQ("glimmer", SysInfo::GetStrippedReleaseBoard());
-
- const char* kLsbRelease2 = "CHROMEOS_RELEASE_BOARD=glimmer-signed-mp-v4keys";
- SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease2, Time());
- EXPECT_EQ("glimmer", SysInfo::GetStrippedReleaseBoard());
-}
-
-#endif // OS_CHROMEOS
-
-} // namespace base
diff --git a/base/system_monitor/system_monitor_unittest.cc b/base/system_monitor/system_monitor_unittest.cc
deleted file mode 100644
index 8963f7b..0000000
--- a/base/system_monitor/system_monitor_unittest.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// 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.
-
-#include "base/system_monitor/system_monitor.h"
-
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/test/mock_devices_changed_observer.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class SystemMonitorTest : public testing::Test {
- protected:
- SystemMonitorTest() {
- system_monitor_.reset(new SystemMonitor);
- }
-
- MessageLoop message_loop_;
- std::unique_ptr<SystemMonitor> system_monitor_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SystemMonitorTest);
-};
-
-TEST_F(SystemMonitorTest, DeviceChangeNotifications) {
- const int kObservers = 5;
-
- testing::Sequence mock_sequencer[kObservers];
- MockDevicesChangedObserver observers[kObservers];
- for (int index = 0; index < kObservers; ++index) {
- system_monitor_->AddDevicesChangedObserver(&observers[index]);
-
- EXPECT_CALL(observers[index],
- OnDevicesChanged(SystemMonitor::DEVTYPE_UNKNOWN))
- .Times(3)
- .InSequence(mock_sequencer[index]);
- }
-
- system_monitor_->ProcessDevicesChanged(SystemMonitor::DEVTYPE_UNKNOWN);
- RunLoop().RunUntilIdle();
-
- system_monitor_->ProcessDevicesChanged(SystemMonitor::DEVTYPE_UNKNOWN);
- system_monitor_->ProcessDevicesChanged(SystemMonitor::DEVTYPE_UNKNOWN);
- RunLoop().RunUntilIdle();
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/task/cancelable_task_tracker_unittest.cc b/base/task/cancelable_task_tracker_unittest.cc
deleted file mode 100644
index c75adc4..0000000
--- a/base/task/cancelable_task_tracker_unittest.cc
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright 2014 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 "base/task/cancelable_task_tracker.h"
-
-#include <cstddef>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class CancelableTaskTrackerTest : public testing::Test {
- protected:
- ~CancelableTaskTrackerTest() override { RunCurrentLoopUntilIdle(); }
-
- void RunCurrentLoopUntilIdle() {
- RunLoop run_loop;
- run_loop.RunUntilIdle();
- }
-
- CancelableTaskTracker task_tracker_;
-
- private:
- // Needed by CancelableTaskTracker methods.
- MessageLoop message_loop_;
-};
-
-void AddFailureAt(const Location& location) {
- ADD_FAILURE_AT(location.file_name(), location.line_number());
-}
-
-// Returns a closure that fails if run.
-Closure MakeExpectedNotRunClosure(const Location& location) {
- return Bind(&AddFailureAt, location);
-}
-
-// A helper class for MakeExpectedRunClosure() that fails if it is
-// destroyed without Run() having been called. This class may be used
-// from multiple threads as long as Run() is called at most once
-// before destruction.
-class RunChecker {
- public:
- explicit RunChecker(const Location& location)
- : location_(location), called_(false) {}
-
- ~RunChecker() {
- if (!called_) {
- ADD_FAILURE_AT(location_.file_name(), location_.line_number());
- }
- }
-
- void Run() { called_ = true; }
-
- private:
- Location location_;
- bool called_;
-};
-
-// Returns a closure that fails on destruction if it hasn't been run.
-Closure MakeExpectedRunClosure(const Location& location) {
- return Bind(&RunChecker::Run, Owned(new RunChecker(location)));
-}
-
-} // namespace
-
-// With the task tracker, post a task, a task with a reply, and get a
-// new task id without canceling any of them. The tasks and the reply
-// should run and the "is canceled" callback should return false.
-TEST_F(CancelableTaskTrackerTest, NoCancel) {
- Thread worker_thread("worker thread");
- ASSERT_TRUE(worker_thread.Start());
-
- ignore_result(task_tracker_.PostTask(worker_thread.task_runner().get(),
- FROM_HERE,
- MakeExpectedRunClosure(FROM_HERE)));
-
- ignore_result(task_tracker_.PostTaskAndReply(
- worker_thread.task_runner().get(), FROM_HERE,
- MakeExpectedRunClosure(FROM_HERE), MakeExpectedRunClosure(FROM_HERE)));
-
- CancelableTaskTracker::IsCanceledCallback is_canceled;
- ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
-
- worker_thread.Stop();
-
- RunCurrentLoopUntilIdle();
-
- EXPECT_FALSE(is_canceled.Run());
-}
-
-// Post a task with the task tracker but cancel it before running the
-// task runner. The task should not run.
-TEST_F(CancelableTaskTrackerTest, CancelPostedTask) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
- test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE));
- EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
-
- EXPECT_EQ(1U, test_task_runner->NumPendingTasks());
-
- task_tracker_.TryCancel(task_id);
-
- test_task_runner->RunUntilIdle();
-}
-
-// Post a task with reply with the task tracker and cancel it before
-// running the task runner. Neither the task nor the reply should
-// run.
-TEST_F(CancelableTaskTrackerTest, CancelPostedTaskAndReply) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- CancelableTaskTracker::TaskId task_id =
- task_tracker_.PostTaskAndReply(test_task_runner.get(),
- FROM_HERE,
- MakeExpectedNotRunClosure(FROM_HERE),
- MakeExpectedNotRunClosure(FROM_HERE));
- EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
-
- task_tracker_.TryCancel(task_id);
-
- test_task_runner->RunUntilIdle();
-}
-
-// Post a task with reply with the task tracker and cancel it after
-// running the task runner but before running the current message
-// loop. The task should run but the reply should not.
-TEST_F(CancelableTaskTrackerTest, CancelReply) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- CancelableTaskTracker::TaskId task_id =
- task_tracker_.PostTaskAndReply(test_task_runner.get(),
- FROM_HERE,
- MakeExpectedRunClosure(FROM_HERE),
- MakeExpectedNotRunClosure(FROM_HERE));
- EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
-
- test_task_runner->RunUntilIdle();
-
- task_tracker_.TryCancel(task_id);
-}
-
-// Post a task with reply with the task tracker on a worker thread and
-// cancel it before running the current message loop. The task should
-// run but the reply should not.
-TEST_F(CancelableTaskTrackerTest, CancelReplyDifferentThread) {
- Thread worker_thread("worker thread");
- ASSERT_TRUE(worker_thread.Start());
-
- CancelableTaskTracker::TaskId task_id = task_tracker_.PostTaskAndReply(
- worker_thread.task_runner().get(), FROM_HERE, DoNothing(),
- MakeExpectedNotRunClosure(FROM_HERE));
- EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
-
- task_tracker_.TryCancel(task_id);
-
- worker_thread.Stop();
-}
-
-void ExpectIsCanceled(
- const CancelableTaskTracker::IsCanceledCallback& is_canceled,
- bool expected_is_canceled) {
- EXPECT_EQ(expected_is_canceled, is_canceled.Run());
-}
-
-// Create a new task ID and check its status on a separate thread
-// before and after canceling. The is-canceled callback should be
-// thread-safe (i.e., nothing should blow up).
-TEST_F(CancelableTaskTrackerTest, NewTrackedTaskIdDifferentThread) {
- CancelableTaskTracker::IsCanceledCallback is_canceled;
- CancelableTaskTracker::TaskId task_id =
- task_tracker_.NewTrackedTaskId(&is_canceled);
-
- EXPECT_FALSE(is_canceled.Run());
-
- Thread other_thread("other thread");
- ASSERT_TRUE(other_thread.Start());
- other_thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&ExpectIsCanceled, is_canceled, false));
- other_thread.Stop();
-
- task_tracker_.TryCancel(task_id);
-
- ASSERT_TRUE(other_thread.Start());
- other_thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&ExpectIsCanceled, is_canceled, true));
- other_thread.Stop();
-}
-
-// With the task tracker, post a task, a task with a reply, get a new
-// task id, and then cancel all of them. None of the tasks nor the
-// reply should run and the "is canceled" callback should return
-// true.
-TEST_F(CancelableTaskTrackerTest, CancelAll) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- ignore_result(task_tracker_.PostTask(
- test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE)));
-
- ignore_result(
- task_tracker_.PostTaskAndReply(test_task_runner.get(),
- FROM_HERE,
- MakeExpectedNotRunClosure(FROM_HERE),
- MakeExpectedNotRunClosure(FROM_HERE)));
-
- CancelableTaskTracker::IsCanceledCallback is_canceled;
- ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
-
- task_tracker_.TryCancelAll();
-
- test_task_runner->RunUntilIdle();
-
- RunCurrentLoopUntilIdle();
-
- EXPECT_TRUE(is_canceled.Run());
-}
-
-// With the task tracker, post a task, a task with a reply, get a new
-// task id, and then cancel all of them. None of the tasks nor the
-// reply should run and the "is canceled" callback should return
-// true.
-TEST_F(CancelableTaskTrackerTest, DestructionCancelsAll) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- CancelableTaskTracker::IsCanceledCallback is_canceled;
-
- {
- // Create another task tracker with a smaller scope.
- CancelableTaskTracker task_tracker;
-
- ignore_result(task_tracker.PostTask(test_task_runner.get(),
- FROM_HERE,
- MakeExpectedNotRunClosure(FROM_HERE)));
-
- ignore_result(
- task_tracker.PostTaskAndReply(test_task_runner.get(),
- FROM_HERE,
- MakeExpectedNotRunClosure(FROM_HERE),
- MakeExpectedNotRunClosure(FROM_HERE)));
-
- ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
- }
-
- test_task_runner->RunUntilIdle();
-
- RunCurrentLoopUntilIdle();
-
- EXPECT_FALSE(is_canceled.Run());
-}
-
-// Post a task and cancel it. HasTrackedTasks() should return false as soon as
-// TryCancelAll() is called.
-TEST_F(CancelableTaskTrackerTest, HasTrackedTasksPost) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- EXPECT_FALSE(task_tracker_.HasTrackedTasks());
-
- ignore_result(task_tracker_.PostTask(
- test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE)));
-
- task_tracker_.TryCancelAll();
-
- EXPECT_FALSE(task_tracker_.HasTrackedTasks());
-
- test_task_runner->RunUntilIdle();
- RunCurrentLoopUntilIdle();
-}
-
-// Post a task with a reply and cancel it. HasTrackedTasks() should return false
-// as soon as TryCancelAll() is called.
-TEST_F(CancelableTaskTrackerTest, HasTrackedTasksPostWithReply) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- EXPECT_FALSE(task_tracker_.HasTrackedTasks());
-
- ignore_result(
- task_tracker_.PostTaskAndReply(test_task_runner.get(),
- FROM_HERE,
- MakeExpectedNotRunClosure(FROM_HERE),
- MakeExpectedNotRunClosure(FROM_HERE)));
-
- task_tracker_.TryCancelAll();
-
- EXPECT_FALSE(task_tracker_.HasTrackedTasks());
-
- test_task_runner->RunUntilIdle();
- RunCurrentLoopUntilIdle();
-}
-
-// Create a new tracked task ID. HasTrackedTasks() should return false as soon
-// as TryCancelAll() is called.
-TEST_F(CancelableTaskTrackerTest, HasTrackedTasksIsCancelled) {
- EXPECT_FALSE(task_tracker_.HasTrackedTasks());
-
- CancelableTaskTracker::IsCanceledCallback is_canceled;
- ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
-
- task_tracker_.TryCancelAll();
-
- EXPECT_FALSE(task_tracker_.HasTrackedTasks());
-}
-
-// The death tests below make sure that calling task tracker member
-// functions from a thread different from its owner thread DCHECKs in
-// debug mode.
-
-class CancelableTaskTrackerDeathTest : public CancelableTaskTrackerTest {
- protected:
- CancelableTaskTrackerDeathTest() {
- // The default style "fast" does not support multi-threaded tests.
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
- }
-};
-
-// Runs |fn| with |task_tracker|, expecting it to crash in debug mode.
-void MaybeRunDeadlyTaskTrackerMemberFunction(
- CancelableTaskTracker* task_tracker,
- const Callback<void(CancelableTaskTracker*)>& fn) {
- EXPECT_DCHECK_DEATH(fn.Run(task_tracker));
-}
-
-void PostDoNothingTask(CancelableTaskTracker* task_tracker) {
- ignore_result(task_tracker->PostTask(
- scoped_refptr<TestSimpleTaskRunner>(new TestSimpleTaskRunner()).get(),
- FROM_HERE, DoNothing()));
-}
-
-TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
- Thread bad_thread("bad thread");
- ASSERT_TRUE(bad_thread.Start());
-
- bad_thread.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&MaybeRunDeadlyTaskTrackerMemberFunction,
- Unretained(&task_tracker_), Bind(&PostDoNothingTask)));
-}
-
-void TryCancel(CancelableTaskTracker::TaskId task_id,
- CancelableTaskTracker* task_tracker) {
- task_tracker->TryCancel(task_id);
-}
-
-TEST_F(CancelableTaskTrackerDeathTest, CancelOnDifferentThread) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- Thread bad_thread("bad thread");
- ASSERT_TRUE(bad_thread.Start());
-
- CancelableTaskTracker::TaskId task_id =
- task_tracker_.PostTask(test_task_runner.get(), FROM_HERE, DoNothing());
- EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
-
- bad_thread.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&MaybeRunDeadlyTaskTrackerMemberFunction,
- Unretained(&task_tracker_), Bind(&TryCancel, task_id)));
-
- test_task_runner->RunUntilIdle();
-}
-
-TEST_F(CancelableTaskTrackerDeathTest, CancelAllOnDifferentThread) {
- scoped_refptr<TestSimpleTaskRunner> test_task_runner(
- new TestSimpleTaskRunner());
-
- Thread bad_thread("bad thread");
- ASSERT_TRUE(bad_thread.Start());
-
- CancelableTaskTracker::TaskId task_id =
- task_tracker_.PostTask(test_task_runner.get(), FROM_HERE, DoNothing());
- EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
-
- bad_thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&MaybeRunDeadlyTaskTrackerMemberFunction,
- Unretained(&task_tracker_),
- Bind(&CancelableTaskTracker::TryCancelAll)));
-
- test_task_runner->RunUntilIdle();
-}
-
-} // namespace base
diff --git a/base/task_runner_util_unittest.cc b/base/task_runner_util_unittest.cc
deleted file mode 100644
index 44baad4..0000000
--- a/base/task_runner_util_unittest.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-// 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.
-
-#include "base/task_runner_util.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-int ReturnFourtyTwo() {
- return 42;
-}
-
-void StoreValue(int* destination, int value) {
- *destination = value;
-}
-
-void StoreDoubleValue(double* destination, double value) {
- *destination = value;
-}
-
-int g_foo_destruct_count = 0;
-int g_foo_free_count = 0;
-
-struct Foo {
- ~Foo() {
- ++g_foo_destruct_count;
- }
-};
-
-std::unique_ptr<Foo> CreateFoo() {
- return std::unique_ptr<Foo>(new Foo);
-}
-
-void ExpectFoo(std::unique_ptr<Foo> foo) {
- EXPECT_TRUE(foo.get());
- std::unique_ptr<Foo> local_foo(std::move(foo));
- EXPECT_TRUE(local_foo.get());
- EXPECT_FALSE(foo.get());
-}
-
-struct FooDeleter {
- void operator()(Foo* foo) const {
- ++g_foo_free_count;
- delete foo;
- };
-};
-
-std::unique_ptr<Foo, FooDeleter> CreateScopedFoo() {
- return std::unique_ptr<Foo, FooDeleter>(new Foo);
-}
-
-void ExpectScopedFoo(std::unique_ptr<Foo, FooDeleter> foo) {
- EXPECT_TRUE(foo.get());
- std::unique_ptr<Foo, FooDeleter> local_foo(std::move(foo));
- EXPECT_TRUE(local_foo.get());
- EXPECT_FALSE(foo.get());
-}
-
-} // namespace
-
-TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResult) {
- int result = 0;
-
- MessageLoop message_loop;
- PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
- Bind(&ReturnFourtyTwo),
- Bind(&StoreValue, &result));
-
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(42, result);
-}
-
-TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultImplicitConvert) {
- double result = 0;
-
- MessageLoop message_loop;
- PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
- Bind(&ReturnFourtyTwo),
- Bind(&StoreDoubleValue, &result));
-
- RunLoop().RunUntilIdle();
-
- EXPECT_DOUBLE_EQ(42.0, result);
-}
-
-TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassed) {
- g_foo_destruct_count = 0;
- g_foo_free_count = 0;
-
- MessageLoop message_loop;
- PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
- Bind(&CreateFoo), Bind(&ExpectFoo));
-
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(1, g_foo_destruct_count);
- EXPECT_EQ(0, g_foo_free_count);
-}
-
-TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassedFreeProc) {
- g_foo_destruct_count = 0;
- g_foo_free_count = 0;
-
- MessageLoop message_loop;
- PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
- Bind(&CreateScopedFoo), Bind(&ExpectScopedFoo));
-
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(1, g_foo_destruct_count);
- EXPECT_EQ(1, g_foo_free_count);
-}
-
-} // namespace base
diff --git a/base/task_scheduler/delayed_task_manager_unittest.cc b/base/task_scheduler/delayed_task_manager_unittest.cc
deleted file mode 100644
index 67c797a..0000000
--- a/base/task_scheduler/delayed_task_manager_unittest.cc
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/delayed_task_manager.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/task.h"
-#include "base/test/bind_test_util.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "base/threading/thread.h"
-#include "base/time/time.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-namespace {
-
-constexpr TimeDelta kLongDelay = TimeDelta::FromHours(1);
-
-class MockTask {
- public:
- MOCK_METHOD0(Run, void());
-};
-
-void RunTask(Task task) {
- std::move(task.task).Run();
-}
-
-class TaskSchedulerDelayedTaskManagerTest : public testing::Test {
- protected:
- TaskSchedulerDelayedTaskManagerTest()
- : delayed_task_manager_(
- service_thread_task_runner_->DeprecatedGetMockTickClock()),
- task_(FROM_HERE,
- BindOnce(&MockTask::Run, Unretained(&mock_task_)),
- TaskTraits(),
- kLongDelay) {
- // The constructor of Task computes |delayed_run_time| by adding |delay| to
- // the real time. Recompute it by adding |delay| to the mock time.
- task_.delayed_run_time =
- service_thread_task_runner_->GetMockTickClock()->NowTicks() +
- kLongDelay;
- }
- ~TaskSchedulerDelayedTaskManagerTest() override = default;
-
- const scoped_refptr<TestMockTimeTaskRunner> service_thread_task_runner_ =
- MakeRefCounted<TestMockTimeTaskRunner>();
- DelayedTaskManager delayed_task_manager_;
- testing::StrictMock<MockTask> mock_task_;
- Task task_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerDelayedTaskManagerTest);
-};
-
-} // namespace
-
-// Verify that a delayed task isn't forwarded before Start().
-TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskDoesNotRunBeforeStart) {
- // Send |task| to the DelayedTaskManager.
- delayed_task_manager_.AddDelayedTask(std::move(task_), BindOnce(&RunTask));
-
- // Fast-forward time until the task is ripe for execution. Since Start() has
- // not been called, the task should not be forwarded to RunTask() (MockTask is
- // a StrictMock without expectations so test will fail if RunTask() runs it).
- service_thread_task_runner_->FastForwardBy(kLongDelay);
-}
-
-// Verify that a delayed task added before Start() and whose delay expires after
-// Start() is forwarded when its delay expires.
-TEST_F(TaskSchedulerDelayedTaskManagerTest,
- DelayedTaskPostedBeforeStartExpiresAfterStartRunsOnExpire) {
- // Send |task| to the DelayedTaskManager.
- delayed_task_manager_.AddDelayedTask(std::move(task_), BindOnce(&RunTask));
-
- delayed_task_manager_.Start(service_thread_task_runner_);
-
- // Run tasks on the service thread. Don't expect any forwarding to
- // |task_target_| since the task isn't ripe for execution.
- service_thread_task_runner_->RunUntilIdle();
-
- // Fast-forward time until the task is ripe for execution. Expect the task to
- // be forwarded to RunTask().
- EXPECT_CALL(mock_task_, Run());
- service_thread_task_runner_->FastForwardBy(kLongDelay);
-}
-
-// Verify that a delayed task added before Start() and whose delay expires
-// before Start() is forwarded when Start() is called.
-TEST_F(TaskSchedulerDelayedTaskManagerTest,
- DelayedTaskPostedBeforeStartExpiresBeforeStartRunsOnStart) {
- // Send |task| to the DelayedTaskManager.
- delayed_task_manager_.AddDelayedTask(std::move(task_), BindOnce(&RunTask));
-
- // Run tasks on the service thread. Don't expect any forwarding to
- // |task_target_| since the task isn't ripe for execution.
- service_thread_task_runner_->RunUntilIdle();
-
- // Fast-forward time until the task is ripe for execution. Don't expect the
- // task to be forwarded since Start() hasn't been called yet.
- service_thread_task_runner_->FastForwardBy(kLongDelay);
-
- // Start the DelayedTaskManager. Expect the task to be forwarded to RunTask().
- EXPECT_CALL(mock_task_, Run());
- delayed_task_manager_.Start(service_thread_task_runner_);
- service_thread_task_runner_->RunUntilIdle();
-}
-
-// Verify that a delayed task added after Start() isn't forwarded before it is
-// ripe for execution.
-TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskDoesNotRunTooEarly) {
- delayed_task_manager_.Start(service_thread_task_runner_);
-
- // Send |task| to the DelayedTaskManager.
- delayed_task_manager_.AddDelayedTask(std::move(task_), BindOnce(&RunTask));
-
- // Run tasks that are ripe for execution. Don't expect any forwarding to
- // RunTask().
- service_thread_task_runner_->RunUntilIdle();
-}
-
-// Verify that a delayed task added after Start() is forwarded when it is ripe
-// for execution.
-TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskRunsAfterDelay) {
- delayed_task_manager_.Start(service_thread_task_runner_);
-
- // Send |task| to the DelayedTaskManager.
- delayed_task_manager_.AddDelayedTask(std::move(task_), BindOnce(&RunTask));
-
- // Fast-forward time. Expect the task to be forwarded to RunTask().
- EXPECT_CALL(mock_task_, Run());
- service_thread_task_runner_->FastForwardBy(kLongDelay);
-}
-
-// Verify that multiple delayed tasks added after Start() are forwarded when
-// they are ripe for execution.
-TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTasksRunAfterDelay) {
- delayed_task_manager_.Start(service_thread_task_runner_);
-
- testing::StrictMock<MockTask> mock_task_a;
- Task task_a(FROM_HERE, BindOnce(&MockTask::Run, Unretained(&mock_task_a)),
- TaskTraits(), TimeDelta::FromHours(1));
-
- testing::StrictMock<MockTask> mock_task_b;
- Task task_b(FROM_HERE, BindOnce(&MockTask::Run, Unretained(&mock_task_b)),
- TaskTraits(), TimeDelta::FromHours(2));
-
- testing::StrictMock<MockTask> mock_task_c;
- Task task_c(FROM_HERE, BindOnce(&MockTask::Run, Unretained(&mock_task_c)),
- TaskTraits(), TimeDelta::FromHours(1));
-
- // Send tasks to the DelayedTaskManager.
- delayed_task_manager_.AddDelayedTask(std::move(task_a), BindOnce(&RunTask));
- delayed_task_manager_.AddDelayedTask(std::move(task_b), BindOnce(&RunTask));
- delayed_task_manager_.AddDelayedTask(std::move(task_c), BindOnce(&RunTask));
-
- // Run tasks that are ripe for execution on the service thread. Don't expect
- // any call to RunTask().
- service_thread_task_runner_->RunUntilIdle();
-
- // Fast-forward time. Expect |task_a| and |task_c| to be forwarded to
- // |task_target_|.
- EXPECT_CALL(mock_task_a, Run());
- EXPECT_CALL(mock_task_c, Run());
- service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1));
- testing::Mock::VerifyAndClear(&mock_task_a);
- testing::Mock::VerifyAndClear(&mock_task_c);
-
- // Fast-forward time. Expect |task_b| to be forwarded to RunTask().
- EXPECT_CALL(mock_task_b, Run());
- service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1));
- testing::Mock::VerifyAndClear(&mock_task_b);
-}
-
-TEST_F(TaskSchedulerDelayedTaskManagerTest, PostTaskDuringStart) {
- Thread other_thread("Test");
- other_thread.StartAndWaitForTesting();
-
- WaitableEvent task_posted;
-
- other_thread.task_runner()->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
- delayed_task_manager_.AddDelayedTask(
- std::move(task_),
- BindOnce(&RunTask));
- task_posted.Signal();
- }));
-
- delayed_task_manager_.Start(service_thread_task_runner_);
-
- // The test is testing a race between AddDelayedTask/Start but it still needs
- // synchronization to ensure we don't do the final verification before the
- // task itself is posted.
- task_posted.Wait();
-
- // Fast-forward time. Expect the task to be forwarded to RunTask().
- EXPECT_CALL(mock_task_, Run());
- service_thread_task_runner_->FastForwardBy(kLongDelay);
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/lazy_task_runner_unittest.cc b/base/task_scheduler/lazy_task_runner_unittest.cc
deleted file mode 100644
index e898a1e..0000000
--- a/base/task_scheduler/lazy_task_runner_unittest.cc
+++ /dev/null
@@ -1,199 +0,0 @@
-// Copyright 2017 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 "base/task_scheduler/lazy_task_runner.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/sequence_checker_impl.h"
-#include "base/task_scheduler/scoped_set_task_priority_for_current_thread.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/threading/thread_checker_impl.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include "base/win/com_init_util.h"
-#endif
-
-namespace base {
-
-namespace {
-
-LazySequencedTaskRunner g_sequenced_task_runner_user_visible =
- LAZY_SEQUENCED_TASK_RUNNER_INITIALIZER({TaskPriority::USER_VISIBLE});
-LazySequencedTaskRunner g_sequenced_task_runner_user_blocking =
- LAZY_SEQUENCED_TASK_RUNNER_INITIALIZER({TaskPriority::USER_BLOCKING});
-
-LazySingleThreadTaskRunner g_single_thread_task_runner_user_visible =
- LAZY_SINGLE_THREAD_TASK_RUNNER_INITIALIZER(
- {TaskPriority::USER_VISIBLE},
- SingleThreadTaskRunnerThreadMode::SHARED);
-LazySingleThreadTaskRunner g_single_thread_task_runner_user_blocking =
- LAZY_SINGLE_THREAD_TASK_RUNNER_INITIALIZER(
- {TaskPriority::USER_BLOCKING},
- SingleThreadTaskRunnerThreadMode::SHARED);
-
-#if defined(OS_WIN)
-LazyCOMSTATaskRunner g_com_sta_task_runner_user_visible =
- LAZY_COM_STA_TASK_RUNNER_INITIALIZER(
- {TaskPriority::USER_VISIBLE},
- SingleThreadTaskRunnerThreadMode::SHARED);
-LazyCOMSTATaskRunner g_com_sta_task_runner_user_blocking =
- LAZY_COM_STA_TASK_RUNNER_INITIALIZER(
- {TaskPriority::USER_BLOCKING},
- SingleThreadTaskRunnerThreadMode::SHARED);
-#endif // defined(OS_WIN)
-
-void InitCheckers(SequenceCheckerImpl* sequence_checker,
- ThreadCheckerImpl* thread_checker) {
- sequence_checker->DetachFromSequence();
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
- thread_checker->DetachFromThread();
- EXPECT_TRUE(thread_checker->CalledOnValidThread());
-}
-
-void ExpectSequencedEnvironment(SequenceCheckerImpl* sequence_checker,
- ThreadCheckerImpl* thread_checker,
- TaskPriority expected_priority) {
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
- EXPECT_FALSE(thread_checker->CalledOnValidThread());
- EXPECT_EQ(expected_priority, internal::GetTaskPriorityForCurrentThread());
-}
-
-void ExpectSingleThreadEnvironment(SequenceCheckerImpl* sequence_checker,
- ThreadCheckerImpl* thread_checker,
- TaskPriority expected_priority
-#if defined(OS_WIN)
- ,
- bool expect_com_sta = false
-#endif
- ) {
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
- EXPECT_TRUE(thread_checker->CalledOnValidThread());
- EXPECT_EQ(expected_priority, internal::GetTaskPriorityForCurrentThread());
-
-#if defined(OS_WIN)
- if (expect_com_sta)
- win::AssertComApartmentType(win::ComApartmentType::STA);
-#endif
-}
-
-class TaskSchedulerLazyTaskRunnerEnvironmentTest : public testing::Test {
- protected:
- TaskSchedulerLazyTaskRunnerEnvironmentTest() = default;
-
- void TestTaskRunnerEnvironment(scoped_refptr<SequencedTaskRunner> task_runner,
- bool expect_single_thread,
- TaskPriority expected_priority
-#if defined(OS_WIN)
- ,
- bool expect_com_sta = false
-#endif
- ) {
- SequenceCheckerImpl sequence_checker;
- ThreadCheckerImpl thread_checker;
- task_runner->PostTask(FROM_HERE,
- BindOnce(&InitCheckers, Unretained(&sequence_checker),
- Unretained(&thread_checker)));
- scoped_task_environment_.RunUntilIdle();
-
- OnceClosure task =
- expect_single_thread
- ? BindOnce(&ExpectSingleThreadEnvironment,
- Unretained(&sequence_checker),
- Unretained(&thread_checker), expected_priority
-#if defined(OS_WIN)
- ,
- expect_com_sta
-#endif
- )
- : BindOnce(&ExpectSequencedEnvironment,
- Unretained(&sequence_checker),
- Unretained(&thread_checker), expected_priority);
- task_runner->PostTask(FROM_HERE, std::move(task));
- scoped_task_environment_.RunUntilIdle();
- }
-
- test::ScopedTaskEnvironment scoped_task_environment_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerLazyTaskRunnerEnvironmentTest);
-};
-
-} // namespace
-
-TEST_F(TaskSchedulerLazyTaskRunnerEnvironmentTest,
- LazySequencedTaskRunnerUserVisible) {
- TestTaskRunnerEnvironment(g_sequenced_task_runner_user_visible.Get(), false,
- TaskPriority::USER_VISIBLE);
-}
-
-TEST_F(TaskSchedulerLazyTaskRunnerEnvironmentTest,
- LazySequencedTaskRunnerUserBlocking) {
- TestTaskRunnerEnvironment(g_sequenced_task_runner_user_blocking.Get(), false,
- TaskPriority::USER_BLOCKING);
-}
-
-TEST_F(TaskSchedulerLazyTaskRunnerEnvironmentTest,
- LazySingleThreadTaskRunnerUserVisible) {
- TestTaskRunnerEnvironment(g_single_thread_task_runner_user_visible.Get(),
- true, TaskPriority::USER_VISIBLE);
-}
-
-TEST_F(TaskSchedulerLazyTaskRunnerEnvironmentTest,
- LazySingleThreadTaskRunnerUserBlocking) {
- TestTaskRunnerEnvironment(g_single_thread_task_runner_user_blocking.Get(),
- true, TaskPriority::USER_BLOCKING);
-}
-
-#if defined(OS_WIN)
-TEST_F(TaskSchedulerLazyTaskRunnerEnvironmentTest,
- LazyCOMSTATaskRunnerUserVisible) {
- TestTaskRunnerEnvironment(g_com_sta_task_runner_user_visible.Get(), true,
- TaskPriority::USER_VISIBLE, true);
-}
-
-TEST_F(TaskSchedulerLazyTaskRunnerEnvironmentTest,
- LazyCOMSTATaskRunnerUserBlocking) {
- TestTaskRunnerEnvironment(g_com_sta_task_runner_user_blocking.Get(), true,
- TaskPriority::USER_BLOCKING, true);
-}
-#endif // defined(OS_WIN)
-
-TEST(TaskSchdulerLazyTaskRunnerTest, LazySequencedTaskRunnerReset) {
- for (int i = 0; i < 2; ++i) {
- test::ScopedTaskEnvironment scoped_task_environment;
- // If the TaskRunner isn't released when the test::ScopedTaskEnvironment
- // goes out of scope, the second invocation of the line below will access a
- // deleted TaskScheduler and crash.
- g_sequenced_task_runner_user_visible.Get()->PostTask(FROM_HERE,
- DoNothing());
- }
-}
-
-TEST(TaskSchdulerLazyTaskRunnerTest, LazySingleThreadTaskRunnerReset) {
- for (int i = 0; i < 2; ++i) {
- test::ScopedTaskEnvironment scoped_task_environment;
- // If the TaskRunner isn't released when the test::ScopedTaskEnvironment
- // goes out of scope, the second invocation of the line below will access a
- // deleted TaskScheduler and crash.
- g_single_thread_task_runner_user_visible.Get()->PostTask(FROM_HERE,
- DoNothing());
- }
-}
-
-#if defined(OS_WIN)
-TEST(TaskSchdulerLazyTaskRunnerTest, LazyCOMSTATaskRunnerReset) {
- for (int i = 0; i < 2; ++i) {
- test::ScopedTaskEnvironment scoped_task_environment;
- // If the TaskRunner isn't released when the test::ScopedTaskEnvironment
- // goes out of scope, the second invocation of the line below will access a
- // deleted TaskScheduler and crash.
- g_com_sta_task_runner_user_visible.Get()->PostTask(FROM_HERE, DoNothing());
- }
-}
-#endif // defined(OS_WIN)
-
-} // namespace base
diff --git a/base/task_scheduler/priority_queue_unittest.cc b/base/task_scheduler/priority_queue_unittest.cc
deleted file mode 100644
index 9dc4d13..0000000
--- a/base/task_scheduler/priority_queue_unittest.cc
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/priority_queue.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/sequence.h"
-#include "base/task_scheduler/task.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class ThreadBeginningTransaction : public SimpleThread {
- public:
- explicit ThreadBeginningTransaction(PriorityQueue* priority_queue)
- : SimpleThread("ThreadBeginningTransaction"),
- priority_queue_(priority_queue),
- transaction_began_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- // SimpleThread:
- void Run() override {
- std::unique_ptr<PriorityQueue::Transaction> transaction =
- priority_queue_->BeginTransaction();
- transaction_began_.Signal();
- }
-
- void ExpectTransactionDoesNotBegin() {
- // After a few milliseconds, the call to BeginTransaction() should not have
- // returned.
- EXPECT_FALSE(
- transaction_began_.TimedWait(TimeDelta::FromMilliseconds(250)));
- }
-
- private:
- PriorityQueue* const priority_queue_;
- WaitableEvent transaction_began_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadBeginningTransaction);
-};
-
-} // namespace
-
-TEST(TaskSchedulerPriorityQueueTest, PushPopPeek) {
- // Create test sequences.
- scoped_refptr<Sequence> sequence_a(new Sequence);
- sequence_a->PushTask(Task(FROM_HERE, DoNothing(),
- TaskTraits(TaskPriority::USER_VISIBLE),
- TimeDelta()));
- SequenceSortKey sort_key_a = sequence_a->GetSortKey();
-
- scoped_refptr<Sequence> sequence_b(new Sequence);
- sequence_b->PushTask(Task(FROM_HERE, DoNothing(),
- TaskTraits(TaskPriority::USER_BLOCKING),
- TimeDelta()));
- SequenceSortKey sort_key_b = sequence_b->GetSortKey();
-
- scoped_refptr<Sequence> sequence_c(new Sequence);
- sequence_c->PushTask(Task(FROM_HERE, DoNothing(),
- TaskTraits(TaskPriority::USER_BLOCKING),
- TimeDelta()));
- SequenceSortKey sort_key_c = sequence_c->GetSortKey();
-
- scoped_refptr<Sequence> sequence_d(new Sequence);
- sequence_d->PushTask(Task(FROM_HERE, DoNothing(),
- TaskTraits(TaskPriority::BACKGROUND), TimeDelta()));
- SequenceSortKey sort_key_d = sequence_d->GetSortKey();
-
- // Create a PriorityQueue and a Transaction.
- PriorityQueue pq;
- auto transaction(pq.BeginTransaction());
- EXPECT_TRUE(transaction->IsEmpty());
-
- // Push |sequence_a| in the PriorityQueue. It becomes the sequence with the
- // highest priority.
- transaction->Push(sequence_a, sort_key_a);
- EXPECT_EQ(sort_key_a, transaction->PeekSortKey());
-
- // Push |sequence_b| in the PriorityQueue. It becomes the sequence with the
- // highest priority.
- transaction->Push(sequence_b, sort_key_b);
- EXPECT_EQ(sort_key_b, transaction->PeekSortKey());
-
- // Push |sequence_c| in the PriorityQueue. |sequence_b| is still the sequence
- // with the highest priority.
- transaction->Push(sequence_c, sort_key_c);
- EXPECT_EQ(sort_key_b, transaction->PeekSortKey());
-
- // Push |sequence_d| in the PriorityQueue. |sequence_b| is still the sequence
- // with the highest priority.
- transaction->Push(sequence_d, sort_key_d);
- EXPECT_EQ(sort_key_b, transaction->PeekSortKey());
-
- // Pop |sequence_b| from the PriorityQueue. |sequence_c| becomes the sequence
- // with the highest priority.
- EXPECT_EQ(sequence_b, transaction->PopSequence());
- EXPECT_EQ(sort_key_c, transaction->PeekSortKey());
-
- // Pop |sequence_c| from the PriorityQueue. |sequence_a| becomes the sequence
- // with the highest priority.
- EXPECT_EQ(sequence_c, transaction->PopSequence());
- EXPECT_EQ(sort_key_a, transaction->PeekSortKey());
-
- // Pop |sequence_a| from the PriorityQueue. |sequence_d| becomes the sequence
- // with the highest priority.
- EXPECT_EQ(sequence_a, transaction->PopSequence());
- EXPECT_EQ(sort_key_d, transaction->PeekSortKey());
-
- // Pop |sequence_d| from the PriorityQueue. It is now empty.
- EXPECT_EQ(sequence_d, transaction->PopSequence());
- EXPECT_TRUE(transaction->IsEmpty());
-}
-
-// Check that creating Transactions on the same thread for 2 unrelated
-// PriorityQueues causes a crash.
-TEST(TaskSchedulerPriorityQueueTest, IllegalTwoTransactionsSameThread) {
- PriorityQueue pq_a;
- PriorityQueue pq_b;
-
- EXPECT_DCHECK_DEATH(
- {
- std::unique_ptr<PriorityQueue::Transaction> transaction_a =
- pq_a.BeginTransaction();
- std::unique_ptr<PriorityQueue::Transaction> transaction_b =
- pq_b.BeginTransaction();
- });
-}
-
-// Check that it is possible to begin multiple Transactions for the same
-// PriorityQueue on different threads. The call to BeginTransaction() on the
-// second thread should block until the Transaction has ended on the first
-// thread.
-TEST(TaskSchedulerPriorityQueueTest, TwoTransactionsTwoThreads) {
- PriorityQueue pq;
-
- // Call BeginTransaction() on this thread and keep the Transaction alive.
- std::unique_ptr<PriorityQueue::Transaction> transaction =
- pq.BeginTransaction();
-
- // Call BeginTransaction() on another thread.
- ThreadBeginningTransaction thread_beginning_transaction(&pq);
- thread_beginning_transaction.Start();
-
- // After a few milliseconds, the call to BeginTransaction() on the other
- // thread should not have returned.
- thread_beginning_transaction.ExpectTransactionDoesNotBegin();
-
- // End the Transaction on the current thread.
- transaction.reset();
-
- // The other thread should exit after its call to BeginTransaction() returns.
- thread_beginning_transaction.Join();
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scheduler_lock_unittest.cc b/base/task_scheduler/scheduler_lock_unittest.cc
deleted file mode 100644
index 5518247..0000000
--- a/base/task_scheduler/scheduler_lock_unittest.cc
+++ /dev/null
@@ -1,296 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/scheduler_lock.h"
-
-#include <stdlib.h>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/rand_util.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-namespace {
-
-// Adapted from base::Lock's BasicLockTestThread to make sure
-// Acquire()/Release() don't crash.
-class BasicLockTestThread : public SimpleThread {
- public:
- explicit BasicLockTestThread(SchedulerLock* lock)
- : SimpleThread("BasicLockTestThread"),
- lock_(lock),
- acquired_(0) {}
-
- int acquired() const { return acquired_; }
-
- private:
- void Run() override {
- for (int i = 0; i < 10; i++) {
- lock_->Acquire();
- acquired_++;
- lock_->Release();
- }
- for (int i = 0; i < 10; i++) {
- lock_->Acquire();
- acquired_++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(base::RandInt(0, 19)));
- lock_->Release();
- }
- }
-
- SchedulerLock* const lock_;
- int acquired_;
-
- DISALLOW_COPY_AND_ASSIGN(BasicLockTestThread);
-};
-
-class BasicLockAcquireAndWaitThread : public SimpleThread {
- public:
- explicit BasicLockAcquireAndWaitThread(SchedulerLock* lock)
- : SimpleThread("BasicLockAcquireAndWaitThread"),
- lock_(lock),
- lock_acquire_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- main_thread_continue_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED) {
- }
-
- void WaitForLockAcquisition() {
- lock_acquire_event_.Wait();
- }
-
- void ContinueMain() {
- main_thread_continue_event_.Signal();
- }
-
- private:
- void Run() override {
- lock_->Acquire();
- lock_acquire_event_.Signal();
- main_thread_continue_event_.Wait();
- lock_->Release();
- }
-
- SchedulerLock* const lock_;
- WaitableEvent lock_acquire_event_;
- WaitableEvent main_thread_continue_event_;
-
- DISALLOW_COPY_AND_ASSIGN(BasicLockAcquireAndWaitThread);
-};
-
-TEST(TaskSchedulerLock, Basic) {
- SchedulerLock lock;
- BasicLockTestThread thread(&lock);
-
- thread.Start();
-
- int acquired = 0;
- for (int i = 0; i < 5; i++) {
- lock.Acquire();
- acquired++;
- lock.Release();
- }
- for (int i = 0; i < 10; i++) {
- lock.Acquire();
- acquired++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(base::RandInt(0, 19)));
- lock.Release();
- }
- for (int i = 0; i < 5; i++) {
- lock.Acquire();
- acquired++;
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(base::RandInt(0, 19)));
- lock.Release();
- }
-
- thread.Join();
-
- EXPECT_EQ(acquired, 20);
- EXPECT_EQ(thread.acquired(), 20);
-}
-
-TEST(TaskSchedulerLock, AcquirePredecessor) {
- SchedulerLock predecessor;
- SchedulerLock lock(&predecessor);
- predecessor.Acquire();
- lock.Acquire();
- lock.Release();
- predecessor.Release();
-}
-
-TEST(TaskSchedulerLock, AcquirePredecessorWrongOrder) {
- SchedulerLock predecessor;
- SchedulerLock lock(&predecessor);
- EXPECT_DCHECK_DEATH({
- lock.Acquire();
- predecessor.Acquire();
- });
-}
-
-TEST(TaskSchedulerLock, AcquireNonPredecessor) {
- SchedulerLock lock1;
- SchedulerLock lock2;
- EXPECT_DCHECK_DEATH({
- lock1.Acquire();
- lock2.Acquire();
- });
-}
-
-TEST(TaskSchedulerLock, AcquireMultipleLocksInOrder) {
- SchedulerLock lock1;
- SchedulerLock lock2(&lock1);
- SchedulerLock lock3(&lock2);
- lock1.Acquire();
- lock2.Acquire();
- lock3.Acquire();
- lock3.Release();
- lock2.Release();
- lock1.Release();
-}
-
-TEST(TaskSchedulerLock, AcquireMultipleLocksInTheMiddleOfAChain) {
- SchedulerLock lock1;
- SchedulerLock lock2(&lock1);
- SchedulerLock lock3(&lock2);
- lock2.Acquire();
- lock3.Acquire();
- lock3.Release();
- lock2.Release();
-}
-
-TEST(TaskSchedulerLock, AcquireMultipleLocksNoTransitivity) {
- SchedulerLock lock1;
- SchedulerLock lock2(&lock1);
- SchedulerLock lock3(&lock2);
- EXPECT_DCHECK_DEATH({
- lock1.Acquire();
- lock3.Acquire();
- });
-}
-
-TEST(TaskSchedulerLock, AcquireLocksDifferentThreadsSafely) {
- SchedulerLock lock1;
- SchedulerLock lock2;
- BasicLockAcquireAndWaitThread thread(&lock1);
- thread.Start();
-
- lock2.Acquire();
- thread.WaitForLockAcquisition();
- thread.ContinueMain();
- thread.Join();
- lock2.Release();
-}
-
-TEST(TaskSchedulerLock,
- AcquireLocksWithPredecessorDifferentThreadsSafelyPredecessorFirst) {
- // A lock and its predecessor may be safely acquired on different threads.
- // This Thread Other Thread
- // predecessor.Acquire()
- // lock.Acquire()
- // predecessor.Release()
- // lock.Release()
- SchedulerLock predecessor;
- SchedulerLock lock(&predecessor);
- predecessor.Acquire();
- BasicLockAcquireAndWaitThread thread(&lock);
- thread.Start();
- thread.WaitForLockAcquisition();
- predecessor.Release();
- thread.ContinueMain();
- thread.Join();
-}
-
-TEST(TaskSchedulerLock,
- AcquireLocksWithPredecessorDifferentThreadsSafelyPredecessorLast) {
- // A lock and its predecessor may be safely acquired on different threads.
- // This Thread Other Thread
- // lock.Acquire()
- // predecessor.Acquire()
- // lock.Release()
- // predecessor.Release()
- SchedulerLock predecessor;
- SchedulerLock lock(&predecessor);
- lock.Acquire();
- BasicLockAcquireAndWaitThread thread(&predecessor);
- thread.Start();
- thread.WaitForLockAcquisition();
- lock.Release();
- thread.ContinueMain();
- thread.Join();
-}
-
-TEST(TaskSchedulerLock,
- AcquireLocksWithPredecessorDifferentThreadsSafelyNoInterference) {
- // Acquisition of an unrelated lock on another thread should not affect a
- // legal lock acquisition with a predecessor on this thread.
- // This Thread Other Thread
- // predecessor.Acquire()
- // unrelated.Acquire()
- // lock.Acquire()
- // unrelated.Release()
- // lock.Release()
- // predecessor.Release();
- SchedulerLock predecessor;
- SchedulerLock lock(&predecessor);
- predecessor.Acquire();
- SchedulerLock unrelated;
- BasicLockAcquireAndWaitThread thread(&unrelated);
- thread.Start();
- thread.WaitForLockAcquisition();
- lock.Acquire();
- thread.ContinueMain();
- thread.Join();
- lock.Release();
- predecessor.Release();
-}
-
-TEST(TaskSchedulerLock, SelfReferentialLock) {
- struct SelfReferentialLock {
- SelfReferentialLock() : lock(&lock) {}
-
- SchedulerLock lock;
- };
-
- EXPECT_DCHECK_DEATH({ SelfReferentialLock lock; });
-}
-
-TEST(TaskSchedulerLock, PredecessorCycle) {
- struct LockCycle {
- LockCycle() : lock1(&lock2), lock2(&lock1) {}
-
- SchedulerLock lock1;
- SchedulerLock lock2;
- };
-
- EXPECT_DCHECK_DEATH({ LockCycle cycle; });
-}
-
-TEST(TaskSchedulerLock, PredecessorLongerCycle) {
- struct LockCycle {
- LockCycle()
- : lock1(&lock5),
- lock2(&lock1),
- lock3(&lock2),
- lock4(&lock3),
- lock5(&lock4) {}
-
- SchedulerLock lock1;
- SchedulerLock lock2;
- SchedulerLock lock3;
- SchedulerLock lock4;
- SchedulerLock lock5;
- };
-
- EXPECT_DCHECK_DEATH({ LockCycle cycle; });
-}
-
-} // namespace
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc b/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc
deleted file mode 100644
index 52d99f6..0000000
--- a/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc
+++ /dev/null
@@ -1,676 +0,0 @@
-// Copyright 2017 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 "base/task_scheduler/scheduler_single_thread_task_runner_manager.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/memory/ptr_util.h"
-#include "base/synchronization/atomic_flag.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/delayed_task_manager.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/task_scheduler/scheduler_worker_pool_params.h"
-#include "base/task_scheduler/task_tracker.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-
-#include "base/win/com_init_util.h"
-#include "base/win/current_module.h"
-#endif // defined(OS_WIN)
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test {
- public:
- TaskSchedulerSingleThreadTaskRunnerManagerTest()
- : service_thread_("TaskSchedulerServiceThread") {}
-
- void SetUp() override {
- service_thread_.Start();
- delayed_task_manager_.Start(service_thread_.task_runner());
- single_thread_task_runner_manager_ =
- std::make_unique<SchedulerSingleThreadTaskRunnerManager>(
- task_tracker_.GetTrackedRef(), &delayed_task_manager_);
- StartSingleThreadTaskRunnerManagerFromSetUp();
- }
-
- void TearDown() override {
- if (single_thread_task_runner_manager_)
- TearDownSingleThreadTaskRunnerManager();
- service_thread_.Stop();
- }
-
- protected:
- virtual void StartSingleThreadTaskRunnerManagerFromSetUp() {
- single_thread_task_runner_manager_->Start();
- }
-
- virtual void TearDownSingleThreadTaskRunnerManager() {
- single_thread_task_runner_manager_->JoinForTesting();
- single_thread_task_runner_manager_.reset();
- }
-
- Thread service_thread_;
- TaskTracker task_tracker_ = {"Test"};
- DelayedTaskManager delayed_task_manager_;
- std::unique_ptr<SchedulerSingleThreadTaskRunnerManager>
- single_thread_task_runner_manager_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTest);
-};
-
-void CaptureThreadRef(PlatformThreadRef* thread_ref) {
- ASSERT_TRUE(thread_ref);
- *thread_ref = PlatformThread::CurrentRef();
-}
-
-void CaptureThreadPriority(ThreadPriority* thread_priority) {
- ASSERT_TRUE(thread_priority);
- *thread_priority = PlatformThread::GetCurrentThreadPriority();
-}
-
-void CaptureThreadName(std::string* thread_name) {
- *thread_name = PlatformThread::GetName();
-}
-
-void ShouldNotRun() {
- ADD_FAILURE() << "Ran a task that shouldn't run.";
-}
-
-} // namespace
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
- scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
- scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
-
- PlatformThreadRef thread_ref_1;
- task_runner_1->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadRef, &thread_ref_1));
- PlatformThreadRef thread_ref_2;
- task_runner_2->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadRef, &thread_ref_2));
-
- task_tracker_.Shutdown();
-
- ASSERT_FALSE(thread_ref_1.is_null());
- ASSERT_FALSE(thread_ref_2.is_null());
- EXPECT_NE(thread_ref_1, thread_ref_2);
-}
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, SameThreadUsed) {
- scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::SHARED);
- scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::SHARED);
-
- PlatformThreadRef thread_ref_1;
- task_runner_1->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadRef, &thread_ref_1));
- PlatformThreadRef thread_ref_2;
- task_runner_2->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadRef, &thread_ref_2));
-
- task_tracker_.Shutdown();
-
- ASSERT_FALSE(thread_ref_1.is_null());
- ASSERT_FALSE(thread_ref_2.is_null());
- EXPECT_EQ(thread_ref_1, thread_ref_2);
-}
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
- RunsTasksInCurrentSequence) {
- scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
- scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
-
- EXPECT_FALSE(task_runner_1->RunsTasksInCurrentSequence());
- EXPECT_FALSE(task_runner_2->RunsTasksInCurrentSequence());
-
- task_runner_1->PostTask(
- FROM_HERE,
- BindOnce(
- [](scoped_refptr<SingleThreadTaskRunner> task_runner_1,
- scoped_refptr<SingleThreadTaskRunner> task_runner_2) {
- EXPECT_TRUE(task_runner_1->RunsTasksInCurrentSequence());
- EXPECT_FALSE(task_runner_2->RunsTasksInCurrentSequence());
- },
- task_runner_1, task_runner_2));
-
- task_runner_2->PostTask(
- FROM_HERE,
- BindOnce(
- [](scoped_refptr<SingleThreadTaskRunner> task_runner_1,
- scoped_refptr<SingleThreadTaskRunner> task_runner_2) {
- EXPECT_FALSE(task_runner_1->RunsTasksInCurrentSequence());
- EXPECT_TRUE(task_runner_2->RunsTasksInCurrentSequence());
- },
- task_runner_1, task_runner_2));
-
- task_tracker_.Shutdown();
-}
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
- SharedWithBaseSyncPrimitivesDCHECKs) {
- testing::GTEST_FLAG(death_test_style) = "threadsafe";
- EXPECT_DCHECK_DEATH({
- single_thread_task_runner_manager_->CreateSingleThreadTaskRunnerWithTraits(
- {WithBaseSyncPrimitives()}, SingleThreadTaskRunnerThreadMode::SHARED);
- });
-}
-
-// Regression test for https://crbug.com/829786
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
- ContinueOnShutdownDoesNotBlockBlockShutdown) {
- WaitableEvent task_has_started(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_can_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // Post a CONTINUE_ON_SHUTDOWN task that waits on
- // |task_can_continue| to a shared SingleThreadTaskRunner.
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::SHARED)
- ->PostTask(FROM_HERE, base::BindOnce(
- [](WaitableEvent* task_has_started,
- WaitableEvent* task_can_continue) {
- task_has_started->Signal();
- ScopedAllowBaseSyncPrimitivesForTesting
- allow_base_sync_primitives;
- task_can_continue->Wait();
- },
- Unretained(&task_has_started),
- Unretained(&task_can_continue)));
-
- task_has_started.Wait();
-
- // Post a BLOCK_SHUTDOWN task to a shared SingleThreadTaskRunner.
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::SHARED)
- ->PostTask(FROM_HERE, DoNothing());
-
- // Shutdown should not hang even though the first task hasn't finished.
- task_tracker_.Shutdown();
-
- // Let the first task finish.
- task_can_continue.Signal();
-
- // Tear down from the test body to prevent accesses to |task_can_continue|
- // after it goes out of scope.
- TearDownSingleThreadTaskRunnerManager();
-}
-
-namespace {
-
-class TaskSchedulerSingleThreadTaskRunnerManagerCommonTest
- : public TaskSchedulerSingleThreadTaskRunnerManagerTest,
- public ::testing::WithParamInterface<SingleThreadTaskRunnerThreadMode> {
- public:
- TaskSchedulerSingleThreadTaskRunnerManagerCommonTest() = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(
- TaskSchedulerSingleThreadTaskRunnerManagerCommonTest);
-};
-
-} // namespace
-
-TEST_P(TaskSchedulerSingleThreadTaskRunnerManagerCommonTest,
- PrioritySetCorrectly) {
- // Why are events used here instead of the task tracker?
- // Shutting down can cause priorities to get raised. This means we have to use
- // events to determine when a task is run.
- scoped_refptr<SingleThreadTaskRunner> task_runner_background =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits({TaskPriority::BACKGROUND},
- GetParam());
- scoped_refptr<SingleThreadTaskRunner> task_runner_normal =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits({TaskPriority::USER_VISIBLE},
- GetParam());
-
- ThreadPriority thread_priority_background;
- task_runner_background->PostTask(
- FROM_HERE, BindOnce(&CaptureThreadPriority, &thread_priority_background));
- WaitableEvent waitable_event_background(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner_background->PostTask(
- FROM_HERE,
- BindOnce(&WaitableEvent::Signal, Unretained(&waitable_event_background)));
-
- ThreadPriority thread_priority_normal;
- task_runner_normal->PostTask(
- FROM_HERE, BindOnce(&CaptureThreadPriority, &thread_priority_normal));
- WaitableEvent waitable_event_normal(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner_normal->PostTask(
- FROM_HERE,
- BindOnce(&WaitableEvent::Signal, Unretained(&waitable_event_normal)));
-
- waitable_event_background.Wait();
- waitable_event_normal.Wait();
-
- if (Lock::HandlesMultipleThreadPriorities() &&
- PlatformThread::CanIncreaseCurrentThreadPriority()) {
- EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background);
- } else {
- EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background);
- }
- EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_normal);
-}
-
-TEST_P(TaskSchedulerSingleThreadTaskRunnerManagerCommonTest, ThreadNamesSet) {
- constexpr TaskTraits foo_traits = {TaskPriority::BACKGROUND,
- TaskShutdownBehavior::BLOCK_SHUTDOWN};
- scoped_refptr<SingleThreadTaskRunner> foo_task_runner =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(foo_traits, GetParam());
- std::string foo_captured_name;
- foo_task_runner->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadName, &foo_captured_name));
-
- constexpr TaskTraits user_blocking_traits = {
- TaskPriority::USER_BLOCKING, MayBlock(),
- TaskShutdownBehavior::BLOCK_SHUTDOWN};
- scoped_refptr<SingleThreadTaskRunner> user_blocking_task_runner =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(user_blocking_traits,
- GetParam());
-
- std::string user_blocking_captured_name;
- user_blocking_task_runner->PostTask(
- FROM_HERE, BindOnce(&CaptureThreadName, &user_blocking_captured_name));
-
- task_tracker_.Shutdown();
-
- EXPECT_NE(std::string::npos,
- foo_captured_name.find(
- kEnvironmentParams[GetEnvironmentIndexForTraits(foo_traits)]
- .name_suffix));
- EXPECT_NE(
- std::string::npos,
- user_blocking_captured_name.find(
- kEnvironmentParams[GetEnvironmentIndexForTraits(user_blocking_traits)]
- .name_suffix));
-
- if (GetParam() == SingleThreadTaskRunnerThreadMode::DEDICATED) {
- EXPECT_EQ(std::string::npos, foo_captured_name.find("Shared"));
- EXPECT_EQ(std::string::npos, user_blocking_captured_name.find("Shared"));
- } else {
- EXPECT_NE(std::string::npos, foo_captured_name.find("Shared"));
- EXPECT_NE(std::string::npos, user_blocking_captured_name.find("Shared"));
- }
-}
-
-TEST_P(TaskSchedulerSingleThreadTaskRunnerManagerCommonTest,
- PostTaskAfterShutdown) {
- auto task_runner =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits(), GetParam());
- task_tracker_.Shutdown();
- EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
-}
-
-// Verify that a Task runs shortly after its delay expires.
-TEST_P(TaskSchedulerSingleThreadTaskRunnerManagerCommonTest, PostDelayedTask) {
- TimeTicks start_time = TimeTicks::Now();
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- auto task_runner =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits(), GetParam());
-
- // Wait until the task runner is up and running to make sure the test below is
- // solely timing the delayed task, not bringing up a physical thread.
- task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_ran)));
- task_ran.Wait();
- ASSERT_TRUE(!task_ran.IsSignaled());
-
- // Post a task with a short delay.
- EXPECT_TRUE(task_runner->PostDelayedTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_ran)),
- TestTimeouts::tiny_timeout()));
-
- // Wait until the task runs.
- task_ran.Wait();
-
- // Expect the task to run after its delay expires, but no more than 250 ms
- // after that.
- const TimeDelta actual_delay = TimeTicks::Now() - start_time;
- EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout());
- EXPECT_LT(actual_delay,
- TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
-}
-
-// Verify that posting tasks after the single-thread manager is destroyed fails
-// but doesn't crash.
-TEST_P(TaskSchedulerSingleThreadTaskRunnerManagerCommonTest,
- PostTaskAfterDestroy) {
- auto task_runner =
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits(), GetParam());
- EXPECT_TRUE(task_runner->PostTask(FROM_HERE, DoNothing()));
- task_tracker_.Shutdown();
- TearDownSingleThreadTaskRunnerManager();
- EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
-}
-
-INSTANTIATE_TEST_CASE_P(
- AllModes,
- TaskSchedulerSingleThreadTaskRunnerManagerCommonTest,
- ::testing::Values(SingleThreadTaskRunnerThreadMode::SHARED,
- SingleThreadTaskRunnerThreadMode::DEDICATED));
-
-namespace {
-
-class CallJoinFromDifferentThread : public SimpleThread {
- public:
- CallJoinFromDifferentThread(
- SchedulerSingleThreadTaskRunnerManager* manager_to_join)
- : SimpleThread("SchedulerSingleThreadTaskRunnerManagerJoinThread"),
- manager_to_join_(manager_to_join),
- run_started_event_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- ~CallJoinFromDifferentThread() override = default;
-
- void Run() override {
- run_started_event_.Signal();
- manager_to_join_->JoinForTesting();
- }
-
- void WaitForRunToStart() { run_started_event_.Wait(); }
-
- private:
- SchedulerSingleThreadTaskRunnerManager* const manager_to_join_;
- WaitableEvent run_started_event_;
-
- DISALLOW_COPY_AND_ASSIGN(CallJoinFromDifferentThread);
-};
-
-class TaskSchedulerSingleThreadTaskRunnerManagerJoinTest
- : public TaskSchedulerSingleThreadTaskRunnerManagerTest {
- public:
- TaskSchedulerSingleThreadTaskRunnerManagerJoinTest() = default;
- ~TaskSchedulerSingleThreadTaskRunnerManagerJoinTest() override = default;
-
- protected:
- void TearDownSingleThreadTaskRunnerManager() override {
- // The tests themselves are responsible for calling JoinForTesting().
- single_thread_task_runner_manager_.reset();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest);
-};
-
-} // namespace
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, ConcurrentJoin) {
- // Exercises the codepath where the workers are unavailable for unregistration
- // because of a Join call.
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- {
- auto task_runner = single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {WithBaseSyncPrimitives()},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
- EXPECT_TRUE(task_runner->PostTask(
- FROM_HERE,
- BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
- EXPECT_TRUE(task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Wait, Unretained(&task_blocking))));
- }
-
- task_running.Wait();
- CallJoinFromDifferentThread join_from_different_thread(
- single_thread_task_runner_manager_.get());
- join_from_different_thread.Start();
- join_from_different_thread.WaitForRunToStart();
- task_blocking.Signal();
- join_from_different_thread.Join();
-}
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest,
- ConcurrentJoinExtraSkippedTask) {
- // Tests to make sure that tasks are properly cleaned up at Join, allowing
- // SingleThreadTaskRunners to unregister themselves.
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- {
- auto task_runner = single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- {WithBaseSyncPrimitives()},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
- EXPECT_TRUE(task_runner->PostTask(
- FROM_HERE,
- BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
- EXPECT_TRUE(task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Wait, Unretained(&task_blocking))));
- EXPECT_TRUE(task_runner->PostTask(FROM_HERE, DoNothing()));
- }
-
- task_running.Wait();
- CallJoinFromDifferentThread join_from_different_thread(
- single_thread_task_runner_manager_.get());
- join_from_different_thread.Start();
- join_from_different_thread.WaitForRunToStart();
- task_blocking.Signal();
- join_from_different_thread.Join();
-}
-
-#if defined(OS_WIN)
-
-TEST_P(TaskSchedulerSingleThreadTaskRunnerManagerCommonTest,
- COMSTAInitialized) {
- scoped_refptr<SingleThreadTaskRunner> com_task_runner =
- single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN}, GetParam());
-
- com_task_runner->PostTask(FROM_HERE, BindOnce(&win::AssertComApartmentType,
- win::ComApartmentType::STA));
-
- task_tracker_.Shutdown();
-}
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, COMSTASameThreadUsed) {
- scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
- single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::SHARED);
- scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
- single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::SHARED);
-
- PlatformThreadRef thread_ref_1;
- task_runner_1->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadRef, &thread_ref_1));
- PlatformThreadRef thread_ref_2;
- task_runner_2->PostTask(FROM_HERE,
- BindOnce(&CaptureThreadRef, &thread_ref_2));
-
- task_tracker_.Shutdown();
-
- ASSERT_FALSE(thread_ref_1.is_null());
- ASSERT_FALSE(thread_ref_2.is_null());
- EXPECT_EQ(thread_ref_1, thread_ref_2);
-}
-
-namespace {
-
-const wchar_t* const kTestWindowClassName =
- L"TaskSchedulerSingleThreadTaskRunnerManagerTestWinMessageWindow";
-
-class TaskSchedulerSingleThreadTaskRunnerManagerTestWin
- : public TaskSchedulerSingleThreadTaskRunnerManagerTest {
- public:
- TaskSchedulerSingleThreadTaskRunnerManagerTestWin() = default;
-
- void SetUp() override {
- TaskSchedulerSingleThreadTaskRunnerManagerTest::SetUp();
- register_class_succeeded_ = RegisterTestWindowClass();
- ASSERT_TRUE(register_class_succeeded_);
- }
-
- void TearDown() override {
- if (register_class_succeeded_)
- ::UnregisterClass(kTestWindowClassName, CURRENT_MODULE());
-
- TaskSchedulerSingleThreadTaskRunnerManagerTest::TearDown();
- }
-
- HWND CreateTestWindow() {
- return CreateWindow(kTestWindowClassName, kTestWindowClassName, 0, 0, 0, 0,
- 0, HWND_MESSAGE, nullptr, CURRENT_MODULE(), nullptr);
- }
-
- private:
- bool RegisterTestWindowClass() {
- WNDCLASSEX window_class = {};
- window_class.cbSize = sizeof(window_class);
- window_class.lpfnWndProc = &::DefWindowProc;
- window_class.hInstance = CURRENT_MODULE();
- window_class.lpszClassName = kTestWindowClassName;
- return !!::RegisterClassEx(&window_class);
- }
-
- bool register_class_succeeded_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTestWin);
-};
-
-} // namespace
-
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTestWin, PumpsMessages) {
- scoped_refptr<SingleThreadTaskRunner> com_task_runner =
- single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- SingleThreadTaskRunnerThreadMode::DEDICATED);
- HWND hwnd = nullptr;
- // HWNDs process messages on the thread that created them, so we have to
- // create them within the context of the task runner to properly simulate a
- // COM callback.
- com_task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](TaskSchedulerSingleThreadTaskRunnerManagerTestWin* test_harness,
- HWND* hwnd) { *hwnd = test_harness->CreateTestWindow(); },
- Unretained(this), &hwnd));
-
- task_tracker_.FlushForTesting();
-
- ASSERT_NE(hwnd, nullptr);
- // If the message pump isn't running, we will hang here. This simulates how
- // COM would receive a callback with its own message HWND.
- SendMessage(hwnd, WM_USER, 0, 0);
-
- com_task_runner->PostTask(
- FROM_HERE, BindOnce([](HWND hwnd) { ::DestroyWindow(hwnd); }, hwnd));
-
- task_tracker_.Shutdown();
-}
-
-#endif // defined(OS_WIN)
-
-namespace {
-
-class TaskSchedulerSingleThreadTaskRunnerManagerStartTest
- : public TaskSchedulerSingleThreadTaskRunnerManagerTest {
- public:
- TaskSchedulerSingleThreadTaskRunnerManagerStartTest() = default;
-
- private:
- void StartSingleThreadTaskRunnerManagerFromSetUp() override {
- // Start() is called in the test body rather than in SetUp().
- }
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerStartTest);
-};
-
-} // namespace
-
-// Verify that a task posted before Start() doesn't run until Start() is called.
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerStartTest,
- PostTaskBeforeStart) {
- AtomicFlag manager_started;
- WaitableEvent task_finished(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- single_thread_task_runner_manager_
- ->CreateSingleThreadTaskRunnerWithTraits(
- TaskTraits(), SingleThreadTaskRunnerThreadMode::DEDICATED)
- ->PostTask(
- FROM_HERE,
- BindOnce(
- [](WaitableEvent* task_finished, AtomicFlag* manager_started) {
- // The task should not run before Start().
- EXPECT_TRUE(manager_started->IsSet());
- task_finished->Signal();
- },
- Unretained(&task_finished), Unretained(&manager_started)));
-
- // Wait a little bit to make sure that the task doesn't run before start.
- // Note: This test won't catch a case where the task runs between setting
- // |manager_started| and calling Start(). However, we expect the test to be
- // flaky if the tested code allows that to happen.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- manager_started.Set();
- single_thread_task_runner_manager_->Start();
-
- // Wait for the task to complete to keep |manager_started| alive.
- task_finished.Wait();
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
deleted file mode 100644
index 21e77f4..0000000
--- a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
+++ /dev/null
@@ -1,1566 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/scheduler_worker_pool_impl.h"
-
-#include <stddef.h>
-
-#include <memory>
-#include <unordered_set>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/barrier_closure.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_runner.h"
-#include "base/task_scheduler/delayed_task_manager.h"
-#include "base/task_scheduler/scheduler_worker_pool_params.h"
-#include "base/task_scheduler/sequence.h"
-#include "base/task_scheduler/sequence_sort_key.h"
-#include "base/task_scheduler/task_tracker.h"
-#include "base/task_scheduler/test_task_factory.h"
-#include "base/task_scheduler/test_utils.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/scoped_blocking_call.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_checker_impl.h"
-#include "base/threading/thread_local_storage.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include "base/win/com_init_util.h"
-#endif // defined(OS_WIN)
-
-namespace base {
-namespace internal {
-namespace {
-
-constexpr size_t kNumWorkersInWorkerPool = 4;
-constexpr size_t kNumThreadsPostingTasks = 4;
-constexpr size_t kNumTasksPostedPerThread = 150;
-// This can't be lower because Windows' WaitableEvent wakes up too early when a
-// small timeout is used. This results in many spurious wake ups before a worker
-// is allowed to cleanup.
-constexpr TimeDelta kReclaimTimeForCleanupTests =
- TimeDelta::FromMilliseconds(500);
-
-// Waits on |event| in a scope where the blocking observer is null, to avoid
-// affecting the worker capacity.
-void WaitWithoutBlockingObserver(WaitableEvent* event) {
- internal::ScopedClearBlockingObserverForTesting clear_blocking_observer;
- event->Wait();
-}
-
-class TaskSchedulerWorkerPoolImplTestBase {
- protected:
- TaskSchedulerWorkerPoolImplTestBase()
- : service_thread_("TaskSchedulerServiceThread"){};
-
- void CommonSetUp() {
- CreateAndStartWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
- }
-
- void CommonTearDown() {
- service_thread_.Stop();
- task_tracker_.FlushForTesting();
- worker_pool_->WaitForAllWorkersIdleForTesting();
- worker_pool_->JoinForTesting();
- }
-
- void CreateWorkerPool() {
- ASSERT_FALSE(worker_pool_);
- service_thread_.Start();
- delayed_task_manager_.Start(service_thread_.task_runner());
- worker_pool_ = std::make_unique<SchedulerWorkerPoolImpl>(
- "TestWorkerPool", "A", ThreadPriority::NORMAL,
- task_tracker_.GetTrackedRef(), &delayed_task_manager_);
- ASSERT_TRUE(worker_pool_);
- }
-
- virtual void StartWorkerPool(TimeDelta suggested_reclaim_time,
- size_t num_workers) {
- ASSERT_TRUE(worker_pool_);
- worker_pool_->Start(
- SchedulerWorkerPoolParams(num_workers, suggested_reclaim_time),
- service_thread_.task_runner(), nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::NONE);
- }
-
- void CreateAndStartWorkerPool(TimeDelta suggested_reclaim_time,
- size_t num_workers) {
- CreateWorkerPool();
- StartWorkerPool(suggested_reclaim_time, num_workers);
- }
-
- Thread service_thread_;
- TaskTracker task_tracker_ = {"Test"};
-
- std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_;
-
- private:
- DelayedTaskManager delayed_task_manager_;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTestBase);
-};
-
-class TaskSchedulerWorkerPoolImplTest
- : public TaskSchedulerWorkerPoolImplTestBase,
- public testing::Test {
- protected:
- TaskSchedulerWorkerPoolImplTest() = default;
-
- void SetUp() override { TaskSchedulerWorkerPoolImplTestBase::CommonSetUp(); }
-
- void TearDown() override {
- TaskSchedulerWorkerPoolImplTestBase::CommonTearDown();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTest);
-};
-
-class TaskSchedulerWorkerPoolImplTestParam
- : public TaskSchedulerWorkerPoolImplTestBase,
- public testing::TestWithParam<test::ExecutionMode> {
- protected:
- TaskSchedulerWorkerPoolImplTestParam() = default;
-
- void SetUp() override { TaskSchedulerWorkerPoolImplTestBase::CommonSetUp(); }
-
- void TearDown() override {
- TaskSchedulerWorkerPoolImplTestBase::CommonTearDown();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTestParam);
-};
-
-using PostNestedTask = test::TestTaskFactory::PostNestedTask;
-
-class ThreadPostingTasksWaitIdle : public SimpleThread {
- public:
- // Constructs a thread that posts tasks to |worker_pool| through an
- // |execution_mode| task runner. The thread waits until all workers in
- // |worker_pool| are idle before posting a new task.
- ThreadPostingTasksWaitIdle(SchedulerWorkerPoolImpl* worker_pool,
- test::ExecutionMode execution_mode)
- : SimpleThread("ThreadPostingTasksWaitIdle"),
- worker_pool_(worker_pool),
- factory_(CreateTaskRunnerWithExecutionMode(worker_pool, execution_mode),
- execution_mode) {
- DCHECK(worker_pool_);
- }
-
- const test::TestTaskFactory* factory() const { return &factory_; }
-
- private:
- void Run() override {
- EXPECT_FALSE(factory_.task_runner()->RunsTasksInCurrentSequence());
-
- for (size_t i = 0; i < kNumTasksPostedPerThread; ++i) {
- worker_pool_->WaitForAllWorkersIdleForTesting();
- EXPECT_TRUE(factory_.PostTask(PostNestedTask::NO, Closure()));
- }
- }
-
- SchedulerWorkerPoolImpl* const worker_pool_;
- const scoped_refptr<TaskRunner> task_runner_;
- test::TestTaskFactory factory_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasksWaitIdle);
-};
-
-} // namespace
-
-TEST_P(TaskSchedulerWorkerPoolImplTestParam, PostTasksWaitAllWorkersIdle) {
- // Create threads to post tasks. To verify that workers can sleep and be woken
- // up when new tasks are posted, wait for all workers to become idle before
- // posting a new task.
- std::vector<std::unique_ptr<ThreadPostingTasksWaitIdle>>
- threads_posting_tasks;
- for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
- threads_posting_tasks.push_back(
- std::make_unique<ThreadPostingTasksWaitIdle>(worker_pool_.get(),
- GetParam()));
- threads_posting_tasks.back()->Start();
- }
-
- // Wait for all tasks to run.
- for (const auto& thread_posting_tasks : threads_posting_tasks) {
- thread_posting_tasks->Join();
- thread_posting_tasks->factory()->WaitForAllTasksToRun();
- }
-
- // Wait until all workers are idle to be sure that no task accesses its
- // TestTaskFactory after |thread_posting_tasks| is destroyed.
- worker_pool_->WaitForAllWorkersIdleForTesting();
-}
-
-TEST_P(TaskSchedulerWorkerPoolImplTestParam, PostTasksWithOneAvailableWorker) {
- // Post blocking tasks to keep all workers busy except one until |event| is
- // signaled. Use different factories so that tasks are added to different
- // sequences and can run simultaneously when the execution mode is SEQUENCED.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- std::vector<std::unique_ptr<test::TestTaskFactory>> blocked_task_factories;
- for (size_t i = 0; i < (kNumWorkersInWorkerPool - 1); ++i) {
- blocked_task_factories.push_back(std::make_unique<test::TestTaskFactory>(
- CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()),
- GetParam()));
- EXPECT_TRUE(blocked_task_factories.back()->PostTask(
- PostNestedTask::NO,
- BindOnce(&WaitWithoutBlockingObserver, Unretained(&event))));
- blocked_task_factories.back()->WaitForAllTasksToRun();
- }
-
- // Post |kNumTasksPostedPerThread| tasks that should all run despite the fact
- // that only one worker in |worker_pool_| isn't busy.
- test::TestTaskFactory short_task_factory(
- CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()),
- GetParam());
- for (size_t i = 0; i < kNumTasksPostedPerThread; ++i)
- EXPECT_TRUE(short_task_factory.PostTask(PostNestedTask::NO, Closure()));
- short_task_factory.WaitForAllTasksToRun();
-
- // Release tasks waiting on |event|.
- event.Signal();
-
- // Wait until all workers are idle to be sure that no task accesses
- // its TestTaskFactory after it is destroyed.
- worker_pool_->WaitForAllWorkersIdleForTesting();
-}
-
-TEST_P(TaskSchedulerWorkerPoolImplTestParam, Saturate) {
- // Verify that it is possible to have |kNumWorkersInWorkerPool|
- // tasks/sequences running simultaneously. Use different factories so that the
- // blocking tasks are added to different sequences and can run simultaneously
- // when the execution mode is SEQUENCED.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- std::vector<std::unique_ptr<test::TestTaskFactory>> factories;
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- factories.push_back(std::make_unique<test::TestTaskFactory>(
- CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()),
- GetParam()));
- EXPECT_TRUE(factories.back()->PostTask(
- PostNestedTask::NO,
- BindOnce(&WaitWithoutBlockingObserver, Unretained(&event))));
- factories.back()->WaitForAllTasksToRun();
- }
-
- // Release tasks waiting on |event|.
- event.Signal();
-
- // Wait until all workers are idle to be sure that no task accesses
- // its TestTaskFactory after it is destroyed.
- worker_pool_->WaitForAllWorkersIdleForTesting();
-}
-
-#if defined(OS_WIN)
-TEST_P(TaskSchedulerWorkerPoolImplTestParam, NoEnvironment) {
- // Verify that COM is not initialized in a SchedulerWorkerPoolImpl initialized
- // with SchedulerWorkerPoolImpl::WorkerEnvironment::NONE.
- scoped_refptr<TaskRunner> task_runner =
- CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam());
-
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner->PostTask(
- FROM_HERE, BindOnce(
- [](WaitableEvent* task_running) {
- win::AssertComApartmentType(win::ComApartmentType::NONE);
- task_running->Signal();
- },
- &task_running));
-
- task_running.Wait();
-
- worker_pool_->WaitForAllWorkersIdleForTesting();
-}
-#endif // defined(OS_WIN)
-
-INSTANTIATE_TEST_CASE_P(Parallel,
- TaskSchedulerWorkerPoolImplTestParam,
- ::testing::Values(test::ExecutionMode::PARALLEL));
-INSTANTIATE_TEST_CASE_P(Sequenced,
- TaskSchedulerWorkerPoolImplTestParam,
- ::testing::Values(test::ExecutionMode::SEQUENCED));
-
-#if defined(OS_WIN)
-
-namespace {
-
-class TaskSchedulerWorkerPoolImplTestCOMMTAParam
- : public TaskSchedulerWorkerPoolImplTestBase,
- public testing::TestWithParam<test::ExecutionMode> {
- protected:
- TaskSchedulerWorkerPoolImplTestCOMMTAParam() = default;
-
- void SetUp() override { TaskSchedulerWorkerPoolImplTestBase::CommonSetUp(); }
-
- void TearDown() override {
- TaskSchedulerWorkerPoolImplTestBase::CommonTearDown();
- }
-
- private:
- void StartWorkerPool(TimeDelta suggested_reclaim_time,
- size_t num_workers) override {
- ASSERT_TRUE(worker_pool_);
- worker_pool_->Start(
- SchedulerWorkerPoolParams(num_workers, suggested_reclaim_time),
- service_thread_.task_runner(), nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::COM_MTA);
- }
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTestCOMMTAParam);
-};
-
-} // namespace
-
-TEST_P(TaskSchedulerWorkerPoolImplTestCOMMTAParam, COMMTAInitialized) {
- // Verify that SchedulerWorkerPoolImpl workers have a COM MTA available.
- scoped_refptr<TaskRunner> task_runner =
- CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam());
-
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner->PostTask(
- FROM_HERE, BindOnce(
- [](WaitableEvent* task_running) {
- win::AssertComApartmentType(win::ComApartmentType::MTA);
- task_running->Signal();
- },
- &task_running));
-
- task_running.Wait();
-
- worker_pool_->WaitForAllWorkersIdleForTesting();
-}
-
-INSTANTIATE_TEST_CASE_P(Parallel,
- TaskSchedulerWorkerPoolImplTestCOMMTAParam,
- ::testing::Values(test::ExecutionMode::PARALLEL));
-INSTANTIATE_TEST_CASE_P(Sequenced,
- TaskSchedulerWorkerPoolImplTestCOMMTAParam,
- ::testing::Values(test::ExecutionMode::SEQUENCED));
-
-#endif // defined(OS_WIN)
-
-namespace {
-
-class TaskSchedulerWorkerPoolImplPostTaskBeforeStartTest
- : public TaskSchedulerWorkerPoolImplTest {
- public:
- void SetUp() override {
- CreateWorkerPool();
- // Let the test start the worker pool.
- }
-};
-
-void TaskPostedBeforeStart(PlatformThreadRef* platform_thread_ref,
- WaitableEvent* task_running,
- WaitableEvent* barrier) {
- *platform_thread_ref = PlatformThread::CurrentRef();
- task_running->Signal();
- WaitWithoutBlockingObserver(barrier);
-}
-
-} // namespace
-
-// Verify that 2 tasks posted before Start() to a SchedulerWorkerPoolImpl with
-// more than 2 workers run on different workers when Start() is called.
-TEST_F(TaskSchedulerWorkerPoolImplPostTaskBeforeStartTest,
- PostTasksBeforeStart) {
- PlatformThreadRef task_1_thread_ref;
- PlatformThreadRef task_2_thread_ref;
- WaitableEvent task_1_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_2_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // This event is used to prevent a task from completing before the other task
- // starts running. If that happened, both tasks could run on the same worker
- // and this test couldn't verify that the correct number of workers were woken
- // up.
- WaitableEvent barrier(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()})
- ->PostTask(
- FROM_HERE,
- BindOnce(&TaskPostedBeforeStart, Unretained(&task_1_thread_ref),
- Unretained(&task_1_running), Unretained(&barrier)));
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()})
- ->PostTask(
- FROM_HERE,
- BindOnce(&TaskPostedBeforeStart, Unretained(&task_2_thread_ref),
- Unretained(&task_2_running), Unretained(&barrier)));
-
- // Workers should not be created and tasks should not run before the pool is
- // started.
- EXPECT_EQ(0U, worker_pool_->NumberOfWorkersForTesting());
- EXPECT_FALSE(task_1_running.IsSignaled());
- EXPECT_FALSE(task_2_running.IsSignaled());
-
- StartWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
-
- // Tasks should run shortly after the pool is started.
- task_1_running.Wait();
- task_2_running.Wait();
-
- // Tasks should run on different threads.
- EXPECT_NE(task_1_thread_ref, task_2_thread_ref);
-
- barrier.Signal();
- task_tracker_.FlushForTesting();
-}
-
-// Verify that posting many tasks before Start will cause the number of workers
-// to grow to |worker_capacity_| during Start.
-TEST_F(TaskSchedulerWorkerPoolImplPostTaskBeforeStartTest, PostManyTasks) {
- scoped_refptr<TaskRunner> task_runner =
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
- constexpr size_t kNumTasksPosted = 2 * kNumWorkersInWorkerPool;
- for (size_t i = 0; i < kNumTasksPosted; ++i)
- task_runner->PostTask(FROM_HERE, DoNothing());
-
- EXPECT_EQ(0U, worker_pool_->NumberOfWorkersForTesting());
-
- StartWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
- ASSERT_GT(kNumTasksPosted, worker_pool_->GetWorkerCapacityForTesting());
- EXPECT_EQ(kNumWorkersInWorkerPool,
- worker_pool_->GetWorkerCapacityForTesting());
-
- EXPECT_EQ(worker_pool_->NumberOfWorkersForTesting(),
- worker_pool_->GetWorkerCapacityForTesting());
-}
-
-namespace {
-
-constexpr size_t kMagicTlsValue = 42;
-
-class TaskSchedulerWorkerPoolCheckTlsReuse
- : public TaskSchedulerWorkerPoolImplTest {
- public:
- void SetTlsValueAndWait() {
- slot_.Set(reinterpret_cast<void*>(kMagicTlsValue));
- WaitWithoutBlockingObserver(&waiter_);
- }
-
- void CountZeroTlsValuesAndWait(WaitableEvent* count_waiter) {
- if (!slot_.Get())
- subtle::NoBarrier_AtomicIncrement(&zero_tls_values_, 1);
-
- count_waiter->Signal();
- WaitWithoutBlockingObserver(&waiter_);
- }
-
- protected:
- TaskSchedulerWorkerPoolCheckTlsReuse() :
- waiter_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- void SetUp() override {
- CreateAndStartWorkerPool(kReclaimTimeForCleanupTests,
- kNumWorkersInWorkerPool);
- }
-
- subtle::Atomic32 zero_tls_values_ = 0;
-
- WaitableEvent waiter_;
-
- private:
- ThreadLocalStorage::Slot slot_;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolCheckTlsReuse);
-};
-
-} // namespace
-
-// Checks that at least one worker has been cleaned up by checking the TLS.
-TEST_F(TaskSchedulerWorkerPoolCheckTlsReuse, CheckCleanupWorkers) {
- // Saturate the workers and mark each worker's thread with a magic TLS value.
- std::vector<std::unique_ptr<test::TestTaskFactory>> factories;
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- factories.push_back(std::make_unique<test::TestTaskFactory>(
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()}),
- test::ExecutionMode::PARALLEL));
- ASSERT_TRUE(factories.back()->PostTask(
- PostNestedTask::NO,
- Bind(&TaskSchedulerWorkerPoolCheckTlsReuse::SetTlsValueAndWait,
- Unretained(this))));
- factories.back()->WaitForAllTasksToRun();
- }
-
- // Release tasks waiting on |waiter_|.
- waiter_.Signal();
- worker_pool_->WaitForAllWorkersIdleForTesting();
-
- // All workers should be done running by now, so reset for the next phase.
- waiter_.Reset();
-
- // Wait for the worker pool to clean up at least one worker.
- worker_pool_->WaitForWorkersCleanedUpForTesting(1U);
-
- // Saturate and count the worker threads that do not have the magic TLS value.
- // If the value is not there, that means we're at a new worker.
- std::vector<std::unique_ptr<WaitableEvent>> count_waiters;
- for (auto& factory : factories) {
- count_waiters.push_back(WrapUnique(new WaitableEvent(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED)));
- ASSERT_TRUE(factory->PostTask(
- PostNestedTask::NO,
- Bind(&TaskSchedulerWorkerPoolCheckTlsReuse::CountZeroTlsValuesAndWait,
- Unretained(this),
- count_waiters.back().get())));
- factory->WaitForAllTasksToRun();
- }
-
- // Wait for all counters to complete.
- for (auto& count_waiter : count_waiters)
- count_waiter->Wait();
-
- EXPECT_GT(subtle::NoBarrier_Load(&zero_tls_values_), 0);
-
- // Release tasks waiting on |waiter_|.
- waiter_.Signal();
-}
-
-namespace {
-
-class TaskSchedulerWorkerPoolHistogramTest
- : public TaskSchedulerWorkerPoolImplTest {
- public:
- TaskSchedulerWorkerPoolHistogramTest() = default;
-
- protected:
- // Override SetUp() to allow every test case to initialize a worker pool with
- // its own arguments.
- void SetUp() override {}
-
- // Floods |worker_pool_| with a single task each that blocks until
- // |continue_event| is signaled. Every worker in the pool is blocked on
- // |continue_event| when this method returns. Note: this helper can easily be
- // generalized to be useful in other tests, but it's here for now because it's
- // only used in a TaskSchedulerWorkerPoolHistogramTest at the moment.
- void FloodPool(WaitableEvent* continue_event) {
- ASSERT_FALSE(continue_event->IsSignaled());
-
- auto task_runner =
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
-
- const auto pool_capacity = worker_pool_->GetWorkerCapacityForTesting();
-
- WaitableEvent workers_flooded(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure all_workers_running_barrier = BarrierClosure(
- pool_capacity,
- BindOnce(&WaitableEvent::Signal, Unretained(&workers_flooded)));
- for (size_t i = 0; i < pool_capacity; ++i) {
- task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](OnceClosure on_running, WaitableEvent* continue_event) {
- std::move(on_running).Run();
- WaitWithoutBlockingObserver(continue_event);
- },
- all_workers_running_barrier, continue_event));
- }
- workers_flooded.Wait();
- }
-
- private:
- std::unique_ptr<StatisticsRecorder> statistics_recorder_ =
- StatisticsRecorder::CreateTemporaryForTesting();
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolHistogramTest);
-};
-
-} // namespace
-
-TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaits) {
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- CreateAndStartWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
- auto task_runner = worker_pool_->CreateSequencedTaskRunnerWithTraits(
- {WithBaseSyncPrimitives()});
-
- // Post a task.
- task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitWithoutBlockingObserver, Unretained(&event)));
-
- // Post 2 more tasks while the first task hasn't completed its execution. It
- // is guaranteed that these tasks will run immediately after the first task,
- // without allowing the worker to sleep.
- task_runner->PostTask(FROM_HERE, DoNothing());
- task_runner->PostTask(FROM_HERE, DoNothing());
-
- // Allow tasks to run and wait until the SchedulerWorker is idle.
- event.Signal();
- worker_pool_->WaitForAllWorkersIdleForTesting();
-
- // Wake up the SchedulerWorker that just became idle by posting a task and
- // wait until it becomes idle again. The SchedulerWorker should record the
- // TaskScheduler.NumTasksBetweenWaits.* histogram on wake up.
- task_runner->PostTask(FROM_HERE, DoNothing());
- worker_pool_->WaitForAllWorkersIdleForTesting();
-
- // Verify that counts were recorded to the histogram as expected.
- const auto* histogram = worker_pool_->num_tasks_between_waits_histogram();
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
- EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
-}
-
-// Verifies that NumTasksBetweenWaits histogram is logged as expected across
-// idle and cleanup periods.
-TEST_F(TaskSchedulerWorkerPoolHistogramTest,
- NumTasksBetweenWaitsWithIdlePeriodAndCleanup) {
- WaitableEvent tasks_can_exit_event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- CreateAndStartWorkerPool(kReclaimTimeForCleanupTests,
- kNumWorkersInWorkerPool);
-
- WaitableEvent workers_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- FloodPool(&workers_continue);
-
- const auto* histogram = worker_pool_->num_tasks_between_waits_histogram();
-
- // NumTasksBetweenWaits shouldn't be logged until idle.
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(1));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
-
- // Make all workers go idle.
- workers_continue.Signal();
- worker_pool_->WaitForAllWorkersIdleForTesting();
-
- // All workers should have reported a single hit in the "1" bucket per the the
- // histogram being reported when going idle and each worker having processed
- // precisely 1 task per the controlled flooding logic above.
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
- EXPECT_EQ(static_cast<int>(kNumWorkersInWorkerPool),
- histogram->SnapshotSamples()->GetCount(1));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
-
- worker_pool_->WaitForWorkersCleanedUpForTesting(kNumWorkersInWorkerPool - 1);
-
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
- EXPECT_EQ(static_cast<int>(kNumWorkersInWorkerPool),
- histogram->SnapshotSamples()->GetCount(1));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
-
- // Flooding the pool once again (without letting any workers go idle)
- // shouldn't affect the counts either.
-
- workers_continue.Reset();
- FloodPool(&workers_continue);
-
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
- EXPECT_EQ(static_cast<int>(kNumWorkersInWorkerPool),
- histogram->SnapshotSamples()->GetCount(1));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
-
- workers_continue.Signal();
- worker_pool_->WaitForAllWorkersIdleForTesting();
-}
-
-TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeCleanup) {
- CreateWorkerPool();
- auto histogrammed_thread_task_runner =
- worker_pool_->CreateSequencedTaskRunnerWithTraits(
- {WithBaseSyncPrimitives()});
-
- // Post 3 tasks and hold the thread for idle thread stack ordering.
- // This test assumes |histogrammed_thread_task_runner| gets assigned the same
- // thread for each of its tasks.
- PlatformThreadRef thread_ref;
- histogrammed_thread_task_runner->PostTask(
- FROM_HERE, BindOnce(
- [](PlatformThreadRef* thread_ref) {
- ASSERT_TRUE(thread_ref);
- *thread_ref = PlatformThread::CurrentRef();
- },
- Unretained(&thread_ref)));
- histogrammed_thread_task_runner->PostTask(
- FROM_HERE, BindOnce(
- [](PlatformThreadRef* thread_ref) {
- ASSERT_FALSE(thread_ref->is_null());
- EXPECT_EQ(*thread_ref, PlatformThread::CurrentRef());
- },
- Unretained(&thread_ref)));
-
- WaitableEvent cleanup_thread_running(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent cleanup_thread_continue(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- histogrammed_thread_task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](PlatformThreadRef* thread_ref,
- WaitableEvent* cleanup_thread_running,
- WaitableEvent* cleanup_thread_continue) {
- ASSERT_FALSE(thread_ref->is_null());
- EXPECT_EQ(*thread_ref, PlatformThread::CurrentRef());
- cleanup_thread_running->Signal();
- WaitWithoutBlockingObserver(cleanup_thread_continue);
- },
- Unretained(&thread_ref), Unretained(&cleanup_thread_running),
- Unretained(&cleanup_thread_continue)));
-
- // Start the worker pool with 2 workers, to avoid depending on the scheduler's
- // logic to always keep one extra idle worker.
- //
- // The pool is started after the 3 initial tasks have been posted to ensure
- // that they are scheduled on the same worker. If the tasks could run as they
- // are posted, there would be a chance that:
- // 1. Worker #1: Runs a tasks and empties the sequence, without adding
- // itself to the idle stack yet.
- // 2. Posting thread: Posts another task to the now empty sequence. Wakes
- // up a new worker, since worker #1 isn't on the idle
- // stack yet.
- // 3: Worker #2: Runs the tasks, violating the expectation that the 3
- // initial tasks run on the same worker.
- constexpr size_t kTwoWorkers = 2;
- StartWorkerPool(kReclaimTimeForCleanupTests, kTwoWorkers);
-
- // Wait until the 3rd task is scheduled.
- cleanup_thread_running.Wait();
-
- // To allow the SchedulerWorker associated with
- // |histogrammed_thread_task_runner| to cleanup, make sure it isn't on top of
- // the idle stack by waking up another SchedulerWorker via
- // |task_runner_for_top_idle|. |histogrammed_thread_task_runner| should
- // release and go idle first and then |task_runner_for_top_idle| should
- // release and go idle. This allows the SchedulerWorker associated with
- // |histogrammed_thread_task_runner| to cleanup.
- WaitableEvent top_idle_thread_running(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent top_idle_thread_continue(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- auto task_runner_for_top_idle =
- worker_pool_->CreateSequencedTaskRunnerWithTraits(
- {WithBaseSyncPrimitives()});
- task_runner_for_top_idle->PostTask(
- FROM_HERE, BindOnce(
- [](PlatformThreadRef thread_ref,
- WaitableEvent* top_idle_thread_running,
- WaitableEvent* top_idle_thread_continue) {
- ASSERT_FALSE(thread_ref.is_null());
- EXPECT_NE(thread_ref, PlatformThread::CurrentRef())
- << "Worker reused. Worker will not cleanup and the "
- "histogram value will be wrong.";
- top_idle_thread_running->Signal();
- WaitWithoutBlockingObserver(top_idle_thread_continue);
- },
- thread_ref, Unretained(&top_idle_thread_running),
- Unretained(&top_idle_thread_continue)));
- top_idle_thread_running.Wait();
- EXPECT_EQ(0U, worker_pool_->NumberOfIdleWorkersForTesting());
- cleanup_thread_continue.Signal();
- // Wait for the cleanup thread to also become idle.
- worker_pool_->WaitForWorkersIdleForTesting(1U);
- top_idle_thread_continue.Signal();
- // Allow the thread processing the |histogrammed_thread_task_runner| work to
- // cleanup.
- worker_pool_->WaitForWorkersCleanedUpForTesting(1U);
-
- // Verify that counts were recorded to the histogram as expected.
- const auto* histogram = worker_pool_->num_tasks_before_detach_histogram();
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(1));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(2));
- EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(4));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(5));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(6));
- EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
-}
-
-TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitOne) {
- TaskTracker task_tracker("Test");
- DelayedTaskManager delayed_task_manager;
- scoped_refptr<TaskRunner> service_thread_task_runner =
- MakeRefCounted<TestSimpleTaskRunner>();
- delayed_task_manager.Start(service_thread_task_runner);
- auto worker_pool = std::make_unique<SchedulerWorkerPoolImpl>(
- "OnePolicyWorkerPool", "A", ThreadPriority::NORMAL,
- task_tracker.GetTrackedRef(), &delayed_task_manager);
- worker_pool->Start(SchedulerWorkerPoolParams(8U, TimeDelta::Max()),
- service_thread_task_runner, nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::NONE);
- ASSERT_TRUE(worker_pool);
- EXPECT_EQ(1U, worker_pool->NumberOfWorkersForTesting());
- worker_pool->JoinForTesting();
-}
-
-// Verify the SchedulerWorkerPoolImpl keeps at least one idle standby thread,
-// capacity permitting.
-TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, VerifyStandbyThread) {
- constexpr size_t kWorkerCapacity = 3;
-
- TaskTracker task_tracker("Test");
- DelayedTaskManager delayed_task_manager;
- scoped_refptr<TaskRunner> service_thread_task_runner =
- MakeRefCounted<TestSimpleTaskRunner>();
- delayed_task_manager.Start(service_thread_task_runner);
- auto worker_pool = std::make_unique<SchedulerWorkerPoolImpl>(
- "StandbyThreadWorkerPool", "A", ThreadPriority::NORMAL,
- task_tracker.GetTrackedRef(), &delayed_task_manager);
- worker_pool->Start(
- SchedulerWorkerPoolParams(kWorkerCapacity, kReclaimTimeForCleanupTests),
- service_thread_task_runner, nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::NONE);
- ASSERT_TRUE(worker_pool);
- EXPECT_EQ(1U, worker_pool->NumberOfWorkersForTesting());
-
- auto task_runner =
- worker_pool->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
-
- WaitableEvent thread_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent thread_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- RepeatingClosure closure = BindRepeating(
- [](WaitableEvent* thread_running, WaitableEvent* thread_continue) {
- thread_running->Signal();
- WaitWithoutBlockingObserver(thread_continue);
- },
- Unretained(&thread_running), Unretained(&thread_continue));
-
- // There should be one idle thread until we reach worker capacity
- for (size_t i = 0; i < kWorkerCapacity; ++i) {
- EXPECT_EQ(i + 1, worker_pool->NumberOfWorkersForTesting());
- task_runner->PostTask(FROM_HERE, closure);
- thread_running.Wait();
- }
-
- // There should not be an extra idle thread if it means going above capacity
- EXPECT_EQ(kWorkerCapacity, worker_pool->NumberOfWorkersForTesting());
-
- thread_continue.Signal();
- // Wait long enough for all but one worker to clean up.
- worker_pool->WaitForWorkersCleanedUpForTesting(kWorkerCapacity - 1);
- EXPECT_EQ(1U, worker_pool->NumberOfWorkersForTesting());
- // Give extra time for a worker to cleanup : none should as the pool is
- // expected to keep a worker ready regardless of how long it was idle for.
- PlatformThread::Sleep(kReclaimTimeForCleanupTests);
- EXPECT_EQ(1U, worker_pool->NumberOfWorkersForTesting());
-
- worker_pool->JoinForTesting();
-}
-
-namespace {
-
-enum class OptionalBlockingType {
- NO_BLOCK,
- MAY_BLOCK,
- WILL_BLOCK,
-};
-
-struct NestedBlockingType {
- NestedBlockingType(BlockingType first_in,
- OptionalBlockingType second_in,
- BlockingType behaves_as_in)
- : first(first_in), second(second_in), behaves_as(behaves_as_in) {}
-
- BlockingType first;
- OptionalBlockingType second;
- BlockingType behaves_as;
-};
-
-class NestedScopedBlockingCall {
- public:
- NestedScopedBlockingCall(const NestedBlockingType& nested_blocking_type)
- : first_scoped_blocking_call_(nested_blocking_type.first),
- second_scoped_blocking_call_(
- nested_blocking_type.second == OptionalBlockingType::WILL_BLOCK
- ? std::make_unique<ScopedBlockingCall>(BlockingType::WILL_BLOCK)
- : (nested_blocking_type.second ==
- OptionalBlockingType::MAY_BLOCK
- ? std::make_unique<ScopedBlockingCall>(
- BlockingType::MAY_BLOCK)
- : nullptr)) {}
-
- private:
- ScopedBlockingCall first_scoped_blocking_call_;
- std::unique_ptr<ScopedBlockingCall> second_scoped_blocking_call_;
-
- DISALLOW_COPY_AND_ASSIGN(NestedScopedBlockingCall);
-};
-
-} // namespace
-
-class TaskSchedulerWorkerPoolBlockingTest
- : public TaskSchedulerWorkerPoolImplTestBase,
- public testing::TestWithParam<NestedBlockingType> {
- public:
- TaskSchedulerWorkerPoolBlockingTest()
- : blocking_thread_running_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- blocking_thread_continue_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- static std::string ParamInfoToString(
- ::testing::TestParamInfo<NestedBlockingType> param_info) {
- std::string str = param_info.param.first == BlockingType::MAY_BLOCK
- ? "MAY_BLOCK"
- : "WILL_BLOCK";
- if (param_info.param.second == OptionalBlockingType::MAY_BLOCK)
- str += "_MAY_BLOCK";
- else if (param_info.param.second == OptionalBlockingType::WILL_BLOCK)
- str += "_WILL_BLOCK";
- return str;
- }
-
- void SetUp() override {
- TaskSchedulerWorkerPoolImplTestBase::CommonSetUp();
- task_runner_ =
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
- }
-
- void TearDown() override {
- TaskSchedulerWorkerPoolImplTestBase::CommonTearDown();
- }
-
- protected:
- // Saturates the worker pool with a task that first blocks, waits to be
- // unblocked, then exits.
- void SaturateWithBlockingTasks(
- const NestedBlockingType& nested_blocking_type) {
- RepeatingClosure blocking_thread_running_closure =
- BarrierClosure(kNumWorkersInWorkerPool,
- BindOnce(&WaitableEvent::Signal,
- Unretained(&blocking_thread_running_)));
-
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- task_runner_->PostTask(
- FROM_HERE,
- BindOnce(
- [](Closure* blocking_thread_running_closure,
- WaitableEvent* blocking_thread_continue_,
- const NestedBlockingType& nested_blocking_type) {
- NestedScopedBlockingCall nested_scoped_blocking_call(
- nested_blocking_type);
- blocking_thread_running_closure->Run();
- WaitWithoutBlockingObserver(blocking_thread_continue_);
- },
- Unretained(&blocking_thread_running_closure),
- Unretained(&blocking_thread_continue_), nested_blocking_type));
- }
- blocking_thread_running_.Wait();
- }
-
- // Returns how long we can expect a change to |worker_capacity_| to occur
- // after a task has become blocked.
- TimeDelta GetWorkerCapacityChangeSleepTime() {
- return std::max(SchedulerWorkerPoolImpl::kBlockedWorkersPollPeriod,
- worker_pool_->MayBlockThreshold()) +
- TestTimeouts::tiny_timeout();
- }
-
- // Waits indefinitely, until |worker_pool_|'s worker capacity increases to
- // |expected_worker_capacity|.
- void ExpectWorkerCapacityIncreasesTo(size_t expected_worker_capacity) {
- size_t capacity = worker_pool_->GetWorkerCapacityForTesting();
- while (capacity != expected_worker_capacity) {
- PlatformThread::Sleep(GetWorkerCapacityChangeSleepTime());
- size_t new_capacity = worker_pool_->GetWorkerCapacityForTesting();
- ASSERT_GE(new_capacity, capacity);
- capacity = new_capacity;
- }
- }
-
- // Unblocks tasks posted by SaturateWithBlockingTasks().
- void UnblockTasks() { blocking_thread_continue_.Signal(); }
-
- scoped_refptr<TaskRunner> task_runner_;
-
- private:
- WaitableEvent blocking_thread_running_;
- WaitableEvent blocking_thread_continue_;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolBlockingTest);
-};
-
-// Verify that BlockingScopeEntered() causes worker capacity to increase and
-// creates a worker if needed. Also verify that BlockingScopeExited() decreases
-// worker capacity after an increase.
-TEST_P(TaskSchedulerWorkerPoolBlockingTest, ThreadBlockedUnblocked) {
- ASSERT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-
- SaturateWithBlockingTasks(GetParam());
- if (GetParam().behaves_as == BlockingType::MAY_BLOCK)
- ExpectWorkerCapacityIncreasesTo(2 * kNumWorkersInWorkerPool);
- // A range of possible number of workers is accepted because of
- // crbug.com/757897.
- EXPECT_GE(worker_pool_->NumberOfWorkersForTesting(),
- kNumWorkersInWorkerPool + 1);
- EXPECT_LE(worker_pool_->NumberOfWorkersForTesting(),
- 2 * kNumWorkersInWorkerPool);
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- 2 * kNumWorkersInWorkerPool);
-
- UnblockTasks();
- task_tracker_.FlushForTesting();
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-}
-
-// Verify that tasks posted in a saturated pool before a ScopedBlockingCall will
-// execute after ScopedBlockingCall is instantiated.
-TEST_P(TaskSchedulerWorkerPoolBlockingTest, PostBeforeBlocking) {
- WaitableEvent thread_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent thread_can_block(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent thread_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- task_runner_->PostTask(
- FROM_HERE,
- BindOnce(
- [](const NestedBlockingType& nested_blocking_type,
- WaitableEvent* thread_running, WaitableEvent* thread_can_block,
- WaitableEvent* thread_continue) {
- thread_running->Signal();
- WaitWithoutBlockingObserver(thread_can_block);
-
- NestedScopedBlockingCall nested_scoped_blocking_call(
- nested_blocking_type);
- WaitWithoutBlockingObserver(thread_continue);
- },
- GetParam(), Unretained(&thread_running),
- Unretained(&thread_can_block), Unretained(&thread_continue)));
- thread_running.Wait();
- }
-
- // All workers should be occupied and the pool should be saturated. Workers
- // have not entered ScopedBlockingCall yet.
- EXPECT_EQ(worker_pool_->NumberOfWorkersForTesting(), kNumWorkersInWorkerPool);
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-
- WaitableEvent extra_thread_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent extra_threads_continue(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure extra_threads_running_barrier = BarrierClosure(
- kNumWorkersInWorkerPool,
- BindOnce(&WaitableEvent::Signal, Unretained(&extra_thread_running)));
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- task_runner_->PostTask(FROM_HERE,
- BindOnce(
- [](Closure* extra_threads_running_barrier,
- WaitableEvent* extra_threads_continue) {
- extra_threads_running_barrier->Run();
- WaitWithoutBlockingObserver(
- extra_threads_continue);
- },
- Unretained(&extra_threads_running_barrier),
- Unretained(&extra_threads_continue)));
- }
-
- // Allow tasks to enter ScopedBlockingCall. Workers should be created for the
- // tasks we just posted.
- thread_can_block.Signal();
- if (GetParam().behaves_as == BlockingType::MAY_BLOCK)
- ExpectWorkerCapacityIncreasesTo(2 * kNumWorkersInWorkerPool);
-
- // Should not block forever.
- extra_thread_running.Wait();
- EXPECT_EQ(worker_pool_->NumberOfWorkersForTesting(),
- 2 * kNumWorkersInWorkerPool);
- extra_threads_continue.Signal();
-
- thread_continue.Signal();
- task_tracker_.FlushForTesting();
-}
-// Verify that workers become idle when the pool is over-capacity and that
-// those workers do no work.
-TEST_P(TaskSchedulerWorkerPoolBlockingTest, WorkersIdleWhenOverCapacity) {
- ASSERT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-
- SaturateWithBlockingTasks(GetParam());
- if (GetParam().behaves_as == BlockingType::MAY_BLOCK)
- ExpectWorkerCapacityIncreasesTo(2 * kNumWorkersInWorkerPool);
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- 2 * kNumWorkersInWorkerPool);
- // A range of possible number of workers is accepted because of
- // crbug.com/757897.
- EXPECT_GE(worker_pool_->NumberOfWorkersForTesting(),
- kNumWorkersInWorkerPool + 1);
- EXPECT_LE(worker_pool_->NumberOfWorkersForTesting(),
- 2 * kNumWorkersInWorkerPool);
-
- WaitableEvent thread_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent thread_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- RepeatingClosure thread_running_barrier = BarrierClosure(
- kNumWorkersInWorkerPool,
- BindOnce(&WaitableEvent::Signal, Unretained(&thread_running)));
- // Posting these tasks should cause new workers to be created.
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- auto callback = BindOnce(
- [](Closure* thread_running_barrier, WaitableEvent* thread_continue) {
- thread_running_barrier->Run();
- WaitWithoutBlockingObserver(thread_continue);
- },
- Unretained(&thread_running_barrier), Unretained(&thread_continue));
- task_runner_->PostTask(FROM_HERE, std::move(callback));
- }
- thread_running.Wait();
-
- ASSERT_EQ(worker_pool_->NumberOfIdleWorkersForTesting(), 0U);
- EXPECT_EQ(worker_pool_->NumberOfWorkersForTesting(),
- 2 * kNumWorkersInWorkerPool);
-
- AtomicFlag is_exiting;
- // These tasks should not get executed until after other tasks become
- // unblocked.
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- task_runner_->PostTask(FROM_HERE, BindOnce(
- [](AtomicFlag* is_exiting) {
- EXPECT_TRUE(is_exiting->IsSet());
- },
- Unretained(&is_exiting)));
- }
-
- // The original |kNumWorkersInWorkerPool| will finish their tasks after being
- // unblocked. There will be work in the work queue, but the pool should now
- // be over-capacity and workers will become idle.
- UnblockTasks();
- worker_pool_->WaitForWorkersIdleForTesting(kNumWorkersInWorkerPool);
- EXPECT_EQ(worker_pool_->NumberOfIdleWorkersForTesting(),
- kNumWorkersInWorkerPool);
-
- // Posting more tasks should not cause workers idle from the pool being over
- // capacity to begin doing work.
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- task_runner_->PostTask(FROM_HERE, BindOnce(
- [](AtomicFlag* is_exiting) {
- EXPECT_TRUE(is_exiting->IsSet());
- },
- Unretained(&is_exiting)));
- }
-
- // Give time for those idle workers to possibly do work (which should not
- // happen).
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-
- is_exiting.Set();
- // Unblocks the new workers.
- thread_continue.Signal();
- task_tracker_.FlushForTesting();
-}
-
-INSTANTIATE_TEST_CASE_P(
- ,
- TaskSchedulerWorkerPoolBlockingTest,
- ::testing::Values(NestedBlockingType(BlockingType::MAY_BLOCK,
- OptionalBlockingType::NO_BLOCK,
- BlockingType::MAY_BLOCK),
- NestedBlockingType(BlockingType::WILL_BLOCK,
- OptionalBlockingType::NO_BLOCK,
- BlockingType::WILL_BLOCK),
- NestedBlockingType(BlockingType::MAY_BLOCK,
- OptionalBlockingType::WILL_BLOCK,
- BlockingType::WILL_BLOCK),
- NestedBlockingType(BlockingType::WILL_BLOCK,
- OptionalBlockingType::MAY_BLOCK,
- BlockingType::WILL_BLOCK)),
- TaskSchedulerWorkerPoolBlockingTest::ParamInfoToString);
-
-// Verify that if a thread enters the scope of a MAY_BLOCK ScopedBlockingCall,
-// but exits the scope before the MayBlockThreshold() is reached, that the
-// worker capacity does not increase.
-TEST_F(TaskSchedulerWorkerPoolBlockingTest, ThreadBlockUnblockPremature) {
- ASSERT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-
- TimeDelta worker_capacity_change_sleep = GetWorkerCapacityChangeSleepTime();
- worker_pool_->MaximizeMayBlockThresholdForTesting();
-
- SaturateWithBlockingTasks(NestedBlockingType(BlockingType::MAY_BLOCK,
- OptionalBlockingType::NO_BLOCK,
- BlockingType::MAY_BLOCK));
- PlatformThread::Sleep(worker_capacity_change_sleep);
- EXPECT_EQ(worker_pool_->NumberOfWorkersForTesting(), kNumWorkersInWorkerPool);
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-
- UnblockTasks();
- task_tracker_.FlushForTesting();
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-}
-
-// Verify that if worker capacity is incremented because of a MAY_BLOCK
-// ScopedBlockingCall, it isn't incremented again when there is a nested
-// WILL_BLOCK ScopedBlockingCall.
-TEST_F(TaskSchedulerWorkerPoolBlockingTest,
- MayBlockIncreaseCapacityNestedWillBlock) {
- ASSERT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
- auto task_runner =
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
- WaitableEvent can_return(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // Saturate the pool so that a MAY_BLOCK ScopedBlockingCall would increment
- // the worker capacity.
- for (size_t i = 0; i < kNumWorkersInWorkerPool - 1; ++i) {
- task_runner->PostTask(FROM_HERE, BindOnce(&WaitWithoutBlockingObserver,
- Unretained(&can_return)));
- }
-
- WaitableEvent can_instantiate_will_block(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent did_instantiate_will_block(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // Post a task that instantiates a MAY_BLOCK ScopedBlockingCall.
- task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](WaitableEvent* can_instantiate_will_block,
- WaitableEvent* did_instantiate_will_block,
- WaitableEvent* can_return) {
- ScopedBlockingCall may_block(BlockingType::MAY_BLOCK);
- WaitWithoutBlockingObserver(can_instantiate_will_block);
- ScopedBlockingCall will_block(BlockingType::WILL_BLOCK);
- did_instantiate_will_block->Signal();
- WaitWithoutBlockingObserver(can_return);
- },
- Unretained(&can_instantiate_will_block),
- Unretained(&did_instantiate_will_block), Unretained(&can_return)));
-
- // After a short delay, worker capacity should be incremented.
- ExpectWorkerCapacityIncreasesTo(kNumWorkersInWorkerPool + 1);
-
- // Wait until the task instantiates a WILL_BLOCK ScopedBlockingCall.
- can_instantiate_will_block.Signal();
- did_instantiate_will_block.Wait();
-
- // Worker capacity shouldn't be incremented again.
- EXPECT_EQ(kNumWorkersInWorkerPool + 1,
- worker_pool_->GetWorkerCapacityForTesting());
-
- // Tear down.
- can_return.Signal();
- task_tracker_.FlushForTesting();
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool);
-}
-
-// Verify that workers that become idle due to the pool being over capacity will
-// eventually cleanup.
-TEST(TaskSchedulerWorkerPoolOverWorkerCapacityTest, VerifyCleanup) {
- constexpr size_t kWorkerCapacity = 3;
-
- TaskTracker task_tracker("Test");
- DelayedTaskManager delayed_task_manager;
- scoped_refptr<TaskRunner> service_thread_task_runner =
- MakeRefCounted<TestSimpleTaskRunner>();
- delayed_task_manager.Start(service_thread_task_runner);
- SchedulerWorkerPoolImpl worker_pool(
- "OverWorkerCapacityTestWorkerPool", "A", ThreadPriority::NORMAL,
- task_tracker.GetTrackedRef(), &delayed_task_manager);
- worker_pool.Start(
- SchedulerWorkerPoolParams(kWorkerCapacity, kReclaimTimeForCleanupTests),
- service_thread_task_runner, nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::NONE);
-
- scoped_refptr<TaskRunner> task_runner =
- worker_pool.CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
-
- WaitableEvent threads_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent threads_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure threads_running_barrier = BarrierClosure(
- kWorkerCapacity,
- BindOnce(&WaitableEvent::Signal, Unretained(&threads_running)));
-
- WaitableEvent blocked_call_continue(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- RepeatingClosure closure = BindRepeating(
- [](Closure* threads_running_barrier, WaitableEvent* threads_continue,
- WaitableEvent* blocked_call_continue) {
- threads_running_barrier->Run();
- {
- ScopedBlockingCall scoped_blocking_call(BlockingType::WILL_BLOCK);
- WaitWithoutBlockingObserver(blocked_call_continue);
- }
- WaitWithoutBlockingObserver(threads_continue);
- },
- Unretained(&threads_running_barrier), Unretained(&threads_continue),
- Unretained(&blocked_call_continue));
-
- for (size_t i = 0; i < kWorkerCapacity; ++i)
- task_runner->PostTask(FROM_HERE, closure);
-
- threads_running.Wait();
-
- WaitableEvent extra_threads_running(
- WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent extra_threads_continue(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- RepeatingClosure extra_threads_running_barrier = BarrierClosure(
- kWorkerCapacity,
- BindOnce(&WaitableEvent::Signal, Unretained(&extra_threads_running)));
- // These tasks should run on the new threads from increasing worker capacity.
- for (size_t i = 0; i < kWorkerCapacity; ++i) {
- task_runner->PostTask(FROM_HERE,
- BindOnce(
- [](Closure* extra_threads_running_barrier,
- WaitableEvent* extra_threads_continue) {
- extra_threads_running_barrier->Run();
- WaitWithoutBlockingObserver(
- extra_threads_continue);
- },
- Unretained(&extra_threads_running_barrier),
- Unretained(&extra_threads_continue)));
- }
- extra_threads_running.Wait();
-
- ASSERT_EQ(kWorkerCapacity * 2, worker_pool.NumberOfWorkersForTesting());
- EXPECT_EQ(kWorkerCapacity * 2, worker_pool.GetWorkerCapacityForTesting());
- blocked_call_continue.Signal();
- extra_threads_continue.Signal();
-
- // Periodically post tasks to ensure that posting tasks does not prevent
- // workers that are idle due to the pool being over capacity from cleaning up.
- for (int i = 0; i < 16; ++i) {
- task_runner->PostDelayedTask(FROM_HERE, DoNothing(),
- kReclaimTimeForCleanupTests * i * 0.5);
- }
-
- // Note: one worker above capacity will not get cleaned up since it's on the
- // top of the idle stack.
- worker_pool.WaitForWorkersCleanedUpForTesting(kWorkerCapacity - 1);
- EXPECT_EQ(kWorkerCapacity + 1, worker_pool.NumberOfWorkersForTesting());
-
- threads_continue.Signal();
-
- worker_pool.JoinForTesting();
-}
-
-// Verify that the maximum number of workers is 256 and that hitting the max
-// leaves the pool in a valid state with regards to worker capacity.
-TEST_F(TaskSchedulerWorkerPoolBlockingTest, MaximumWorkersTest) {
- constexpr size_t kMaxNumberOfWorkers = 256;
- constexpr size_t kNumExtraTasks = 10;
-
- WaitableEvent early_blocking_thread_running(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure early_threads_barrier_closure =
- BarrierClosure(kMaxNumberOfWorkers,
- BindOnce(&WaitableEvent::Signal,
- Unretained(&early_blocking_thread_running)));
-
- WaitableEvent early_threads_finished(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure early_threads_finished_barrier = BarrierClosure(
- kMaxNumberOfWorkers,
- BindOnce(&WaitableEvent::Signal, Unretained(&early_threads_finished)));
-
- WaitableEvent early_release_thread_continue(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- // Post ScopedBlockingCall tasks to hit the worker cap.
- for (size_t i = 0; i < kMaxNumberOfWorkers; ++i) {
- task_runner_->PostTask(FROM_HERE,
- BindOnce(
- [](Closure* early_threads_barrier_closure,
- WaitableEvent* early_release_thread_continue,
- Closure* early_threads_finished) {
- {
- ScopedBlockingCall scoped_blocking_call(
- BlockingType::WILL_BLOCK);
- early_threads_barrier_closure->Run();
- WaitWithoutBlockingObserver(
- early_release_thread_continue);
- }
- early_threads_finished->Run();
- },
- Unretained(&early_threads_barrier_closure),
- Unretained(&early_release_thread_continue),
- Unretained(&early_threads_finished_barrier)));
- }
-
- early_blocking_thread_running.Wait();
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool + kMaxNumberOfWorkers);
-
- WaitableEvent late_release_thread_contine(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitableEvent late_blocking_thread_running(
- WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure late_threads_barrier_closure = BarrierClosure(
- kNumExtraTasks, BindOnce(&WaitableEvent::Signal,
- Unretained(&late_blocking_thread_running)));
-
- // Posts additional tasks. Note: we should already have |kMaxNumberOfWorkers|
- // tasks running. These tasks should not be able to get executed yet as
- // the pool is already at its max worker cap.
- for (size_t i = 0; i < kNumExtraTasks; ++i) {
- task_runner_->PostTask(
- FROM_HERE,
- BindOnce(
- [](Closure* late_threads_barrier_closure,
- WaitableEvent* late_release_thread_contine) {
- ScopedBlockingCall scoped_blocking_call(BlockingType::WILL_BLOCK);
- late_threads_barrier_closure->Run();
- WaitWithoutBlockingObserver(late_release_thread_contine);
- },
- Unretained(&late_threads_barrier_closure),
- Unretained(&late_release_thread_contine)));
- }
-
- // Give time to see if we exceed the max number of workers.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_LE(worker_pool_->NumberOfWorkersForTesting(), kMaxNumberOfWorkers);
-
- early_release_thread_continue.Signal();
- early_threads_finished.Wait();
- late_blocking_thread_running.Wait();
-
- WaitableEvent final_tasks_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent final_tasks_continue(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure final_tasks_running_barrier = BarrierClosure(
- kNumWorkersInWorkerPool,
- BindOnce(&WaitableEvent::Signal, Unretained(&final_tasks_running)));
-
- // Verify that we are still able to saturate the pool.
- for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
- task_runner_->PostTask(
- FROM_HERE,
- BindOnce(
- [](Closure* closure, WaitableEvent* final_tasks_continue) {
- closure->Run();
- WaitWithoutBlockingObserver(final_tasks_continue);
- },
- Unretained(&final_tasks_running_barrier),
- Unretained(&final_tasks_continue)));
- }
- final_tasks_running.Wait();
- EXPECT_EQ(worker_pool_->GetWorkerCapacityForTesting(),
- kNumWorkersInWorkerPool + kNumExtraTasks);
- late_release_thread_contine.Signal();
- final_tasks_continue.Signal();
- task_tracker_.FlushForTesting();
-}
-
-// Verify that worker detachement doesn't race with worker cleanup, regression
-// test for https://crbug.com/810464.
-TEST(TaskSchedulerWorkerPoolTest, RacyCleanup) {
-#if defined(OS_FUCHSIA)
- // Fuchsia + QEMU doesn't deal well with *many* threads being
- // created/destroyed at once: https://crbug.com/816575.
- constexpr size_t kWorkerCapacity = 16;
-#else // defined(OS_FUCHSIA)
- constexpr size_t kWorkerCapacity = 256;
-#endif // defined(OS_FUCHSIA)
- constexpr TimeDelta kReclaimTimeForRacyCleanupTest =
- TimeDelta::FromMilliseconds(10);
-
- TaskTracker task_tracker("Test");
- DelayedTaskManager delayed_task_manager;
- scoped_refptr<TaskRunner> service_thread_task_runner =
- MakeRefCounted<TestSimpleTaskRunner>();
- delayed_task_manager.Start(service_thread_task_runner);
- SchedulerWorkerPoolImpl worker_pool(
- "RacyCleanupTestWorkerPool", "A", ThreadPriority::NORMAL,
- task_tracker.GetTrackedRef(), &delayed_task_manager);
- worker_pool.Start(SchedulerWorkerPoolParams(kWorkerCapacity,
- kReclaimTimeForRacyCleanupTest),
- service_thread_task_runner, nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::NONE);
-
- scoped_refptr<TaskRunner> task_runner =
- worker_pool.CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
-
- WaitableEvent threads_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent unblock_threads(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingClosure threads_running_barrier = BarrierClosure(
- kWorkerCapacity,
- BindOnce(&WaitableEvent::Signal, Unretained(&threads_running)));
-
- for (size_t i = 0; i < kWorkerCapacity; ++i) {
- task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](OnceClosure on_running, WaitableEvent* unblock_threads) {
- std::move(on_running).Run();
- WaitWithoutBlockingObserver(unblock_threads);
- },
- threads_running_barrier, Unretained(&unblock_threads)));
- }
-
- // Wait for all workers to be ready and release them all at once.
- threads_running.Wait();
- unblock_threads.Signal();
-
- // Sleep to wakeup precisely when all workers are going to try to cleanup per
- // being idle.
- PlatformThread::Sleep(kReclaimTimeForRacyCleanupTest);
-
- worker_pool.JoinForTesting();
-
- // Unwinding this test will be racy if worker cleanup can race with
- // SchedulerWorkerPoolImpl destruction : https://crbug.com/810464.
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scheduler_worker_pool_unittest.cc b/base/task_scheduler/scheduler_worker_pool_unittest.cc
deleted file mode 100644
index 20c1ad0..0000000
--- a/base/task_scheduler/scheduler_worker_pool_unittest.cc
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright 2017 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 "base/task_scheduler/scheduler_worker_pool.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/task_runner.h"
-#include "base/task_scheduler/delayed_task_manager.h"
-#include "base/task_scheduler/scheduler_worker_pool_impl.h"
-#include "base/task_scheduler/scheduler_worker_pool_params.h"
-#include "base/task_scheduler/task_tracker.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/task_scheduler/test_task_factory.h"
-#include "base/task_scheduler/test_utils.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include "base/task_scheduler/platform_native_worker_pool_win.h"
-#endif
-
-namespace base {
-namespace internal {
-
-namespace {
-
-constexpr size_t kNumWorkersInWorkerPool = 4;
-constexpr size_t kNumThreadsPostingTasks = 4;
-constexpr size_t kNumTasksPostedPerThread = 150;
-
-enum class PoolType {
- GENERIC,
-#if defined(OS_WIN)
- WINDOWS,
-#endif
-};
-
-struct PoolExecutionType {
- PoolType pool_type;
- test::ExecutionMode execution_mode;
-};
-
-using PostNestedTask = test::TestTaskFactory::PostNestedTask;
-
-class ThreadPostingTasks : public SimpleThread {
- public:
- // Constructs a thread that posts |num_tasks_posted_per_thread| tasks to
- // |worker_pool| through an |execution_mode| task runner. If
- // |post_nested_task| is YES, each task posted by this thread posts another
- // task when it runs.
- ThreadPostingTasks(SchedulerWorkerPool* worker_pool,
- test::ExecutionMode execution_mode,
- PostNestedTask post_nested_task)
- : SimpleThread("ThreadPostingTasks"),
- worker_pool_(worker_pool),
- post_nested_task_(post_nested_task),
- factory_(test::CreateTaskRunnerWithExecutionMode(worker_pool,
- execution_mode),
- execution_mode) {
- DCHECK(worker_pool_);
- }
-
- const test::TestTaskFactory* factory() const { return &factory_; }
-
- private:
- void Run() override {
- EXPECT_FALSE(factory_.task_runner()->RunsTasksInCurrentSequence());
-
- for (size_t i = 0; i < kNumTasksPostedPerThread; ++i)
- EXPECT_TRUE(factory_.PostTask(post_nested_task_, Closure()));
- }
-
- SchedulerWorkerPool* const worker_pool_;
- const scoped_refptr<TaskRunner> task_runner_;
- const PostNestedTask post_nested_task_;
- test::TestTaskFactory factory_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
-};
-
-class TaskSchedulerWorkerPoolTest
- : public testing::TestWithParam<PoolExecutionType> {
- protected:
- TaskSchedulerWorkerPoolTest()
- : service_thread_("TaskSchedulerServiceThread") {}
-
- void SetUp() override {
- service_thread_.Start();
- delayed_task_manager_.Start(service_thread_.task_runner());
- CreateWorkerPool();
- }
-
- void TearDown() override {
- service_thread_.Stop();
- if (worker_pool_)
- worker_pool_->JoinForTesting();
- }
-
- void CreateWorkerPool() {
- ASSERT_FALSE(worker_pool_);
- switch (GetParam().pool_type) {
- case PoolType::GENERIC:
- worker_pool_ = std::make_unique<SchedulerWorkerPoolImpl>(
- "TestWorkerPool", "A", ThreadPriority::NORMAL,
- task_tracker_.GetTrackedRef(), &delayed_task_manager_);
- break;
-#if defined(OS_WIN)
- case PoolType::WINDOWS:
- worker_pool_ = std::make_unique<PlatformNativeWorkerPoolWin>(
- task_tracker_.GetTrackedRef(), &delayed_task_manager_);
- break;
-#endif
- }
- ASSERT_TRUE(worker_pool_);
- }
-
- void StartWorkerPool() {
- ASSERT_TRUE(worker_pool_);
- switch (GetParam().pool_type) {
- case PoolType::GENERIC: {
- SchedulerWorkerPoolImpl* scheduler_worker_pool_impl =
- static_cast<SchedulerWorkerPoolImpl*>(worker_pool_.get());
- scheduler_worker_pool_impl->Start(
- SchedulerWorkerPoolParams(kNumWorkersInWorkerPool,
- TimeDelta::Max()),
- service_thread_.task_runner(), nullptr,
- SchedulerWorkerPoolImpl::WorkerEnvironment::NONE);
- break;
- }
-#if defined(OS_WIN)
- case PoolType::WINDOWS: {
- PlatformNativeWorkerPoolWin* scheduler_worker_pool_windows_impl =
- static_cast<PlatformNativeWorkerPoolWin*>(worker_pool_.get());
- scheduler_worker_pool_windows_impl->Start();
- break;
- }
-#endif
- }
- }
-
- Thread service_thread_;
- TaskTracker task_tracker_ = {"Test"};
- DelayedTaskManager delayed_task_manager_;
-
- std::unique_ptr<SchedulerWorkerPool> worker_pool_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolTest);
-};
-
-void ShouldNotRun() {
- ADD_FAILURE() << "Ran a task that shouldn't run.";
-}
-
-} // namespace
-
-TEST_P(TaskSchedulerWorkerPoolTest, PostTasks) {
- StartWorkerPool();
- // Create threads to post tasks.
- std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
- for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
- threads_posting_tasks.push_back(std::make_unique<ThreadPostingTasks>(
- worker_pool_.get(), GetParam().execution_mode, PostNestedTask::NO));
- threads_posting_tasks.back()->Start();
- }
-
- // Wait for all tasks to run.
- for (const auto& thread_posting_tasks : threads_posting_tasks) {
- thread_posting_tasks->Join();
- thread_posting_tasks->factory()->WaitForAllTasksToRun();
- }
-
- // Flush the task tracker to be sure that no task accesses its TestTaskFactory
- // after |thread_posting_tasks| is destroyed.
- task_tracker_.FlushForTesting();
-}
-
-TEST_P(TaskSchedulerWorkerPoolTest, NestedPostTasks) {
- StartWorkerPool();
- // Create threads to post tasks. Each task posted by these threads will post
- // another task when it runs.
- std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
- for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
- threads_posting_tasks.push_back(std::make_unique<ThreadPostingTasks>(
- worker_pool_.get(), GetParam().execution_mode, PostNestedTask::YES));
- threads_posting_tasks.back()->Start();
- }
-
- // Wait for all tasks to run.
- for (const auto& thread_posting_tasks : threads_posting_tasks) {
- thread_posting_tasks->Join();
- thread_posting_tasks->factory()->WaitForAllTasksToRun();
- }
-
- // Flush the task tracker to be sure that no task accesses its TestTaskFactory
- // after |thread_posting_tasks| is destroyed.
- task_tracker_.FlushForTesting();
-}
-
-// Verify that a Task can't be posted after shutdown.
-TEST_P(TaskSchedulerWorkerPoolTest, PostTaskAfterShutdown) {
- StartWorkerPool();
- auto task_runner = test::CreateTaskRunnerWithExecutionMode(
- worker_pool_.get(), GetParam().execution_mode);
- task_tracker_.Shutdown();
- EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
-}
-
-// Verify that posting tasks after the pool was destroyed fails but doesn't
-// crash.
-TEST_P(TaskSchedulerWorkerPoolTest, PostAfterDestroy) {
- StartWorkerPool();
- auto task_runner = test::CreateTaskRunnerWithExecutionMode(
- worker_pool_.get(), GetParam().execution_mode);
- EXPECT_TRUE(task_runner->PostTask(FROM_HERE, DoNothing()));
- task_tracker_.Shutdown();
- worker_pool_->JoinForTesting();
- worker_pool_.reset();
- EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
-}
-
-// Verify that a Task runs shortly after its delay expires.
-TEST_P(TaskSchedulerWorkerPoolTest, PostDelayedTask) {
- StartWorkerPool();
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- auto task_runner = test::CreateTaskRunnerWithExecutionMode(
- worker_pool_.get(), GetParam().execution_mode);
-
- // Wait until the task runner is up and running to make sure the test below is
- // solely timing the delayed task, not bringing up a physical thread.
- task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_ran)));
- task_ran.Wait();
- ASSERT_TRUE(!task_ran.IsSignaled());
-
- // Post a task with a short delay.
- TimeTicks start_time = TimeTicks::Now();
- EXPECT_TRUE(task_runner->PostDelayedTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_ran)),
- TestTimeouts::tiny_timeout()));
-
- // Wait until the task runs.
- task_ran.Wait();
-
- // Expect the task to run after its delay expires, but no more than 250
- // ms after that.
- const TimeDelta actual_delay = TimeTicks::Now() - start_time;
- EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout());
- EXPECT_LT(actual_delay,
- TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
-}
-
-// Verify that the RunsTasksInCurrentSequence() method of a SEQUENCED TaskRunner
-// returns false when called from a task that isn't part of the sequence. Note:
-// Tests that use TestTaskFactory already verify that
-// RunsTasksInCurrentSequence() returns true when appropriate so this method
-// complements it to get full coverage of that method.
-TEST_P(TaskSchedulerWorkerPoolTest, SequencedRunsTasksInCurrentSequence) {
- StartWorkerPool();
- auto task_runner = test::CreateTaskRunnerWithExecutionMode(
- worker_pool_.get(), GetParam().execution_mode);
- auto sequenced_task_runner =
- worker_pool_->CreateSequencedTaskRunnerWithTraits(TaskTraits());
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](scoped_refptr<TaskRunner> sequenced_task_runner,
- WaitableEvent* task_ran) {
- EXPECT_FALSE(sequenced_task_runner->RunsTasksInCurrentSequence());
- task_ran->Signal();
- },
- sequenced_task_runner, Unretained(&task_ran)));
- task_ran.Wait();
-}
-
-// Verify that tasks posted before Start run after Start.
-TEST_P(TaskSchedulerWorkerPoolTest, PostBeforeStart) {
- WaitableEvent task_1_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_2_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- scoped_refptr<TaskRunner> task_runner =
- worker_pool_->CreateTaskRunnerWithTraits({WithBaseSyncPrimitives()});
-
- task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_1_running)));
- task_runner->PostTask(
- FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_2_running)));
-
- // Workers should not be created and tasks should not run before the pool is
- // started. The sleep is to give time for the tasks to potentially run.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(task_1_running.IsSignaled());
- EXPECT_FALSE(task_2_running.IsSignaled());
-
- StartWorkerPool();
-
- // Tasks should run shortly after the pool is started.
- task_1_running.Wait();
- task_2_running.Wait();
-
- task_tracker_.FlushForTesting();
-}
-
-INSTANTIATE_TEST_CASE_P(GenericParallel,
- TaskSchedulerWorkerPoolTest,
- ::testing::Values(PoolExecutionType{
- PoolType::GENERIC, test::ExecutionMode::PARALLEL}));
-INSTANTIATE_TEST_CASE_P(GenericSequenced,
- TaskSchedulerWorkerPoolTest,
- ::testing::Values(PoolExecutionType{
- PoolType::GENERIC,
- test::ExecutionMode::SEQUENCED}));
-
-#if defined(OS_WIN)
-INSTANTIATE_TEST_CASE_P(WinParallel,
- TaskSchedulerWorkerPoolTest,
- ::testing::Values(PoolExecutionType{
- PoolType::WINDOWS, test::ExecutionMode::PARALLEL}));
-INSTANTIATE_TEST_CASE_P(WinSequenced,
- TaskSchedulerWorkerPoolTest,
- ::testing::Values(PoolExecutionType{
- PoolType::WINDOWS,
- test::ExecutionMode::SEQUENCED}));
-#endif
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scheduler_worker_stack_unittest.cc b/base/task_scheduler/scheduler_worker_stack_unittest.cc
deleted file mode 100644
index 8707874..0000000
--- a/base/task_scheduler/scheduler_worker_stack_unittest.cc
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/scheduler_worker_stack.h"
-
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/task_scheduler/scheduler_worker.h"
-#include "base/task_scheduler/sequence.h"
-#include "base/task_scheduler/task_tracker.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class MockSchedulerWorkerDelegate : public SchedulerWorker::Delegate {
- public:
- void OnCanScheduleSequence(scoped_refptr<Sequence> sequence) override {
- ADD_FAILURE() << "Unexpected call to OnCanScheduleSequence().";
- }
- SchedulerWorker::ThreadLabel GetThreadLabel() const override {
- return SchedulerWorker::ThreadLabel::DEDICATED;
- }
- void OnMainEntry(const SchedulerWorker* worker) override {}
- scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
- return nullptr;
- }
- void DidRunTask() override {
- ADD_FAILURE() << "Unexpected call to DidRunTask()";
- }
- void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
- ADD_FAILURE() << "Unexpected call to ReEnqueueSequence()";
- }
- TimeDelta GetSleepTimeout() override {
- return TimeDelta::Max();
- }
-};
-
-class TaskSchedulerWorkerStackTest : public testing::Test {
- protected:
- void SetUp() override {
- worker_a_ = MakeRefCounted<SchedulerWorker>(
- ThreadPriority::NORMAL, WrapUnique(new MockSchedulerWorkerDelegate),
- task_tracker_.GetTrackedRef());
- ASSERT_TRUE(worker_a_);
- worker_b_ = MakeRefCounted<SchedulerWorker>(
- ThreadPriority::NORMAL, WrapUnique(new MockSchedulerWorkerDelegate),
- task_tracker_.GetTrackedRef());
- ASSERT_TRUE(worker_b_);
- worker_c_ = MakeRefCounted<SchedulerWorker>(
- ThreadPriority::NORMAL, WrapUnique(new MockSchedulerWorkerDelegate),
- task_tracker_.GetTrackedRef());
- ASSERT_TRUE(worker_c_);
- }
-
- private:
- TaskTracker task_tracker_ = {"Test"};
-
- protected:
- scoped_refptr<SchedulerWorker> worker_a_;
- scoped_refptr<SchedulerWorker> worker_b_;
- scoped_refptr<SchedulerWorker> worker_c_;
-};
-
-} // namespace
-
-// Verify that Push() and Pop() add/remove values in FIFO order.
-TEST_F(TaskSchedulerWorkerStackTest, PushPop) {
- SchedulerWorkerStack stack;
- EXPECT_EQ(nullptr, stack.Pop());
-
- EXPECT_TRUE(stack.IsEmpty());
- EXPECT_EQ(0U, stack.Size());
-
- stack.Push(worker_a_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(1U, stack.Size());
-
- stack.Push(worker_b_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- stack.Push(worker_c_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(3U, stack.Size());
-
- EXPECT_EQ(worker_c_.get(), stack.Pop());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- stack.Push(worker_c_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(3U, stack.Size());
-
- EXPECT_EQ(worker_c_.get(), stack.Pop());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- EXPECT_EQ(worker_b_.get(), stack.Pop());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(1U, stack.Size());
-
- EXPECT_EQ(worker_a_.get(), stack.Pop());
- EXPECT_TRUE(stack.IsEmpty());
- EXPECT_EQ(0U, stack.Size());
-
- EXPECT_EQ(nullptr, stack.Pop());
-}
-
-// Verify that Peek() returns the correct values in FIFO order.
-TEST_F(TaskSchedulerWorkerStackTest, PeekPop) {
- SchedulerWorkerStack stack;
- EXPECT_EQ(nullptr, stack.Peek());
-
- EXPECT_TRUE(stack.IsEmpty());
- EXPECT_EQ(0U, stack.Size());
-
- stack.Push(worker_a_.get());
- EXPECT_EQ(worker_a_.get(), stack.Peek());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(1U, stack.Size());
-
- stack.Push(worker_b_.get());
- EXPECT_EQ(worker_b_.get(), stack.Peek());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- stack.Push(worker_c_.get());
- EXPECT_EQ(worker_c_.get(), stack.Peek());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(3U, stack.Size());
-
- EXPECT_EQ(worker_c_.get(), stack.Pop());
- EXPECT_EQ(worker_b_.get(), stack.Peek());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- EXPECT_EQ(worker_b_.get(), stack.Pop());
- EXPECT_EQ(worker_a_.get(), stack.Peek());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(1U, stack.Size());
-
- EXPECT_EQ(worker_a_.get(), stack.Pop());
- EXPECT_TRUE(stack.IsEmpty());
- EXPECT_EQ(0U, stack.Size());
-
- EXPECT_EQ(nullptr, stack.Peek());
-}
-
-// Verify that Contains() returns true for workers on the stack.
-TEST_F(TaskSchedulerWorkerStackTest, Contains) {
- SchedulerWorkerStack stack;
- EXPECT_FALSE(stack.Contains(worker_a_.get()));
- EXPECT_FALSE(stack.Contains(worker_b_.get()));
- EXPECT_FALSE(stack.Contains(worker_c_.get()));
-
- stack.Push(worker_a_.get());
- EXPECT_TRUE(stack.Contains(worker_a_.get()));
- EXPECT_FALSE(stack.Contains(worker_b_.get()));
- EXPECT_FALSE(stack.Contains(worker_c_.get()));
-
- stack.Push(worker_b_.get());
- EXPECT_TRUE(stack.Contains(worker_a_.get()));
- EXPECT_TRUE(stack.Contains(worker_b_.get()));
- EXPECT_FALSE(stack.Contains(worker_c_.get()));
-
- stack.Push(worker_c_.get());
- EXPECT_TRUE(stack.Contains(worker_a_.get()));
- EXPECT_TRUE(stack.Contains(worker_b_.get()));
- EXPECT_TRUE(stack.Contains(worker_c_.get()));
-
- stack.Pop();
- EXPECT_TRUE(stack.Contains(worker_a_.get()));
- EXPECT_TRUE(stack.Contains(worker_b_.get()));
- EXPECT_FALSE(stack.Contains(worker_c_.get()));
-
- stack.Pop();
- EXPECT_TRUE(stack.Contains(worker_a_.get()));
- EXPECT_FALSE(stack.Contains(worker_b_.get()));
- EXPECT_FALSE(stack.Contains(worker_c_.get()));
-
- stack.Pop();
- EXPECT_FALSE(stack.Contains(worker_a_.get()));
- EXPECT_FALSE(stack.Contains(worker_b_.get()));
- EXPECT_FALSE(stack.Contains(worker_c_.get()));
-}
-
-// Verify that a value can be removed by Remove().
-TEST_F(TaskSchedulerWorkerStackTest, Remove) {
- SchedulerWorkerStack stack;
- EXPECT_TRUE(stack.IsEmpty());
- EXPECT_EQ(0U, stack.Size());
-
- stack.Push(worker_a_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(1U, stack.Size());
-
- stack.Push(worker_b_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- stack.Push(worker_c_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(3U, stack.Size());
-
- stack.Remove(worker_b_.get());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(2U, stack.Size());
-
- EXPECT_EQ(worker_c_.get(), stack.Pop());
- EXPECT_FALSE(stack.IsEmpty());
- EXPECT_EQ(1U, stack.Size());
-
- EXPECT_EQ(worker_a_.get(), stack.Pop());
- EXPECT_TRUE(stack.IsEmpty());
- EXPECT_EQ(0U, stack.Size());
-}
-
-// Verify that a value can be pushed again after it has been removed.
-TEST_F(TaskSchedulerWorkerStackTest, PushAfterRemove) {
- SchedulerWorkerStack stack;
- EXPECT_EQ(0U, stack.Size());
- EXPECT_TRUE(stack.IsEmpty());
-
- stack.Push(worker_a_.get());
- EXPECT_EQ(1U, stack.Size());
- EXPECT_FALSE(stack.IsEmpty());
-
- stack.Remove(worker_a_.get());
- EXPECT_EQ(0U, stack.Size());
- EXPECT_TRUE(stack.IsEmpty());
-
- stack.Push(worker_a_.get());
- EXPECT_EQ(1U, stack.Size());
- EXPECT_FALSE(stack.IsEmpty());
-}
-
-// Verify that Push() DCHECKs when a value is inserted twice.
-TEST_F(TaskSchedulerWorkerStackTest, PushTwice) {
- SchedulerWorkerStack stack;
- stack.Push(worker_a_.get());
- EXPECT_DCHECK_DEATH({ stack.Push(worker_a_.get()); });
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scheduler_worker_unittest.cc b/base/task_scheduler/scheduler_worker_unittest.cc
deleted file mode 100644
index b7a2eda..0000000
--- a/base/task_scheduler/scheduler_worker_unittest.cc
+++ /dev/null
@@ -1,907 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/scheduler_worker.h"
-
-#include <stddef.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/scheduler_lock.h"
-#include "base/task_scheduler/scheduler_worker_observer.h"
-#include "base/task_scheduler/sequence.h"
-#include "base/task_scheduler/task.h"
-#include "base/task_scheduler/task_tracker.h"
-#include "base/task_scheduler/test_utils.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <objbase.h>
-
-#include "base/win/com_init_check_hook.h"
-#endif
-
-using testing::_;
-using testing::Mock;
-using testing::Ne;
-using testing::StrictMock;
-
-namespace base {
-namespace internal {
-namespace {
-
-const size_t kNumSequencesPerTest = 150;
-
-class SchedulerWorkerDefaultDelegate : public SchedulerWorker::Delegate {
- public:
- SchedulerWorkerDefaultDelegate() = default;
-
- // SchedulerWorker::Delegate:
- void OnCanScheduleSequence(scoped_refptr<Sequence> sequence) override {
- ADD_FAILURE() << "Unexpected call to OnCanScheduleSequence().";
- }
- SchedulerWorker::ThreadLabel GetThreadLabel() const override {
- return SchedulerWorker::ThreadLabel::DEDICATED;
- }
- void OnMainEntry(const SchedulerWorker* worker) override {}
- scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
- return nullptr;
- }
- void DidRunTask() override {
- ADD_FAILURE() << "Unexpected call to DidRunTask()";
- }
- void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
- ADD_FAILURE() << "Unexpected call to ReEnqueueSequence()";
- }
- TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerDefaultDelegate);
-};
-
-// The test parameter is the number of Tasks per Sequence returned by GetWork().
-class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
- protected:
- TaskSchedulerWorkerTest()
- : main_entry_called_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- num_get_work_cv_(lock_.CreateConditionVariable()),
- worker_set_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- void SetUp() override {
- worker_ = MakeRefCounted<SchedulerWorker>(
- ThreadPriority::NORMAL,
- std::make_unique<TestSchedulerWorkerDelegate>(this),
- task_tracker_.GetTrackedRef());
- ASSERT_TRUE(worker_);
- worker_->Start();
- worker_set_.Signal();
- main_entry_called_.Wait();
- }
-
- void TearDown() override {
- // |worker_| needs to be released before ~TaskTracker() as it holds a
- // TrackedRef to it.
- worker_->JoinForTesting();
- worker_ = nullptr;
- }
-
- size_t TasksPerSequence() const { return GetParam(); }
-
- // Wait until GetWork() has been called |num_get_work| times.
- void WaitForNumGetWork(size_t num_get_work) {
- AutoSchedulerLock auto_lock(lock_);
- while (num_get_work_ < num_get_work)
- num_get_work_cv_->Wait();
- }
-
- void SetMaxGetWork(size_t max_get_work) {
- AutoSchedulerLock auto_lock(lock_);
- max_get_work_ = max_get_work;
- }
-
- void SetNumSequencesToCreate(size_t num_sequences_to_create) {
- AutoSchedulerLock auto_lock(lock_);
- EXPECT_EQ(0U, num_sequences_to_create_);
- num_sequences_to_create_ = num_sequences_to_create;
- }
-
- size_t NumRunTasks() {
- AutoSchedulerLock auto_lock(lock_);
- return num_run_tasks_;
- }
-
- std::vector<scoped_refptr<Sequence>> CreatedSequences() {
- AutoSchedulerLock auto_lock(lock_);
- return created_sequences_;
- }
-
- std::vector<scoped_refptr<Sequence>> EnqueuedSequences() {
- AutoSchedulerLock auto_lock(lock_);
- return re_enqueued_sequences_;
- }
-
- scoped_refptr<SchedulerWorker> worker_;
-
- private:
- class TestSchedulerWorkerDelegate : public SchedulerWorkerDefaultDelegate {
- public:
- TestSchedulerWorkerDelegate(TaskSchedulerWorkerTest* outer)
- : outer_(outer) {}
-
- ~TestSchedulerWorkerDelegate() override {
- EXPECT_FALSE(IsCallToDidRunTaskExpected());
- }
-
- // SchedulerWorker::Delegate:
- void OnMainEntry(const SchedulerWorker* worker) override {
- outer_->worker_set_.Wait();
- EXPECT_EQ(outer_->worker_.get(), worker);
- EXPECT_FALSE(IsCallToDidRunTaskExpected());
-
- // Without synchronization, OnMainEntry() could be called twice without
- // generating an error.
- AutoSchedulerLock auto_lock(outer_->lock_);
- EXPECT_FALSE(outer_->main_entry_called_.IsSignaled());
- outer_->main_entry_called_.Signal();
- }
-
- scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
- EXPECT_FALSE(IsCallToDidRunTaskExpected());
- EXPECT_EQ(outer_->worker_.get(), worker);
-
- {
- AutoSchedulerLock auto_lock(outer_->lock_);
-
- // Increment the number of times that this method has been called.
- ++outer_->num_get_work_;
- outer_->num_get_work_cv_->Signal();
-
- // Verify that this method isn't called more times than expected.
- EXPECT_LE(outer_->num_get_work_, outer_->max_get_work_);
-
- // Check if a Sequence should be returned.
- if (outer_->num_sequences_to_create_ == 0)
- return nullptr;
- --outer_->num_sequences_to_create_;
- }
-
- // Create a Sequence with TasksPerSequence() Tasks.
- scoped_refptr<Sequence> sequence(new Sequence);
- for (size_t i = 0; i < outer_->TasksPerSequence(); ++i) {
- Task task(FROM_HERE,
- BindOnce(&TaskSchedulerWorkerTest::RunTaskCallback,
- Unretained(outer_)),
- TaskTraits(), TimeDelta());
- EXPECT_TRUE(outer_->task_tracker_.WillPostTask(task));
- sequence->PushTask(std::move(task));
- }
-
- ExpectCallToDidRunTask();
-
- {
- // Add the Sequence to the vector of created Sequences.
- AutoSchedulerLock auto_lock(outer_->lock_);
- outer_->created_sequences_.push_back(sequence);
- }
-
- sequence = outer_->task_tracker_.WillScheduleSequence(std::move(sequence),
- nullptr);
- EXPECT_TRUE(sequence);
- return sequence;
- }
-
- void DidRunTask() override {
- AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
- EXPECT_TRUE(expect_did_run_task_);
- expect_did_run_task_ = false;
- }
-
- // This override verifies that |sequence| contains the expected number of
- // Tasks and adds it to |enqueued_sequences_|. Unlike a normal
- // EnqueueSequence implementation, it doesn't reinsert |sequence| into a
- // queue for further execution.
- void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
- EXPECT_FALSE(IsCallToDidRunTaskExpected());
- EXPECT_GT(outer_->TasksPerSequence(), 1U);
-
- // Verify that |sequence| contains TasksPerSequence() - 1 Tasks.
- for (size_t i = 0; i < outer_->TasksPerSequence() - 1; ++i) {
- EXPECT_TRUE(sequence->TakeTask());
- EXPECT_EQ(i == outer_->TasksPerSequence() - 2, sequence->Pop());
- }
-
- // Add |sequence| to |re_enqueued_sequences_|.
- AutoSchedulerLock auto_lock(outer_->lock_);
- outer_->re_enqueued_sequences_.push_back(std::move(sequence));
- EXPECT_LE(outer_->re_enqueued_sequences_.size(),
- outer_->created_sequences_.size());
- }
-
- private:
- // Expect a call to DidRunTask() before the next call to any other method of
- // this delegate.
- void ExpectCallToDidRunTask() {
- AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
- expect_did_run_task_ = true;
- }
-
- bool IsCallToDidRunTaskExpected() const {
- AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
- return expect_did_run_task_;
- }
-
- TaskSchedulerWorkerTest* outer_;
-
- // Synchronizes access to |expect_did_run_task_|.
- mutable SchedulerLock expect_did_run_task_lock_;
-
- // Whether the next method called on this delegate should be DidRunTask().
- bool expect_did_run_task_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(TestSchedulerWorkerDelegate);
- };
-
- void RunTaskCallback() {
- AutoSchedulerLock auto_lock(lock_);
- ++num_run_tasks_;
- EXPECT_LE(num_run_tasks_, created_sequences_.size());
- }
-
- TaskTracker task_tracker_ = {"Test"};
-
- // Synchronizes access to all members below.
- mutable SchedulerLock lock_;
-
- // Signaled once OnMainEntry() has been called.
- WaitableEvent main_entry_called_;
-
- // Number of Sequences that should be created by GetWork(). When this
- // is 0, GetWork() returns nullptr.
- size_t num_sequences_to_create_ = 0;
-
- // Number of times that GetWork() has been called.
- size_t num_get_work_ = 0;
-
- // Maximum number of times that GetWork() can be called.
- size_t max_get_work_ = 0;
-
- // Condition variable signaled when |num_get_work_| is incremented.
- std::unique_ptr<ConditionVariable> num_get_work_cv_;
-
- // Sequences created by GetWork().
- std::vector<scoped_refptr<Sequence>> created_sequences_;
-
- // Sequences passed to EnqueueSequence().
- std::vector<scoped_refptr<Sequence>> re_enqueued_sequences_;
-
- // Number of times that RunTaskCallback() has been called.
- size_t num_run_tasks_ = 0;
-
- // Signaled after |worker_| is set.
- WaitableEvent worker_set_;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerTest);
-};
-
-} // namespace
-
-// Verify that when GetWork() continuously returns Sequences, all Tasks in these
-// Sequences run successfully. The test wakes up the SchedulerWorker once.
-TEST_P(TaskSchedulerWorkerTest, ContinuousWork) {
- // Set GetWork() to return |kNumSequencesPerTest| Sequences before starting to
- // return nullptr.
- SetNumSequencesToCreate(kNumSequencesPerTest);
-
- // Expect |kNumSequencesPerTest| calls to GetWork() in which it returns a
- // Sequence and one call in which its returns nullptr.
- const size_t kExpectedNumGetWork = kNumSequencesPerTest + 1;
- SetMaxGetWork(kExpectedNumGetWork);
-
- // Wake up |worker_| and wait until GetWork() has been invoked the
- // expected amount of times.
- worker_->WakeUp();
- WaitForNumGetWork(kExpectedNumGetWork);
-
- // All tasks should have run.
- EXPECT_EQ(kNumSequencesPerTest, NumRunTasks());
-
- // If Sequences returned by GetWork() contain more than one Task, they aren't
- // empty after the worker pops Tasks from them and thus should be returned to
- // EnqueueSequence().
- if (TasksPerSequence() > 1)
- EXPECT_EQ(CreatedSequences(), EnqueuedSequences());
- else
- EXPECT_TRUE(EnqueuedSequences().empty());
-}
-
-// Verify that when GetWork() alternates between returning a Sequence and
-// returning nullptr, all Tasks in the returned Sequences run successfully. The
-// test wakes up the SchedulerWorker once for each Sequence.
-TEST_P(TaskSchedulerWorkerTest, IntermittentWork) {
- for (size_t i = 0; i < kNumSequencesPerTest; ++i) {
- // Set GetWork() to return 1 Sequence before starting to return
- // nullptr.
- SetNumSequencesToCreate(1);
-
- // Expect |i + 1| calls to GetWork() in which it returns a Sequence and
- // |i + 1| calls in which it returns nullptr.
- const size_t expected_num_get_work = 2 * (i + 1);
- SetMaxGetWork(expected_num_get_work);
-
- // Wake up |worker_| and wait until GetWork() has been invoked
- // the expected amount of times.
- worker_->WakeUp();
- WaitForNumGetWork(expected_num_get_work);
-
- // The Task should have run
- EXPECT_EQ(i + 1, NumRunTasks());
-
- // If Sequences returned by GetWork() contain more than one Task, they
- // aren't empty after the worker pops Tasks from them and thus should be
- // returned to EnqueueSequence().
- if (TasksPerSequence() > 1)
- EXPECT_EQ(CreatedSequences(), EnqueuedSequences());
- else
- EXPECT_TRUE(EnqueuedSequences().empty());
- }
-}
-
-INSTANTIATE_TEST_CASE_P(OneTaskPerSequence,
- TaskSchedulerWorkerTest,
- ::testing::Values(1));
-INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
- TaskSchedulerWorkerTest,
- ::testing::Values(2));
-
-namespace {
-
-class ControllableCleanupDelegate : public SchedulerWorkerDefaultDelegate {
- public:
- class Controls : public RefCountedThreadSafe<Controls> {
- public:
- Controls()
- : work_running_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::SIGNALED),
- work_processed_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- cleanup_requested_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- destroyed_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- exited_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- void HaveWorkBlock() { work_running_.Reset(); }
-
- void UnblockWork() { work_running_.Signal(); }
-
- void WaitForWorkToRun() { work_processed_.Wait(); }
-
- void WaitForCleanupRequest() { cleanup_requested_.Wait(); }
-
- void WaitForDelegateDestroy() { destroyed_.Wait(); }
-
- void WaitForMainExit() { exited_.Wait(); }
-
- void set_expect_get_work(bool expect_get_work) {
- expect_get_work_ = expect_get_work;
- }
-
- void ResetState() {
- work_running_.Signal();
- work_processed_.Reset();
- cleanup_requested_.Reset();
- exited_.Reset();
- work_requested_ = false;
- }
-
- void set_can_cleanup(bool can_cleanup) { can_cleanup_ = can_cleanup; }
-
- private:
- friend class ControllableCleanupDelegate;
- friend class RefCountedThreadSafe<Controls>;
- ~Controls() = default;
-
- WaitableEvent work_running_;
- WaitableEvent work_processed_;
- WaitableEvent cleanup_requested_;
- WaitableEvent destroyed_;
- WaitableEvent exited_;
-
- bool expect_get_work_ = true;
- bool can_cleanup_ = false;
- bool work_requested_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(Controls);
- };
-
- ControllableCleanupDelegate(TaskTracker* task_tracker)
- : task_tracker_(task_tracker), controls_(new Controls()) {}
-
- ~ControllableCleanupDelegate() override { controls_->destroyed_.Signal(); }
-
- scoped_refptr<Sequence> GetWork(SchedulerWorker* worker)
- override {
- EXPECT_TRUE(controls_->expect_get_work_);
-
- // Sends one item of work to signal |work_processed_|. On subsequent calls,
- // sends nullptr to indicate there's no more work to be done.
- if (controls_->work_requested_) {
- if (CanCleanup(worker)) {
- OnCleanup();
- worker->Cleanup();
- controls_->set_expect_get_work(false);
- }
- return nullptr;
- }
-
- controls_->work_requested_ = true;
- scoped_refptr<Sequence> sequence(new Sequence);
- Task task(
- FROM_HERE,
- BindOnce(
- [](WaitableEvent* work_processed, WaitableEvent* work_running) {
- work_processed->Signal();
- work_running->Wait();
- },
- Unretained(&controls_->work_processed_),
- Unretained(&controls_->work_running_)),
- {WithBaseSyncPrimitives(), TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
- TimeDelta());
- EXPECT_TRUE(task_tracker_->WillPostTask(task));
- sequence->PushTask(std::move(task));
- sequence =
- task_tracker_->WillScheduleSequence(std::move(sequence), nullptr);
- EXPECT_TRUE(sequence);
- return sequence;
- }
-
- void DidRunTask() override {}
-
- void OnMainExit(SchedulerWorker* worker) override {
- controls_->exited_.Signal();
- }
-
- bool CanCleanup(SchedulerWorker* worker) {
- // Saving |can_cleanup_| now so that callers waiting on |cleanup_requested_|
- // have the thread go to sleep and then allow timing out.
- bool can_cleanup = controls_->can_cleanup_;
- controls_->cleanup_requested_.Signal();
- return can_cleanup;
- }
-
- void OnCleanup() {
- EXPECT_TRUE(controls_->can_cleanup_);
- EXPECT_TRUE(controls_->cleanup_requested_.IsSignaled());
- }
-
- // ControllableCleanupDelegate:
- scoped_refptr<Controls> controls() { return controls_; }
-
- private:
- scoped_refptr<Sequence> work_sequence_;
- TaskTracker* const task_tracker_;
- scoped_refptr<Controls> controls_;
-
- DISALLOW_COPY_AND_ASSIGN(ControllableCleanupDelegate);
-};
-
-class MockedControllableCleanupDelegate : public ControllableCleanupDelegate {
- public:
- MockedControllableCleanupDelegate(TaskTracker* task_tracker)
- : ControllableCleanupDelegate(task_tracker){};
- ~MockedControllableCleanupDelegate() override = default;
-
- // SchedulerWorker::Delegate:
- MOCK_METHOD1(OnMainEntry, void(const SchedulerWorker* worker));
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MockedControllableCleanupDelegate);
-};
-
-} // namespace
-
-// Verify that calling SchedulerWorker::Cleanup() from GetWork() causes
-// the SchedulerWorker's thread to exit.
-TEST(TaskSchedulerWorkerTest, WorkerCleanupFromGetWork) {
- TaskTracker task_tracker("Test");
- // Will be owned by SchedulerWorker.
- MockedControllableCleanupDelegate* delegate =
- new StrictMock<MockedControllableCleanupDelegate>(&task_tracker);
- scoped_refptr<ControllableCleanupDelegate::Controls> controls =
- delegate->controls();
- controls->set_can_cleanup(true);
- EXPECT_CALL(*delegate, OnMainEntry(_));
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- WrapUnique(delegate),
- task_tracker.GetTrackedRef());
- worker->Start();
- worker->WakeUp();
- controls->WaitForWorkToRun();
- Mock::VerifyAndClear(delegate);
- controls->WaitForMainExit();
-}
-
-TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringWork) {
- TaskTracker task_tracker("Test");
- // Will be owned by SchedulerWorker.
- // No mock here as that's reasonably covered by other tests and the delegate
- // may destroy on a different thread. Mocks aren't designed with that in mind.
- std::unique_ptr<ControllableCleanupDelegate> delegate =
- std::make_unique<ControllableCleanupDelegate>(&task_tracker);
- scoped_refptr<ControllableCleanupDelegate::Controls> controls =
- delegate->controls();
-
- controls->HaveWorkBlock();
-
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- std::move(delegate),
- task_tracker.GetTrackedRef());
- worker->Start();
- worker->WakeUp();
-
- controls->WaitForWorkToRun();
- worker->Cleanup();
- worker = nullptr;
- controls->UnblockWork();
- controls->WaitForDelegateDestroy();
-}
-
-TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringWait) {
- TaskTracker task_tracker("Test");
- // Will be owned by SchedulerWorker.
- // No mock here as that's reasonably covered by other tests and the delegate
- // may destroy on a different thread. Mocks aren't designed with that in mind.
- std::unique_ptr<ControllableCleanupDelegate> delegate =
- std::make_unique<ControllableCleanupDelegate>(&task_tracker);
- scoped_refptr<ControllableCleanupDelegate::Controls> controls =
- delegate->controls();
-
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- std::move(delegate),
- task_tracker.GetTrackedRef());
- worker->Start();
- worker->WakeUp();
-
- controls->WaitForCleanupRequest();
- worker->Cleanup();
- worker = nullptr;
- controls->WaitForDelegateDestroy();
-}
-
-TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringShutdown) {
- TaskTracker task_tracker("Test");
- // Will be owned by SchedulerWorker.
- // No mock here as that's reasonably covered by other tests and the delegate
- // may destroy on a different thread. Mocks aren't designed with that in mind.
- std::unique_ptr<ControllableCleanupDelegate> delegate =
- std::make_unique<ControllableCleanupDelegate>(&task_tracker);
- scoped_refptr<ControllableCleanupDelegate::Controls> controls =
- delegate->controls();
-
- controls->HaveWorkBlock();
-
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- std::move(delegate),
- task_tracker.GetTrackedRef());
- worker->Start();
- worker->WakeUp();
-
- controls->WaitForWorkToRun();
- task_tracker.Shutdown();
- worker->Cleanup();
- worker = nullptr;
- controls->UnblockWork();
- controls->WaitForDelegateDestroy();
-}
-
-// Verify that Start() is a no-op after Cleanup().
-TEST(TaskSchedulerWorkerTest, CleanupBeforeStart) {
- TaskTracker task_tracker("Test");
- // Will be owned by SchedulerWorker.
- // No mock here as that's reasonably covered by other tests and the delegate
- // may destroy on a different thread. Mocks aren't designed with that in mind.
- std::unique_ptr<ControllableCleanupDelegate> delegate =
- std::make_unique<ControllableCleanupDelegate>(&task_tracker);
- scoped_refptr<ControllableCleanupDelegate::Controls> controls =
- delegate->controls();
- controls->set_expect_get_work(false);
-
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- std::move(delegate),
- task_tracker.GetTrackedRef());
-
- worker->Cleanup();
- worker->Start();
-
- EXPECT_FALSE(worker->ThreadAliveForTesting());
-}
-
-namespace {
-
-class CallJoinFromDifferentThread : public SimpleThread {
- public:
- CallJoinFromDifferentThread(SchedulerWorker* worker_to_join)
- : SimpleThread("SchedulerWorkerJoinThread"),
- worker_to_join_(worker_to_join),
- run_started_event_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- ~CallJoinFromDifferentThread() override = default;
-
- void Run() override {
- run_started_event_.Signal();
- worker_to_join_->JoinForTesting();
- }
-
- void WaitForRunToStart() { run_started_event_.Wait(); }
-
- private:
- SchedulerWorker* const worker_to_join_;
- WaitableEvent run_started_event_;
- DISALLOW_COPY_AND_ASSIGN(CallJoinFromDifferentThread);
-};
-
-} // namespace
-
-TEST(TaskSchedulerWorkerTest, WorkerCleanupDuringJoin) {
- TaskTracker task_tracker("Test");
- // Will be owned by SchedulerWorker.
- // No mock here as that's reasonably covered by other tests and the
- // delegate may destroy on a different thread. Mocks aren't designed with that
- // in mind.
- std::unique_ptr<ControllableCleanupDelegate> delegate =
- std::make_unique<ControllableCleanupDelegate>(&task_tracker);
- scoped_refptr<ControllableCleanupDelegate::Controls> controls =
- delegate->controls();
-
- controls->HaveWorkBlock();
-
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- std::move(delegate),
- task_tracker.GetTrackedRef());
- worker->Start();
- worker->WakeUp();
-
- controls->WaitForWorkToRun();
- CallJoinFromDifferentThread join_from_different_thread(worker.get());
- join_from_different_thread.Start();
- join_from_different_thread.WaitForRunToStart();
- // Sleep here to give the other thread a chance to call JoinForTesting().
- // Receiving a signal that Run() was called doesn't mean JoinForTesting() was
- // necessarily called, and we can't signal after JoinForTesting() as
- // JoinForTesting() blocks until we call UnblockWork().
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- worker->Cleanup();
- worker = nullptr;
- controls->UnblockWork();
- controls->WaitForDelegateDestroy();
- join_from_different_thread.Join();
-}
-
-namespace {
-
-class ExpectThreadPriorityDelegate : public SchedulerWorkerDefaultDelegate {
- public:
- ExpectThreadPriorityDelegate()
- : priority_verified_in_get_work_event_(
- WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- expected_thread_priority_(ThreadPriority::BACKGROUND) {}
-
- void SetExpectedThreadPriority(ThreadPriority expected_thread_priority) {
- expected_thread_priority_ = expected_thread_priority;
- }
-
- void WaitForPriorityVerifiedInGetWork() {
- priority_verified_in_get_work_event_.Wait();
- }
-
- // SchedulerWorker::Delegate:
- void OnMainEntry(const SchedulerWorker* worker) override {
- VerifyThreadPriority();
- }
- scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
- VerifyThreadPriority();
- priority_verified_in_get_work_event_.Signal();
- return nullptr;
- }
-
- private:
- void VerifyThreadPriority() {
- AutoSchedulerLock auto_lock(expected_thread_priority_lock_);
- EXPECT_EQ(expected_thread_priority_,
- PlatformThread::GetCurrentThreadPriority());
- }
-
- // Signaled after GetWork() has verified the priority of the worker thread.
- WaitableEvent priority_verified_in_get_work_event_;
-
- // Synchronizes access to |expected_thread_priority_|.
- SchedulerLock expected_thread_priority_lock_;
-
- // Expected thread priority for the next call to OnMainEntry() or GetWork().
- ThreadPriority expected_thread_priority_;
-
- DISALLOW_COPY_AND_ASSIGN(ExpectThreadPriorityDelegate);
-};
-
-} // namespace
-
-TEST(TaskSchedulerWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
- TaskTracker task_tracker("Test");
-
- std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
- new ExpectThreadPriorityDelegate);
- ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
- delegate_raw->SetExpectedThreadPriority(
- PlatformThread::CanIncreaseCurrentThreadPriority()
- ? ThreadPriority::BACKGROUND
- : ThreadPriority::NORMAL);
-
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::BACKGROUND,
- std::move(delegate),
- task_tracker.GetTrackedRef());
- worker->Start();
-
- // Verify that the initial thread priority is BACKGROUND (or NORMAL if thread
- // priority can't be increased).
- worker->WakeUp();
- delegate_raw->WaitForPriorityVerifiedInGetWork();
-
- // Verify that the thread priority is bumped to NORMAL during shutdown.
- delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
- task_tracker.SetHasShutdownStartedForTesting();
- worker->WakeUp();
- delegate_raw->WaitForPriorityVerifiedInGetWork();
-
- worker->JoinForTesting();
-}
-
-namespace {
-
-class VerifyCallsToObserverDelegate : public SchedulerWorkerDefaultDelegate {
- public:
- VerifyCallsToObserverDelegate(test::MockSchedulerWorkerObserver* observer)
- : observer_(observer) {}
-
- // SchedulerWorker::Delegate:
- void OnMainEntry(const SchedulerWorker* worker) override {
- Mock::VerifyAndClear(observer_);
- }
-
- void OnMainExit(SchedulerWorker* worker) override {
- EXPECT_CALL(*observer_, OnSchedulerWorkerMainExit());
- }
-
- private:
- test::MockSchedulerWorkerObserver* const observer_;
-
- DISALLOW_COPY_AND_ASSIGN(VerifyCallsToObserverDelegate);
-};
-
-} // namespace
-
-// Verify that the SchedulerWorkerObserver is notified when the worker enters
-// and exits its main function.
-TEST(TaskSchedulerWorkerTest, SchedulerWorkerObserver) {
- StrictMock<test::MockSchedulerWorkerObserver> observer;
- {
- TaskTracker task_tracker("Test");
- auto delegate = std::make_unique<VerifyCallsToObserverDelegate>(&observer);
- auto worker = MakeRefCounted<SchedulerWorker>(ThreadPriority::NORMAL,
- std::move(delegate),
- task_tracker.GetTrackedRef());
-
- EXPECT_CALL(observer, OnSchedulerWorkerMainEntry());
- worker->Start(&observer);
- worker->Cleanup();
- worker = nullptr;
- }
- Mock::VerifyAndClear(&observer);
-}
-
-#if defined(OS_WIN)
-
-namespace {
-
-class CoInitializeDelegate : public SchedulerWorkerDefaultDelegate {
- public:
- CoInitializeDelegate()
- : get_work_returned_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
- EXPECT_FALSE(get_work_returned_.IsSignaled());
- EXPECT_EQ(E_UNEXPECTED, coinitialize_hresult_);
-
- coinitialize_hresult_ = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
- if (SUCCEEDED(coinitialize_hresult_))
- CoUninitialize();
-
- get_work_returned_.Signal();
- return nullptr;
- }
-
- void WaitUntilGetWorkReturned() { get_work_returned_.Wait(); }
-
- HRESULT coinitialize_hresult() const { return coinitialize_hresult_; }
-
- private:
- WaitableEvent get_work_returned_;
- HRESULT coinitialize_hresult_ = E_UNEXPECTED;
-
- DISALLOW_COPY_AND_ASSIGN(CoInitializeDelegate);
-};
-
-} // namespace
-
-TEST(TaskSchedulerWorkerTest, BackwardCompatibilityEnabled) {
- TaskTracker task_tracker("Test");
- auto delegate = std::make_unique<CoInitializeDelegate>();
- CoInitializeDelegate* const delegate_raw = delegate.get();
-
- // Create a worker with backward compatibility ENABLED. Wake it up and wait
- // until GetWork() returns.
- auto worker = MakeRefCounted<SchedulerWorker>(
- ThreadPriority::NORMAL, std::move(delegate), task_tracker.GetTrackedRef(),
- nullptr, SchedulerBackwardCompatibility::INIT_COM_STA);
- worker->Start();
- worker->WakeUp();
- delegate_raw->WaitUntilGetWorkReturned();
-
- // The call to CoInitializeEx() should have returned S_FALSE to indicate that
- // the COM library was already initialized on the thread.
- // See SchedulerWorker::Thread::ThreadMain for why we expect two different
- // results here.
-#if defined(COM_INIT_CHECK_HOOK_ENABLED)
- EXPECT_EQ(S_OK, delegate_raw->coinitialize_hresult());
-#else
- EXPECT_EQ(S_FALSE, delegate_raw->coinitialize_hresult());
-#endif
-
- worker->JoinForTesting();
-}
-
-TEST(TaskSchedulerWorkerTest, BackwardCompatibilityDisabled) {
- TaskTracker task_tracker("Test");
- auto delegate = std::make_unique<CoInitializeDelegate>();
- CoInitializeDelegate* const delegate_raw = delegate.get();
-
- // Create a worker with backward compatibility DISABLED. Wake it up and wait
- // until GetWork() returns.
- auto worker = MakeRefCounted<SchedulerWorker>(
- ThreadPriority::NORMAL, std::move(delegate), task_tracker.GetTrackedRef(),
- nullptr, SchedulerBackwardCompatibility::DISABLED);
- worker->Start();
- worker->WakeUp();
- delegate_raw->WaitUntilGetWorkReturned();
-
- // The call to CoInitializeEx() should have returned S_OK to indicate that the
- // COM library wasn't already initialized on the thread.
- EXPECT_EQ(S_OK, delegate_raw->coinitialize_hresult());
-
- worker->JoinForTesting();
-}
-
-#endif // defined(OS_WIN)
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/scoped_set_task_priority_for_current_thread_unittest.cc b/base/task_scheduler/scoped_set_task_priority_for_current_thread_unittest.cc
deleted file mode 100644
index c497af6..0000000
--- a/base/task_scheduler/scoped_set_task_priority_for_current_thread_unittest.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/scoped_set_task_priority_for_current_thread.h"
-
-#include "base/task_scheduler/task_traits.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-TEST(TaskSchedulerScopedSetTaskPriorityForCurrentThreadTest,
- ScopedSetTaskPriorityForCurrentThread) {
- EXPECT_EQ(TaskPriority::USER_VISIBLE, GetTaskPriorityForCurrentThread());
- {
- ScopedSetTaskPriorityForCurrentThread
- scoped_set_task_priority_for_current_thread(
- TaskPriority::USER_BLOCKING);
- EXPECT_EQ(TaskPriority::USER_BLOCKING, GetTaskPriorityForCurrentThread());
- }
- EXPECT_EQ(TaskPriority::USER_VISIBLE, GetTaskPriorityForCurrentThread());
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/sequence_sort_key_unittest.cc b/base/task_scheduler/sequence_sort_key_unittest.cc
deleted file mode 100644
index 2c1d80d..0000000
--- a/base/task_scheduler/sequence_sort_key_unittest.cc
+++ /dev/null
@@ -1,243 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/sequence_sort_key.h"
-
-#include "base/task_scheduler/task_traits.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-TEST(TaskSchedulerSequenceSortKeyTest, OperatorLessThan) {
- SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_e(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_f(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(2000));
-
- EXPECT_FALSE(key_a < key_a);
- EXPECT_LT(key_b, key_a);
- EXPECT_LT(key_c, key_a);
- EXPECT_LT(key_d, key_a);
- EXPECT_LT(key_e, key_a);
- EXPECT_LT(key_f, key_a);
-
- EXPECT_FALSE(key_a < key_b);
- EXPECT_FALSE(key_b < key_b);
- EXPECT_LT(key_c, key_b);
- EXPECT_LT(key_d, key_b);
- EXPECT_LT(key_e, key_b);
- EXPECT_LT(key_f, key_b);
-
- EXPECT_FALSE(key_a < key_c);
- EXPECT_FALSE(key_b < key_c);
- EXPECT_FALSE(key_c < key_c);
- EXPECT_LT(key_d, key_c);
- EXPECT_LT(key_e, key_c);
- EXPECT_LT(key_f, key_c);
-
- EXPECT_FALSE(key_a < key_d);
- EXPECT_FALSE(key_b < key_d);
- EXPECT_FALSE(key_c < key_d);
- EXPECT_FALSE(key_d < key_d);
- EXPECT_LT(key_e, key_d);
- EXPECT_LT(key_f, key_d);
-
- EXPECT_FALSE(key_a < key_e);
- EXPECT_FALSE(key_b < key_e);
- EXPECT_FALSE(key_c < key_e);
- EXPECT_FALSE(key_d < key_e);
- EXPECT_FALSE(key_e < key_e);
- EXPECT_LT(key_f, key_e);
-
- EXPECT_FALSE(key_a < key_f);
- EXPECT_FALSE(key_b < key_f);
- EXPECT_FALSE(key_c < key_f);
- EXPECT_FALSE(key_d < key_f);
- EXPECT_FALSE(key_e < key_f);
- EXPECT_FALSE(key_f < key_f);
-}
-
-TEST(TaskSchedulerSequenceSortKeyTest, OperatorGreaterThan) {
- SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_e(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_f(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(2000));
-
- EXPECT_FALSE(key_a > key_a);
- EXPECT_FALSE(key_b > key_a);
- EXPECT_FALSE(key_c > key_a);
- EXPECT_FALSE(key_d > key_a);
- EXPECT_FALSE(key_e > key_a);
- EXPECT_FALSE(key_f > key_a);
-
- EXPECT_GT(key_a, key_b);
- EXPECT_FALSE(key_b > key_b);
- EXPECT_FALSE(key_c > key_b);
- EXPECT_FALSE(key_d > key_b);
- EXPECT_FALSE(key_e > key_b);
- EXPECT_FALSE(key_f > key_b);
-
- EXPECT_GT(key_a, key_c);
- EXPECT_GT(key_b, key_c);
- EXPECT_FALSE(key_c > key_c);
- EXPECT_FALSE(key_d > key_c);
- EXPECT_FALSE(key_e > key_c);
- EXPECT_FALSE(key_f > key_c);
-
- EXPECT_GT(key_a, key_d);
- EXPECT_GT(key_b, key_d);
- EXPECT_GT(key_c, key_d);
- EXPECT_FALSE(key_d > key_d);
- EXPECT_FALSE(key_e > key_d);
- EXPECT_FALSE(key_f > key_d);
-
- EXPECT_GT(key_a, key_e);
- EXPECT_GT(key_b, key_e);
- EXPECT_GT(key_c, key_e);
- EXPECT_GT(key_d, key_e);
- EXPECT_FALSE(key_e > key_e);
- EXPECT_FALSE(key_f > key_e);
-
- EXPECT_GT(key_a, key_f);
- EXPECT_GT(key_b, key_f);
- EXPECT_GT(key_c, key_f);
- EXPECT_GT(key_d, key_f);
- EXPECT_GT(key_e, key_f);
- EXPECT_FALSE(key_f > key_f);
-}
-
-TEST(TaskSchedulerSequenceSortKeyTest, OperatorEqual) {
- SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_e(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_f(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(2000));
-
- EXPECT_EQ(key_a, key_a);
- EXPECT_FALSE(key_b == key_a);
- EXPECT_FALSE(key_c == key_a);
- EXPECT_FALSE(key_d == key_a);
- EXPECT_FALSE(key_e == key_a);
- EXPECT_FALSE(key_f == key_a);
-
- EXPECT_FALSE(key_a == key_b);
- EXPECT_EQ(key_b, key_b);
- EXPECT_FALSE(key_c == key_b);
- EXPECT_FALSE(key_d == key_b);
- EXPECT_FALSE(key_e == key_b);
- EXPECT_FALSE(key_f == key_b);
-
- EXPECT_FALSE(key_a == key_c);
- EXPECT_FALSE(key_b == key_c);
- EXPECT_EQ(key_c, key_c);
- EXPECT_FALSE(key_d == key_c);
- EXPECT_FALSE(key_e == key_c);
- EXPECT_FALSE(key_f == key_c);
-
- EXPECT_FALSE(key_a == key_d);
- EXPECT_FALSE(key_b == key_d);
- EXPECT_FALSE(key_c == key_d);
- EXPECT_EQ(key_d, key_d);
- EXPECT_FALSE(key_e == key_d);
- EXPECT_FALSE(key_f == key_d);
-
- EXPECT_FALSE(key_a == key_e);
- EXPECT_FALSE(key_b == key_e);
- EXPECT_FALSE(key_c == key_e);
- EXPECT_FALSE(key_d == key_e);
- EXPECT_EQ(key_e, key_e);
- EXPECT_FALSE(key_f == key_e);
-
- EXPECT_FALSE(key_a == key_f);
- EXPECT_FALSE(key_b == key_f);
- EXPECT_FALSE(key_c == key_f);
- EXPECT_FALSE(key_d == key_f);
- EXPECT_FALSE(key_e == key_f);
- EXPECT_EQ(key_f, key_f);
-}
-
-TEST(TaskSchedulerSequenceSortKeyTest, OperatorNotEqual) {
- SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
- TimeTicks::FromInternalValue(2000));
- SequenceSortKey key_e(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(1000));
- SequenceSortKey key_f(TaskPriority::BACKGROUND,
- TimeTicks::FromInternalValue(2000));
-
- EXPECT_FALSE(key_a != key_a);
- EXPECT_NE(key_b, key_a);
- EXPECT_NE(key_c, key_a);
- EXPECT_NE(key_d, key_a);
- EXPECT_NE(key_e, key_a);
- EXPECT_NE(key_f, key_a);
-
- EXPECT_NE(key_a, key_b);
- EXPECT_FALSE(key_b != key_b);
- EXPECT_NE(key_c, key_b);
- EXPECT_NE(key_d, key_b);
- EXPECT_NE(key_e, key_b);
- EXPECT_NE(key_f, key_b);
-
- EXPECT_NE(key_a, key_c);
- EXPECT_NE(key_b, key_c);
- EXPECT_FALSE(key_c != key_c);
- EXPECT_NE(key_d, key_c);
- EXPECT_NE(key_e, key_c);
- EXPECT_NE(key_f, key_c);
-
- EXPECT_NE(key_a, key_d);
- EXPECT_NE(key_b, key_d);
- EXPECT_NE(key_c, key_d);
- EXPECT_FALSE(key_d != key_d);
- EXPECT_NE(key_e, key_d);
- EXPECT_NE(key_f, key_d);
-
- EXPECT_NE(key_a, key_e);
- EXPECT_NE(key_b, key_e);
- EXPECT_NE(key_c, key_e);
- EXPECT_NE(key_d, key_e);
- EXPECT_FALSE(key_e != key_e);
- EXPECT_NE(key_f, key_e);
-
- EXPECT_NE(key_a, key_f);
- EXPECT_NE(key_b, key_f);
- EXPECT_NE(key_c, key_f);
- EXPECT_NE(key_d, key_f);
- EXPECT_NE(key_e, key_f);
- EXPECT_FALSE(key_f != key_f);
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/sequence_unittest.cc b/base/task_scheduler/sequence_unittest.cc
deleted file mode 100644
index 86d1547..0000000
--- a/base/task_scheduler/sequence_unittest.cc
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/sequence.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/memory/ptr_util.h"
-#include "base/test/gtest_util.h"
-#include "base/time/time.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class MockTask {
- public:
- MOCK_METHOD0(Run, void());
-};
-
-Task CreateTask(MockTask* mock_task) {
- return Task(FROM_HERE, BindOnce(&MockTask::Run, Unretained(mock_task)),
- {TaskPriority::BACKGROUND}, TimeDelta());
-}
-
-void ExpectMockTask(MockTask* mock_task, Task* task) {
- EXPECT_CALL(*mock_task, Run());
- std::move(task->task).Run();
- testing::Mock::VerifyAndClear(mock_task);
-}
-
-} // namespace
-
-TEST(TaskSchedulerSequenceTest, PushTakeRemove) {
- testing::StrictMock<MockTask> mock_task_a;
- testing::StrictMock<MockTask> mock_task_b;
- testing::StrictMock<MockTask> mock_task_c;
- testing::StrictMock<MockTask> mock_task_d;
- testing::StrictMock<MockTask> mock_task_e;
-
- scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>();
-
- // Push task A in the sequence. PushTask() should return true since it's the
- // first task->
- EXPECT_TRUE(sequence->PushTask(CreateTask(&mock_task_a)));
-
- // Push task B, C and D in the sequence. PushTask() should return false since
- // there is already a task in a sequence.
- EXPECT_FALSE(sequence->PushTask(CreateTask(&mock_task_b)));
- EXPECT_FALSE(sequence->PushTask(CreateTask(&mock_task_c)));
- EXPECT_FALSE(sequence->PushTask(CreateTask(&mock_task_d)));
-
- // Take the task in front of the sequence. It should be task A.
- Optional<Task> task = sequence->TakeTask();
- ExpectMockTask(&mock_task_a, &task.value());
- EXPECT_FALSE(task->sequenced_time.is_null());
-
- // Remove the empty slot. Task B should now be in front.
- EXPECT_FALSE(sequence->Pop());
- task = sequence->TakeTask();
- ExpectMockTask(&mock_task_b, &task.value());
- EXPECT_FALSE(task->sequenced_time.is_null());
-
- // Remove the empty slot. Task C should now be in front.
- EXPECT_FALSE(sequence->Pop());
- task = sequence->TakeTask();
- ExpectMockTask(&mock_task_c, &task.value());
- EXPECT_FALSE(task->sequenced_time.is_null());
-
- // Remove the empty slot.
- EXPECT_FALSE(sequence->Pop());
-
- // Push task E in the sequence.
- EXPECT_FALSE(sequence->PushTask(CreateTask(&mock_task_e)));
-
- // Task D should be in front.
- task = sequence->TakeTask();
- ExpectMockTask(&mock_task_d, &task.value());
- EXPECT_FALSE(task->sequenced_time.is_null());
-
- // Remove the empty slot. Task E should now be in front.
- EXPECT_FALSE(sequence->Pop());
- task = sequence->TakeTask();
- ExpectMockTask(&mock_task_e, &task.value());
- EXPECT_FALSE(task->sequenced_time.is_null());
-
- // Remove the empty slot. The sequence should now be empty.
- EXPECT_TRUE(sequence->Pop());
-}
-
-// Verifies the sort key of a sequence that contains one BACKGROUND task.
-TEST(TaskSchedulerSequenceTest, GetSortKeyBackground) {
- // Create a sequence with a BACKGROUND task.
- Task background_task(FROM_HERE, DoNothing(), {TaskPriority::BACKGROUND},
- TimeDelta());
- scoped_refptr<Sequence> background_sequence = MakeRefCounted<Sequence>();
- background_sequence->PushTask(std::move(background_task));
-
- // Get the sort key.
- const SequenceSortKey background_sort_key = background_sequence->GetSortKey();
-
- // Take the task from the sequence, so that its sequenced time is available
- // for the check below.
- auto take_background_task = background_sequence->TakeTask();
-
- // Verify the sort key.
- EXPECT_EQ(TaskPriority::BACKGROUND, background_sort_key.priority());
- EXPECT_EQ(take_background_task->sequenced_time,
- background_sort_key.next_task_sequenced_time());
-
- // Pop for correctness.
- background_sequence->Pop();
-}
-
-// Same as TaskSchedulerSequenceTest.GetSortKeyBackground, but with a
-// USER_VISIBLE task.
-TEST(TaskSchedulerSequenceTest, GetSortKeyForeground) {
- // Create a sequence with a USER_VISIBLE task.
- Task foreground_task(FROM_HERE, DoNothing(), {TaskPriority::USER_VISIBLE},
- TimeDelta());
- scoped_refptr<Sequence> foreground_sequence = MakeRefCounted<Sequence>();
- foreground_sequence->PushTask(std::move(foreground_task));
-
- // Get the sort key.
- const SequenceSortKey foreground_sort_key = foreground_sequence->GetSortKey();
-
- // Take the task from the sequence, so that its sequenced time is available
- // for the check below.
- auto take_foreground_task = foreground_sequence->TakeTask();
-
- // Verify the sort key.
- EXPECT_EQ(TaskPriority::USER_VISIBLE, foreground_sort_key.priority());
- EXPECT_EQ(take_foreground_task->sequenced_time,
- foreground_sort_key.next_task_sequenced_time());
-
- // Pop for correctness.
- foreground_sequence->Pop();
-}
-
-// Verify that a DCHECK fires if Pop() is called on a sequence whose front slot
-// isn't empty.
-TEST(TaskSchedulerSequenceTest, PopNonEmptyFrontSlot) {
- scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>();
- sequence->PushTask(Task(FROM_HERE, DoNothing(), TaskTraits(), TimeDelta()));
-
- EXPECT_DCHECK_DEATH({ sequence->Pop(); });
-}
-
-// Verify that a DCHECK fires if TakeTask() is called on a sequence whose front
-// slot is empty.
-TEST(TaskSchedulerSequenceTest, TakeEmptyFrontSlot) {
- scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>();
- sequence->PushTask(Task(FROM_HERE, DoNothing(), TaskTraits(), TimeDelta()));
-
- EXPECT_TRUE(sequence->TakeTask());
- EXPECT_DCHECK_DEATH({ sequence->TakeTask(); });
-}
-
-// Verify that a DCHECK fires if TakeTask() is called on an empty sequence.
-TEST(TaskSchedulerSequenceTest, TakeEmptySequence) {
- scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>();
- EXPECT_DCHECK_DEATH({ sequence->TakeTask(); });
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/service_thread_unittest.cc b/base/task_scheduler/service_thread_unittest.cc
deleted file mode 100644
index df4d8d6..0000000
--- a/base/task_scheduler/service_thread_unittest.cc
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2018 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 "base/task_scheduler/service_thread.h"
-
-#include <string>
-
-#include "base/bind.h"
-#include "base/debug/stack_trace.h"
-#include "base/task_scheduler/task_scheduler.h"
-#include "base/task_scheduler/task_scheduler_impl.h"
-#include "base/test/histogram_tester.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-// Verifies that |query| is found on the current stack. Ignores failures if this
-// configuration doesn't have symbols.
-void VerifyHasStringOnStack(const std::string& query) {
- const std::string stack = debug::StackTrace().ToString();
- SCOPED_TRACE(stack);
- const bool found_on_stack = stack.find(query) != std::string::npos;
- const bool stack_has_symbols =
- stack.find("SchedulerWorker") != std::string::npos;
- EXPECT_TRUE(found_on_stack || !stack_has_symbols) << query;
-}
-
-} // namespace
-
-#if defined(OS_POSIX)
-// Many POSIX bots flakily crash on |debug::StackTrace().ToString()|,
-// https://crbug.com/840429.
-#define MAYBE_StackHasIdentifyingFrame DISABLED_StackHasIdentifyingFrame
-#else
-#define MAYBE_StackHasIdentifyingFrame StackHasIdentifyingFrame
-#endif
-
-TEST(TaskSchedulerServiceThreadTest, MAYBE_StackHasIdentifyingFrame) {
- ServiceThread service_thread(nullptr);
- service_thread.Start();
-
- service_thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&VerifyHasStringOnStack, "ServiceThread"));
-
- service_thread.FlushForTesting();
-}
-
-// Integration test verifying that a service thread running in a fully
-// integrated TaskScheduler environment results in reporting
-// HeartbeatLatencyMicroseconds metrics.
-TEST(TaskSchedulerServiceThreadIntegrationTest, HeartbeatLatencyReport) {
- TaskScheduler::SetInstance(
- std::make_unique<internal::TaskSchedulerImpl>("Test"));
- TaskScheduler::GetInstance()->StartWithDefaultParams();
-
- static constexpr const char* kExpectedMetrics[] = {
- "TaskScheduler.HeartbeatLatencyMicroseconds.Test."
- "UserBlockingTaskPriority",
- "TaskScheduler.HeartbeatLatencyMicroseconds.Test."
- "UserBlockingTaskPriority_MayBlock",
- "TaskScheduler.HeartbeatLatencyMicroseconds.Test."
- "UserVisibleTaskPriority",
- "TaskScheduler.HeartbeatLatencyMicroseconds.Test."
- "UserVisibleTaskPriority_MayBlock",
- "TaskScheduler.HeartbeatLatencyMicroseconds.Test."
- "BackgroundTaskPriority",
- "TaskScheduler.HeartbeatLatencyMicroseconds.Test."
- "BackgroundTaskPriority_MayBlock"};
-
- constexpr TimeDelta kReasonableTimeout = TimeDelta::FromSeconds(6);
- constexpr TimeDelta kBusyWaitTime = TimeDelta::FromMilliseconds(100);
-
- const TimeTicks start_time = TimeTicks::Now();
-
- HistogramTester tester;
- for (const char* expected_metric : kExpectedMetrics) {
- for (int i = 0; tester.GetAllSamples(expected_metric).empty(); ++i) {
- if (TimeTicks::Now() - start_time > kReasonableTimeout)
- LOG(WARNING) << "Waiting a while for " << expected_metric;
- PlatformThread::Sleep(kBusyWaitTime);
- }
- }
-
- TaskScheduler::GetInstance()->JoinForTesting();
- TaskScheduler::SetInstance(nullptr);
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/task_scheduler_impl_unittest.cc b/base/task_scheduler/task_scheduler_impl_unittest.cc
deleted file mode 100644
index 6eee033..0000000
--- a/base/task_scheduler/task_scheduler_impl_unittest.cc
+++ /dev/null
@@ -1,823 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/task_scheduler_impl.h"
-
-#include <stddef.h>
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/debug/stack_trace.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/field_trial_params.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/scheduler_worker_observer.h"
-#include "base/task_scheduler/scheduler_worker_pool_params.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/task_scheduler/test_task_factory.h"
-#include "base/task_scheduler/test_utils.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequence_local_storage_slot.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include <unistd.h>
-
-#include "base/debug/leak_annotations.h"
-#include "base/files/file_descriptor_watcher_posix.h"
-#include "base/files/file_util.h"
-#include "base/posix/eintr_wrapper.h"
-#endif // defined(OS_POSIX)
-
-#if defined(OS_WIN)
-#include "base/win/com_init_util.h"
-#endif // defined(OS_WIN)
-
-namespace base {
-namespace internal {
-
-namespace {
-
-struct TraitsExecutionModePair {
- TraitsExecutionModePair(const TaskTraits& traits,
- test::ExecutionMode execution_mode)
- : traits(traits), execution_mode(execution_mode) {}
-
- TaskTraits traits;
- test::ExecutionMode execution_mode;
-};
-
-#if DCHECK_IS_ON()
-// Returns whether I/O calls are allowed on the current thread.
-bool GetIOAllowed() {
- const bool previous_value = ThreadRestrictions::SetIOAllowed(true);
- ThreadRestrictions::SetIOAllowed(previous_value);
- return previous_value;
-}
-#endif
-
-// Verify that the current thread priority and I/O restrictions are appropriate
-// to run a Task with |traits|.
-// Note: ExecutionMode is verified inside TestTaskFactory.
-void VerifyTaskEnvironment(const TaskTraits& traits) {
- const bool supports_background_priority =
- Lock::HandlesMultipleThreadPriorities() &&
- PlatformThread::CanIncreaseCurrentThreadPriority();
-
- EXPECT_EQ(supports_background_priority &&
- traits.priority() == TaskPriority::BACKGROUND
- ? ThreadPriority::BACKGROUND
- : ThreadPriority::NORMAL,
- PlatformThread::GetCurrentThreadPriority());
-
-#if DCHECK_IS_ON()
- // The #if above is required because GetIOAllowed() always returns true when
- // !DCHECK_IS_ON(), even when |traits| don't allow file I/O.
- EXPECT_EQ(traits.may_block(), GetIOAllowed());
-#endif
-
- // Verify that the thread the task is running on is named as expected.
- const std::string current_thread_name(PlatformThread::GetName());
- EXPECT_NE(std::string::npos, current_thread_name.find("TaskScheduler"));
- EXPECT_NE(std::string::npos,
- current_thread_name.find(
- traits.priority() == TaskPriority::BACKGROUND ? "Background"
- : "Foreground"));
- EXPECT_EQ(traits.may_block(),
- current_thread_name.find("Blocking") != std::string::npos);
-}
-
-void VerifyTaskEnvironmentAndSignalEvent(const TaskTraits& traits,
- WaitableEvent* event) {
- DCHECK(event);
- VerifyTaskEnvironment(traits);
- event->Signal();
-}
-
-void VerifyTimeAndTaskEnvironmentAndSignalEvent(const TaskTraits& traits,
- TimeTicks expected_time,
- WaitableEvent* event) {
- DCHECK(event);
- EXPECT_LE(expected_time, TimeTicks::Now());
- VerifyTaskEnvironment(traits);
- event->Signal();
-}
-
-scoped_refptr<TaskRunner> CreateTaskRunnerWithTraitsAndExecutionMode(
- TaskScheduler* scheduler,
- const TaskTraits& traits,
- test::ExecutionMode execution_mode,
- SingleThreadTaskRunnerThreadMode default_single_thread_task_runner_mode =
- SingleThreadTaskRunnerThreadMode::SHARED) {
- switch (execution_mode) {
- case test::ExecutionMode::PARALLEL:
- return scheduler->CreateTaskRunnerWithTraits(traits);
- case test::ExecutionMode::SEQUENCED:
- return scheduler->CreateSequencedTaskRunnerWithTraits(traits);
- case test::ExecutionMode::SINGLE_THREADED: {
- return scheduler->CreateSingleThreadTaskRunnerWithTraits(
- traits, default_single_thread_task_runner_mode);
- }
- }
- ADD_FAILURE() << "Unknown ExecutionMode";
- return nullptr;
-}
-
-class ThreadPostingTasks : public SimpleThread {
- public:
- // Creates a thread that posts Tasks to |scheduler| with |traits| and
- // |execution_mode|.
- ThreadPostingTasks(TaskSchedulerImpl* scheduler,
- const TaskTraits& traits,
- test::ExecutionMode execution_mode)
- : SimpleThread("ThreadPostingTasks"),
- traits_(traits),
- factory_(CreateTaskRunnerWithTraitsAndExecutionMode(scheduler,
- traits,
- execution_mode),
- execution_mode) {}
-
- void WaitForAllTasksToRun() { factory_.WaitForAllTasksToRun(); }
-
- private:
- void Run() override {
- EXPECT_FALSE(factory_.task_runner()->RunsTasksInCurrentSequence());
-
- const size_t kNumTasksPerThread = 150;
- for (size_t i = 0; i < kNumTasksPerThread; ++i) {
- factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO,
- Bind(&VerifyTaskEnvironment, traits_));
- }
- }
-
- const TaskTraits traits_;
- test::TestTaskFactory factory_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
-};
-
-// Returns a vector with a TraitsExecutionModePair for each valid
-// combination of {ExecutionMode, TaskPriority, MayBlock()}.
-std::vector<TraitsExecutionModePair> GetTraitsExecutionModePairs() {
- std::vector<TraitsExecutionModePair> params;
-
- const test::ExecutionMode execution_modes[] = {
- test::ExecutionMode::PARALLEL, test::ExecutionMode::SEQUENCED,
- test::ExecutionMode::SINGLE_THREADED};
-
- for (test::ExecutionMode execution_mode : execution_modes) {
- for (size_t priority_index = static_cast<size_t>(TaskPriority::LOWEST);
- priority_index <= static_cast<size_t>(TaskPriority::HIGHEST);
- ++priority_index) {
- const TaskPriority priority = static_cast<TaskPriority>(priority_index);
- params.push_back(TraitsExecutionModePair({priority}, execution_mode));
- params.push_back(TraitsExecutionModePair({MayBlock()}, execution_mode));
- }
- }
-
- return params;
-}
-
-class TaskSchedulerImplTest
- : public testing::TestWithParam<TraitsExecutionModePair> {
- protected:
- TaskSchedulerImplTest() : scheduler_("Test"), field_trial_list_(nullptr) {}
-
- void EnableAllTasksUserBlocking() {
- constexpr char kFieldTrialName[] = "BrowserScheduler";
- constexpr char kFieldTrialTestGroup[] = "DummyGroup";
- std::map<std::string, std::string> variation_params;
- variation_params["AllTasksUserBlocking"] = "true";
- base::AssociateFieldTrialParams(kFieldTrialName, kFieldTrialTestGroup,
- variation_params);
- base::FieldTrialList::CreateFieldTrial(kFieldTrialName,
- kFieldTrialTestGroup);
- }
-
- void set_scheduler_worker_observer(
- SchedulerWorkerObserver* scheduler_worker_observer) {
- scheduler_worker_observer_ = scheduler_worker_observer;
- }
-
- void StartTaskScheduler() {
- constexpr TimeDelta kSuggestedReclaimTime = TimeDelta::FromSeconds(30);
- constexpr int kMaxNumBackgroundThreads = 1;
- constexpr int kMaxNumBackgroundBlockingThreads = 3;
- constexpr int kMaxNumForegroundThreads = 4;
- constexpr int kMaxNumForegroundBlockingThreads = 12;
-
- scheduler_.Start(
- {{kMaxNumBackgroundThreads, kSuggestedReclaimTime},
- {kMaxNumBackgroundBlockingThreads, kSuggestedReclaimTime},
- {kMaxNumForegroundThreads, kSuggestedReclaimTime},
- {kMaxNumForegroundBlockingThreads, kSuggestedReclaimTime}},
- scheduler_worker_observer_);
- }
-
- void TearDown() override {
- if (did_tear_down_)
- return;
-
- scheduler_.FlushForTesting();
- scheduler_.JoinForTesting();
- did_tear_down_ = true;
- }
-
- TaskSchedulerImpl scheduler_;
-
- private:
- base::FieldTrialList field_trial_list_;
- SchedulerWorkerObserver* scheduler_worker_observer_ = nullptr;
- bool did_tear_down_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerImplTest);
-};
-
-} // namespace
-
-// Verifies that a Task posted via PostDelayedTaskWithTraits with parameterized
-// TaskTraits and no delay runs on a thread with the expected priority and I/O
-// restrictions. The ExecutionMode parameter is ignored by this test.
-TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsNoDelay) {
- StartTaskScheduler();
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scheduler_.PostDelayedTaskWithTraits(
- FROM_HERE, GetParam().traits,
- BindOnce(&VerifyTaskEnvironmentAndSignalEvent, GetParam().traits,
- Unretained(&task_ran)),
- TimeDelta());
- task_ran.Wait();
-}
-
-// Verifies that a Task posted via PostDelayedTaskWithTraits with parameterized
-// TaskTraits and a non-zero delay runs on a thread with the expected priority
-// and I/O restrictions after the delay expires. The ExecutionMode parameter is
-// ignored by this test.
-TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsWithDelay) {
- StartTaskScheduler();
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scheduler_.PostDelayedTaskWithTraits(
- FROM_HERE, GetParam().traits,
- BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent, GetParam().traits,
- TimeTicks::Now() + TestTimeouts::tiny_timeout(),
- Unretained(&task_ran)),
- TestTimeouts::tiny_timeout());
- task_ran.Wait();
-}
-
-// Verifies that Tasks posted via a TaskRunner with parameterized TaskTraits and
-// ExecutionMode run on a thread with the expected priority and I/O restrictions
-// and respect the characteristics of their ExecutionMode.
-TEST_P(TaskSchedulerImplTest, PostTasksViaTaskRunner) {
- StartTaskScheduler();
- test::TestTaskFactory factory(
- CreateTaskRunnerWithTraitsAndExecutionMode(&scheduler_, GetParam().traits,
- GetParam().execution_mode),
- GetParam().execution_mode);
- EXPECT_FALSE(factory.task_runner()->RunsTasksInCurrentSequence());
-
- const size_t kNumTasksPerTest = 150;
- for (size_t i = 0; i < kNumTasksPerTest; ++i) {
- factory.PostTask(test::TestTaskFactory::PostNestedTask::NO,
- Bind(&VerifyTaskEnvironment, GetParam().traits));
- }
-
- factory.WaitForAllTasksToRun();
-}
-
-// Verifies that a task posted via PostDelayedTaskWithTraits without a delay
-// doesn't run before Start() is called.
-TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsNoDelayBeforeStart) {
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scheduler_.PostDelayedTaskWithTraits(
- FROM_HERE, GetParam().traits,
- BindOnce(&VerifyTaskEnvironmentAndSignalEvent, GetParam().traits,
- Unretained(&task_running)),
- TimeDelta());
-
- // Wait a little bit to make sure that the task doesn't run before Start().
- // Note: This test won't catch a case where the task runs just after the check
- // and before Start(). However, we expect the test to be flaky if the tested
- // code allows that to happen.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(task_running.IsSignaled());
-
- StartTaskScheduler();
- task_running.Wait();
-}
-
-// Verifies that a task posted via PostDelayedTaskWithTraits with a delay
-// doesn't run before Start() is called.
-TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsWithDelayBeforeStart) {
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scheduler_.PostDelayedTaskWithTraits(
- FROM_HERE, GetParam().traits,
- BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent, GetParam().traits,
- TimeTicks::Now() + TestTimeouts::tiny_timeout(),
- Unretained(&task_running)),
- TestTimeouts::tiny_timeout());
-
- // Wait a little bit to make sure that the task doesn't run before Start().
- // Note: This test won't catch a case where the task runs just after the check
- // and before Start(). However, we expect the test to be flaky if the tested
- // code allows that to happen.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(task_running.IsSignaled());
-
- StartTaskScheduler();
- task_running.Wait();
-}
-
-// Verifies that a task posted via a TaskRunner doesn't run before Start() is
-// called.
-TEST_P(TaskSchedulerImplTest, PostTaskViaTaskRunnerBeforeStart) {
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- CreateTaskRunnerWithTraitsAndExecutionMode(&scheduler_, GetParam().traits,
- GetParam().execution_mode)
- ->PostTask(FROM_HERE,
- BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
- GetParam().traits, Unretained(&task_running)));
-
- // Wait a little bit to make sure that the task doesn't run before Start().
- // Note: This test won't catch a case where the task runs just after the check
- // and before Start(). However, we expect the test to be flaky if the tested
- // code allows that to happen.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(task_running.IsSignaled());
-
- StartTaskScheduler();
-
- // This should not hang if the task runs after Start().
- task_running.Wait();
-}
-
-// Verify that all tasks posted to a TaskRunner after Start() run in a
-// USER_BLOCKING environment when the AllTasksUserBlocking variation param of
-// the BrowserScheduler experiment is true.
-TEST_P(TaskSchedulerImplTest, AllTasksAreUserBlockingTaskRunner) {
- EnableAllTasksUserBlocking();
- StartTaskScheduler();
-
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- CreateTaskRunnerWithTraitsAndExecutionMode(&scheduler_, GetParam().traits,
- GetParam().execution_mode)
- ->PostTask(FROM_HERE,
- BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
- TaskTraits::Override(GetParam().traits,
- {TaskPriority::USER_BLOCKING}),
- Unretained(&task_running)));
- task_running.Wait();
-}
-
-// Verify that all tasks posted via PostDelayedTaskWithTraits() after Start()
-// run in a USER_BLOCKING environment when the AllTasksUserBlocking variation
-// param of the BrowserScheduler experiment is true.
-TEST_P(TaskSchedulerImplTest, AllTasksAreUserBlocking) {
- EnableAllTasksUserBlocking();
- StartTaskScheduler();
-
- WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- // Ignore |params.execution_mode| in this test.
- scheduler_.PostDelayedTaskWithTraits(
- FROM_HERE, GetParam().traits,
- BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
- TaskTraits::Override(GetParam().traits,
- {TaskPriority::USER_BLOCKING}),
- Unretained(&task_running)),
- TimeDelta());
- task_running.Wait();
-}
-
-// Verifies that FlushAsyncForTesting() calls back correctly for all trait and
-// execution mode pairs.
-TEST_P(TaskSchedulerImplTest, FlushAsyncForTestingSimple) {
- StartTaskScheduler();
-
- WaitableEvent unblock_task(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- CreateTaskRunnerWithTraitsAndExecutionMode(
- &scheduler_,
- TaskTraits::Override(GetParam().traits, {WithBaseSyncPrimitives()}),
- GetParam().execution_mode, SingleThreadTaskRunnerThreadMode::DEDICATED)
- ->PostTask(FROM_HERE,
- BindOnce(&WaitableEvent::Wait, Unretained(&unblock_task)));
-
- WaitableEvent flush_event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scheduler_.FlushAsyncForTesting(
- BindOnce(&WaitableEvent::Signal, Unretained(&flush_event)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(flush_event.IsSignaled());
-
- unblock_task.Signal();
-
- flush_event.Wait();
-}
-
-INSTANTIATE_TEST_CASE_P(OneTraitsExecutionModePair,
- TaskSchedulerImplTest,
- ::testing::ValuesIn(GetTraitsExecutionModePairs()));
-
-// Spawns threads that simultaneously post Tasks to TaskRunners with various
-// TaskTraits and ExecutionModes. Verifies that each Task runs on a thread with
-// the expected priority and I/O restrictions and respects the characteristics
-// of its ExecutionMode.
-TEST_F(TaskSchedulerImplTest, MultipleTraitsExecutionModePairs) {
- StartTaskScheduler();
- std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
- for (const auto& traits_execution_mode_pair : GetTraitsExecutionModePairs()) {
- threads_posting_tasks.push_back(WrapUnique(
- new ThreadPostingTasks(&scheduler_, traits_execution_mode_pair.traits,
- traits_execution_mode_pair.execution_mode)));
- threads_posting_tasks.back()->Start();
- }
-
- for (const auto& thread : threads_posting_tasks) {
- thread->WaitForAllTasksToRun();
- thread->Join();
- }
-}
-
-TEST_F(TaskSchedulerImplTest,
- GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated) {
- StartTaskScheduler();
- EXPECT_EQ(1, scheduler_.GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
- {TaskPriority::BACKGROUND}));
- EXPECT_EQ(3, scheduler_.GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
- {MayBlock(), TaskPriority::BACKGROUND}));
- EXPECT_EQ(4, scheduler_.GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
- {TaskPriority::USER_VISIBLE}));
- EXPECT_EQ(12, scheduler_.GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
- {MayBlock(), TaskPriority::USER_VISIBLE}));
- EXPECT_EQ(4, scheduler_.GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
- {TaskPriority::USER_BLOCKING}));
- EXPECT_EQ(12, scheduler_.GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
- {MayBlock(), TaskPriority::USER_BLOCKING}));
-}
-
-// Verify that the RunsTasksInCurrentSequence() method of a SequencedTaskRunner
-// returns false when called from a task that isn't part of the sequence.
-TEST_F(TaskSchedulerImplTest, SequencedRunsTasksInCurrentSequence) {
- StartTaskScheduler();
- auto single_thread_task_runner =
- scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- TaskTraits(), SingleThreadTaskRunnerThreadMode::SHARED);
- auto sequenced_task_runner =
- scheduler_.CreateSequencedTaskRunnerWithTraits(TaskTraits());
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- single_thread_task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](scoped_refptr<TaskRunner> sequenced_task_runner,
- WaitableEvent* task_ran) {
- EXPECT_FALSE(sequenced_task_runner->RunsTasksInCurrentSequence());
- task_ran->Signal();
- },
- sequenced_task_runner, Unretained(&task_ran)));
- task_ran.Wait();
-}
-
-// Verify that the RunsTasksInCurrentSequence() method of a
-// SingleThreadTaskRunner returns false when called from a task that isn't part
-// of the sequence.
-TEST_F(TaskSchedulerImplTest, SingleThreadRunsTasksInCurrentSequence) {
- StartTaskScheduler();
- auto sequenced_task_runner =
- scheduler_.CreateSequencedTaskRunnerWithTraits(TaskTraits());
- auto single_thread_task_runner =
- scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- TaskTraits(), SingleThreadTaskRunnerThreadMode::SHARED);
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- sequenced_task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](scoped_refptr<TaskRunner> single_thread_task_runner,
- WaitableEvent* task_ran) {
- EXPECT_FALSE(
- single_thread_task_runner->RunsTasksInCurrentSequence());
- task_ran->Signal();
- },
- single_thread_task_runner, Unretained(&task_ran)));
- task_ran.Wait();
-}
-
-#if defined(OS_WIN)
-TEST_F(TaskSchedulerImplTest, COMSTATaskRunnersRunWithCOMSTA) {
- StartTaskScheduler();
- auto com_sta_task_runner = scheduler_.CreateCOMSTATaskRunnerWithTraits(
- TaskTraits(), SingleThreadTaskRunnerThreadMode::SHARED);
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- com_sta_task_runner->PostTask(
- FROM_HERE, Bind(
- [](WaitableEvent* task_ran) {
- win::AssertComApartmentType(win::ComApartmentType::STA);
- task_ran->Signal();
- },
- Unretained(&task_ran)));
- task_ran.Wait();
-}
-#endif // defined(OS_WIN)
-
-TEST_F(TaskSchedulerImplTest, DelayedTasksNotRunAfterShutdown) {
- StartTaskScheduler();
- // As with delayed tasks in general, this is racy. If the task does happen to
- // run after Shutdown within the timeout, it will fail this test.
- //
- // The timeout should be set sufficiently long enough to ensure that the
- // delayed task did not run. 2x is generally good enough.
- //
- // A non-racy way to do this would be to post two sequenced tasks:
- // 1) Regular Post Task: A WaitableEvent.Wait
- // 2) Delayed Task: ADD_FAILURE()
- // and signalling the WaitableEvent after Shutdown() on a different thread
- // since Shutdown() will block. However, the cost of managing this extra
- // thread was deemed to be too great for the unlikely race.
- scheduler_.PostDelayedTaskWithTraits(FROM_HERE, TaskTraits(),
- BindOnce([]() { ADD_FAILURE(); }),
- TestTimeouts::tiny_timeout());
- scheduler_.Shutdown();
- PlatformThread::Sleep(TestTimeouts::tiny_timeout() * 2);
-}
-
-#if defined(OS_POSIX)
-
-TEST_F(TaskSchedulerImplTest, FileDescriptorWatcherNoOpsAfterShutdown) {
- StartTaskScheduler();
-
- int pipes[2];
- ASSERT_EQ(0, pipe(pipes));
-
- scoped_refptr<TaskRunner> blocking_task_runner =
- scheduler_.CreateSequencedTaskRunnerWithTraits(
- {TaskShutdownBehavior::BLOCK_SHUTDOWN});
- blocking_task_runner->PostTask(
- FROM_HERE,
- BindOnce(
- [](int read_fd) {
- std::unique_ptr<FileDescriptorWatcher::Controller> controller =
- FileDescriptorWatcher::WatchReadable(
- read_fd, BindRepeating([]() { NOTREACHED(); }));
-
- // This test is for components that intentionally leak their
- // watchers at shutdown. We can't clean |controller| up because its
- // destructor will assert that it's being called from the correct
- // sequence. After the task scheduler is shutdown, it is not
- // possible to run tasks on this sequence.
- //
- // Note: Do not inline the controller.release() call into the
- // ANNOTATE_LEAKING_OBJECT_PTR as the annotation is removed
- // by the preprocessor in non-LEAK_SANITIZER builds,
- // effectively breaking this test.
- ANNOTATE_LEAKING_OBJECT_PTR(controller.get());
- controller.release();
- },
- pipes[0]));
-
- scheduler_.Shutdown();
-
- constexpr char kByte = '!';
- ASSERT_TRUE(WriteFileDescriptor(pipes[1], &kByte, sizeof(kByte)));
-
- // Give a chance for the file watcher to fire before closing the handles.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-
- EXPECT_EQ(0, IGNORE_EINTR(close(pipes[0])));
- EXPECT_EQ(0, IGNORE_EINTR(close(pipes[1])));
-}
-#endif // defined(OS_POSIX)
-
-// Verify that tasks posted on the same sequence access the same values on
-// SequenceLocalStorage, and tasks on different sequences see different values.
-TEST_F(TaskSchedulerImplTest, SequenceLocalStorage) {
- StartTaskScheduler();
-
- SequenceLocalStorageSlot<int> slot;
- auto sequenced_task_runner1 =
- scheduler_.CreateSequencedTaskRunnerWithTraits(TaskTraits());
- auto sequenced_task_runner2 =
- scheduler_.CreateSequencedTaskRunnerWithTraits(TaskTraits());
-
- sequenced_task_runner1->PostTask(
- FROM_HERE,
- BindOnce([](SequenceLocalStorageSlot<int>* slot) { slot->Set(11); },
- &slot));
-
- sequenced_task_runner1->PostTask(FROM_HERE,
- BindOnce(
- [](SequenceLocalStorageSlot<int>* slot) {
- EXPECT_EQ(slot->Get(), 11);
- },
- &slot));
-
- sequenced_task_runner2->PostTask(FROM_HERE,
- BindOnce(
- [](SequenceLocalStorageSlot<int>* slot) {
- EXPECT_NE(slot->Get(), 11);
- },
- &slot));
-
- scheduler_.FlushForTesting();
-}
-
-TEST_F(TaskSchedulerImplTest, FlushAsyncNoTasks) {
- StartTaskScheduler();
- bool called_back = false;
- scheduler_.FlushAsyncForTesting(
- BindOnce([](bool* called_back) { *called_back = true; },
- Unretained(&called_back)));
- EXPECT_TRUE(called_back);
-}
-
-namespace {
-
-// Verifies that |query| is found on the current stack. Ignores failures if this
-// configuration doesn't have symbols.
-void VerifyHasStringOnStack(const std::string& query) {
- const std::string stack = debug::StackTrace().ToString();
- SCOPED_TRACE(stack);
- const bool found_on_stack = stack.find(query) != std::string::npos;
- const bool stack_has_symbols =
- stack.find("SchedulerWorker") != std::string::npos;
- EXPECT_TRUE(found_on_stack || !stack_has_symbols) << query;
-}
-
-} // namespace
-
-#if defined(OS_POSIX)
-// Many POSIX bots flakily crash on |debug::StackTrace().ToString()|,
-// https://crbug.com/840429.
-#define MAYBE_IdentifiableStacks DISABLED_IdentifiableStacks
-#else
-#define MAYBE_IdentifiableStacks IdentifiableStacks
-#endif
-
-// Integration test that verifies that workers have a frame on their stacks
-// which easily identifies the type of worker (useful to diagnose issues from
-// logs without memory dumps).
-TEST_F(TaskSchedulerImplTest, MAYBE_IdentifiableStacks) {
- StartTaskScheduler();
-
- scheduler_.CreateSequencedTaskRunnerWithTraits({})->PostTask(
- FROM_HERE, BindOnce(&VerifyHasStringOnStack, "RunPooledWorker"));
- scheduler_.CreateSequencedTaskRunnerWithTraits({TaskPriority::BACKGROUND})
- ->PostTask(FROM_HERE, BindOnce(&VerifyHasStringOnStack,
- "RunBackgroundPooledWorker"));
-
- scheduler_
- .CreateSingleThreadTaskRunnerWithTraits(
- {}, SingleThreadTaskRunnerThreadMode::SHARED)
- ->PostTask(FROM_HERE,
- BindOnce(&VerifyHasStringOnStack, "RunSharedWorker"));
- scheduler_
- .CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::BACKGROUND}, SingleThreadTaskRunnerThreadMode::SHARED)
- ->PostTask(FROM_HERE, BindOnce(&VerifyHasStringOnStack,
- "RunBackgroundSharedWorker"));
-
- scheduler_
- .CreateSingleThreadTaskRunnerWithTraits(
- {}, SingleThreadTaskRunnerThreadMode::DEDICATED)
- ->PostTask(FROM_HERE,
- BindOnce(&VerifyHasStringOnStack, "RunDedicatedWorker"));
- scheduler_
- .CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::BACKGROUND},
- SingleThreadTaskRunnerThreadMode::DEDICATED)
- ->PostTask(FROM_HERE, BindOnce(&VerifyHasStringOnStack,
- "RunBackgroundDedicatedWorker"));
-
-#if defined(OS_WIN)
- scheduler_
- .CreateCOMSTATaskRunnerWithTraits(
- {}, SingleThreadTaskRunnerThreadMode::SHARED)
- ->PostTask(FROM_HERE,
- BindOnce(&VerifyHasStringOnStack, "RunSharedCOMWorker"));
- scheduler_
- .CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::BACKGROUND}, SingleThreadTaskRunnerThreadMode::SHARED)
- ->PostTask(FROM_HERE, BindOnce(&VerifyHasStringOnStack,
- "RunBackgroundSharedCOMWorker"));
-
- scheduler_
- .CreateCOMSTATaskRunnerWithTraits(
- {}, SingleThreadTaskRunnerThreadMode::DEDICATED)
- ->PostTask(FROM_HERE,
- BindOnce(&VerifyHasStringOnStack, "RunDedicatedCOMWorker"));
- scheduler_
- .CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::BACKGROUND},
- SingleThreadTaskRunnerThreadMode::DEDICATED)
- ->PostTask(FROM_HERE, BindOnce(&VerifyHasStringOnStack,
- "RunBackgroundDedicatedCOMWorker"));
-#endif // defined(OS_WIN)
-
- scheduler_.FlushForTesting();
-}
-
-TEST_F(TaskSchedulerImplTest, SchedulerWorkerObserver) {
- testing::StrictMock<test::MockSchedulerWorkerObserver> observer;
- set_scheduler_worker_observer(&observer);
-
-// 4 workers should be created for the 4 pools. After that, 8 threads should
-// be created for single-threaded work (16 on Windows).
-#if defined(OS_WIN)
- constexpr int kExpectedNumWorkers = 20;
-#else
- constexpr int kExpectedNumWorkers = 12;
-#endif
- EXPECT_CALL(observer, OnSchedulerWorkerMainEntry())
- .Times(kExpectedNumWorkers);
-
- StartTaskScheduler();
-
- std::vector<scoped_refptr<SingleThreadTaskRunner>> task_runners;
-
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::BACKGROUND}, SingleThreadTaskRunnerThreadMode::SHARED));
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::BACKGROUND, MayBlock()},
- SingleThreadTaskRunnerThreadMode::SHARED));
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING}, SingleThreadTaskRunnerThreadMode::SHARED));
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING, MayBlock()},
- SingleThreadTaskRunnerThreadMode::SHARED));
-
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::BACKGROUND}, SingleThreadTaskRunnerThreadMode::DEDICATED));
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::BACKGROUND, MayBlock()},
- SingleThreadTaskRunnerThreadMode::DEDICATED));
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING},
- SingleThreadTaskRunnerThreadMode::DEDICATED));
- task_runners.push_back(scheduler_.CreateSingleThreadTaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING, MayBlock()},
- SingleThreadTaskRunnerThreadMode::DEDICATED));
-
-#if defined(OS_WIN)
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::BACKGROUND}, SingleThreadTaskRunnerThreadMode::SHARED));
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::BACKGROUND, MayBlock()},
- SingleThreadTaskRunnerThreadMode::SHARED));
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING}, SingleThreadTaskRunnerThreadMode::SHARED));
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING, MayBlock()},
- SingleThreadTaskRunnerThreadMode::SHARED));
-
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::BACKGROUND}, SingleThreadTaskRunnerThreadMode::DEDICATED));
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::BACKGROUND, MayBlock()},
- SingleThreadTaskRunnerThreadMode::DEDICATED));
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING},
- SingleThreadTaskRunnerThreadMode::DEDICATED));
- task_runners.push_back(scheduler_.CreateCOMSTATaskRunnerWithTraits(
- {TaskPriority::USER_BLOCKING, MayBlock()},
- SingleThreadTaskRunnerThreadMode::DEDICATED));
-#endif
-
- for (auto& task_runner : task_runners)
- task_runner->PostTask(FROM_HERE, DoNothing());
-
- EXPECT_CALL(observer, OnSchedulerWorkerMainExit()).Times(kExpectedNumWorkers);
-
- // Allow single-threaded workers to be released.
- task_runners.clear();
-
- TearDown();
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/task_tracker_posix_unittest.cc b/base/task_scheduler/task_tracker_posix_unittest.cc
deleted file mode 100644
index d8849de..0000000
--- a/base/task_scheduler/task_tracker_posix_unittest.cc
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/task_tracker_posix.h"
-
-#include <unistd.h>
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/files/file_descriptor_watcher_posix.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/run_loop.h"
-#include "base/sequence_token.h"
-#include "base/task_scheduler/task.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/task_scheduler/test_utils.h"
-#include "base/test/null_task_runner.h"
-#include "base/threading/thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class TaskSchedulerTaskTrackerPosixTest : public testing::Test {
- public:
- TaskSchedulerTaskTrackerPosixTest() : service_thread_("ServiceThread") {
- Thread::Options service_thread_options;
- service_thread_options.message_loop_type = MessageLoop::TYPE_IO;
- service_thread_.StartWithOptions(service_thread_options);
- tracker_.set_watch_file_descriptor_message_loop(
- static_cast<MessageLoopForIO*>(service_thread_.message_loop()));
- }
-
- protected:
- Thread service_thread_;
- TaskTrackerPosix tracker_ = {"Test"};
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerTaskTrackerPosixTest);
-};
-
-} // namespace
-
-// Verify that TaskTrackerPosix runs a Task it receives.
-TEST_F(TaskSchedulerTaskTrackerPosixTest, RunTask) {
- bool did_run = false;
- Task task(FROM_HERE,
- Bind([](bool* did_run) { *did_run = true; }, Unretained(&did_run)),
- TaskTraits(), TimeDelta());
-
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- auto sequence = test::CreateSequenceWithTask(std::move(task));
- EXPECT_EQ(sequence, tracker_.WillScheduleSequence(sequence, nullptr));
- // Expect RunAndPopNextTask to return nullptr since |sequence| is empty after
- // popping a task from it.
- EXPECT_FALSE(tracker_.RunAndPopNextTask(sequence, nullptr));
-
- EXPECT_TRUE(did_run);
-}
-
-// Verify that FileDescriptorWatcher::WatchReadable() can be called from a task
-// running in TaskTrackerPosix without a crash.
-TEST_F(TaskSchedulerTaskTrackerPosixTest, FileDescriptorWatcher) {
- int fds[2];
- ASSERT_EQ(0, pipe(fds));
- Task task(FROM_HERE,
- Bind(IgnoreResult(&FileDescriptorWatcher::WatchReadable), fds[0],
- DoNothing()),
- TaskTraits(), TimeDelta());
- // FileDescriptorWatcher::WatchReadable needs a SequencedTaskRunnerHandle.
- task.sequenced_task_runner_ref = MakeRefCounted<NullTaskRunner>();
-
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- auto sequence = test::CreateSequenceWithTask(std::move(task));
- EXPECT_EQ(sequence, tracker_.WillScheduleSequence(sequence, nullptr));
- // Expect RunAndPopNextTask to return nullptr since |sequence| is empty after
- // popping a task from it.
- EXPECT_FALSE(tracker_.RunAndPopNextTask(sequence, nullptr));
-
- // Join the service thread to make sure that the read watch is registered and
- // unregistered before file descriptors are closed.
- service_thread_.Stop();
-
- EXPECT_EQ(0, IGNORE_EINTR(close(fds[0])));
- EXPECT_EQ(0, IGNORE_EINTR(close(fds[1])));
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/task_tracker_unittest.cc b/base/task_scheduler/task_tracker_unittest.cc
deleted file mode 100644
index ea8a3c1..0000000
--- a/base/task_scheduler/task_tracker_unittest.cc
+++ /dev/null
@@ -1,1368 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/task_tracker.h"
-
-#include <stdint.h>
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/metrics/statistics_recorder.h"
-#include "base/sequence_token.h"
-#include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/atomic_flag.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/scheduler_lock.h"
-#include "base/task_scheduler/task.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/task_scheduler/test_utils.h"
-#include "base/test/gtest_util.h"
-#include "base/test/histogram_tester.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-constexpr size_t kLoadTestNumIterations = 75;
-
-class MockCanScheduleSequenceObserver : public CanScheduleSequenceObserver {
- public:
- void OnCanScheduleSequence(scoped_refptr<Sequence> sequence) override {
- MockOnCanScheduleSequence(sequence.get());
- }
-
- MOCK_METHOD1(MockOnCanScheduleSequence, void(Sequence*));
-};
-
-// Invokes a closure asynchronously.
-class CallbackThread : public SimpleThread {
- public:
- explicit CallbackThread(const Closure& closure)
- : SimpleThread("CallbackThread"), closure_(closure) {}
-
- // Returns true once the callback returns.
- bool has_returned() { return has_returned_.IsSet(); }
-
- private:
- void Run() override {
- closure_.Run();
- has_returned_.Set();
- }
-
- const Closure closure_;
- AtomicFlag has_returned_;
-
- DISALLOW_COPY_AND_ASSIGN(CallbackThread);
-};
-
-class ThreadPostingAndRunningTask : public SimpleThread {
- public:
- enum class Action {
- WILL_POST,
- RUN,
- WILL_POST_AND_RUN,
- };
-
- ThreadPostingAndRunningTask(TaskTracker* tracker,
- Task* task,
- Action action,
- bool expect_post_succeeds)
- : SimpleThread("ThreadPostingAndRunningTask"),
- tracker_(tracker),
- owned_task_(FROM_HERE, OnceClosure(), TaskTraits(), TimeDelta()),
- task_(task),
- action_(action),
- expect_post_succeeds_(expect_post_succeeds) {
- EXPECT_TRUE(task_);
-
- // Ownership of the Task is required to run it.
- EXPECT_NE(Action::RUN, action_);
- EXPECT_NE(Action::WILL_POST_AND_RUN, action_);
- }
-
- ThreadPostingAndRunningTask(TaskTracker* tracker,
- Task task,
- Action action,
- bool expect_post_succeeds)
- : SimpleThread("ThreadPostingAndRunningTask"),
- tracker_(tracker),
- owned_task_(std::move(task)),
- task_(&owned_task_),
- action_(action),
- expect_post_succeeds_(expect_post_succeeds) {
- EXPECT_TRUE(owned_task_.task);
- }
-
- private:
- void Run() override {
- bool post_succeeded = true;
- if (action_ == Action::WILL_POST || action_ == Action::WILL_POST_AND_RUN) {
- post_succeeded = tracker_->WillPostTask(*task_);
- EXPECT_EQ(expect_post_succeeds_, post_succeeded);
- }
- if (post_succeeded &&
- (action_ == Action::RUN || action_ == Action::WILL_POST_AND_RUN)) {
- EXPECT_TRUE(owned_task_.task);
-
- testing::StrictMock<MockCanScheduleSequenceObserver>
- never_notified_observer;
- auto sequence = tracker_->WillScheduleSequence(
- test::CreateSequenceWithTask(std::move(owned_task_)),
- &never_notified_observer);
- ASSERT_TRUE(sequence);
- // Expect RunAndPopNextTask to return nullptr since |sequence| is empty
- // after popping a task from it.
- EXPECT_FALSE(tracker_->RunAndPopNextTask(std::move(sequence),
- &never_notified_observer));
- }
- }
-
- TaskTracker* const tracker_;
- Task owned_task_;
- Task* task_;
- const Action action_;
- const bool expect_post_succeeds_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadPostingAndRunningTask);
-};
-
-class ScopedSetSingletonAllowed {
- public:
- ScopedSetSingletonAllowed(bool singleton_allowed)
- : previous_value_(
- ThreadRestrictions::SetSingletonAllowed(singleton_allowed)) {}
- ~ScopedSetSingletonAllowed() {
- ThreadRestrictions::SetSingletonAllowed(previous_value_);
- }
-
- private:
- const bool previous_value_;
-};
-
-class TaskSchedulerTaskTrackerTest
- : public testing::TestWithParam<TaskShutdownBehavior> {
- protected:
- TaskSchedulerTaskTrackerTest() = default;
-
- // Creates a task with |shutdown_behavior|.
- Task CreateTask(TaskShutdownBehavior shutdown_behavior) {
- return Task(
- FROM_HERE,
- Bind(&TaskSchedulerTaskTrackerTest::RunTaskCallback, Unretained(this)),
- TaskTraits(shutdown_behavior), TimeDelta());
- }
-
- void DispatchAndRunTaskWithTracker(Task task) {
- auto sequence = tracker_.WillScheduleSequence(
- test::CreateSequenceWithTask(std::move(task)),
- &never_notified_observer_);
- ASSERT_TRUE(sequence);
- tracker_.RunAndPopNextTask(std::move(sequence), &never_notified_observer_);
- }
-
- // Calls tracker_->Shutdown() on a new thread. When this returns, Shutdown()
- // method has been entered on the new thread, but it hasn't necessarily
- // returned.
- void CallShutdownAsync() {
- ASSERT_FALSE(thread_calling_shutdown_);
- thread_calling_shutdown_.reset(new CallbackThread(
- Bind(&TaskTracker::Shutdown, Unretained(&tracker_))));
- thread_calling_shutdown_->Start();
- while (!tracker_.HasShutdownStarted())
- PlatformThread::YieldCurrentThread();
- }
-
- void WaitForAsyncIsShutdownComplete() {
- ASSERT_TRUE(thread_calling_shutdown_);
- thread_calling_shutdown_->Join();
- EXPECT_TRUE(thread_calling_shutdown_->has_returned());
- EXPECT_TRUE(tracker_.IsShutdownComplete());
- }
-
- void VerifyAsyncShutdownInProgress() {
- ASSERT_TRUE(thread_calling_shutdown_);
- EXPECT_FALSE(thread_calling_shutdown_->has_returned());
- EXPECT_TRUE(tracker_.HasShutdownStarted());
- EXPECT_FALSE(tracker_.IsShutdownComplete());
- }
-
- // Calls tracker_->FlushForTesting() on a new thread.
- void CallFlushFromAnotherThread() {
- ASSERT_FALSE(thread_calling_flush_);
- thread_calling_flush_.reset(new CallbackThread(
- Bind(&TaskTracker::FlushForTesting, Unretained(&tracker_))));
- thread_calling_flush_->Start();
- }
-
- void WaitForAsyncFlushReturned() {
- ASSERT_TRUE(thread_calling_flush_);
- thread_calling_flush_->Join();
- EXPECT_TRUE(thread_calling_flush_->has_returned());
- }
-
- void VerifyAsyncFlushInProgress() {
- ASSERT_TRUE(thread_calling_flush_);
- EXPECT_FALSE(thread_calling_flush_->has_returned());
- }
-
- size_t NumTasksExecuted() {
- AutoSchedulerLock auto_lock(lock_);
- return num_tasks_executed_;
- }
-
- TaskTracker tracker_ = {"Test"};
- testing::StrictMock<MockCanScheduleSequenceObserver> never_notified_observer_;
-
- private:
- void RunTaskCallback() {
- AutoSchedulerLock auto_lock(lock_);
- ++num_tasks_executed_;
- }
-
- std::unique_ptr<CallbackThread> thread_calling_shutdown_;
- std::unique_ptr<CallbackThread> thread_calling_flush_;
-
- // Synchronizes accesses to |num_tasks_executed_|.
- SchedulerLock lock_;
-
- size_t num_tasks_executed_ = 0;
-
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerTaskTrackerTest);
-};
-
-#define WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED() \
- do { \
- SCOPED_TRACE(""); \
- WaitForAsyncIsShutdownComplete(); \
- } while (false)
-
-#define VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS() \
- do { \
- SCOPED_TRACE(""); \
- VerifyAsyncShutdownInProgress(); \
- } while (false)
-
-#define WAIT_FOR_ASYNC_FLUSH_RETURNED() \
- do { \
- SCOPED_TRACE(""); \
- WaitForAsyncFlushReturned(); \
- } while (false)
-
-#define VERIFY_ASYNC_FLUSH_IN_PROGRESS() \
- do { \
- SCOPED_TRACE(""); \
- VerifyAsyncFlushInProgress(); \
- } while (false)
-
-} // namespace
-
-TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunBeforeShutdown) {
- Task task(CreateTask(GetParam()));
-
- // Inform |task_tracker_| that |task| will be posted.
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- // Run the task.
- EXPECT_EQ(0U, NumTasksExecuted());
-
- DispatchAndRunTaskWithTracker(std::move(task));
- EXPECT_EQ(1U, NumTasksExecuted());
-
- // Shutdown() shouldn't block.
- tracker_.Shutdown();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {
- // Create a task that signals |task_running| and blocks until |task_barrier|
- // is signaled.
- WaitableEvent task_running(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_barrier(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- Task blocked_task(
- FROM_HERE,
- Bind(
- [](WaitableEvent* task_running, WaitableEvent* task_barrier) {
- task_running->Signal();
- task_barrier->Wait();
- },
- Unretained(&task_running), Unretained(&task_barrier)),
- TaskTraits(WithBaseSyncPrimitives(), GetParam()), TimeDelta());
-
- // Inform |task_tracker_| that |blocked_task| will be posted.
- EXPECT_TRUE(tracker_.WillPostTask(blocked_task));
-
- // Create a thread to run the task. Wait until the task starts running.
- ThreadPostingAndRunningTask thread_running_task(
- &tracker_, std::move(blocked_task),
- ThreadPostingAndRunningTask::Action::RUN, false);
- thread_running_task.Start();
- task_running.Wait();
-
- // Initiate shutdown after the task has started to run.
- CallShutdownAsync();
-
- if (GetParam() == TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
- // Shutdown should complete even with a CONTINUE_ON_SHUTDOWN in progress.
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
- } else {
- // Shutdown should block with any non CONTINUE_ON_SHUTDOWN task in progress.
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
- }
-
- // Unblock the task.
- task_barrier.Signal();
- thread_running_task.Join();
-
- // Shutdown should now complete for a non CONTINUE_ON_SHUTDOWN task.
- if (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunDuringShutdown) {
- // Inform |task_tracker_| that a task will be posted.
- Task task(CreateTask(GetParam()));
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to
- // block shutdown.
- Task block_shutdown_task(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
- EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task));
-
- // Call Shutdown() asynchronously.
- CallShutdownAsync();
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
-
- // Try to run |task|. It should only run it it's BLOCK_SHUTDOWN. Otherwise it
- // should be discarded.
- EXPECT_EQ(0U, NumTasksExecuted());
- const bool should_run = GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN;
-
- DispatchAndRunTaskWithTracker(std::move(task));
- EXPECT_EQ(should_run ? 1U : 0U, NumTasksExecuted());
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
-
- // Unblock shutdown by running the remaining BLOCK_SHUTDOWN task.
- DispatchAndRunTaskWithTracker(std::move(block_shutdown_task));
- EXPECT_EQ(should_run ? 2U : 1U, NumTasksExecuted());
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunAfterShutdown) {
- // Inform |task_tracker_| that a task will be posted.
- Task task(CreateTask(GetParam()));
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- // Call Shutdown() asynchronously.
- CallShutdownAsync();
- EXPECT_EQ(0U, NumTasksExecuted());
-
- if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
-
- // Run the task to unblock shutdown.
- DispatchAndRunTaskWithTracker(std::move(task));
- EXPECT_EQ(1U, NumTasksExecuted());
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-
- // It is not possible to test running a BLOCK_SHUTDOWN task posted before
- // shutdown after shutdown because Shutdown() won't return if there are
- // pending BLOCK_SHUTDOWN tasks.
- } else {
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-
- // The task shouldn't be allowed to run after shutdown.
- DispatchAndRunTaskWithTracker(std::move(task));
- EXPECT_EQ(0U, NumTasksExecuted());
- }
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunDuringShutdown) {
- // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to
- // block shutdown.
- Task block_shutdown_task(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
- EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task));
-
- // Call Shutdown() asynchronously.
- CallShutdownAsync();
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
-
- if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
- // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted.
- Task task(CreateTask(GetParam()));
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- // Run the BLOCK_SHUTDOWN task.
- EXPECT_EQ(0U, NumTasksExecuted());
- DispatchAndRunTaskWithTracker(std::move(task));
- EXPECT_EQ(1U, NumTasksExecuted());
- } else {
- // It shouldn't be allowed to post a non BLOCK_SHUTDOWN task.
- Task task(CreateTask(GetParam()));
- EXPECT_FALSE(tracker_.WillPostTask(task));
-
- // Don't try to run the task, because it wasn't allowed to be posted.
- }
-
- // Unblock shutdown by running |block_shutdown_task|.
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
- DispatchAndRunTaskWithTracker(std::move(block_shutdown_task));
- EXPECT_EQ(GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN ? 2U : 1U,
- NumTasksExecuted());
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, WillPostAfterShutdown) {
- tracker_.Shutdown();
-
- Task task(CreateTask(GetParam()));
-
- // |task_tracker_| shouldn't allow a task to be posted after shutdown.
- EXPECT_FALSE(tracker_.WillPostTask(task));
-}
-
-// Verify that BLOCK_SHUTDOWN and SKIP_ON_SHUTDOWN tasks can
-// AssertSingletonAllowed() but CONTINUE_ON_SHUTDOWN tasks can't.
-TEST_P(TaskSchedulerTaskTrackerTest, SingletonAllowed) {
- const bool can_use_singletons =
- (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
-
- Task task(FROM_HERE, BindOnce(&ThreadRestrictions::AssertSingletonAllowed),
- TaskTraits(GetParam()), TimeDelta());
- EXPECT_TRUE(tracker_.WillPostTask(task));
-
- // Set the singleton allowed bit to the opposite of what it is expected to be
- // when |tracker| runs |task| to verify that |tracker| actually sets the
- // correct value.
- ScopedSetSingletonAllowed scoped_singleton_allowed(!can_use_singletons);
-
- // Running the task should fail iff the task isn't allowed to use singletons.
- if (can_use_singletons) {
- DispatchAndRunTaskWithTracker(std::move(task));
- } else {
- EXPECT_DCHECK_DEATH({ DispatchAndRunTaskWithTracker(std::move(task)); });
- }
-}
-
-// Verify that AssertIOAllowed() succeeds only for a MayBlock() task.
-TEST_P(TaskSchedulerTaskTrackerTest, IOAllowed) {
- // Unset the IO allowed bit. Expect TaskTracker to set it before running a
- // task with the MayBlock() trait.
- ThreadRestrictions::SetIOAllowed(false);
- Task task_with_may_block(FROM_HERE, Bind([]() {
- // Shouldn't fail.
- AssertBlockingAllowed();
- }),
- TaskTraits(MayBlock(), GetParam()), TimeDelta());
- EXPECT_TRUE(tracker_.WillPostTask(task_with_may_block));
- DispatchAndRunTaskWithTracker(std::move(task_with_may_block));
-
- // Set the IO allowed bit. Expect TaskTracker to unset it before running a
- // task without the MayBlock() trait.
- ThreadRestrictions::SetIOAllowed(true);
- Task task_without_may_block(
- FROM_HERE,
- Bind([]() { EXPECT_DCHECK_DEATH({ AssertBlockingAllowed(); }); }),
- TaskTraits(GetParam()), TimeDelta());
- EXPECT_TRUE(tracker_.WillPostTask(task_without_may_block));
- DispatchAndRunTaskWithTracker(std::move(task_without_may_block));
-}
-
-static void RunTaskRunnerHandleVerificationTask(TaskTracker* tracker,
- Task verify_task) {
- // Pretend |verify_task| is posted to respect TaskTracker's contract.
- EXPECT_TRUE(tracker->WillPostTask(verify_task));
-
- // Confirm that the test conditions are right (no TaskRunnerHandles set
- // already).
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
-
- testing::StrictMock<MockCanScheduleSequenceObserver> never_notified_observer;
- auto sequence = tracker->WillScheduleSequence(
- test::CreateSequenceWithTask(std::move(verify_task)),
- &never_notified_observer);
- ASSERT_TRUE(sequence);
- tracker->RunAndPopNextTask(std::move(sequence), &never_notified_observer);
-
- // TaskRunnerHandle state is reset outside of task's scope.
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
-}
-
-static void VerifyNoTaskRunnerHandle() {
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, TaskRunnerHandleIsNotSetOnParallel) {
- // Create a task that will verify that TaskRunnerHandles are not set in its
- // scope per no TaskRunner ref being set to it.
- Task verify_task(FROM_HERE, BindOnce(&VerifyNoTaskRunnerHandle),
- TaskTraits(GetParam()), TimeDelta());
-
- RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
-}
-
-static void VerifySequencedTaskRunnerHandle(
- const SequencedTaskRunner* expected_task_runner) {
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
- EXPECT_EQ(expected_task_runner, SequencedTaskRunnerHandle::Get());
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest,
- SequencedTaskRunnerHandleIsSetOnSequenced) {
- scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);
-
- // Create a task that will verify that SequencedTaskRunnerHandle is properly
- // set to |test_task_runner| in its scope per |sequenced_task_runner_ref|
- // being set to it.
- Task verify_task(FROM_HERE,
- BindOnce(&VerifySequencedTaskRunnerHandle,
- Unretained(test_task_runner.get())),
- TaskTraits(GetParam()), TimeDelta());
- verify_task.sequenced_task_runner_ref = test_task_runner;
-
- RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
-}
-
-static void VerifyThreadTaskRunnerHandle(
- const SingleThreadTaskRunner* expected_task_runner) {
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- // SequencedTaskRunnerHandle inherits ThreadTaskRunnerHandle for thread.
- EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
- EXPECT_EQ(expected_task_runner, ThreadTaskRunnerHandle::Get());
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest,
- ThreadTaskRunnerHandleIsSetOnSingleThreaded) {
- scoped_refptr<SingleThreadTaskRunner> test_task_runner(
- new TestSimpleTaskRunner);
-
- // Create a task that will verify that ThreadTaskRunnerHandle is properly set
- // to |test_task_runner| in its scope per |single_thread_task_runner_ref|
- // being set on it.
- Task verify_task(FROM_HERE,
- BindOnce(&VerifyThreadTaskRunnerHandle,
- Unretained(test_task_runner.get())),
- TaskTraits(GetParam()), TimeDelta());
- verify_task.single_thread_task_runner_ref = test_task_runner;
-
- RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingDelayedTask) {
- const Task delayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta::FromDays(1));
- tracker_.WillPostTask(delayed_task);
- // FlushForTesting() should return even if the delayed task didn't run.
- tracker_.FlushForTesting();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, FlushAsyncForTestingPendingDelayedTask) {
- const Task delayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta::FromDays(1));
- tracker_.WillPostTask(delayed_task);
- // FlushAsyncForTesting() should callback even if the delayed task didn't run.
- bool called_back = false;
- tracker_.FlushAsyncForTesting(
- BindOnce([](bool* called_back) { *called_back = true; },
- Unretained(&called_back)));
- EXPECT_TRUE(called_back);
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingUndelayedTask) {
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushForTesting() shouldn't return before the undelayed task runs.
- CallFlushFromAnotherThread();
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- VERIFY_ASYNC_FLUSH_IN_PROGRESS();
-
- // FlushForTesting() should return after the undelayed task runs.
- DispatchAndRunTaskWithTracker(std::move(undelayed_task));
- WAIT_FOR_ASYNC_FLUSH_RETURNED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, FlushAsyncForTestingPendingUndelayedTask) {
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushAsyncForTesting() shouldn't callback before the undelayed task runs.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- tracker_.FlushAsyncForTesting(
- BindOnce(&WaitableEvent::Signal, Unretained(&event)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(event.IsSignaled());
-
- // FlushAsyncForTesting() should callback after the undelayed task runs.
- DispatchAndRunTaskWithTracker(std::move(undelayed_task));
- event.Wait();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, PostTaskDuringFlush) {
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushForTesting() shouldn't return before the undelayed task runs.
- CallFlushFromAnotherThread();
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- VERIFY_ASYNC_FLUSH_IN_PROGRESS();
-
- // Simulate posting another undelayed task.
- Task other_undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(other_undelayed_task);
-
- // Run the first undelayed task.
- DispatchAndRunTaskWithTracker(std::move(undelayed_task));
-
- // FlushForTesting() shouldn't return before the second undelayed task runs.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- VERIFY_ASYNC_FLUSH_IN_PROGRESS();
-
- // FlushForTesting() should return after the second undelayed task runs.
- DispatchAndRunTaskWithTracker(std::move(other_undelayed_task));
- WAIT_FOR_ASYNC_FLUSH_RETURNED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, PostTaskDuringFlushAsyncForTesting) {
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushAsyncForTesting() shouldn't callback before the undelayed task runs.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- tracker_.FlushAsyncForTesting(
- BindOnce(&WaitableEvent::Signal, Unretained(&event)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(event.IsSignaled());
-
- // Simulate posting another undelayed task.
- Task other_undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(other_undelayed_task);
-
- // Run the first undelayed task.
- DispatchAndRunTaskWithTracker(std::move(undelayed_task));
-
- // FlushAsyncForTesting() shouldn't callback before the second undelayed task
- // runs.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(event.IsSignaled());
-
- // FlushAsyncForTesting() should callback after the second undelayed task
- // runs.
- DispatchAndRunTaskWithTracker(std::move(other_undelayed_task));
- event.Wait();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, RunDelayedTaskDuringFlush) {
- // Simulate posting a delayed and an undelayed task.
- Task delayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta::FromDays(1));
- tracker_.WillPostTask(delayed_task);
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushForTesting() shouldn't return before the undelayed task runs.
- CallFlushFromAnotherThread();
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- VERIFY_ASYNC_FLUSH_IN_PROGRESS();
-
- // Run the delayed task.
- DispatchAndRunTaskWithTracker(std::move(delayed_task));
-
- // FlushForTesting() shouldn't return since there is still a pending undelayed
- // task.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- VERIFY_ASYNC_FLUSH_IN_PROGRESS();
-
- // Run the undelayed task.
- DispatchAndRunTaskWithTracker(std::move(undelayed_task));
-
- // FlushForTesting() should now return.
- WAIT_FOR_ASYNC_FLUSH_RETURNED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, RunDelayedTaskDuringFlushAsyncForTesting) {
- // Simulate posting a delayed and an undelayed task.
- Task delayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta::FromDays(1));
- tracker_.WillPostTask(delayed_task);
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushAsyncForTesting() shouldn't callback before the undelayed task runs.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- tracker_.FlushAsyncForTesting(
- BindOnce(&WaitableEvent::Signal, Unretained(&event)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(event.IsSignaled());
-
- // Run the delayed task.
- DispatchAndRunTaskWithTracker(std::move(delayed_task));
-
- // FlushAsyncForTesting() shouldn't callback since there is still a pending
- // undelayed task.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(event.IsSignaled());
-
- // Run the undelayed task.
- DispatchAndRunTaskWithTracker(std::move(undelayed_task));
-
- // FlushAsyncForTesting() should now callback.
- event.Wait();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, FlushAfterShutdown) {
- if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
- return;
-
- // Simulate posting a task.
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // Shutdown() should return immediately since there are no pending
- // BLOCK_SHUTDOWN tasks.
- tracker_.Shutdown();
-
- // FlushForTesting() should return immediately after shutdown, even if an
- // undelayed task hasn't run.
- tracker_.FlushForTesting();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, FlushAfterShutdownAsync) {
- if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
- return;
-
- // Simulate posting a task.
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // Shutdown() should return immediately since there are no pending
- // BLOCK_SHUTDOWN tasks.
- tracker_.Shutdown();
-
- // FlushForTesting() should callback immediately after shutdown, even if an
- // undelayed task hasn't run.
- bool called_back = false;
- tracker_.FlushAsyncForTesting(
- BindOnce([](bool* called_back) { *called_back = true; },
- Unretained(&called_back)));
- EXPECT_TRUE(called_back);
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlush) {
- if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
- return;
-
- // Simulate posting a task.
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushForTesting() shouldn't return before the undelayed task runs or
- // shutdown completes.
- CallFlushFromAnotherThread();
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- VERIFY_ASYNC_FLUSH_IN_PROGRESS();
-
- // Shutdown() should return immediately since there are no pending
- // BLOCK_SHUTDOWN tasks.
- tracker_.Shutdown();
-
- // FlushForTesting() should now return, even if an undelayed task hasn't run.
- WAIT_FOR_ASYNC_FLUSH_RETURNED();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlushAsyncForTesting) {
- if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
- return;
-
- // Simulate posting a task.
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushAsyncForTesting() shouldn't callback before the undelayed task runs or
- // shutdown completes.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- tracker_.FlushAsyncForTesting(
- BindOnce(&WaitableEvent::Signal, Unretained(&event)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- EXPECT_FALSE(event.IsSignaled());
-
- // Shutdown() should return immediately since there are no pending
- // BLOCK_SHUTDOWN tasks.
- tracker_.Shutdown();
-
- // FlushAsyncForTesting() should now callback, even if an undelayed task
- // hasn't run.
- event.Wait();
-}
-
-TEST_P(TaskSchedulerTaskTrackerTest, DoublePendingFlushAsyncForTestingFails) {
- Task undelayed_task(FROM_HERE, DoNothing(), TaskTraits(GetParam()),
- TimeDelta());
- tracker_.WillPostTask(undelayed_task);
-
- // FlushAsyncForTesting() shouldn't callback before the undelayed task runs.
- bool called_back = false;
- tracker_.FlushAsyncForTesting(
- BindOnce([](bool* called_back) { *called_back = true; },
- Unretained(&called_back)));
- EXPECT_FALSE(called_back);
- EXPECT_DCHECK_DEATH({ tracker_.FlushAsyncForTesting(BindOnce([]() {})); });
-}
-
-INSTANTIATE_TEST_CASE_P(
- ContinueOnShutdown,
- TaskSchedulerTaskTrackerTest,
- ::testing::Values(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
-INSTANTIATE_TEST_CASE_P(
- SkipOnShutdown,
- TaskSchedulerTaskTrackerTest,
- ::testing::Values(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
-INSTANTIATE_TEST_CASE_P(
- BlockShutdown,
- TaskSchedulerTaskTrackerTest,
- ::testing::Values(TaskShutdownBehavior::BLOCK_SHUTDOWN));
-
-namespace {
-
-void ExpectSequenceToken(SequenceToken sequence_token) {
- EXPECT_EQ(sequence_token, SequenceToken::GetForCurrentThread());
-}
-
-} // namespace
-
-// Verify that SequenceToken::GetForCurrentThread() returns the Sequence's token
-// when a Task runs.
-TEST_F(TaskSchedulerTaskTrackerTest, CurrentSequenceToken) {
- scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>();
-
- const SequenceToken sequence_token = sequence->token();
- Task task(FROM_HERE, Bind(&ExpectSequenceToken, sequence_token), TaskTraits(),
- TimeDelta());
- tracker_.WillPostTask(task);
-
- sequence->PushTask(std::move(task));
-
- EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
- sequence = tracker_.WillScheduleSequence(std::move(sequence),
- &never_notified_observer_);
- ASSERT_TRUE(sequence);
- tracker_.RunAndPopNextTask(std::move(sequence), &never_notified_observer_);
- EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
-}
-
-TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunBeforeShutdown) {
- // Post and run tasks asynchronously.
- std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
-
- for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
- threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
- ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
- threads.back()->Start();
-
- threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),
- ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
- threads.back()->Start();
-
- threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),
- ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
- threads.back()->Start();
- }
-
- for (const auto& thread : threads)
- thread->Join();
-
- // Expect all tasks to be executed.
- EXPECT_EQ(kLoadTestNumIterations * 3, NumTasksExecuted());
-
- // Should return immediately because no tasks are blocking shutdown.
- tracker_.Shutdown();
-}
-
-TEST_F(TaskSchedulerTaskTrackerTest,
- LoadWillPostBeforeShutdownAndRunDuringShutdown) {
- // Post tasks asynchronously.
- std::vector<Task> tasks_continue_on_shutdown;
- std::vector<Task> tasks_skip_on_shutdown;
- std::vector<Task> tasks_block_shutdown;
- for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
- tasks_continue_on_shutdown.push_back(
- CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
- tasks_skip_on_shutdown.push_back(
- CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
- tasks_block_shutdown.push_back(
- CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
- }
-
- std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> post_threads;
- for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
- post_threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, &tasks_continue_on_shutdown[i],
- ThreadPostingAndRunningTask::Action::WILL_POST, true));
- post_threads.back()->Start();
-
- post_threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, &tasks_skip_on_shutdown[i],
- ThreadPostingAndRunningTask::Action::WILL_POST, true));
- post_threads.back()->Start();
-
- post_threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, &tasks_block_shutdown[i],
- ThreadPostingAndRunningTask::Action::WILL_POST, true));
- post_threads.back()->Start();
- }
-
- for (const auto& thread : post_threads)
- thread->Join();
-
- // Call Shutdown() asynchronously.
- CallShutdownAsync();
-
- // Run tasks asynchronously.
- std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> run_threads;
- for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
- run_threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, std::move(tasks_continue_on_shutdown[i]),
- ThreadPostingAndRunningTask::Action::RUN, false));
- run_threads.back()->Start();
-
- run_threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, std::move(tasks_skip_on_shutdown[i]),
- ThreadPostingAndRunningTask::Action::RUN, false));
- run_threads.back()->Start();
-
- run_threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, std::move(tasks_block_shutdown[i]),
- ThreadPostingAndRunningTask::Action::RUN, false));
- run_threads.back()->Start();
- }
-
- for (const auto& thread : run_threads)
- thread->Join();
-
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-
- // Expect BLOCK_SHUTDOWN tasks to have been executed.
- EXPECT_EQ(kLoadTestNumIterations, NumTasksExecuted());
-}
-
-TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunDuringShutdown) {
- // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to
- // block shutdown.
- Task block_shutdown_task(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
- EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task));
-
- // Call Shutdown() asynchronously.
- CallShutdownAsync();
-
- // Post and run tasks asynchronously.
- std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
-
- for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
- threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
- ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));
- threads.back()->Start();
-
- threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),
- ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));
- threads.back()->Start();
-
- threads.push_back(std::make_unique<ThreadPostingAndRunningTask>(
- &tracker_, CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),
- ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
- threads.back()->Start();
- }
-
- for (const auto& thread : threads)
- thread->Join();
-
- // Expect BLOCK_SHUTDOWN tasks to have been executed.
- EXPECT_EQ(kLoadTestNumIterations, NumTasksExecuted());
-
- // Shutdown() shouldn't return before |block_shutdown_task| is executed.
- VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
-
- // Unblock shutdown by running |block_shutdown_task|.
- DispatchAndRunTaskWithTracker(std::move(block_shutdown_task));
- EXPECT_EQ(kLoadTestNumIterations + 1, NumTasksExecuted());
- WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
-}
-
-// Verify that RunAndPopNextTask() returns the sequence from which it ran a task
-// when it can be rescheduled.
-TEST_F(TaskSchedulerTaskTrackerTest,
- RunAndPopNextTaskReturnsSequenceToReschedule) {
- Task task_1(FROM_HERE, DoNothing(), TaskTraits(), TimeDelta());
- EXPECT_TRUE(tracker_.WillPostTask(task_1));
- Task task_2(FROM_HERE, DoNothing(), TaskTraits(), TimeDelta());
- EXPECT_TRUE(tracker_.WillPostTask(task_2));
-
- scoped_refptr<Sequence> sequence =
- test::CreateSequenceWithTask(std::move(task_1));
- sequence->PushTask(std::move(task_2));
- EXPECT_EQ(sequence, tracker_.WillScheduleSequence(sequence, nullptr));
-
- EXPECT_EQ(sequence, tracker_.RunAndPopNextTask(sequence, nullptr));
-}
-
-// Verify that WillScheduleSequence() returns nullptr when it receives a
-// background sequence and the maximum number of background sequences that can
-// be scheduled concurrently is reached. Verify that an observer is notified
-// when a background sequence can be scheduled (i.e. when one of the previously
-// scheduled background sequences has run).
-TEST_F(TaskSchedulerTaskTrackerTest,
- WillScheduleBackgroundSequenceWithMaxBackgroundSequences) {
- constexpr int kMaxNumScheduledBackgroundSequences = 2;
- TaskTracker tracker("Test", kMaxNumScheduledBackgroundSequences);
-
- // Simulate posting |kMaxNumScheduledBackgroundSequences| background tasks
- // and scheduling the associated sequences. This should succeed.
- std::vector<scoped_refptr<Sequence>> scheduled_sequences;
- testing::StrictMock<MockCanScheduleSequenceObserver> never_notified_observer;
- for (int i = 0; i < kMaxNumScheduledBackgroundSequences; ++i) {
- Task task(FROM_HERE, DoNothing(), TaskTraits(TaskPriority::BACKGROUND),
- TimeDelta());
- EXPECT_TRUE(tracker.WillPostTask(task));
- scoped_refptr<Sequence> sequence =
- test::CreateSequenceWithTask(std::move(task));
- EXPECT_EQ(sequence,
- tracker.WillScheduleSequence(sequence, &never_notified_observer));
- scheduled_sequences.push_back(std::move(sequence));
- }
-
- // Simulate posting extra background tasks and scheduling the associated
- // sequences. This should fail because the maximum number of background
- // sequences that can be scheduled concurrently is already reached.
- std::vector<std::unique_ptr<bool>> extra_tasks_did_run;
- std::vector<
- std::unique_ptr<testing::StrictMock<MockCanScheduleSequenceObserver>>>
- extra_observers;
- std::vector<scoped_refptr<Sequence>> extra_sequences;
- for (int i = 0; i < kMaxNumScheduledBackgroundSequences; ++i) {
- extra_tasks_did_run.push_back(std::make_unique<bool>());
- Task extra_task(
- FROM_HERE,
- BindOnce([](bool* extra_task_did_run) { *extra_task_did_run = true; },
- Unretained(extra_tasks_did_run.back().get())),
- TaskTraits(TaskPriority::BACKGROUND), TimeDelta());
- EXPECT_TRUE(tracker.WillPostTask(extra_task));
- extra_sequences.push_back(
- test::CreateSequenceWithTask(std::move(extra_task)));
- extra_observers.push_back(
- std::make_unique<
- testing::StrictMock<MockCanScheduleSequenceObserver>>());
- EXPECT_EQ(nullptr,
- tracker.WillScheduleSequence(extra_sequences.back(),
- extra_observers.back().get()));
- }
-
- // Run the sequences scheduled at the beginning of the test. Expect an
- // observer from |extra_observer| to be notified every time a task finishes to
- // run.
- for (int i = 0; i < kMaxNumScheduledBackgroundSequences; ++i) {
- EXPECT_CALL(*extra_observers[i].get(),
- MockOnCanScheduleSequence(extra_sequences[i].get()));
- EXPECT_FALSE(tracker.RunAndPopNextTask(scheduled_sequences[i],
- &never_notified_observer));
- testing::Mock::VerifyAndClear(extra_observers[i].get());
- }
-
- // Run the extra sequences.
- for (int i = 0; i < kMaxNumScheduledBackgroundSequences; ++i) {
- EXPECT_FALSE(*extra_tasks_did_run[i]);
- EXPECT_FALSE(tracker.RunAndPopNextTask(extra_sequences[i],
- &never_notified_observer));
- EXPECT_TRUE(*extra_tasks_did_run[i]);
- }
-}
-
-namespace {
-
-void SetBool(bool* arg) {
- ASSERT_TRUE(arg);
- EXPECT_FALSE(*arg);
- *arg = true;
-}
-
-} // namespace
-
-// Verify that RunAndPopNextTask() doesn't reschedule the background sequence it
-// was assigned if there is a preempted background sequence with an earlier
-// sequence time (compared to the next task in the sequence assigned to
-// RunAndPopNextTask()).
-TEST_F(TaskSchedulerTaskTrackerTest,
- RunNextBackgroundTaskWithEarlierPendingBackgroundTask) {
- constexpr int kMaxNumScheduledBackgroundSequences = 1;
- TaskTracker tracker("Test", kMaxNumScheduledBackgroundSequences);
- testing::StrictMock<MockCanScheduleSequenceObserver> never_notified_observer;
-
- // Simulate posting a background task and scheduling the associated sequence.
- // This should succeed.
- bool task_a_1_did_run = false;
- Task task_a_1(FROM_HERE, BindOnce(&SetBool, Unretained(&task_a_1_did_run)),
- TaskTraits(TaskPriority::BACKGROUND), TimeDelta());
- EXPECT_TRUE(tracker.WillPostTask(task_a_1));
- scoped_refptr<Sequence> sequence_a =
- test::CreateSequenceWithTask(std::move(task_a_1));
- EXPECT_EQ(sequence_a,
- tracker.WillScheduleSequence(sequence_a, &never_notified_observer));
-
- // Simulate posting an extra background task and scheduling the associated
- // sequence. This should fail because the maximum number of background
- // sequences that can be scheduled concurrently is already reached.
- bool task_b_1_did_run = false;
- Task task_b_1(FROM_HERE, BindOnce(&SetBool, Unretained(&task_b_1_did_run)),
- TaskTraits(TaskPriority::BACKGROUND), TimeDelta());
- EXPECT_TRUE(tracker.WillPostTask(task_b_1));
- scoped_refptr<Sequence> sequence_b =
- test::CreateSequenceWithTask(std::move(task_b_1));
- testing::StrictMock<MockCanScheduleSequenceObserver> task_b_1_observer;
- EXPECT_FALSE(tracker.WillScheduleSequence(sequence_b, &task_b_1_observer));
-
- // Wait to be sure that the sequence time of |task_a_2| is after the sequenced
- // time of |task_b_1|.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-
- // Post an extra background task in |sequence_a|.
- bool task_a_2_did_run = false;
- Task task_a_2(FROM_HERE, BindOnce(&SetBool, Unretained(&task_a_2_did_run)),
- TaskTraits(TaskPriority::BACKGROUND), TimeDelta());
- EXPECT_TRUE(tracker.WillPostTask(task_a_2));
- sequence_a->PushTask(std::move(task_a_2));
-
- // Run the first task in |sequence_a|. RunAndPopNextTask() should return
- // nullptr since |sequence_a| can't be rescheduled immediately.
- // |task_b_1_observer| should be notified that |sequence_b| can be scheduled.
- testing::StrictMock<MockCanScheduleSequenceObserver> task_a_2_observer;
- EXPECT_CALL(task_b_1_observer, MockOnCanScheduleSequence(sequence_b.get()));
- EXPECT_FALSE(tracker.RunAndPopNextTask(sequence_a, &task_a_2_observer));
- testing::Mock::VerifyAndClear(&task_b_1_observer);
- EXPECT_TRUE(task_a_1_did_run);
-
- // Run the first task in |sequence_b|. RunAndPopNextTask() should return
- // nullptr since |sequence_b| is empty after popping a task from it.
- // |task_a_2_observer| should be notified that |sequence_a| can be
- // scheduled.
- EXPECT_CALL(task_a_2_observer, MockOnCanScheduleSequence(sequence_a.get()));
- EXPECT_FALSE(tracker.RunAndPopNextTask(sequence_b, &never_notified_observer));
- testing::Mock::VerifyAndClear(&task_a_2_observer);
- EXPECT_TRUE(task_b_1_did_run);
-
- // Run the first task in |sequence_a|. RunAndPopNextTask() should return
- // nullptr since |sequence_b| is empty after popping a task from it. No
- // observer should be notified.
- EXPECT_FALSE(tracker.RunAndPopNextTask(sequence_a, &never_notified_observer));
- EXPECT_TRUE(task_a_2_did_run);
-}
-
-// Verify that preempted background sequences are scheduled when shutdown
-// starts.
-TEST_F(TaskSchedulerTaskTrackerTest,
- SchedulePreemptedBackgroundSequencesOnShutdown) {
- constexpr int kMaxNumScheduledBackgroundSequences = 0;
- TaskTracker tracker("Test", kMaxNumScheduledBackgroundSequences);
- testing::StrictMock<MockCanScheduleSequenceObserver> observer;
-
- // Simulate scheduling sequences. TaskTracker should prevent this.
- std::vector<scoped_refptr<Sequence>> preempted_sequences;
- for (int i = 0; i < 3; ++i) {
- Task task(FROM_HERE, DoNothing(),
- TaskTraits(TaskPriority::BACKGROUND,
- TaskShutdownBehavior::BLOCK_SHUTDOWN),
- TimeDelta());
- EXPECT_TRUE(tracker.WillPostTask(task));
- scoped_refptr<Sequence> sequence =
- test::CreateSequenceWithTask(std::move(task));
- EXPECT_FALSE(tracker.WillScheduleSequence(sequence, &observer));
- preempted_sequences.push_back(std::move(sequence));
-
- // Wait to be sure that tasks have different |sequenced_time|.
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- }
-
- // Perform shutdown. Expect |preempted_sequences| to be scheduled in posting
- // order.
- {
- testing::InSequence in_sequence;
- for (auto& preempted_sequence : preempted_sequences) {
- EXPECT_CALL(observer, MockOnCanScheduleSequence(preempted_sequence.get()))
- .WillOnce(testing::Invoke([&tracker](Sequence* sequence) {
- // Run the task to unblock shutdown.
- tracker.RunAndPopNextTask(sequence, nullptr);
- }));
- }
- tracker.Shutdown();
- }
-}
-
-namespace {
-
-class WaitAllowedTestThread : public SimpleThread {
- public:
- WaitAllowedTestThread() : SimpleThread("WaitAllowedTestThread") {}
-
- private:
- void Run() override {
- auto task_tracker = std::make_unique<TaskTracker>("Test");
-
- // Waiting is allowed by default. Expect TaskTracker to disallow it before
- // running a task without the WithBaseSyncPrimitives() trait.
- internal::AssertBaseSyncPrimitivesAllowed();
- Task task_without_sync_primitives(
- FROM_HERE, Bind([]() {
- EXPECT_DCHECK_DEATH({ internal::AssertBaseSyncPrimitivesAllowed(); });
- }),
- TaskTraits(), TimeDelta());
- EXPECT_TRUE(task_tracker->WillPostTask(task_without_sync_primitives));
- testing::StrictMock<MockCanScheduleSequenceObserver>
- never_notified_observer;
- auto sequence_without_sync_primitives = task_tracker->WillScheduleSequence(
- test::CreateSequenceWithTask(std::move(task_without_sync_primitives)),
- &never_notified_observer);
- ASSERT_TRUE(sequence_without_sync_primitives);
- task_tracker->RunAndPopNextTask(std::move(sequence_without_sync_primitives),
- &never_notified_observer);
-
- // Disallow waiting. Expect TaskTracker to allow it before running a task
- // with the WithBaseSyncPrimitives() trait.
- ThreadRestrictions::DisallowWaiting();
- Task task_with_sync_primitives(
- FROM_HERE, Bind([]() {
- // Shouldn't fail.
- internal::AssertBaseSyncPrimitivesAllowed();
- }),
- TaskTraits(WithBaseSyncPrimitives()), TimeDelta());
- EXPECT_TRUE(task_tracker->WillPostTask(task_with_sync_primitives));
- auto sequence_with_sync_primitives = task_tracker->WillScheduleSequence(
- test::CreateSequenceWithTask(std::move(task_with_sync_primitives)),
- &never_notified_observer);
- ASSERT_TRUE(sequence_with_sync_primitives);
- task_tracker->RunAndPopNextTask(std::move(sequence_with_sync_primitives),
- &never_notified_observer);
-
- ScopedAllowBaseSyncPrimitivesForTesting
- allow_wait_in_task_tracker_destructor;
- task_tracker.reset();
- }
-
- DISALLOW_COPY_AND_ASSIGN(WaitAllowedTestThread);
-};
-
-} // namespace
-
-// Verify that AssertIOAllowed() succeeds only for a WithBaseSyncPrimitives()
-// task.
-TEST(TaskSchedulerTaskTrackerWaitAllowedTest, WaitAllowed) {
- // Run the test on the separate thread since it is not possible to reset the
- // "wait allowed" bit of a thread without being a friend of
- // ThreadRestrictions.
- testing::GTEST_FLAG(death_test_style) = "threadsafe";
- WaitAllowedTestThread wait_allowed_test_thread;
- wait_allowed_test_thread.Start();
- wait_allowed_test_thread.Join();
-}
-
-// Verify that TaskScheduler.TaskLatency.* histograms are correctly recorded
-// when a task runs.
-TEST(TaskSchedulerTaskTrackerHistogramTest, TaskLatency) {
- auto statistics_recorder = StatisticsRecorder::CreateTemporaryForTesting();
-
- TaskTracker tracker("Test");
- testing::StrictMock<MockCanScheduleSequenceObserver> never_notified_observer;
-
- struct {
- const TaskTraits traits;
- const char* const expected_histogram;
- } static constexpr kTests[] = {
- {{TaskPriority::BACKGROUND},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "BackgroundTaskPriority"},
- {{MayBlock(), TaskPriority::BACKGROUND},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "BackgroundTaskPriority_MayBlock"},
- {{WithBaseSyncPrimitives(), TaskPriority::BACKGROUND},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "BackgroundTaskPriority_MayBlock"},
- {{TaskPriority::USER_VISIBLE},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "UserVisibleTaskPriority"},
- {{MayBlock(), TaskPriority::USER_VISIBLE},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "UserVisibleTaskPriority_MayBlock"},
- {{WithBaseSyncPrimitives(), TaskPriority::USER_VISIBLE},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "UserVisibleTaskPriority_MayBlock"},
- {{TaskPriority::USER_BLOCKING},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "UserBlockingTaskPriority"},
- {{MayBlock(), TaskPriority::USER_BLOCKING},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "UserBlockingTaskPriority_MayBlock"},
- {{WithBaseSyncPrimitives(), TaskPriority::USER_BLOCKING},
- "TaskScheduler.TaskLatencyMicroseconds.Test."
- "UserBlockingTaskPriority_MayBlock"}};
-
- for (const auto& test : kTests) {
- Task task(FROM_HERE, DoNothing(), test.traits, TimeDelta());
- ASSERT_TRUE(tracker.WillPostTask(task));
-
- HistogramTester tester;
-
- auto sequence = tracker.WillScheduleSequence(
- test::CreateSequenceWithTask(std::move(task)),
- &never_notified_observer);
- ASSERT_TRUE(sequence);
- tracker.RunAndPopNextTask(std::move(sequence), &never_notified_observer);
- tester.ExpectTotalCount(test.expected_histogram, 1);
- }
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/task_traits_unittest.cc b/base/task_scheduler/task_traits_unittest.cc
deleted file mode 100644
index 2a35048..0000000
--- a/base/task_scheduler/task_traits_unittest.cc
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2017 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 "base/task_scheduler/task_traits.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(TaskSchedulerTaskTraitsTest, Default) {
- constexpr TaskTraits traits = {};
- EXPECT_FALSE(traits.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, traits.priority());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN, traits.shutdown_behavior());
- EXPECT_FALSE(traits.may_block());
- EXPECT_FALSE(traits.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, TaskPriority) {
- constexpr TaskTraits traits = {TaskPriority::BACKGROUND};
- EXPECT_TRUE(traits.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::BACKGROUND, traits.priority());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN, traits.shutdown_behavior());
- EXPECT_FALSE(traits.may_block());
- EXPECT_FALSE(traits.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, TaskShutdownBehavior) {
- constexpr TaskTraits traits = {TaskShutdownBehavior::BLOCK_SHUTDOWN};
- EXPECT_FALSE(traits.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, traits.priority());
- EXPECT_EQ(TaskShutdownBehavior::BLOCK_SHUTDOWN, traits.shutdown_behavior());
- EXPECT_FALSE(traits.may_block());
- EXPECT_FALSE(traits.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, MayBlock) {
- constexpr TaskTraits traits = {MayBlock()};
- EXPECT_FALSE(traits.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, traits.priority());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN, traits.shutdown_behavior());
- EXPECT_TRUE(traits.may_block());
- EXPECT_FALSE(traits.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, WithBaseSyncPrimitives) {
- constexpr TaskTraits traits = {WithBaseSyncPrimitives()};
- EXPECT_FALSE(traits.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, traits.priority());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN, traits.shutdown_behavior());
- EXPECT_FALSE(traits.may_block());
- EXPECT_TRUE(traits.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, MultipleTraits) {
- constexpr TaskTraits traits = {TaskPriority::BACKGROUND,
- TaskShutdownBehavior::BLOCK_SHUTDOWN,
- MayBlock(), WithBaseSyncPrimitives()};
- EXPECT_TRUE(traits.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::BACKGROUND, traits.priority());
- EXPECT_EQ(TaskShutdownBehavior::BLOCK_SHUTDOWN, traits.shutdown_behavior());
- EXPECT_TRUE(traits.may_block());
- EXPECT_TRUE(traits.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, Copy) {
- constexpr TaskTraits traits = {TaskPriority::BACKGROUND,
- TaskShutdownBehavior::BLOCK_SHUTDOWN,
- MayBlock(), WithBaseSyncPrimitives()};
- constexpr TaskTraits traits_copy(traits);
- EXPECT_EQ(traits.priority_set_explicitly(),
- traits_copy.priority_set_explicitly());
- EXPECT_EQ(traits.priority(), traits_copy.priority());
- EXPECT_EQ(traits.shutdown_behavior(), traits_copy.shutdown_behavior());
- EXPECT_EQ(traits.may_block(), traits_copy.may_block());
- EXPECT_EQ(traits.with_base_sync_primitives(),
- traits_copy.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, OverridePriority) {
- constexpr TaskTraits left = {TaskPriority::BACKGROUND};
- constexpr TaskTraits right = {TaskPriority::USER_BLOCKING};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_TRUE(overridden.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_BLOCKING, overridden.priority());
- EXPECT_FALSE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- overridden.shutdown_behavior());
- EXPECT_FALSE(overridden.may_block());
- EXPECT_FALSE(overridden.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, OverrideShutdownBehavior) {
- constexpr TaskTraits left = {TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN};
- constexpr TaskTraits right = {TaskShutdownBehavior::BLOCK_SHUTDOWN};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_FALSE(overridden.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, overridden.priority());
- EXPECT_TRUE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(TaskShutdownBehavior::BLOCK_SHUTDOWN,
- overridden.shutdown_behavior());
- EXPECT_FALSE(overridden.may_block());
- EXPECT_FALSE(overridden.with_base_sync_primitives());
-}
-
-TEST(TaskSchedulerTaskTraitsTest, OverrideMayBlock) {
- {
- constexpr TaskTraits left = {MayBlock()};
- constexpr TaskTraits right = {};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_FALSE(overridden.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, overridden.priority());
- EXPECT_FALSE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- overridden.shutdown_behavior());
- EXPECT_TRUE(overridden.may_block());
- EXPECT_FALSE(overridden.with_base_sync_primitives());
- }
- {
- constexpr TaskTraits left = {};
- constexpr TaskTraits right = {MayBlock()};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_FALSE(overridden.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, overridden.priority());
- EXPECT_FALSE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- overridden.shutdown_behavior());
- EXPECT_TRUE(overridden.may_block());
- EXPECT_FALSE(overridden.with_base_sync_primitives());
- }
-}
-
-TEST(TaskSchedulerTaskTraitsTest, OverrideWithBaseSyncPrimitives) {
- {
- constexpr TaskTraits left = {WithBaseSyncPrimitives()};
- constexpr TaskTraits right = {};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_FALSE(overridden.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, overridden.priority());
- EXPECT_FALSE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- overridden.shutdown_behavior());
- EXPECT_FALSE(overridden.may_block());
- EXPECT_TRUE(overridden.with_base_sync_primitives());
- }
- {
- constexpr TaskTraits left = {};
- constexpr TaskTraits right = {WithBaseSyncPrimitives()};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_FALSE(overridden.priority_set_explicitly());
- EXPECT_EQ(TaskPriority::USER_VISIBLE, overridden.priority());
- EXPECT_FALSE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- overridden.shutdown_behavior());
- EXPECT_FALSE(overridden.may_block());
- EXPECT_TRUE(overridden.with_base_sync_primitives());
- }
-}
-
-TEST(TaskSchedulerTaskTraitsTest, OverrideMultipleTraits) {
- constexpr TaskTraits left = {MayBlock(), TaskPriority::BACKGROUND,
- TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN};
- constexpr TaskTraits right = {WithBaseSyncPrimitives(),
- TaskPriority::USER_BLOCKING};
- constexpr TaskTraits overridden = TaskTraits::Override(left, right);
- EXPECT_TRUE(overridden.priority_set_explicitly());
- EXPECT_EQ(right.priority(), overridden.priority());
- EXPECT_TRUE(overridden.shutdown_behavior_set_explicitly());
- EXPECT_EQ(left.shutdown_behavior(), overridden.shutdown_behavior());
- EXPECT_TRUE(overridden.may_block());
- EXPECT_TRUE(overridden.with_base_sync_primitives());
-}
-
-} // namespace base
diff --git a/base/task_scheduler/task_traits_unittest.nc b/base/task_scheduler/task_traits_unittest.nc
deleted file mode 100644
index 97f9c4b..0000000
--- a/base/task_scheduler/task_traits_unittest.nc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2017 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 is a "No Compile Test" suite.
-// http://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/task_scheduler/task_traits.h"
-
-namespace base {
-
-#if defined(NCTEST_TASK_TRAITS_MULTIPLE_MAY_BLOCK) // [r"Multiple arguments of the same type were provided to the constructor of TaskTraits."]
-constexpr TaskTraits traits = {MayBlock(), MayBlock()};
-#elif defined(NCTEST_TASK_TRAITS_MULTIPLE_WITH_BASE_SYNC_PRIMITIVES) // [r"Multiple arguments of the same type were provided to the constructor of TaskTraits."]
-constexpr TaskTraits traits = {WithBaseSyncPrimitives(),
- WithBaseSyncPrimitives()};
-#elif defined(NCTEST_TASK_TRAITS_MULTIPLE_TASK_PRIORITY) // [r"Multiple arguments of the same type were provided to the constructor of TaskTraits."]
-constexpr TaskTraits traits = {TaskPriority::BACKGROUND,
- TaskPriority::USER_BLOCKING};
-#elif defined(NCTEST_TASK_TRAITS_MULTIPLE_SHUTDOWN_BEHAVIOR) // [r"Multiple arguments of the same type were provided to the constructor of TaskTraits."]
-constexpr TaskTraits traits = {TaskShutdownBehavior::BLOCK_SHUTDOWN,
- TaskShutdownBehavior::BLOCK_SHUTDOWN};
-#elif defined(NCTEST_TASK_TRAITS_MULTIPLE_SAME_TYPE_MIX) // [r"Multiple arguments of the same type were provided to the constructor of TaskTraits."]
-constexpr TaskTraits traits = {TaskShutdownBehavior::BLOCK_SHUTDOWN,
- MayBlock(),
- TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN};
-#elif defined(NCTEST_TASK_TRAITS_INVALID_TYPE) // [r"no matching constructor for initialization of 'const base::TaskTraits'"]
-constexpr TaskTraits traits = {TaskShutdownBehavior::BLOCK_SHUTDOWN, true};
-#endif
-
-} // namespace base
diff --git a/base/task_scheduler/task_unittest.cc b/base/task_scheduler/task_unittest.cc
deleted file mode 100644
index 31a59de..0000000
--- a/base/task_scheduler/task_unittest.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2016 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 "base/task_scheduler/task.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/task_scheduler/task_traits.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-// Verify that the shutdown behavior of a BLOCK_SHUTDOWN delayed task is
-// adjusted to SKIP_ON_SHUTDOWN. The shutown behavior of other delayed tasks
-// should not change.
-TEST(TaskSchedulerTaskTest, ShutdownBehaviorChangeWithDelay) {
- Task continue_on_shutdown(FROM_HERE, DoNothing(),
- {TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
- TimeDelta::FromSeconds(1));
- EXPECT_EQ(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
- continue_on_shutdown.traits.shutdown_behavior());
-
- Task skip_on_shutdown(FROM_HERE, DoNothing(),
- {TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
- TimeDelta::FromSeconds(1));
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- skip_on_shutdown.traits.shutdown_behavior());
-
- Task block_shutdown(FROM_HERE, DoNothing(),
- {TaskShutdownBehavior::BLOCK_SHUTDOWN},
- TimeDelta::FromSeconds(1));
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- block_shutdown.traits.shutdown_behavior());
-}
-
-// Verify that the shutdown behavior of undelayed tasks is not adjusted.
-TEST(TaskSchedulerTaskTest, NoShutdownBehaviorChangeNoDelay) {
- Task continue_on_shutdown(FROM_HERE, DoNothing(),
- {TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
- TimeDelta());
- EXPECT_EQ(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
- continue_on_shutdown.traits.shutdown_behavior());
-
- Task skip_on_shutdown(FROM_HERE, DoNothing(),
- {TaskShutdownBehavior::SKIP_ON_SHUTDOWN}, TimeDelta());
- EXPECT_EQ(TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
- skip_on_shutdown.traits.shutdown_behavior());
-
- Task block_shutdown(FROM_HERE, DoNothing(),
- {TaskShutdownBehavior::BLOCK_SHUTDOWN}, TimeDelta());
- EXPECT_EQ(TaskShutdownBehavior::BLOCK_SHUTDOWN,
- block_shutdown.traits.shutdown_behavior());
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/task_scheduler/tracked_ref_unittest.cc b/base/task_scheduler/tracked_ref_unittest.cc
deleted file mode 100644
index b793c07..0000000
--- a/base/task_scheduler/tracked_ref_unittest.cc
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2018 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 "base/task_scheduler/tracked_ref.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/macros.h"
-#include "base/synchronization/atomic_flag.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class ObjectWithTrackedRefs {
- public:
- ObjectWithTrackedRefs() : tracked_ref_factory_(this) {}
- ~ObjectWithTrackedRefs() { under_destruction_.Set(); }
-
- TrackedRef<ObjectWithTrackedRefs> GetTrackedRef() {
- return tracked_ref_factory_.GetTrackedRef();
- }
-
- bool under_destruction() const { return under_destruction_.IsSet(); }
-
- private:
- // True once ~ObjectWithTrackedRefs() has been initiated.
- AtomicFlag under_destruction_;
-
- TrackedRefFactory<ObjectWithTrackedRefs> tracked_ref_factory_;
-
- DISALLOW_COPY_AND_ASSIGN(ObjectWithTrackedRefs);
-};
-
-} // namespace
-
-// Test that an object with a TrackedRefFactory can be destroyed by a single
-// owner but that its destruction will be blocked on the TrackedRefs being
-// released.
-TEST(TrackedRefTest, TrackedRefObjectDeletion) {
- Thread thread("TrackedRefTestThread");
- thread.Start();
-
- std::unique_ptr<ObjectWithTrackedRefs> obj =
- std::make_unique<ObjectWithTrackedRefs>();
-
- TimeTicks begin = TimeTicks::Now();
-
- thread.task_runner()->PostDelayedTask(
- FROM_HERE,
- BindOnce(
- [](TrackedRef<ObjectWithTrackedRefs> obj) {
- // By the time this kicks in, the object should already be under
- // destruction, but blocked on this TrackedRef being released. This
- // is technically racy (main thread has to run |obj.reset()| and
- // this thread has to observe the side-effects before this delayed
- // task fires). If this ever flakes this expectation could be turned
- // into a while(!obj->under_destruction()); but until that's proven
- // flaky in practice, this expectation is more readable and
- // diagnosable then a hang.
- EXPECT_TRUE(obj->under_destruction());
- },
- obj->GetTrackedRef()),
- TestTimeouts::tiny_timeout());
-
- // This should kick off destruction but block until the above task resolves
- // and releases the TrackedRef.
- obj.reset();
- EXPECT_GE(TimeTicks::Now() - begin, TestTimeouts::tiny_timeout());
-}
-
-TEST(TrackedRefTest, ManyThreadsRacing) {
- constexpr int kNumThreads = 16;
- std::vector<std::unique_ptr<Thread>> threads;
- for (int i = 0; i < kNumThreads; ++i) {
- threads.push_back(std::make_unique<Thread>("TrackedRefTestThread"));
- threads.back()->StartAndWaitForTesting();
- }
-
- std::unique_ptr<ObjectWithTrackedRefs> obj =
- std::make_unique<ObjectWithTrackedRefs>();
-
- // Send a TrackedRef to each thread.
- for (auto& thread : threads) {
- thread->task_runner()->PostTask(
- FROM_HERE, BindOnce(
- [](TrackedRef<ObjectWithTrackedRefs> obj) {
- // Confirm it's still safe to
- // dereference |obj| (and, bonus, that
- // playing with TrackedRefs some more
- // isn't problematic).
- EXPECT_TRUE(obj->GetTrackedRef());
- },
- obj->GetTrackedRef()));
- }
-
- // Initiate destruction racily with the above tasks' execution (they will
- // crash if TrackedRefs aren't WAI).
- obj.reset();
-}
-
-// Test that instantiating and deleting a TrackedRefFactory without ever taking
-// a TrackedRef on it is fine.
-TEST(TrackedRefTest, NoTrackedRefs) {
- ObjectWithTrackedRefs obj;
-}
-
-namespace {
-void ConsumesTrackedRef(TrackedRef<ObjectWithTrackedRefs> obj) {}
-} // namespace
-
-// Test that destroying a TrackedRefFactory which had TrackedRefs in the past
-// that are already gone is WAI.
-TEST(TrackedRefTest, NoPendingTrackedRefs) {
- ObjectWithTrackedRefs obj;
- ConsumesTrackedRef(obj.GetTrackedRef());
-}
-
-TEST(TrackedRefTest, CopyAndMoveSemantics) {
- struct Foo {
- Foo() : factory(this) {}
- TrackedRefFactory<Foo> factory;
- };
- Foo foo;
-
- EXPECT_EQ(1, foo.factory.live_tracked_refs_.SubtleRefCountForDebug());
-
- {
- TrackedRef<Foo> plain = foo.factory.GetTrackedRef();
- EXPECT_EQ(2, foo.factory.live_tracked_refs_.SubtleRefCountForDebug());
-
- TrackedRef<Foo> copy_constructed(plain);
- EXPECT_EQ(3, foo.factory.live_tracked_refs_.SubtleRefCountForDebug());
-
- TrackedRef<Foo> moved_constructed(std::move(copy_constructed));
- EXPECT_EQ(3, foo.factory.live_tracked_refs_.SubtleRefCountForDebug());
- }
-
- EXPECT_EQ(1, foo.factory.live_tracked_refs_.SubtleRefCountForDebug());
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/template_util_unittest.cc b/base/template_util_unittest.cc
deleted file mode 100644
index 2c42445..0000000
--- a/base/template_util_unittest.cc
+++ /dev/null
@@ -1,106 +0,0 @@
-// 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.
-
-#include "base/template_util.h"
-
-#include <string>
-
-#include "base/containers/flat_tree.h"
-#include "base/test/move_only_int.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-enum SimpleEnum { SIMPLE_ENUM };
-enum EnumWithExplicitType : uint64_t { ENUM_WITH_EXPLICIT_TYPE };
-enum class ScopedEnum { SCOPED_ENUM };
-enum class ScopedEnumWithOperator { SCOPED_ENUM_WITH_OPERATOR };
-std::ostream& operator<<(std::ostream& os, ScopedEnumWithOperator v) {
- return os;
-}
-struct SimpleStruct {};
-struct StructWithOperator {};
-std::ostream& operator<<(std::ostream& os, const StructWithOperator& v) {
- return os;
-}
-
-// is_non_const_reference<Type>
-static_assert(!is_non_const_reference<int>::value, "IsNonConstReference");
-static_assert(!is_non_const_reference<const int&>::value,
- "IsNonConstReference");
-static_assert(is_non_const_reference<int&>::value, "IsNonConstReference");
-
-// A few standard types that definitely support printing.
-static_assert(internal::SupportsOstreamOperator<int>::value,
- "ints should be printable");
-static_assert(internal::SupportsOstreamOperator<const char*>::value,
- "C strings should be printable");
-static_assert(internal::SupportsOstreamOperator<std::string>::value,
- "std::string should be printable");
-
-// Various kinds of enums operator<< support.
-static_assert(internal::SupportsOstreamOperator<SimpleEnum>::value,
- "simple enum should be printable by value");
-static_assert(internal::SupportsOstreamOperator<const SimpleEnum&>::value,
- "simple enum should be printable by const ref");
-static_assert(internal::SupportsOstreamOperator<EnumWithExplicitType>::value,
- "enum with explicit type should be printable by value");
-static_assert(
- internal::SupportsOstreamOperator<const EnumWithExplicitType&>::value,
- "enum with explicit type should be printable by const ref");
-static_assert(!internal::SupportsOstreamOperator<ScopedEnum>::value,
- "scoped enum should not be printable by value");
-static_assert(!internal::SupportsOstreamOperator<const ScopedEnum&>::value,
- "simple enum should not be printable by const ref");
-static_assert(internal::SupportsOstreamOperator<ScopedEnumWithOperator>::value,
- "scoped enum with operator<< should be printable by value");
-static_assert(
- internal::SupportsOstreamOperator<const ScopedEnumWithOperator&>::value,
- "scoped enum with operator<< should be printable by const ref");
-
-// operator<< support on structs.
-static_assert(!internal::SupportsOstreamOperator<SimpleStruct>::value,
- "simple struct should not be printable by value");
-static_assert(!internal::SupportsOstreamOperator<const SimpleStruct&>::value,
- "simple struct should not be printable by const ref");
-static_assert(internal::SupportsOstreamOperator<StructWithOperator>::value,
- "struct with operator<< should be printable by value");
-static_assert(
- internal::SupportsOstreamOperator<const StructWithOperator&>::value,
- "struct with operator<< should be printable by const ref");
-
-// base::is_trivially_copyable
-class TrivialCopy {
- public:
- TrivialCopy(int d) : data_(d) {}
-
- protected:
- int data_;
-};
-
-class TrivialCopyButWithDestructor : public TrivialCopy {
- public:
- TrivialCopyButWithDestructor(int d) : TrivialCopy(d) {}
- ~TrivialCopyButWithDestructor() { data_ = 0; }
-};
-
-static_assert(base::is_trivially_copyable<TrivialCopy>::value,
- "TrivialCopy should be detected as trivially copyable");
-static_assert(!base::is_trivially_copyable<TrivialCopyButWithDestructor>::value,
- "TrivialCopyButWithDestructor should not be detected as "
- "trivially copyable");
-
-class NoCopy {
- public:
- NoCopy(const NoCopy&) = delete;
-};
-
-static_assert(
- !base::is_trivially_copy_constructible<std::vector<NoCopy>>::value,
- "is_trivially_copy_constructible<std::vector<T>> must be compiled.");
-
-} // namespace
-
-} // namespace base
diff --git a/base/test/BUILD.gn b/base/test/BUILD.gn
deleted file mode 100644
index 576729c..0000000
--- a/base/test/BUILD.gn
+++ /dev/null
@@ -1,443 +0,0 @@
-# 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.
-
-import("//build/compiled_action.gni")
-import("//build/config/ui.gni")
-import("//build/config/nacl/config.gni")
-
-if (is_android) {
- import("//build/config/android/rules.gni")
-}
-
-static_library("test_config") {
- testonly = true
- sources = [
- "test_switches.cc",
- "test_switches.h",
- "test_timeouts.cc",
- "test_timeouts.h",
- ]
- deps = [
- "//base",
- ]
-}
-
-static_library("test_support") {
- testonly = true
- sources = [
- "../trace_event/trace_config_memory_test_util.h",
- "android/java_handler_thread_helpers.cc",
- "android/java_handler_thread_helpers.h",
- "android/url_utils.cc",
- "android/url_utils.h",
- "bind_test_util.h",
- "copy_only_int.h",
- "fuzzed_data_provider.cc",
- "fuzzed_data_provider.h",
- "gtest_util.cc",
- "gtest_util.h",
- "gtest_xml_unittest_result_printer.cc",
- "gtest_xml_unittest_result_printer.h",
- "gtest_xml_util.cc",
- "gtest_xml_util.h",
- "histogram_tester.cc",
- "histogram_tester.h",
- "icu_test_util.cc",
- "icu_test_util.h",
- "ios/wait_util.h",
- "ios/wait_util.mm",
- "launcher/test_result.cc",
- "launcher/test_result.h",
- "launcher/test_results_tracker.h",
- "launcher/unit_test_launcher.h",
- "mock_callback.h",
- "mock_chrome_application_mac.h",
- "mock_chrome_application_mac.mm",
- "mock_devices_changed_observer.cc",
- "mock_devices_changed_observer.h",
- "mock_entropy_provider.cc",
- "mock_entropy_provider.h",
- "mock_log.cc",
- "mock_log.h",
- "move_only_int.h",
- "multiprocess_test.h",
- "multiprocess_test_android.cc",
- "null_task_runner.cc",
- "null_task_runner.h",
- "perf_log.cc",
- "perf_log.h",
- "perf_test_suite.cc",
- "perf_test_suite.h",
- "perf_time_logger.cc",
- "perf_time_logger.h",
- "power_monitor_test_base.cc",
- "power_monitor_test_base.h",
- "scoped_command_line.cc",
- "scoped_command_line.h",
- "scoped_environment_variable_override.cc",
- "scoped_environment_variable_override.h",
- "scoped_feature_list.cc",
- "scoped_feature_list.h",
- "scoped_mock_time_message_loop_task_runner.cc",
- "scoped_mock_time_message_loop_task_runner.h",
- "scoped_path_override.cc",
- "scoped_path_override.h",
- "scoped_task_environment.cc",
- "scoped_task_environment.h",
- "sequenced_task_runner_test_template.cc",
- "sequenced_task_runner_test_template.h",
- "simple_test_clock.cc",
- "simple_test_clock.h",
- "simple_test_tick_clock.cc",
- "simple_test_tick_clock.h",
- "task_runner_test_template.cc",
- "task_runner_test_template.h",
- "test_discardable_memory_allocator.cc",
- "test_discardable_memory_allocator.h",
- "test_file_util.cc",
- "test_file_util.h",
- "test_file_util_android.cc",
- "test_file_util_linux.cc",
- "test_file_util_mac.cc",
- "test_file_util_win.cc",
- "test_io_thread.cc",
- "test_io_thread.h",
- "test_listener_ios.h",
- "test_listener_ios.mm",
- "test_message_loop.cc",
- "test_message_loop.h",
- "test_mock_time_task_runner.cc",
- "test_mock_time_task_runner.h",
- "test_pending_task.cc",
- "test_pending_task.h",
- "test_reg_util_win.cc",
- "test_reg_util_win.h",
- "test_shared_memory_util.cc",
- "test_shared_memory_util.h",
- "test_shortcut_win.cc",
- "test_shortcut_win.h",
- "test_simple_task_runner.cc",
- "test_simple_task_runner.h",
- "test_suite.cc",
- "test_suite.h",
- "test_support_android.cc",
- "test_support_android.h",
- "test_support_ios.h",
- "test_support_ios.mm",
- "test_ui_thread_android.cc",
- "test_ui_thread_android.h",
- "thread_test_helper.cc",
- "thread_test_helper.h",
- "trace_event_analyzer.cc",
- "trace_event_analyzer.h",
- "trace_to_file.cc",
- "trace_to_file.h",
- "user_action_tester.cc",
- "user_action_tester.h",
- "values_test_util.cc",
- "values_test_util.h",
- ]
-
- if (is_ios) {
- sources += [ "launcher/unit_test_launcher_ios.cc" ]
- } else if (!is_nacl_nonsfi) {
- sources += [
- "launcher/test_launcher.cc",
- "launcher/test_launcher.h",
- "launcher/test_launcher_tracer.cc",
- "launcher/test_launcher_tracer.h",
- "launcher/test_results_tracker.cc",
- "launcher/unit_test_launcher.cc",
- "multiprocess_test.cc",
- ]
- }
-
- configs += [ "//build/config:precompiled_headers" ]
-
- data = [
- # The isolate needs this script for setting up the test. It's not actually
- # needed to run this target locally.
- "//testing/test_env.py",
- ]
-
- public_deps = [
- ":test_config",
- "//base",
- "//base:base_static",
- "//base:i18n",
- ]
- deps = [
- "//base/third_party/dynamic_annotations",
- "//testing/gmock",
- "//testing/gtest",
- "//third_party/icu:icuuc",
- "//third_party/libxml",
- ]
-
- if (is_posix || is_fuchsia) {
- sources += [
- "scoped_locale.cc",
- "scoped_locale.h",
- "test_file_util_posix.cc",
- ]
- }
-
- if (is_linux) {
- public_deps += [ ":fontconfig_util_linux" ]
- data_deps = [
- "//third_party/test_fonts",
- ]
- if (current_toolchain == host_toolchain) {
- data_deps += [ ":do_generate_fontconfig_caches" ]
- data += [ "$root_out_dir/fontconfig_caches/" ]
- }
- }
-
- if (is_ios) {
- set_sources_assignment_filter([])
- sources += [ "test_file_util_mac.cc" ]
- set_sources_assignment_filter(sources_assignment_filter)
- }
-
- if (is_mac) {
- libs = [ "AppKit.framework" ]
- }
-
- if (is_android) {
- set_sources_assignment_filter([])
- sources += [ "test_file_util_linux.cc" ]
- set_sources_assignment_filter(sources_assignment_filter)
- deps += [
- ":base_unittests_jni_headers",
- ":test_support_jni_headers",
- ]
- public_deps += [ ":test_support_java" ]
- }
-
- if (is_nacl_nonsfi) {
- sources += [
- "launcher/test_launcher.h",
- "launcher/test_result.h",
- "launcher/unit_test_launcher.h",
- "launcher/unit_test_launcher_nacl_nonsfi.cc",
- ]
- sources -= [
- "gtest_xml_util.cc",
- "gtest_xml_util.h",
- "icu_test_util.cc",
- "icu_test_util.h",
- "perf_test_suite.cc",
- "perf_test_suite.h",
- "scoped_path_override.cc",
- "scoped_path_override.h",
- "test_discardable_memory_allocator.cc",
- "test_discardable_memory_allocator.h",
- "test_file_util.cc",
- "test_file_util.h",
- "test_file_util_posix.cc",
- "test_suite.cc",
- "test_suite.h",
- "trace_to_file.cc",
- "trace_to_file.h",
- ]
- public_deps -= [ "//base:i18n" ]
- deps -= [
- "//third_party/icu:icuuc",
- "//third_party/libxml",
- ]
- }
-}
-
-config("perf_test_config") {
- defines = [ "PERF_TEST" ]
-}
-
-# This is a source set instead of a static library because it seems like some
-# linkers get confused when "main" is in a static library, and if you link to
-# this, you always want the object file anyway.
-source_set("test_support_perf") {
- testonly = true
- sources = [
- "run_all_perftests.cc",
- ]
- deps = [
- ":test_support",
- "//base",
- "//testing/gtest",
- ]
-
- public_configs = [ ":perf_test_config" ]
-}
-
-static_library("test_launcher_nacl_nonsfi") {
- testonly = true
- sources = [
- "launcher/test_launcher_nacl_nonsfi.cc",
- "launcher/test_launcher_nacl_nonsfi.h",
- ]
- deps = [
- ":test_support",
- ]
-}
-
-static_library("run_all_unittests") {
- testonly = true
- sources = [
- "run_all_unittests.cc",
- ]
- deps = [
- ":test_support",
- ]
-}
-
-# These sources are linked into both the base_unittests binary and the test
-# shared library target below.
-source_set("native_library_test_utils") {
- testonly = true
- sources = [
- "native_library_test_utils.cc",
- "native_library_test_utils.h",
- ]
-}
-
-# This shared library is dynamically loaded by NativeLibrary unittests.
-shared_library("test_shared_library") {
- testonly = true
- sources = [
- "test_shared_library.cc",
- ]
-
- deps = [
- ":native_library_test_utils",
- ]
-}
-
-static_library("run_all_base_unittests") {
- # Only targets in base should depend on this, targets outside base
- # should depend on run_all_unittests above.
- visibility = [ "//base/*" ]
- testonly = true
- sources = [
- "run_all_base_unittests.cc",
- ]
- deps = [
- ":test_support",
- ]
-}
-
-if (is_linux) {
- source_set("fontconfig_util_linux") {
- sources = [
- "fontconfig_util_linux.cc",
- "fontconfig_util_linux.h",
- ]
- deps = [
- "//base",
- "//third_party/fontconfig",
- ]
- }
-
- if (current_toolchain == host_toolchain) {
- executable("generate_fontconfig_caches") {
- testonly = true
- sources = [
- "generate_fontconfig_caches.cc",
- ]
- deps = [
- ":fontconfig_util_linux",
- "//base",
- "//build/config:exe_and_shlib_deps",
- ]
- }
-
- compiled_action("do_generate_fontconfig_caches") {
- testonly = true
- tool = ":generate_fontconfig_caches"
- data_deps = [
- "//third_party/test_fonts",
- ]
- args = []
- outputs = [
- "$root_out_dir/fontconfig_caches/STAMP",
- ]
- }
- }
-
- shared_library("malloc_wrapper") {
- testonly = true
- sources = [
- "malloc_wrapper.cc",
- ]
- deps = [
- "//base",
- "//build/config:exe_and_shlib_deps",
- ]
- }
-}
-
-if (is_android) {
- generate_jni("base_unittests_jni_headers") {
- sources = [
- "android/java/src/org/chromium/base/ContentUriTestUtils.java",
- "android/java/src/org/chromium/base/JavaHandlerThreadHelpers.java",
- "android/java/src/org/chromium/base/TestUiThread.java",
- ]
- jni_package = "base"
- }
-
- generate_jni("test_support_jni_headers") {
- sources = [
- "android/java/src/org/chromium/base/MainReturnCodeResult.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientLauncher.java",
- "android/javatests/src/org/chromium/base/test/util/UrlUtils.java",
- ]
- jni_package = "base"
- }
-
- android_library("test_support_java") {
- testonly = true
- deps = [
- "//base:base_java",
- "//testing/android/native_test:native_main_runner_java",
- "//third_party/android_tools:android_support_annotations_java",
- "//third_party/jsr-305:jsr_305_javalib",
- ]
- srcjar_deps = [ ":test_support_java_aidl" ]
- java_files = [
- "android/java/src/org/chromium/base/MainReturnCodeResult.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientLauncher.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientService.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientService0.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientService1.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientService2.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientService3.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientService4.java",
- "android/java/src/org/chromium/base/MultiprocessTestClientServiceDelegate.java",
- ]
- }
-
- android_aidl("test_support_java_aidl") {
- testonly = true
- import_include = [
- "android/java/src",
- "//base/android/java/src",
- ]
- sources = [
- "android/java/src/org/chromium/base/ITestCallback.aidl",
- "android/java/src/org/chromium/base/ITestController.aidl",
- ]
- }
-}
-
-# Trivial executable which outputs space-delimited argv to stdout,
-# used for testing.
-executable("test_child_process") {
- testonly = true
- sources = [
- "test_child_process.cc",
- ]
- deps = [
- "//build/config:exe_and_shlib_deps",
- ]
-}
diff --git a/base/test/histogram_tester_unittest.cc b/base/test/histogram_tester_unittest.cc
deleted file mode 100644
index e49ed97..0000000
--- a/base/test/histogram_tester_unittest.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2014 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 "base/test/histogram_tester.h"
-
-#include <memory>
-
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/histogram_samples.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::ElementsAre;
-using ::testing::IsEmpty;
-
-namespace {
-
-const char kHistogram1[] = "Test1";
-const char kHistogram2[] = "Test2";
-const char kHistogram3[] = "Test3";
-const char kHistogram4[] = "Test4";
-const char kHistogram5[] = "Test5";
-
-} // namespace
-
-namespace base {
-
-typedef testing::Test HistogramTesterTest;
-
-TEST_F(HistogramTesterTest, Scope) {
- // Record a histogram before the creation of the recorder.
- UMA_HISTOGRAM_BOOLEAN(kHistogram1, true);
-
- HistogramTester tester;
-
- // Verify that no histogram is recorded.
- tester.ExpectTotalCount(kHistogram1, 0);
-
- // Record a histogram after the creation of the recorder.
- UMA_HISTOGRAM_BOOLEAN(kHistogram1, true);
-
- // Verify that one histogram is recorded.
- std::unique_ptr<HistogramSamples> samples(
- tester.GetHistogramSamplesSinceCreation(kHistogram1));
- EXPECT_TRUE(samples);
- EXPECT_EQ(1, samples->TotalCount());
-}
-
-TEST_F(HistogramTesterTest, GetHistogramSamplesSinceCreationNotNull) {
- // Chose the histogram name uniquely, to ensure nothing was recorded for it so
- // far.
- static const char kHistogram[] =
- "GetHistogramSamplesSinceCreationNotNullHistogram";
- HistogramTester tester;
-
- // Verify that the returned samples are empty but not null.
- std::unique_ptr<HistogramSamples> samples(
- tester.GetHistogramSamplesSinceCreation(kHistogram1));
- EXPECT_TRUE(samples);
- tester.ExpectTotalCount(kHistogram, 0);
-}
-
-TEST_F(HistogramTesterTest, TestUniqueSample) {
- HistogramTester tester;
-
- // Record into a sample thrice
- UMA_HISTOGRAM_COUNTS_100(kHistogram2, 2);
- UMA_HISTOGRAM_COUNTS_100(kHistogram2, 2);
- UMA_HISTOGRAM_COUNTS_100(kHistogram2, 2);
-
- tester.ExpectUniqueSample(kHistogram2, 2, 3);
-}
-
-TEST_F(HistogramTesterTest, TestBucketsSample) {
- HistogramTester tester;
-
- // Record into a sample twice
- UMA_HISTOGRAM_COUNTS_100(kHistogram3, 2);
- UMA_HISTOGRAM_COUNTS_100(kHistogram3, 2);
- UMA_HISTOGRAM_COUNTS_100(kHistogram3, 2);
- UMA_HISTOGRAM_COUNTS_100(kHistogram3, 2);
- UMA_HISTOGRAM_COUNTS_100(kHistogram3, 3);
-
- tester.ExpectBucketCount(kHistogram3, 2, 4);
- tester.ExpectBucketCount(kHistogram3, 3, 1);
-
- tester.ExpectTotalCount(kHistogram3, 5);
-}
-
-TEST_F(HistogramTesterTest, TestBucketsSampleWithScope) {
- // Record into a sample twice, once before the tester creation and once after.
- UMA_HISTOGRAM_COUNTS_100(kHistogram4, 2);
-
- HistogramTester tester;
- UMA_HISTOGRAM_COUNTS_100(kHistogram4, 3);
-
- tester.ExpectBucketCount(kHistogram4, 2, 0);
- tester.ExpectBucketCount(kHistogram4, 3, 1);
-
- tester.ExpectTotalCount(kHistogram4, 1);
-}
-
-TEST_F(HistogramTesterTest, TestGetAllSamples) {
- HistogramTester tester;
- UMA_HISTOGRAM_ENUMERATION(kHistogram5, 2, 5);
- UMA_HISTOGRAM_ENUMERATION(kHistogram5, 3, 5);
- UMA_HISTOGRAM_ENUMERATION(kHistogram5, 3, 5);
- UMA_HISTOGRAM_ENUMERATION(kHistogram5, 5, 5);
-
- EXPECT_THAT(tester.GetAllSamples(kHistogram5),
- ElementsAre(Bucket(2, 1), Bucket(3, 2), Bucket(5, 1)));
-}
-
-TEST_F(HistogramTesterTest, TestGetAllSamples_NoSamples) {
- HistogramTester tester;
- EXPECT_THAT(tester.GetAllSamples(kHistogram5), IsEmpty());
-}
-
-TEST_F(HistogramTesterTest, TestGetTotalCountsForPrefix) {
- HistogramTester tester;
- UMA_HISTOGRAM_ENUMERATION("Test1.Test2.Test3", 2, 5);
-
- // Regression check for bug https://crbug.com/659977.
- EXPECT_TRUE(tester.GetTotalCountsForPrefix("Test2.").empty());
-
- EXPECT_EQ(1u, tester.GetTotalCountsForPrefix("Test1.").size());
-}
-
-} // namespace base
diff --git a/base/test/mock_callback_unittest.cc b/base/test/mock_callback_unittest.cc
deleted file mode 100644
index c5f109f..0000000
--- a/base/test/mock_callback_unittest.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2017 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 "base/test/mock_callback.h"
-
-#include "base/callback.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-using testing::InSequence;
-using testing::Return;
-
-namespace base {
-namespace {
-
-TEST(MockCallbackTest, ZeroArgs) {
- MockCallback<Closure> mock_closure;
- EXPECT_CALL(mock_closure, Run());
- mock_closure.Get().Run();
-
- MockCallback<Callback<int()>> mock_int_callback;
- {
- InSequence sequence;
- EXPECT_CALL(mock_int_callback, Run()).WillOnce(Return(42));
- EXPECT_CALL(mock_int_callback, Run()).WillOnce(Return(88));
- }
- EXPECT_EQ(42, mock_int_callback.Get().Run());
- EXPECT_EQ(88, mock_int_callback.Get().Run());
-}
-
-TEST(MockCallbackTest, WithArgs) {
- MockCallback<Callback<int(int, int)>> mock_two_int_callback;
- EXPECT_CALL(mock_two_int_callback, Run(1, 2)).WillOnce(Return(42));
- EXPECT_CALL(mock_two_int_callback, Run(0, 0)).WillRepeatedly(Return(-1));
- Callback<int(int, int)> two_int_callback = mock_two_int_callback.Get();
- EXPECT_EQ(-1, two_int_callback.Run(0, 0));
- EXPECT_EQ(42, two_int_callback.Run(1, 2));
- EXPECT_EQ(-1, two_int_callback.Run(0, 0));
-}
-
-TEST(MockCallbackTest, ZeroArgsOnce) {
- MockCallback<OnceClosure> mock_closure;
- EXPECT_CALL(mock_closure, Run());
- mock_closure.Get().Run();
-
- MockCallback<OnceCallback<int()>> mock_int_callback;
- EXPECT_CALL(mock_int_callback, Run()).WillOnce(Return(88));
- EXPECT_EQ(88, mock_int_callback.Get().Run());
-}
-
-TEST(MockCallbackTest, WithArgsOnce) {
- MockCallback<OnceCallback<int(int, int)>> mock_two_int_callback;
- EXPECT_CALL(mock_two_int_callback, Run(1, 2)).WillOnce(Return(42));
- OnceCallback<int(int, int)> two_int_callback = mock_two_int_callback.Get();
- EXPECT_EQ(42, std::move(two_int_callback).Run(1, 2));
-}
-
-} // namespace
-} // namespace base
diff --git a/base/test/scoped_feature_list_unittest.cc b/base/test/scoped_feature_list_unittest.cc
deleted file mode 100644
index 03d9897..0000000
--- a/base/test/scoped_feature_list_unittest.cc
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright 2017 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 "base/test/scoped_feature_list.h"
-
-#include <map>
-#include <string>
-#include <utility>
-
-#include "base/metrics/field_trial.h"
-#include "base/metrics/field_trial_params.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace test {
-
-namespace {
-
-const Feature kTestFeature1{"TestFeature1", FEATURE_DISABLED_BY_DEFAULT};
-const Feature kTestFeature2{"TestFeature2", FEATURE_DISABLED_BY_DEFAULT};
-
-void ExpectFeatures(const std::string& enabled_features,
- const std::string& disabled_features) {
- FeatureList* list = FeatureList::GetInstance();
- std::string actual_enabled_features;
- std::string actual_disabled_features;
-
- list->GetFeatureOverrides(&actual_enabled_features,
- &actual_disabled_features);
-
- EXPECT_EQ(enabled_features, actual_enabled_features);
- EXPECT_EQ(disabled_features, actual_disabled_features);
-}
-
-} // namespace
-
-class ScopedFeatureListTest : public testing::Test {
- public:
- ScopedFeatureListTest() {
- // Clear default feature list.
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- feature_list->InitializeFromCommandLine(std::string(), std::string());
- original_feature_list_ = FeatureList::ClearInstanceForTesting();
- FeatureList::SetInstance(std::move(feature_list));
- }
-
- ~ScopedFeatureListTest() override {
- // Restore feature list.
- if (original_feature_list_) {
- FeatureList::ClearInstanceForTesting();
- FeatureList::RestoreInstanceForTesting(std::move(original_feature_list_));
- }
- }
-
- private:
- // Save the present FeatureList and restore it after test finish.
- std::unique_ptr<FeatureList> original_feature_list_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedFeatureListTest);
-};
-
-TEST_F(ScopedFeatureListTest, BasicScoped) {
- ExpectFeatures(std::string(), std::string());
- EXPECT_FALSE(FeatureList::IsEnabled(kTestFeature1));
- {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitFromCommandLine("TestFeature1", std::string());
- ExpectFeatures("TestFeature1", std::string());
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- }
- ExpectFeatures(std::string(), std::string());
- EXPECT_FALSE(FeatureList::IsEnabled(kTestFeature1));
-}
-
-TEST_F(ScopedFeatureListTest, EnableWithFeatureParameters) {
- const char kParam1[] = "param_1";
- const char kParam2[] = "param_2";
- const char kValue1[] = "value_1";
- const char kValue2[] = "value_2";
- std::map<std::string, std::string> parameters;
- parameters[kParam1] = kValue1;
- parameters[kParam2] = kValue2;
-
- ExpectFeatures(std::string(), std::string());
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam1));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam2));
- FieldTrial::ActiveGroups active_groups;
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_EQ(0u, active_groups.size());
-
- {
- test::ScopedFeatureList feature_list;
-
- feature_list.InitAndEnableFeatureWithParameters(kTestFeature1, parameters);
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_EQ(kValue1,
- GetFieldTrialParamValueByFeature(kTestFeature1, kParam1));
- EXPECT_EQ(kValue2,
- GetFieldTrialParamValueByFeature(kTestFeature1, kParam2));
- active_groups.clear();
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_EQ(1u, active_groups.size());
- }
-
- ExpectFeatures(std::string(), std::string());
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam1));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam2));
- active_groups.clear();
- FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
- EXPECT_EQ(0u, active_groups.size());
-}
-
-TEST_F(ScopedFeatureListTest, OverrideWithFeatureParameters) {
- FieldTrialList field_trial_list(nullptr);
- scoped_refptr<FieldTrial> trial =
- FieldTrialList::CreateFieldTrial("foo", "bar");
- const char kParam[] = "param_1";
- const char kValue[] = "value_1";
- std::map<std::string, std::string> parameters;
- parameters[kParam] = kValue;
-
- test::ScopedFeatureList feature_list1;
- feature_list1.InitFromCommandLine("TestFeature1<foo,TestFeature2",
- std::string());
-
- // Check initial state.
- ExpectFeatures("TestFeature1<foo,TestFeature2", std::string());
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature2));
- EXPECT_EQ(trial.get(), FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kTestFeature2));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature2, kParam));
-
- {
- // Override feature with existing field trial.
- test::ScopedFeatureList feature_list2;
-
- feature_list2.InitAndEnableFeatureWithParameters(kTestFeature1, parameters);
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature2));
- EXPECT_EQ(kValue, GetFieldTrialParamValueByFeature(kTestFeature1, kParam));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature2, kParam));
- EXPECT_NE(trial.get(), FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_NE(nullptr, FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kTestFeature2));
- }
-
- // Check that initial state is restored.
- ExpectFeatures("TestFeature1<foo,TestFeature2", std::string());
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature2));
- EXPECT_EQ(trial.get(), FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kTestFeature2));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature2, kParam));
-
- {
- // Override feature with no existing field trial.
- test::ScopedFeatureList feature_list2;
-
- feature_list2.InitAndEnableFeatureWithParameters(kTestFeature2, parameters);
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature2));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam));
- EXPECT_EQ(kValue, GetFieldTrialParamValueByFeature(kTestFeature2, kParam));
- EXPECT_EQ(trial.get(), FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_NE(nullptr, FeatureList::GetFieldTrial(kTestFeature2));
- }
-
- // Check that initial state is restored.
- ExpectFeatures("TestFeature1<foo,TestFeature2", std::string());
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_TRUE(FeatureList::IsEnabled(kTestFeature2));
- EXPECT_EQ(trial.get(), FeatureList::GetFieldTrial(kTestFeature1));
- EXPECT_EQ(nullptr, FeatureList::GetFieldTrial(kTestFeature2));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature1, kParam));
- EXPECT_EQ("", GetFieldTrialParamValueByFeature(kTestFeature2, kParam));
-}
-
-TEST_F(ScopedFeatureListTest, EnableFeatureOverrideDisable) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitWithFeatures({}, {kTestFeature1});
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({kTestFeature1}, {});
- ExpectFeatures("TestFeature1", std::string());
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideNotMakeDuplicate) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitWithFeatures({}, {kTestFeature1});
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({}, {kTestFeature1});
- ExpectFeatures(std::string(), "TestFeature1");
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideFeatureWithDefault) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitFromCommandLine("*TestFeature1", std::string());
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({kTestFeature1}, {});
- ExpectFeatures("TestFeature1", std::string());
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideFeatureWithDefault2) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitFromCommandLine("*TestFeature1", std::string());
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({}, {kTestFeature1});
- ExpectFeatures(std::string(), "TestFeature1");
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideFeatureWithEnabledFieldTrial) {
- test::ScopedFeatureList feature_list1;
-
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- FieldTrialList field_trial_list(nullptr);
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample", "A");
- feature_list->RegisterFieldTrialOverride(
- kTestFeature1.name, FeatureList::OVERRIDE_ENABLE_FEATURE, trial);
- feature_list1.InitWithFeatureList(std::move(feature_list));
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({kTestFeature1}, {});
- ExpectFeatures("TestFeature1", std::string());
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideFeatureWithDisabledFieldTrial) {
- test::ScopedFeatureList feature_list1;
-
- std::unique_ptr<FeatureList> feature_list(new FeatureList);
- FieldTrialList field_trial_list(nullptr);
- FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample", "A");
- feature_list->RegisterFieldTrialOverride(
- kTestFeature1.name, FeatureList::OVERRIDE_DISABLE_FEATURE, trial);
- feature_list1.InitWithFeatureList(std::move(feature_list));
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({kTestFeature1}, {});
- ExpectFeatures("TestFeature1", std::string());
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideKeepsOtherExistingFeature) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitWithFeatures({}, {kTestFeature1});
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({}, {kTestFeature2});
- EXPECT_FALSE(FeatureList::IsEnabled(kTestFeature1));
- EXPECT_FALSE(FeatureList::IsEnabled(kTestFeature2));
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideKeepsOtherExistingFeature2) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitWithFeatures({}, {kTestFeature1});
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({kTestFeature2}, {});
- ExpectFeatures("TestFeature2", "TestFeature1");
- }
-}
-
-TEST_F(ScopedFeatureListTest, FeatureOverrideKeepsOtherExistingDefaultFeature) {
- test::ScopedFeatureList feature_list1;
- feature_list1.InitFromCommandLine("*TestFeature1", std::string());
-
- {
- test::ScopedFeatureList feature_list2;
- feature_list2.InitWithFeatures({}, {kTestFeature2});
- ExpectFeatures("*TestFeature1", "TestFeature2");
- }
-}
-
-} // namespace test
-} // namespace base
diff --git a/base/test/scoped_mock_time_message_loop_task_runner_unittest.cc b/base/test/scoped_mock_time_message_loop_task_runner_unittest.cc
deleted file mode 100644
index b08323d..0000000
--- a/base/test/scoped_mock_time_message_loop_task_runner_unittest.cc
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2015 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 "base/test/scoped_mock_time_message_loop_task_runner.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback_forward.h"
-#include "base/containers/circular_deque.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_current.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "base/test/test_pending_task.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-TaskRunner* GetCurrentTaskRunner() {
- return MessageLoopCurrent::Get()->task_runner().get();
-}
-
-void AssignTrue(bool* out) {
- *out = true;
-}
-
-// Pops a task from the front of |pending_tasks| and returns it.
-TestPendingTask PopFront(base::circular_deque<TestPendingTask>* pending_tasks) {
- TestPendingTask task = std::move(pending_tasks->front());
- pending_tasks->pop_front();
- return task;
-}
-
-class ScopedMockTimeMessageLoopTaskRunnerTest : public testing::Test {
- public:
- ScopedMockTimeMessageLoopTaskRunnerTest()
- : original_task_runner_(new TestMockTimeTaskRunner()) {
- MessageLoopCurrent::Get()->SetTaskRunner(original_task_runner_);
- }
-
- protected:
- TestMockTimeTaskRunner* original_task_runner() {
- return original_task_runner_.get();
- }
-
- private:
- scoped_refptr<TestMockTimeTaskRunner> original_task_runner_;
-
- MessageLoop message_loop_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedMockTimeMessageLoopTaskRunnerTest);
-};
-
-// Verifies a new TaskRunner is installed while a
-// ScopedMockTimeMessageLoopTaskRunner exists and the previous one is installed
-// after destruction.
-TEST_F(ScopedMockTimeMessageLoopTaskRunnerTest, CurrentTaskRunners) {
- auto scoped_task_runner_ =
- std::make_unique<ScopedMockTimeMessageLoopTaskRunner>();
- EXPECT_EQ(scoped_task_runner_->task_runner(), GetCurrentTaskRunner());
- scoped_task_runner_.reset();
- EXPECT_EQ(original_task_runner(), GetCurrentTaskRunner());
-}
-
-TEST_F(ScopedMockTimeMessageLoopTaskRunnerTest,
- IncompleteTasksAreCopiedToPreviousTaskRunnerAfterDestruction) {
- auto scoped_task_runner_ =
- std::make_unique<ScopedMockTimeMessageLoopTaskRunner>();
-
- bool task_10_has_run = false;
- bool task_11_has_run = false;
-
- Closure task_1 = DoNothing();
- Closure task_2 = DoNothing();
- Closure task_10 = Bind(&AssignTrue, &task_10_has_run);
- Closure task_11 = Bind(&AssignTrue, &task_11_has_run);
-
- constexpr TimeDelta task_1_delay = TimeDelta::FromSeconds(1);
- constexpr TimeDelta task_2_delay = TimeDelta::FromSeconds(2);
- constexpr TimeDelta task_10_delay = TimeDelta::FromSeconds(10);
- constexpr TimeDelta task_11_delay = TimeDelta::FromSeconds(11);
-
- constexpr TimeDelta step_time_by = TimeDelta::FromSeconds(5);
-
- GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_1, task_1_delay);
- GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_2, task_2_delay);
- GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_10, task_10_delay);
- GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_11, task_11_delay);
-
- scoped_task_runner_->task_runner()->FastForwardBy(step_time_by);
-
- scoped_task_runner_.reset();
-
- base::circular_deque<TestPendingTask> pending_tasks =
- original_task_runner()->TakePendingTasks();
-
- EXPECT_EQ(2U, pending_tasks.size());
-
- TestPendingTask pending_task = PopFront(&pending_tasks);
- EXPECT_FALSE(task_10_has_run);
- std::move(pending_task.task).Run();
- EXPECT_TRUE(task_10_has_run);
- EXPECT_EQ(task_10_delay - step_time_by, pending_task.delay);
-
- pending_task = PopFront(&pending_tasks);
- EXPECT_FALSE(task_11_has_run);
- std::move(pending_task.task).Run();
- EXPECT_TRUE(task_11_has_run);
- EXPECT_EQ(task_11_delay - step_time_by, pending_task.delay);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/test/scoped_task_environment_unittest.cc b/base/test/scoped_task_environment_unittest.cc
deleted file mode 100644
index 1c10d69..0000000
--- a/base/test/scoped_task_environment_unittest.cc
+++ /dev/null
@@ -1,324 +0,0 @@
-// Copyright 2017 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 "base/test/scoped_task_environment.h"
-
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/synchronization/atomic_flag.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequence_local_storage_slot.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/tick_clock.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include <unistd.h>
-#include "base/files/file_descriptor_watcher_posix.h"
-#endif // defined(OS_POSIX)
-
-namespace base {
-namespace test {
-
-namespace {
-
-class ScopedTaskEnvironmentTest
- : public testing::TestWithParam<ScopedTaskEnvironment::MainThreadType> {};
-
-void VerifyRunUntilIdleDidNotReturnAndSetFlag(
- AtomicFlag* run_until_idle_returned,
- AtomicFlag* task_ran) {
- EXPECT_FALSE(run_until_idle_returned->IsSet());
- task_ran->Set();
-}
-
-void RunUntilIdleTest(
- ScopedTaskEnvironment::MainThreadType main_thread_type,
- ScopedTaskEnvironment::ExecutionMode execution_control_mode) {
- AtomicFlag run_until_idle_returned;
- ScopedTaskEnvironment scoped_task_environment(main_thread_type,
- execution_control_mode);
-
- AtomicFlag first_main_thread_task_ran;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
- Unretained(&run_until_idle_returned),
- Unretained(&first_main_thread_task_ran)));
-
- AtomicFlag first_task_scheduler_task_ran;
- PostTask(FROM_HERE, BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
- Unretained(&run_until_idle_returned),
- Unretained(&first_task_scheduler_task_ran)));
-
- AtomicFlag second_task_scheduler_task_ran;
- AtomicFlag second_main_thread_task_ran;
- PostTaskAndReply(FROM_HERE,
- BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
- Unretained(&run_until_idle_returned),
- Unretained(&second_task_scheduler_task_ran)),
- BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
- Unretained(&run_until_idle_returned),
- Unretained(&second_main_thread_task_ran)));
-
- scoped_task_environment.RunUntilIdle();
- run_until_idle_returned.Set();
-
- EXPECT_TRUE(first_main_thread_task_ran.IsSet());
- EXPECT_TRUE(first_task_scheduler_task_ran.IsSet());
- EXPECT_TRUE(second_task_scheduler_task_ran.IsSet());
- EXPECT_TRUE(second_main_thread_task_ran.IsSet());
-}
-
-} // namespace
-
-TEST_P(ScopedTaskEnvironmentTest, QueuedRunUntilIdle) {
- RunUntilIdleTest(GetParam(), ScopedTaskEnvironment::ExecutionMode::QUEUED);
-}
-
-TEST_P(ScopedTaskEnvironmentTest, AsyncRunUntilIdle) {
- RunUntilIdleTest(GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
-}
-
-// Verify that tasks posted to an ExecutionMode::QUEUED ScopedTaskEnvironment do
-// not run outside of RunUntilIdle().
-TEST_P(ScopedTaskEnvironmentTest, QueuedTasksDoNotRunOutsideOfRunUntilIdle) {
- ScopedTaskEnvironment scoped_task_environment(
- GetParam(), ScopedTaskEnvironment::ExecutionMode::QUEUED);
-
- AtomicFlag run_until_idle_called;
- PostTask(FROM_HERE, BindOnce(
- [](AtomicFlag* run_until_idle_called) {
- EXPECT_TRUE(run_until_idle_called->IsSet());
- },
- Unretained(&run_until_idle_called)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- run_until_idle_called.Set();
- scoped_task_environment.RunUntilIdle();
-
- AtomicFlag other_run_until_idle_called;
- PostTask(FROM_HERE, BindOnce(
- [](AtomicFlag* other_run_until_idle_called) {
- EXPECT_TRUE(other_run_until_idle_called->IsSet());
- },
- Unretained(&other_run_until_idle_called)));
- PlatformThread::Sleep(TestTimeouts::tiny_timeout());
- other_run_until_idle_called.Set();
- scoped_task_environment.RunUntilIdle();
-}
-
-// Verify that a task posted to an ExecutionMode::ASYNC ScopedTaskEnvironment
-// can run without a call to RunUntilIdle().
-TEST_P(ScopedTaskEnvironmentTest, AsyncTasksRunAsTheyArePosted) {
- ScopedTaskEnvironment scoped_task_environment(
- GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- PostTask(FROM_HERE,
- BindOnce([](WaitableEvent* task_ran) { task_ran->Signal(); },
- Unretained(&task_ran)));
- task_ran.Wait();
-}
-
-// Verify that a task posted to an ExecutionMode::ASYNC ScopedTaskEnvironment
-// after a call to RunUntilIdle() can run without another call to
-// RunUntilIdle().
-TEST_P(ScopedTaskEnvironmentTest,
- AsyncTasksRunAsTheyArePostedAfterRunUntilIdle) {
- ScopedTaskEnvironment scoped_task_environment(
- GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
-
- scoped_task_environment.RunUntilIdle();
-
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- PostTask(FROM_HERE,
- BindOnce([](WaitableEvent* task_ran) { task_ran->Signal(); },
- Unretained(&task_ran)));
- task_ran.Wait();
-}
-
-TEST_P(ScopedTaskEnvironmentTest, DelayedTasks) {
- // Use a QUEUED execution-mode environment, so that no tasks are actually
- // executed until RunUntilIdle()/FastForwardBy() are invoked.
- ScopedTaskEnvironment scoped_task_environment(
- GetParam(), ScopedTaskEnvironment::ExecutionMode::QUEUED);
-
- subtle::Atomic32 counter = 0;
-
- constexpr base::TimeDelta kShortTaskDelay = TimeDelta::FromDays(1);
- // Should run only in MOCK_TIME environment when time is fast-forwarded.
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- Bind(
- [](subtle::Atomic32* counter) {
- subtle::NoBarrier_AtomicIncrement(counter, 4);
- },
- Unretained(&counter)),
- kShortTaskDelay);
- // TODO(gab): This currently doesn't run because the TaskScheduler's clock
- // isn't mocked but it should be.
- PostDelayedTask(FROM_HERE,
- Bind(
- [](subtle::Atomic32* counter) {
- subtle::NoBarrier_AtomicIncrement(counter, 128);
- },
- Unretained(&counter)),
- kShortTaskDelay);
-
- constexpr base::TimeDelta kLongTaskDelay = TimeDelta::FromDays(7);
- // Same as first task, longer delays to exercise
- // FastForwardUntilNoTasksRemain().
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- Bind(
- [](subtle::Atomic32* counter) {
- subtle::NoBarrier_AtomicIncrement(counter, 8);
- },
- Unretained(&counter)),
- TimeDelta::FromDays(5));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- Bind(
- [](subtle::Atomic32* counter) {
- subtle::NoBarrier_AtomicIncrement(counter, 16);
- },
- Unretained(&counter)),
- kLongTaskDelay);
-
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, Bind(
- [](subtle::Atomic32* counter) {
- subtle::NoBarrier_AtomicIncrement(counter, 1);
- },
- Unretained(&counter)));
- PostTask(FROM_HERE, Bind(
- [](subtle::Atomic32* counter) {
- subtle::NoBarrier_AtomicIncrement(counter, 2);
- },
- Unretained(&counter)));
-
- // This expectation will fail flakily if the preceding PostTask() is executed
- // asynchronously, indicating a problem with the QUEUED execution mode.
- int expected_value = 0;
- EXPECT_EQ(expected_value, counter);
-
- // RunUntilIdle() should process non-delayed tasks only in all queues.
- scoped_task_environment.RunUntilIdle();
- expected_value += 1;
- expected_value += 2;
- EXPECT_EQ(expected_value, counter);
-
- if (GetParam() == ScopedTaskEnvironment::MainThreadType::MOCK_TIME) {
- // Delay inferior to the delay of the first posted task.
- constexpr base::TimeDelta kInferiorTaskDelay = TimeDelta::FromSeconds(1);
- static_assert(kInferiorTaskDelay < kShortTaskDelay,
- "|kInferiorTaskDelay| should be "
- "set to a value inferior to the first posted task's delay.");
- scoped_task_environment.FastForwardBy(kInferiorTaskDelay);
- EXPECT_EQ(expected_value, counter);
-
- scoped_task_environment.FastForwardBy(kShortTaskDelay - kInferiorTaskDelay);
- expected_value += 4;
- EXPECT_EQ(expected_value, counter);
-
- scoped_task_environment.FastForwardUntilNoTasksRemain();
- expected_value += 8;
- expected_value += 16;
- EXPECT_EQ(expected_value, counter);
- }
-}
-
-// Regression test for https://crbug.com/824770.
-TEST_P(ScopedTaskEnvironmentTest, SupportsSequenceLocalStorageOnMainThread) {
- ScopedTaskEnvironment scoped_task_environment(
- GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
-
- SequenceLocalStorageSlot<int> sls_slot;
- sls_slot.Set(5);
- EXPECT_EQ(5, sls_slot.Get());
-}
-
-#if defined(OS_POSIX)
-TEST_F(ScopedTaskEnvironmentTest, SupportsFileDescriptorWatcherOnIOMainThread) {
- ScopedTaskEnvironment scoped_task_environment(
- ScopedTaskEnvironment::MainThreadType::IO,
- ScopedTaskEnvironment::ExecutionMode::ASYNC);
-
- int pipe_fds_[2];
- ASSERT_EQ(0, pipe(pipe_fds_));
-
- RunLoop run_loop;
-
- // The write end of a newly created pipe is immediately writable.
- auto controller = FileDescriptorWatcher::WatchWritable(
- pipe_fds_[1], run_loop.QuitClosure());
-
- // This will hang if the notification doesn't occur as expected.
- run_loop.Run();
-}
-#endif // defined(OS_POSIX)
-
-// Verify that the TickClock returned by
-// |ScopedTaskEnvironment::GetMockTickClock| gets updated when the
-// FastForward(By|UntilNoTasksRemain) functions are called.
-TEST_F(ScopedTaskEnvironmentTest, FastForwardAdvanceTickClock) {
- // Use a QUEUED execution-mode environment, so that no tasks are actually
- // executed until RunUntilIdle()/FastForwardBy() are invoked.
- ScopedTaskEnvironment scoped_task_environment(
- ScopedTaskEnvironment::MainThreadType::MOCK_TIME,
- ScopedTaskEnvironment::ExecutionMode::QUEUED);
-
- constexpr base::TimeDelta kShortTaskDelay = TimeDelta::FromDays(1);
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, base::DoNothing(),
- kShortTaskDelay);
-
- constexpr base::TimeDelta kLongTaskDelay = TimeDelta::FromDays(7);
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, base::DoNothing(),
- kLongTaskDelay);
-
- const base::TickClock* tick_clock =
- scoped_task_environment.GetMockTickClock();
- base::TimeTicks tick_clock_ref = tick_clock->NowTicks();
-
- // Make sure that |FastForwardBy| advances the clock.
- scoped_task_environment.FastForwardBy(kShortTaskDelay);
- EXPECT_EQ(kShortTaskDelay, tick_clock->NowTicks() - tick_clock_ref);
-
- // Make sure that |FastForwardUntilNoTasksRemain| advances the clock.
- scoped_task_environment.FastForwardUntilNoTasksRemain();
- EXPECT_EQ(kLongTaskDelay, tick_clock->NowTicks() - tick_clock_ref);
-
- // Fast-forwarding to a time at which there's no tasks should also advance the
- // clock.
- scoped_task_environment.FastForwardBy(kLongTaskDelay);
- EXPECT_EQ(kLongTaskDelay * 2, tick_clock->NowTicks() - tick_clock_ref);
-}
-
-INSTANTIATE_TEST_CASE_P(
- MainThreadDefault,
- ScopedTaskEnvironmentTest,
- ::testing::Values(ScopedTaskEnvironment::MainThreadType::DEFAULT));
-INSTANTIATE_TEST_CASE_P(
- MainThreadMockTime,
- ScopedTaskEnvironmentTest,
- ::testing::Values(ScopedTaskEnvironment::MainThreadType::MOCK_TIME));
-INSTANTIATE_TEST_CASE_P(
- MainThreadUI,
- ScopedTaskEnvironmentTest,
- ::testing::Values(ScopedTaskEnvironment::MainThreadType::UI));
-INSTANTIATE_TEST_CASE_P(
- MainThreadIO,
- ScopedTaskEnvironmentTest,
- ::testing::Values(ScopedTaskEnvironment::MainThreadType::IO));
-
-} // namespace test
-} // namespace base
diff --git a/base/test/test_mock_time_task_runner_unittest.cc b/base/test/test_mock_time_task_runner_unittest.cc
deleted file mode 100644
index 04be466..0000000
--- a/base/test/test_mock_time_task_runner_unittest.cc
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright 2017 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 "base/test/test_mock_time_task_runner.h"
-
-#include "base/cancelable_callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_timeouts.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-// Basic usage should work the same from default and bound
-// TestMockTimeTaskRunners.
-TEST(TestMockTimeTaskRunnerTest, Basic) {
- static constexpr TestMockTimeTaskRunner::Type kTestCases[] = {
- TestMockTimeTaskRunner::Type::kStandalone,
- TestMockTimeTaskRunner::Type::kBoundToThread};
-
- for (auto type : kTestCases) {
- SCOPED_TRACE(static_cast<int>(type));
-
- auto mock_time_task_runner = MakeRefCounted<TestMockTimeTaskRunner>(type);
- int counter = 0;
-
- mock_time_task_runner->PostTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 1; }, Unretained(&counter)));
- mock_time_task_runner->PostTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 32; }, Unretained(&counter)));
- mock_time_task_runner->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 256; }, Unretained(&counter)),
- TimeDelta::FromSeconds(3));
- mock_time_task_runner->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 64; }, Unretained(&counter)),
- TimeDelta::FromSeconds(1));
- mock_time_task_runner->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 1024; },
- Unretained(&counter)),
- TimeDelta::FromMinutes(20));
- mock_time_task_runner->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 4096; },
- Unretained(&counter)),
- TimeDelta::FromDays(20));
-
- int expected_value = 0;
- EXPECT_EQ(expected_value, counter);
- mock_time_task_runner->RunUntilIdle();
- expected_value += 1;
- expected_value += 32;
- EXPECT_EQ(expected_value, counter);
-
- mock_time_task_runner->RunUntilIdle();
- EXPECT_EQ(expected_value, counter);
-
- mock_time_task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
- expected_value += 64;
- EXPECT_EQ(expected_value, counter);
-
- mock_time_task_runner->FastForwardBy(TimeDelta::FromSeconds(5));
- expected_value += 256;
- EXPECT_EQ(expected_value, counter);
-
- mock_time_task_runner->FastForwardUntilNoTasksRemain();
- expected_value += 1024;
- expected_value += 4096;
- EXPECT_EQ(expected_value, counter);
- }
-}
-
-// A default TestMockTimeTaskRunner shouldn't result in a thread association.
-TEST(TestMockTimeTaskRunnerTest, DefaultUnbound) {
- auto unbound_mock_time_task_runner = MakeRefCounted<TestMockTimeTaskRunner>();
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
- EXPECT_DEATH_IF_SUPPORTED({ RunLoop().RunUntilIdle(); }, "");
-}
-
-TEST(TestMockTimeTaskRunnerTest, RunLoopDriveableWhenBound) {
- auto bound_mock_time_task_runner = MakeRefCounted<TestMockTimeTaskRunner>(
- TestMockTimeTaskRunner::Type::kBoundToThread);
-
- int counter = 0;
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 1; }, Unretained(&counter)));
- ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 32; }, Unretained(&counter)));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 256; }, Unretained(&counter)),
- TimeDelta::FromSeconds(3));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 64; }, Unretained(&counter)),
- TimeDelta::FromSeconds(1));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 1024; }, Unretained(&counter)),
- TimeDelta::FromMinutes(20));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 4096; }, Unretained(&counter)),
- TimeDelta::FromDays(20));
-
- int expected_value = 0;
- EXPECT_EQ(expected_value, counter);
- RunLoop().RunUntilIdle();
- expected_value += 1;
- expected_value += 32;
- EXPECT_EQ(expected_value, counter);
-
- RunLoop().RunUntilIdle();
- EXPECT_EQ(expected_value, counter);
-
- {
- RunLoop run_loop;
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, run_loop.QuitClosure(), TimeDelta::FromSeconds(1));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 8192; },
- Unretained(&counter)),
- TimeDelta::FromSeconds(1));
-
- // The QuitClosure() should be ordered between the 64 and the 8192
- // increments and should preempt the latter.
- run_loop.Run();
- expected_value += 64;
- EXPECT_EQ(expected_value, counter);
-
- // Running until idle should process the 8192 increment whose delay has
- // expired in the previous Run().
- RunLoop().RunUntilIdle();
- expected_value += 8192;
- EXPECT_EQ(expected_value, counter);
- }
-
- {
- RunLoop run_loop;
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, run_loop.QuitWhenIdleClosure(), TimeDelta::FromSeconds(5));
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::Bind([](int* counter) { *counter += 16384; },
- Unretained(&counter)),
- TimeDelta::FromSeconds(5));
-
- // The QuitWhenIdleClosure() shouldn't preempt equally delayed tasks and as
- // such the 16384 increment should be processed before quitting.
- run_loop.Run();
- expected_value += 256;
- expected_value += 16384;
- EXPECT_EQ(expected_value, counter);
- }
-
- // Process the remaining tasks (note: do not mimic this elsewhere,
- // TestMockTimeTaskRunner::FastForwardUntilNoTasksRemain() is a better API to
- // do this, this is just done here for the purpose of extensively testing the
- // RunLoop approach).
- RunLoop run_loop;
- ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, run_loop.QuitWhenIdleClosure(), TimeDelta::FromDays(50));
-
- run_loop.Run();
- expected_value += 1024;
- expected_value += 4096;
- EXPECT_EQ(expected_value, counter);
-}
-
-// Regression test that receiving the quit-when-idle signal when already empty
-// works as intended (i.e. that |TestMockTimeTaskRunner::tasks_lock_cv| is
-// properly signaled).
-TEST(TestMockTimeTaskRunnerTest, RunLoopQuitFromIdle) {
- auto bound_mock_time_task_runner = MakeRefCounted<TestMockTimeTaskRunner>(
- TestMockTimeTaskRunner::Type::kBoundToThread);
-
- Thread quitting_thread("quitting thread");
- quitting_thread.Start();
-
- RunLoop run_loop;
- quitting_thread.task_runner()->PostDelayedTask(
- FROM_HERE, run_loop.QuitWhenIdleClosure(), TestTimeouts::tiny_timeout());
- run_loop.Run();
-}
-
-TEST(TestMockTimeTaskRunnerTest, TakePendingTasks) {
- auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();
- task_runner->PostTask(FROM_HERE, Bind([]() {}));
- EXPECT_TRUE(task_runner->HasPendingTask());
- EXPECT_EQ(1u, task_runner->TakePendingTasks().size());
- EXPECT_FALSE(task_runner->HasPendingTask());
-}
-
-TEST(TestMockTimeTaskRunnerTest, CancelPendingTask) {
- auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();
- CancelableClosure task1(Bind([]() {}));
- task_runner->PostDelayedTask(FROM_HERE, task1.callback(),
- TimeDelta::FromSeconds(1));
- EXPECT_TRUE(task_runner->HasPendingTask());
- EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
- EXPECT_EQ(TimeDelta::FromSeconds(1), task_runner->NextPendingTaskDelay());
- task1.Cancel();
- EXPECT_FALSE(task_runner->HasPendingTask());
-
- CancelableClosure task2(Bind([]() {}));
- task_runner->PostDelayedTask(FROM_HERE, task2.callback(),
- TimeDelta::FromSeconds(1));
- task2.Cancel();
- EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
-
- CancelableClosure task3(Bind([]() {}));
- task_runner->PostDelayedTask(FROM_HERE, task3.callback(),
- TimeDelta::FromSeconds(1));
- task3.Cancel();
- EXPECT_EQ(TimeDelta::Max(), task_runner->NextPendingTaskDelay());
-
- CancelableClosure task4(Bind([]() {}));
- task_runner->PostDelayedTask(FROM_HERE, task4.callback(),
- TimeDelta::FromSeconds(1));
- task4.Cancel();
- EXPECT_TRUE(task_runner->TakePendingTasks().empty());
-}
-
-TEST(TestMockTimeTaskRunnerTest, NoFastForwardToCancelledTask) {
- auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();
- TimeTicks start_time = task_runner->NowTicks();
- CancelableClosure task(Bind([]() {}));
- task_runner->PostDelayedTask(FROM_HERE, task.callback(),
- TimeDelta::FromSeconds(1));
- EXPECT_EQ(TimeDelta::FromSeconds(1), task_runner->NextPendingTaskDelay());
- task.Cancel();
- task_runner->FastForwardUntilNoTasksRemain();
- EXPECT_EQ(start_time, task_runner->NowTicks());
-}
-
-TEST(TestMockTimeTaskRunnerTest, AdvanceMockTickClockDoesNotRunTasks) {
- auto task_runner = MakeRefCounted<TestMockTimeTaskRunner>();
- TimeTicks start_time = task_runner->NowTicks();
- task_runner->PostTask(FROM_HERE, BindOnce([]() { ADD_FAILURE(); }));
- task_runner->PostDelayedTask(FROM_HERE, BindOnce([]() { ADD_FAILURE(); }),
- TimeDelta::FromSeconds(1));
-
- task_runner->AdvanceMockTickClock(TimeDelta::FromSeconds(3));
- EXPECT_EQ(start_time + TimeDelta::FromSeconds(3), task_runner->NowTicks());
- EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
-}
-
-} // namespace base
diff --git a/base/test/test_pending_task_unittest.cc b/base/test/test_pending_task_unittest.cc
deleted file mode 100644
index 6e01c8c..0000000
--- a/base/test/test_pending_task_unittest.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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.
-
-#include "base/test/test_pending_task.h"
-
-#include "base/bind.h"
-#include "base/trace_event/trace_event.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest-spi.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(TestPendingTaskTest, TraceSupport) {
- base::TestPendingTask task;
-
- // Check that TestPendingTask can be sent to the trace subsystem.
- TRACE_EVENT1("test", "TestPendingTask::TraceSupport", "task", task.AsValue());
-
- // Just a basic check that the trace output has *something* in it.
- std::unique_ptr<base::trace_event::ConvertableToTraceFormat> task_value(
- task.AsValue());
- EXPECT_THAT(task_value->ToString(), ::testing::HasSubstr("post_time"));
-}
-
-TEST(TestPendingTaskTest, ToString) {
- base::TestPendingTask task;
-
- // Just a basic check that ToString has *something* in it.
- EXPECT_THAT(task.ToString(), ::testing::StartsWith("TestPendingTask("));
-}
-
-TEST(TestPendingTaskTest, GTestPrettyPrint) {
- base::TestPendingTask task;
-
- // Check that gtest is calling the TestPendingTask's PrintTo method.
- EXPECT_THAT(::testing::PrintToString(task),
- ::testing::StartsWith("TestPendingTask("));
-
- // Check that pretty printing works with the gtest iostreams operator.
- EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << task, "TestPendingTask(");
-}
-
-TEST(TestPendingTaskTest, ShouldRunBefore) {
- base::TestPendingTask task_first;
- task_first.delay = base::TimeDelta::FromMilliseconds(1);
- base::TestPendingTask task_after;
- task_after.delay = base::TimeDelta::FromMilliseconds(2);
-
- EXPECT_FALSE(task_after.ShouldRunBefore(task_first))
- << task_after << ".ShouldRunBefore(" << task_first << ")\n";
- EXPECT_TRUE(task_first.ShouldRunBefore(task_after))
- << task_first << ".ShouldRunBefore(" << task_after << ")\n";
-}
-
-} // namespace base
diff --git a/base/test/test_reg_util_win_unittest.cc b/base/test/test_reg_util_win_unittest.cc
deleted file mode 100644
index ca3bc99..0000000
--- a/base/test/test_reg_util_win_unittest.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 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 "base/test/test_reg_util_win.h"
-
-#include <memory>
-
-#include "base/compiler_specific.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace registry_util {
-
-namespace {
-const wchar_t kTestKeyPath[] = L"Software\\Chromium\\Foo\\Baz\\TestKey";
-const wchar_t kTestValueName[] = L"TestValue";
-} // namespace
-
-class RegistryOverrideManagerTest : public testing::Test {
- protected:
- RegistryOverrideManagerTest() {
- // We assign a fake test key path to our test RegistryOverrideManager
- // so we don't interfere with any actual RegistryOverrideManagers running
- // on the system. This fake path will be auto-deleted by other
- // RegistryOverrideManagers in case we crash.
- fake_test_key_root_ = registry_util::GenerateTempKeyPath();
-
- // Ensure a clean test environment.
- base::win::RegKey key(HKEY_CURRENT_USER);
- key.DeleteKey(fake_test_key_root_.c_str());
- key.DeleteKey(kTestKeyPath);
- }
-
- ~RegistryOverrideManagerTest() override {
- base::win::RegKey key(HKEY_CURRENT_USER);
- key.DeleteKey(fake_test_key_root_.c_str());
- }
-
- void AssertKeyExists(const base::string16& key_path) {
- base::win::RegKey key;
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ))
- << key_path << " does not exist.";
- }
-
- void AssertKeyAbsent(const base::string16& key_path) {
- base::win::RegKey key;
- ASSERT_NE(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ))
- << key_path << " exists but it should not.";
- }
-
- void CreateKey(const base::string16& key_path) {
- base::win::RegKey key;
- ASSERT_EQ(ERROR_SUCCESS,
- key.Create(HKEY_CURRENT_USER, key_path.c_str(), KEY_ALL_ACCESS));
- }
-
- base::string16 FakeOverrideManagerPath(const base::Time& time) {
- return fake_test_key_root_ + L"\\" +
- base::Int64ToString16(time.ToInternalValue());
- }
-
- void CreateManager(const base::Time& timestamp) {
- manager_.reset(new RegistryOverrideManager(timestamp, fake_test_key_root_));
- manager_->OverrideRegistry(HKEY_CURRENT_USER);
- }
-
- base::string16 fake_test_key_root_;
- std::unique_ptr<RegistryOverrideManager> manager_;
-};
-
-TEST_F(RegistryOverrideManagerTest, Basic) {
- ASSERT_NO_FATAL_FAILURE(CreateManager(base::Time::Now()));
-
- base::win::RegKey create_key;
- EXPECT_EQ(ERROR_SUCCESS,
- create_key.Create(HKEY_CURRENT_USER, kTestKeyPath, KEY_ALL_ACCESS));
- EXPECT_TRUE(create_key.Valid());
- EXPECT_EQ(ERROR_SUCCESS, create_key.WriteValue(kTestValueName, 42));
- create_key.Close();
-
- ASSERT_NO_FATAL_FAILURE(AssertKeyExists(kTestKeyPath));
-
- DWORD value;
- base::win::RegKey read_key;
- EXPECT_EQ(ERROR_SUCCESS,
- read_key.Open(HKEY_CURRENT_USER, kTestKeyPath, KEY_READ));
- EXPECT_TRUE(read_key.Valid());
- EXPECT_EQ(ERROR_SUCCESS, read_key.ReadValueDW(kTestValueName, &value));
- EXPECT_EQ(42u, value);
- read_key.Close();
-
- manager_.reset();
-
- ASSERT_NO_FATAL_FAILURE(AssertKeyAbsent(kTestKeyPath));
-}
-
-TEST_F(RegistryOverrideManagerTest, DeleteStaleKeys) {
- base::Time::Exploded kTestTimeExploded = {2013, 11, 1, 4, 0, 0, 0, 0};
- base::Time kTestTime;
- EXPECT_TRUE(base::Time::FromUTCExploded(kTestTimeExploded, &kTestTime));
-
- base::string16 path_garbage = fake_test_key_root_ + L"\\Blah";
- base::string16 path_very_stale =
- FakeOverrideManagerPath(kTestTime - base::TimeDelta::FromDays(100));
- base::string16 path_stale =
- FakeOverrideManagerPath(kTestTime - base::TimeDelta::FromDays(5));
- base::string16 path_current =
- FakeOverrideManagerPath(kTestTime - base::TimeDelta::FromMinutes(1));
- base::string16 path_future =
- FakeOverrideManagerPath(kTestTime + base::TimeDelta::FromMinutes(1));
-
- ASSERT_NO_FATAL_FAILURE(CreateKey(path_garbage));
- ASSERT_NO_FATAL_FAILURE(CreateKey(path_very_stale));
- ASSERT_NO_FATAL_FAILURE(CreateKey(path_stale));
- ASSERT_NO_FATAL_FAILURE(CreateKey(path_current));
- ASSERT_NO_FATAL_FAILURE(CreateKey(path_future));
-
- ASSERT_NO_FATAL_FAILURE(CreateManager(kTestTime));
- manager_.reset();
-
- ASSERT_NO_FATAL_FAILURE(AssertKeyAbsent(path_garbage));
- ASSERT_NO_FATAL_FAILURE(AssertKeyAbsent(path_very_stale));
- ASSERT_NO_FATAL_FAILURE(AssertKeyAbsent(path_stale));
- ASSERT_NO_FATAL_FAILURE(AssertKeyExists(path_current));
- ASSERT_NO_FATAL_FAILURE(AssertKeyExists(path_future));
-}
-
-} // namespace registry_util
diff --git a/base/test/trace_event_analyzer_unittest.cc b/base/test/trace_event_analyzer_unittest.cc
deleted file mode 100644
index 6461b0f..0000000
--- a/base/test/trace_event_analyzer_unittest.cc
+++ /dev/null
@@ -1,961 +0,0 @@
-// 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.
-
-#include "base/test/trace_event_analyzer.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/bind.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/trace_event/trace_buffer.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace trace_analyzer {
-
-namespace {
-
-class TraceEventAnalyzerTest : public testing::Test {
- public:
- void ManualSetUp();
- void OnTraceDataCollected(
- base::WaitableEvent* flush_complete_event,
- const scoped_refptr<base::RefCountedString>& json_events_str,
- bool has_more_events);
- void BeginTracing();
- void EndTracing();
-
- base::trace_event::TraceResultBuffer::SimpleOutput output_;
- base::trace_event::TraceResultBuffer buffer_;
-};
-
-void TraceEventAnalyzerTest::ManualSetUp() {
- ASSERT_TRUE(base::trace_event::TraceLog::GetInstance());
- buffer_.SetOutputCallback(output_.GetCallback());
- output_.json_output.clear();
-}
-
-void TraceEventAnalyzerTest::OnTraceDataCollected(
- base::WaitableEvent* flush_complete_event,
- const scoped_refptr<base::RefCountedString>& json_events_str,
- bool has_more_events) {
- buffer_.AddFragment(json_events_str->data());
- if (!has_more_events)
- flush_complete_event->Signal();
-}
-
-void TraceEventAnalyzerTest::BeginTracing() {
- output_.json_output.clear();
- buffer_.Start();
- base::trace_event::TraceLog::GetInstance()->SetEnabled(
- base::trace_event::TraceConfig("*", ""),
- base::trace_event::TraceLog::RECORDING_MODE);
-}
-
-void TraceEventAnalyzerTest::EndTracing() {
- base::trace_event::TraceLog::GetInstance()->SetDisabled();
- base::WaitableEvent flush_complete_event(
- base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- base::trace_event::TraceLog::GetInstance()->Flush(
- base::Bind(&TraceEventAnalyzerTest::OnTraceDataCollected,
- base::Unretained(this),
- base::Unretained(&flush_complete_event)));
- flush_complete_event.Wait();
- buffer_.Finish();
-}
-
-} // namespace
-
-TEST_F(TraceEventAnalyzerTest, NoEvents) {
- ManualSetUp();
-
- // Create an empty JSON event string:
- buffer_.Start();
- buffer_.Finish();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
-
- // Search for all events and verify that nothing is returned.
- TraceEventVector found;
- analyzer->FindEvents(Query::Bool(true), &found);
- EXPECT_EQ(0u, found.size());
-}
-
-TEST_F(TraceEventAnalyzerTest, TraceEvent) {
- ManualSetUp();
-
- int int_num = 2;
- double double_num = 3.5;
- const char str[] = "the string";
-
- TraceEvent event;
- event.arg_numbers["false"] = 0.0;
- event.arg_numbers["true"] = 1.0;
- event.arg_numbers["int"] = static_cast<double>(int_num);
- event.arg_numbers["double"] = double_num;
- event.arg_strings["string"] = str;
- event.arg_values["dict"] = WrapUnique(new base::DictionaryValue());
-
- ASSERT_TRUE(event.HasNumberArg("false"));
- ASSERT_TRUE(event.HasNumberArg("true"));
- ASSERT_TRUE(event.HasNumberArg("int"));
- ASSERT_TRUE(event.HasNumberArg("double"));
- ASSERT_TRUE(event.HasStringArg("string"));
- ASSERT_FALSE(event.HasNumberArg("notfound"));
- ASSERT_FALSE(event.HasStringArg("notfound"));
- ASSERT_TRUE(event.HasArg("dict"));
- ASSERT_FALSE(event.HasArg("notfound"));
-
- EXPECT_FALSE(event.GetKnownArgAsBool("false"));
- EXPECT_TRUE(event.GetKnownArgAsBool("true"));
- EXPECT_EQ(int_num, event.GetKnownArgAsInt("int"));
- EXPECT_EQ(double_num, event.GetKnownArgAsDouble("double"));
- EXPECT_STREQ(str, event.GetKnownArgAsString("string").c_str());
-
- std::unique_ptr<base::Value> arg;
- EXPECT_TRUE(event.GetArgAsValue("dict", &arg));
- EXPECT_EQ(base::Value::Type::DICTIONARY, arg->type());
-}
-
-TEST_F(TraceEventAnalyzerTest, QueryEventMember) {
- ManualSetUp();
-
- TraceEvent event;
- event.thread.process_id = 3;
- event.thread.thread_id = 4;
- event.timestamp = 1.5;
- event.phase = TRACE_EVENT_PHASE_BEGIN;
- event.category = "category";
- event.name = "name";
- event.id = "1";
- event.arg_numbers["num"] = 7.0;
- event.arg_strings["str"] = "the string";
-
- // Other event with all different members:
- TraceEvent other;
- other.thread.process_id = 5;
- other.thread.thread_id = 6;
- other.timestamp = 2.5;
- other.phase = TRACE_EVENT_PHASE_END;
- other.category = "category2";
- other.name = "name2";
- other.id = "2";
- other.arg_numbers["num2"] = 8.0;
- other.arg_strings["str2"] = "the string 2";
-
- event.other_event = &other;
- ASSERT_TRUE(event.has_other_event());
- double duration = event.GetAbsTimeToOtherEvent();
-
- Query event_pid = Query::EventPidIs(event.thread.process_id);
- Query event_tid = Query::EventTidIs(event.thread.thread_id);
- Query event_time = Query::EventTimeIs(event.timestamp);
- Query event_duration = Query::EventDurationIs(duration);
- Query event_phase = Query::EventPhaseIs(event.phase);
- Query event_category = Query::EventCategoryIs(event.category);
- Query event_name = Query::EventNameIs(event.name);
- Query event_id = Query::EventIdIs(event.id);
- Query event_has_arg1 = Query::EventHasNumberArg("num");
- Query event_has_arg2 = Query::EventHasStringArg("str");
- Query event_arg1 =
- (Query::EventArg("num") == Query::Double(event.arg_numbers["num"]));
- Query event_arg2 =
- (Query::EventArg("str") == Query::String(event.arg_strings["str"]));
- Query event_has_other = Query::EventHasOther();
- Query other_pid = Query::OtherPidIs(other.thread.process_id);
- Query other_tid = Query::OtherTidIs(other.thread.thread_id);
- Query other_time = Query::OtherTimeIs(other.timestamp);
- Query other_phase = Query::OtherPhaseIs(other.phase);
- Query other_category = Query::OtherCategoryIs(other.category);
- Query other_name = Query::OtherNameIs(other.name);
- Query other_id = Query::OtherIdIs(other.id);
- Query other_has_arg1 = Query::OtherHasNumberArg("num2");
- Query other_has_arg2 = Query::OtherHasStringArg("str2");
- Query other_arg1 =
- (Query::OtherArg("num2") == Query::Double(other.arg_numbers["num2"]));
- Query other_arg2 =
- (Query::OtherArg("str2") == Query::String(other.arg_strings["str2"]));
-
- EXPECT_TRUE(event_pid.Evaluate(event));
- EXPECT_TRUE(event_tid.Evaluate(event));
- EXPECT_TRUE(event_time.Evaluate(event));
- EXPECT_TRUE(event_duration.Evaluate(event));
- EXPECT_TRUE(event_phase.Evaluate(event));
- EXPECT_TRUE(event_category.Evaluate(event));
- EXPECT_TRUE(event_name.Evaluate(event));
- EXPECT_TRUE(event_id.Evaluate(event));
- EXPECT_TRUE(event_has_arg1.Evaluate(event));
- EXPECT_TRUE(event_has_arg2.Evaluate(event));
- EXPECT_TRUE(event_arg1.Evaluate(event));
- EXPECT_TRUE(event_arg2.Evaluate(event));
- EXPECT_TRUE(event_has_other.Evaluate(event));
- EXPECT_TRUE(other_pid.Evaluate(event));
- EXPECT_TRUE(other_tid.Evaluate(event));
- EXPECT_TRUE(other_time.Evaluate(event));
- EXPECT_TRUE(other_phase.Evaluate(event));
- EXPECT_TRUE(other_category.Evaluate(event));
- EXPECT_TRUE(other_name.Evaluate(event));
- EXPECT_TRUE(other_id.Evaluate(event));
- EXPECT_TRUE(other_has_arg1.Evaluate(event));
- EXPECT_TRUE(other_has_arg2.Evaluate(event));
- EXPECT_TRUE(other_arg1.Evaluate(event));
- EXPECT_TRUE(other_arg2.Evaluate(event));
-
- // Evaluate event queries against other to verify the queries fail when the
- // event members are wrong.
- EXPECT_FALSE(event_pid.Evaluate(other));
- EXPECT_FALSE(event_tid.Evaluate(other));
- EXPECT_FALSE(event_time.Evaluate(other));
- EXPECT_FALSE(event_duration.Evaluate(other));
- EXPECT_FALSE(event_phase.Evaluate(other));
- EXPECT_FALSE(event_category.Evaluate(other));
- EXPECT_FALSE(event_name.Evaluate(other));
- EXPECT_FALSE(event_id.Evaluate(other));
- EXPECT_FALSE(event_has_arg1.Evaluate(other));
- EXPECT_FALSE(event_has_arg2.Evaluate(other));
- EXPECT_FALSE(event_arg1.Evaluate(other));
- EXPECT_FALSE(event_arg2.Evaluate(other));
- EXPECT_FALSE(event_has_other.Evaluate(other));
-}
-
-TEST_F(TraceEventAnalyzerTest, BooleanOperators) {
- ManualSetUp();
-
- BeginTracing();
- {
- TRACE_EVENT_INSTANT1("cat1", "name1", TRACE_EVENT_SCOPE_THREAD, "num", 1);
- TRACE_EVENT_INSTANT1("cat1", "name2", TRACE_EVENT_SCOPE_THREAD, "num", 2);
- TRACE_EVENT_INSTANT1("cat2", "name3", TRACE_EVENT_SCOPE_THREAD, "num", 3);
- TRACE_EVENT_INSTANT1("cat2", "name4", TRACE_EVENT_SCOPE_THREAD, "num", 4);
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer);
- analyzer->SetIgnoreMetadataEvents(true);
-
- TraceEventVector found;
-
- // ==
-
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat1"), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name2", found[1]->name.c_str());
-
- analyzer->FindEvents(Query::EventArg("num") == Query::Int(2), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("name2", found[0]->name.c_str());
-
- // !=
-
- analyzer->FindEvents(Query::EventCategory() != Query::String("cat1"), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name3", found[0]->name.c_str());
- EXPECT_STREQ("name4", found[1]->name.c_str());
-
- analyzer->FindEvents(Query::EventArg("num") != Query::Int(2), &found);
- ASSERT_EQ(3u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name3", found[1]->name.c_str());
- EXPECT_STREQ("name4", found[2]->name.c_str());
-
- // <
- analyzer->FindEvents(Query::EventArg("num") < Query::Int(2), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
-
- // <=
- analyzer->FindEvents(Query::EventArg("num") <= Query::Int(2), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name2", found[1]->name.c_str());
-
- // >
- analyzer->FindEvents(Query::EventArg("num") > Query::Int(3), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("name4", found[0]->name.c_str());
-
- // >=
- analyzer->FindEvents(Query::EventArg("num") >= Query::Int(4), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("name4", found[0]->name.c_str());
-
- // &&
- analyzer->FindEvents(Query::EventName() != Query::String("name1") &&
- Query::EventArg("num") < Query::Int(3), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("name2", found[0]->name.c_str());
-
- // ||
- analyzer->FindEvents(Query::EventName() == Query::String("name1") ||
- Query::EventArg("num") == Query::Int(3), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name3", found[1]->name.c_str());
-
- // !
- analyzer->FindEvents(!(Query::EventName() == Query::String("name1") ||
- Query::EventArg("num") == Query::Int(3)), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name2", found[0]->name.c_str());
- EXPECT_STREQ("name4", found[1]->name.c_str());
-}
-
-TEST_F(TraceEventAnalyzerTest, ArithmeticOperators) {
- ManualSetUp();
-
- BeginTracing();
- {
- // These events are searched for:
- TRACE_EVENT_INSTANT2("cat1", "math1", TRACE_EVENT_SCOPE_THREAD,
- "a", 10, "b", 5);
- TRACE_EVENT_INSTANT2("cat1", "math2", TRACE_EVENT_SCOPE_THREAD,
- "a", 10, "b", 10);
- // Extra events that never match, for noise:
- TRACE_EVENT_INSTANT2("noise", "math3", TRACE_EVENT_SCOPE_THREAD,
- "a", 1, "b", 3);
- TRACE_EVENT_INSTANT2("noise", "math4", TRACE_EVENT_SCOPE_THREAD,
- "c", 10, "d", 5);
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
-
- TraceEventVector found;
-
- // Verify that arithmetic operators function:
-
- // +
- analyzer->FindEvents(Query::EventArg("a") + Query::EventArg("b") ==
- Query::Int(20), &found);
- EXPECT_EQ(1u, found.size());
- EXPECT_STREQ("math2", found.front()->name.c_str());
-
- // -
- analyzer->FindEvents(Query::EventArg("a") - Query::EventArg("b") ==
- Query::Int(5), &found);
- EXPECT_EQ(1u, found.size());
- EXPECT_STREQ("math1", found.front()->name.c_str());
-
- // *
- analyzer->FindEvents(Query::EventArg("a") * Query::EventArg("b") ==
- Query::Int(50), &found);
- EXPECT_EQ(1u, found.size());
- EXPECT_STREQ("math1", found.front()->name.c_str());
-
- // /
- analyzer->FindEvents(Query::EventArg("a") / Query::EventArg("b") ==
- Query::Int(2), &found);
- EXPECT_EQ(1u, found.size());
- EXPECT_STREQ("math1", found.front()->name.c_str());
-
- // %
- analyzer->FindEvents(Query::EventArg("a") % Query::EventArg("b") ==
- Query::Int(0), &found);
- EXPECT_EQ(2u, found.size());
-
- // - (negate)
- analyzer->FindEvents(-Query::EventArg("b") == Query::Int(-10), &found);
- EXPECT_EQ(1u, found.size());
- EXPECT_STREQ("math2", found.front()->name.c_str());
-}
-
-TEST_F(TraceEventAnalyzerTest, StringPattern) {
- ManualSetUp();
-
- BeginTracing();
- {
- TRACE_EVENT_INSTANT0("cat1", "name1", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat1", "name2", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat1", "no match", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat1", "name3x", TRACE_EVENT_SCOPE_THREAD);
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->SetIgnoreMetadataEvents(true);
-
- TraceEventVector found;
-
- analyzer->FindEvents(Query::EventName() == Query::Pattern("name?"), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name2", found[1]->name.c_str());
-
- analyzer->FindEvents(Query::EventName() == Query::Pattern("name*"), &found);
- ASSERT_EQ(3u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name2", found[1]->name.c_str());
- EXPECT_STREQ("name3x", found[2]->name.c_str());
-
- analyzer->FindEvents(Query::EventName() != Query::Pattern("name*"), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("no match", found[0]->name.c_str());
-}
-
-// Test that duration queries work.
-TEST_F(TraceEventAnalyzerTest, BeginEndDuration) {
- ManualSetUp();
-
- const base::TimeDelta kSleepTime = base::TimeDelta::FromMilliseconds(200);
- // We will search for events that have a duration of greater than 90% of the
- // sleep time, so that there is no flakiness.
- int64_t duration_cutoff_us = (kSleepTime.InMicroseconds() * 9) / 10;
-
- BeginTracing();
- {
- TRACE_EVENT_BEGIN0("cat1", "name1"); // found by duration query
- TRACE_EVENT_BEGIN0("noise", "name2"); // not searched for, just noise
- {
- TRACE_EVENT_BEGIN0("cat2", "name3"); // found by duration query
- // next event not searched for, just noise
- TRACE_EVENT_INSTANT0("noise", "name4", TRACE_EVENT_SCOPE_THREAD);
- base::PlatformThread::Sleep(kSleepTime);
- TRACE_EVENT_BEGIN0("cat2", "name5"); // not found (duration too short)
- TRACE_EVENT_END0("cat2", "name5"); // not found (duration too short)
- TRACE_EVENT_END0("cat2", "name3"); // found by duration query
- }
- TRACE_EVENT_END0("noise", "name2"); // not searched for, just noise
- TRACE_EVENT_END0("cat1", "name1"); // found by duration query
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->AssociateBeginEndEvents();
-
- TraceEventVector found;
- analyzer->FindEvents(
- Query::MatchBeginWithEnd() &&
- Query::EventDuration() >
- Query::Int(static_cast<int>(duration_cutoff_us)) &&
- (Query::EventCategory() == Query::String("cat1") ||
- Query::EventCategory() == Query::String("cat2") ||
- Query::EventCategory() == Query::String("cat3")),
- &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name3", found[1]->name.c_str());
-}
-
-// Test that duration queries work.
-TEST_F(TraceEventAnalyzerTest, CompleteDuration) {
- ManualSetUp();
-
- const base::TimeDelta kSleepTime = base::TimeDelta::FromMilliseconds(200);
- // We will search for events that have a duration of greater than 90% of the
- // sleep time, so that there is no flakiness.
- int64_t duration_cutoff_us = (kSleepTime.InMicroseconds() * 9) / 10;
-
- BeginTracing();
- {
- TRACE_EVENT0("cat1", "name1"); // found by duration query
- TRACE_EVENT0("noise", "name2"); // not searched for, just noise
- {
- TRACE_EVENT0("cat2", "name3"); // found by duration query
- // next event not searched for, just noise
- TRACE_EVENT_INSTANT0("noise", "name4", TRACE_EVENT_SCOPE_THREAD);
- base::PlatformThread::Sleep(kSleepTime);
- TRACE_EVENT0("cat2", "name5"); // not found (duration too short)
- }
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->AssociateBeginEndEvents();
-
- TraceEventVector found;
- analyzer->FindEvents(
- Query::EventCompleteDuration() >
- Query::Int(static_cast<int>(duration_cutoff_us)) &&
- (Query::EventCategory() == Query::String("cat1") ||
- Query::EventCategory() == Query::String("cat2") ||
- Query::EventCategory() == Query::String("cat3")),
- &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STREQ("name1", found[0]->name.c_str());
- EXPECT_STREQ("name3", found[1]->name.c_str());
-}
-
-// Test AssociateBeginEndEvents
-TEST_F(TraceEventAnalyzerTest, BeginEndAssocations) {
- ManualSetUp();
-
- BeginTracing();
- {
- TRACE_EVENT_END0("cat1", "name1"); // does not match out of order begin
- TRACE_EVENT_BEGIN0("cat1", "name2");
- TRACE_EVENT_INSTANT0("cat1", "name3", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_BEGIN0("cat1", "name1");
- TRACE_EVENT_END0("cat1", "name2");
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->AssociateBeginEndEvents();
-
- TraceEventVector found;
- analyzer->FindEvents(Query::MatchBeginWithEnd(), &found);
- ASSERT_EQ(1u, found.size());
- EXPECT_STREQ("name2", found[0]->name.c_str());
-}
-
-// Test MergeAssociatedEventArgs
-TEST_F(TraceEventAnalyzerTest, MergeAssociatedEventArgs) {
- ManualSetUp();
-
- const char arg_string[] = "arg_string";
- BeginTracing();
- {
- TRACE_EVENT_BEGIN0("cat1", "name1");
- TRACE_EVENT_END1("cat1", "name1", "arg", arg_string);
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->AssociateBeginEndEvents();
-
- TraceEventVector found;
- analyzer->FindEvents(Query::MatchBeginName("name1"), &found);
- ASSERT_EQ(1u, found.size());
- std::string arg_actual;
- EXPECT_FALSE(found[0]->GetArgAsString("arg", &arg_actual));
-
- analyzer->MergeAssociatedEventArgs();
- EXPECT_TRUE(found[0]->GetArgAsString("arg", &arg_actual));
- EXPECT_STREQ(arg_string, arg_actual.c_str());
-}
-
-// Test AssociateAsyncBeginEndEvents
-TEST_F(TraceEventAnalyzerTest, AsyncBeginEndAssocations) {
- ManualSetUp();
-
- BeginTracing();
- {
- TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xA); // no match / out of order
- TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xB);
- TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xC);
- TRACE_EVENT_INSTANT0("cat1", "name1", TRACE_EVENT_SCOPE_THREAD); // noise
- TRACE_EVENT0("cat1", "name1"); // noise
- TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xB);
- TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xC);
- TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xA); // no match / out of order
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->AssociateAsyncBeginEndEvents();
-
- TraceEventVector found;
- analyzer->FindEvents(Query::MatchAsyncBeginWithNext(), &found);
- ASSERT_EQ(2u, found.size());
- EXPECT_STRCASEEQ("0xb", found[0]->id.c_str());
- EXPECT_STRCASEEQ("0xc", found[1]->id.c_str());
-}
-
-// Test AssociateAsyncBeginEndEvents
-TEST_F(TraceEventAnalyzerTest, AsyncBeginEndAssocationsWithSteps) {
- ManualSetUp();
-
- BeginTracing();
- {
- TRACE_EVENT_ASYNC_STEP_INTO0("c", "n", 0xA, "s1");
- TRACE_EVENT_ASYNC_END0("c", "n", 0xA);
- TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xB);
- TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xC);
- TRACE_EVENT_ASYNC_STEP_PAST0("c", "n", 0xB, "s1");
- TRACE_EVENT_ASYNC_STEP_INTO0("c", "n", 0xC, "s1");
- TRACE_EVENT_ASYNC_STEP_INTO1("c", "n", 0xC, "s2", "a", 1);
- TRACE_EVENT_ASYNC_END0("c", "n", 0xB);
- TRACE_EVENT_ASYNC_END0("c", "n", 0xC);
- TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xA);
- TRACE_EVENT_ASYNC_STEP_INTO0("c", "n", 0xA, "s2");
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
- analyzer->AssociateAsyncBeginEndEvents();
-
- TraceEventVector found;
- analyzer->FindEvents(Query::MatchAsyncBeginWithNext(), &found);
- ASSERT_EQ(3u, found.size());
-
- EXPECT_STRCASEEQ("0xb", found[0]->id.c_str());
- EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, found[0]->other_event->phase);
- EXPECT_EQ(found[0], found[0]->other_event->prev_event);
- EXPECT_TRUE(found[0]->other_event->other_event);
- EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_END,
- found[0]->other_event->other_event->phase);
- EXPECT_EQ(found[0]->other_event,
- found[0]->other_event->other_event->prev_event);
-
- EXPECT_STRCASEEQ("0xc", found[1]->id.c_str());
- EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, found[1]->other_event->phase);
- EXPECT_EQ(found[1], found[1]->other_event->prev_event);
- EXPECT_TRUE(found[1]->other_event->other_event);
- EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP_INTO,
- found[1]->other_event->other_event->phase);
- EXPECT_EQ(found[1]->other_event,
- found[1]->other_event->other_event->prev_event);
- double arg_actual = 0;
- EXPECT_TRUE(found[1]->other_event->other_event->GetArgAsNumber(
- "a", &arg_actual));
- EXPECT_EQ(1.0, arg_actual);
- EXPECT_TRUE(found[1]->other_event->other_event->other_event);
- EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_END,
- found[1]->other_event->other_event->other_event->phase);
-
- EXPECT_STRCASEEQ("0xa", found[2]->id.c_str());
- EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, found[2]->other_event->phase);
-}
-
-// Test that the TraceAnalyzer custom associations work.
-TEST_F(TraceEventAnalyzerTest, CustomAssociations) {
- ManualSetUp();
-
- // Add events that begin/end in pipelined ordering with unique ID parameter
- // to match up the begin/end pairs.
- BeginTracing();
- {
- // no begin match
- TRACE_EVENT_INSTANT1("cat1", "end", TRACE_EVENT_SCOPE_THREAD, "id", 1);
- // end is cat4
- TRACE_EVENT_INSTANT1("cat2", "begin", TRACE_EVENT_SCOPE_THREAD, "id", 2);
- // end is cat5
- TRACE_EVENT_INSTANT1("cat3", "begin", TRACE_EVENT_SCOPE_THREAD, "id", 3);
- TRACE_EVENT_INSTANT1("cat4", "end", TRACE_EVENT_SCOPE_THREAD, "id", 2);
- TRACE_EVENT_INSTANT1("cat5", "end", TRACE_EVENT_SCOPE_THREAD, "id", 3);
- // no end match
- TRACE_EVENT_INSTANT1("cat6", "begin", TRACE_EVENT_SCOPE_THREAD, "id", 1);
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
-
- // begin, end, and match queries to find proper begin/end pairs.
- Query begin(Query::EventName() == Query::String("begin"));
- Query end(Query::EventName() == Query::String("end"));
- Query match(Query::EventArg("id") == Query::OtherArg("id"));
- analyzer->AssociateEvents(begin, end, match);
-
- TraceEventVector found;
-
- // cat1 has no other_event.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat1") &&
- Query::EventHasOther(), &found);
- EXPECT_EQ(0u, found.size());
-
- // cat1 has no other_event.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat1") &&
- !Query::EventHasOther(), &found);
- EXPECT_EQ(1u, found.size());
-
- // cat6 has no other_event.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat6") &&
- !Query::EventHasOther(), &found);
- EXPECT_EQ(1u, found.size());
-
- // cat2 and cat4 are associated.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat2") &&
- Query::OtherCategory() == Query::String("cat4"), &found);
- EXPECT_EQ(1u, found.size());
-
- // cat4 and cat2 are not associated.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat4") &&
- Query::OtherCategory() == Query::String("cat2"), &found);
- EXPECT_EQ(0u, found.size());
-
- // cat3 and cat5 are associated.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat3") &&
- Query::OtherCategory() == Query::String("cat5"), &found);
- EXPECT_EQ(1u, found.size());
-
- // cat5 and cat3 are not associated.
- analyzer->FindEvents(Query::EventCategory() == Query::String("cat5") &&
- Query::OtherCategory() == Query::String("cat3"), &found);
- EXPECT_EQ(0u, found.size());
-}
-
-// Verify that Query literals and types are properly casted.
-TEST_F(TraceEventAnalyzerTest, Literals) {
- ManualSetUp();
-
- // Since these queries don't refer to the event data, the dummy event below
- // will never be accessed.
- TraceEvent dummy;
- char char_num = 5;
- short short_num = -5;
- EXPECT_TRUE((Query::Double(5.0) == Query::Int(char_num)).Evaluate(dummy));
- EXPECT_TRUE((Query::Double(-5.0) == Query::Int(short_num)).Evaluate(dummy));
- EXPECT_TRUE((Query::Double(1.0) == Query::Uint(1u)).Evaluate(dummy));
- EXPECT_TRUE((Query::Double(1.0) == Query::Int(1)).Evaluate(dummy));
- EXPECT_TRUE((Query::Double(-1.0) == Query::Int(-1)).Evaluate(dummy));
- EXPECT_TRUE((Query::Double(1.0) == Query::Double(1.0f)).Evaluate(dummy));
- EXPECT_TRUE((Query::Bool(true) == Query::Int(1)).Evaluate(dummy));
- EXPECT_TRUE((Query::Bool(false) == Query::Int(0)).Evaluate(dummy));
- EXPECT_TRUE((Query::Bool(true) == Query::Double(1.0f)).Evaluate(dummy));
- EXPECT_TRUE((Query::Bool(false) == Query::Double(0.0f)).Evaluate(dummy));
-}
-
-// Test GetRateStats.
-TEST_F(TraceEventAnalyzerTest, RateStats) {
- std::vector<TraceEvent> events;
- events.reserve(100);
- TraceEventVector event_ptrs;
- double timestamp = 0.0;
- double little_delta = 1.0;
- double big_delta = 10.0;
- double tiny_delta = 0.1;
- RateStats stats;
- RateStatsOptions options;
-
- // Insert 10 events, each apart by little_delta.
- for (int i = 0; i < 10; ++i) {
- timestamp += little_delta;
- TraceEvent event;
- event.timestamp = timestamp;
- events.push_back(std::move(event));
- event_ptrs.push_back(&events.back());
- }
-
- ASSERT_TRUE(GetRateStats(event_ptrs, &stats, nullptr));
- EXPECT_EQ(little_delta, stats.mean_us);
- EXPECT_EQ(little_delta, stats.min_us);
- EXPECT_EQ(little_delta, stats.max_us);
- EXPECT_EQ(0.0, stats.standard_deviation_us);
-
- // Add an event apart by big_delta.
- {
- timestamp += big_delta;
- TraceEvent event;
- event.timestamp = timestamp;
- events.push_back(std::move(event));
- event_ptrs.push_back(&events.back());
- }
-
- ASSERT_TRUE(GetRateStats(event_ptrs, &stats, nullptr));
- EXPECT_LT(little_delta, stats.mean_us);
- EXPECT_EQ(little_delta, stats.min_us);
- EXPECT_EQ(big_delta, stats.max_us);
- EXPECT_LT(0.0, stats.standard_deviation_us);
-
- // Trim off the biggest delta and verify stats.
- options.trim_min = 0;
- options.trim_max = 1;
- ASSERT_TRUE(GetRateStats(event_ptrs, &stats, &options));
- EXPECT_EQ(little_delta, stats.mean_us);
- EXPECT_EQ(little_delta, stats.min_us);
- EXPECT_EQ(little_delta, stats.max_us);
- EXPECT_EQ(0.0, stats.standard_deviation_us);
-
- // Add an event apart by tiny_delta.
- {
- timestamp += tiny_delta;
- TraceEvent event;
- event.timestamp = timestamp;
- events.push_back(std::move(event));
- event_ptrs.push_back(&events.back());
- }
-
- // Trim off both the biggest and tiniest delta and verify stats.
- options.trim_min = 1;
- options.trim_max = 1;
- ASSERT_TRUE(GetRateStats(event_ptrs, &stats, &options));
- EXPECT_EQ(little_delta, stats.mean_us);
- EXPECT_EQ(little_delta, stats.min_us);
- EXPECT_EQ(little_delta, stats.max_us);
- EXPECT_EQ(0.0, stats.standard_deviation_us);
-
- // Verify smallest allowed number of events.
- {
- TraceEvent event;
- TraceEventVector few_event_ptrs;
- few_event_ptrs.push_back(&event);
- few_event_ptrs.push_back(&event);
- ASSERT_FALSE(GetRateStats(few_event_ptrs, &stats, nullptr));
- few_event_ptrs.push_back(&event);
- ASSERT_TRUE(GetRateStats(few_event_ptrs, &stats, nullptr));
-
- // Trim off more than allowed and verify failure.
- options.trim_min = 0;
- options.trim_max = 1;
- ASSERT_FALSE(GetRateStats(few_event_ptrs, &stats, &options));
- }
-}
-
-// Test FindFirstOf and FindLastOf.
-TEST_F(TraceEventAnalyzerTest, FindOf) {
- size_t num_events = 100;
- size_t index = 0;
- TraceEventVector event_ptrs;
- EXPECT_FALSE(FindFirstOf(event_ptrs, Query::Bool(true), 0, &index));
- EXPECT_FALSE(FindFirstOf(event_ptrs, Query::Bool(true), 10, &index));
- EXPECT_FALSE(FindLastOf(event_ptrs, Query::Bool(true), 0, &index));
- EXPECT_FALSE(FindLastOf(event_ptrs, Query::Bool(true), 10, &index));
-
- std::vector<TraceEvent> events;
- events.resize(num_events);
- for (size_t i = 0; i < events.size(); ++i)
- event_ptrs.push_back(&events[i]);
- size_t bam_index = num_events/2;
- events[bam_index].name = "bam";
- Query query_bam = Query::EventName() == Query::String(events[bam_index].name);
-
- // FindFirstOf
- EXPECT_FALSE(FindFirstOf(event_ptrs, Query::Bool(false), 0, &index));
- EXPECT_TRUE(FindFirstOf(event_ptrs, Query::Bool(true), 0, &index));
- EXPECT_EQ(0u, index);
- EXPECT_TRUE(FindFirstOf(event_ptrs, Query::Bool(true), 5, &index));
- EXPECT_EQ(5u, index);
-
- EXPECT_FALSE(FindFirstOf(event_ptrs, query_bam, bam_index + 1, &index));
- EXPECT_TRUE(FindFirstOf(event_ptrs, query_bam, 0, &index));
- EXPECT_EQ(bam_index, index);
- EXPECT_TRUE(FindFirstOf(event_ptrs, query_bam, bam_index, &index));
- EXPECT_EQ(bam_index, index);
-
- // FindLastOf
- EXPECT_FALSE(FindLastOf(event_ptrs, Query::Bool(false), 1000, &index));
- EXPECT_TRUE(FindLastOf(event_ptrs, Query::Bool(true), 1000, &index));
- EXPECT_EQ(num_events - 1, index);
- EXPECT_TRUE(FindLastOf(event_ptrs, Query::Bool(true), num_events - 5,
- &index));
- EXPECT_EQ(num_events - 5, index);
-
- EXPECT_FALSE(FindLastOf(event_ptrs, query_bam, bam_index - 1, &index));
- EXPECT_TRUE(FindLastOf(event_ptrs, query_bam, num_events, &index));
- EXPECT_EQ(bam_index, index);
- EXPECT_TRUE(FindLastOf(event_ptrs, query_bam, bam_index, &index));
- EXPECT_EQ(bam_index, index);
-}
-
-// Test FindClosest.
-TEST_F(TraceEventAnalyzerTest, FindClosest) {
- size_t index_1 = 0;
- size_t index_2 = 0;
- TraceEventVector event_ptrs;
- EXPECT_FALSE(FindClosest(event_ptrs, Query::Bool(true), 0,
- &index_1, &index_2));
-
- size_t num_events = 5;
- std::vector<TraceEvent> events;
- events.resize(num_events);
- for (size_t i = 0; i < events.size(); ++i) {
- // timestamps go up exponentially so the lower index is always closer in
- // time than the higher index.
- events[i].timestamp = static_cast<double>(i) * static_cast<double>(i);
- event_ptrs.push_back(&events[i]);
- }
- events[0].name = "one";
- events[2].name = "two";
- events[4].name = "three";
- Query query_named = Query::EventName() != Query::String(std::string());
- Query query_one = Query::EventName() == Query::String("one");
-
- // Only one event matches query_one, so two closest can't be found.
- EXPECT_FALSE(FindClosest(event_ptrs, query_one, 0, &index_1, &index_2));
-
- EXPECT_TRUE(FindClosest(event_ptrs, query_one, 3, &index_1, nullptr));
- EXPECT_EQ(0u, index_1);
-
- EXPECT_TRUE(FindClosest(event_ptrs, query_named, 1, &index_1, &index_2));
- EXPECT_EQ(0u, index_1);
- EXPECT_EQ(2u, index_2);
-
- EXPECT_TRUE(FindClosest(event_ptrs, query_named, 4, &index_1, &index_2));
- EXPECT_EQ(4u, index_1);
- EXPECT_EQ(2u, index_2);
-
- EXPECT_TRUE(FindClosest(event_ptrs, query_named, 3, &index_1, &index_2));
- EXPECT_EQ(2u, index_1);
- EXPECT_EQ(0u, index_2);
-}
-
-// Test CountMatches.
-TEST_F(TraceEventAnalyzerTest, CountMatches) {
- TraceEventVector event_ptrs;
- EXPECT_EQ(0u, CountMatches(event_ptrs, Query::Bool(true), 0, 10));
-
- size_t num_events = 5;
- size_t num_named = 3;
- std::vector<TraceEvent> events;
- events.resize(num_events);
- for (size_t i = 0; i < events.size(); ++i)
- event_ptrs.push_back(&events[i]);
- events[0].name = "one";
- events[2].name = "two";
- events[4].name = "three";
- Query query_named = Query::EventName() != Query::String(std::string());
- Query query_one = Query::EventName() == Query::String("one");
-
- EXPECT_EQ(0u, CountMatches(event_ptrs, Query::Bool(false)));
- EXPECT_EQ(num_events, CountMatches(event_ptrs, Query::Bool(true)));
- EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, Query::Bool(true),
- 1, num_events));
- EXPECT_EQ(1u, CountMatches(event_ptrs, query_one));
- EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, !query_one));
- EXPECT_EQ(num_named, CountMatches(event_ptrs, query_named));
-}
-
-TEST_F(TraceEventAnalyzerTest, ComplexArgument) {
- ManualSetUp();
-
- BeginTracing();
- {
- std::unique_ptr<base::trace_event::TracedValue> value(
- new base::trace_event::TracedValue);
- value->SetString("property", "value");
- TRACE_EVENT1("cat", "name", "arg", std::move(value));
- }
- EndTracing();
-
- std::unique_ptr<TraceAnalyzer> analyzer(
- TraceAnalyzer::Create(output_.json_output));
- ASSERT_TRUE(analyzer.get());
-
- TraceEventVector events;
- analyzer->FindEvents(Query::EventName() == Query::String("name"), &events);
-
- EXPECT_EQ(1u, events.size());
- EXPECT_EQ("cat", events[0]->category);
- EXPECT_EQ("name", events[0]->name);
- EXPECT_TRUE(events[0]->HasArg("arg"));
-
- std::unique_ptr<base::Value> arg;
- events[0]->GetArgAsValue("arg", &arg);
- base::DictionaryValue* arg_dict;
- EXPECT_TRUE(arg->GetAsDictionary(&arg_dict));
- std::string property;
- EXPECT_TRUE(arg_dict->GetString("property", &property));
- EXPECT_EQ("value", property);
-}
-
-} // namespace trace_analyzer
diff --git a/base/test/user_action_tester_unittest.cc b/base/test/user_action_tester_unittest.cc
deleted file mode 100644
index a51849f..0000000
--- a/base/test/user_action_tester_unittest.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2015 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 "base/test/user_action_tester.h"
-
-#include "base/metrics/user_metrics.h"
-#include "base/metrics/user_metrics_action.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-const char kUserAction1[] = "user.action.1";
-const char kUserAction2[] = "user.action.2";
-const char kUserAction3[] = "user.action.3";
-
-// Record an action and cause all ActionCallback observers to be notified.
-void RecordAction(const char user_action[]) {
- base::RecordAction(base::UserMetricsAction(user_action));
-}
-
-} // namespace
-
-// Verify user action counts are zero initially.
-TEST(UserActionTesterTest, GetActionCountWhenNoActionsHaveBeenRecorded) {
- UserActionTester user_action_tester;
- EXPECT_EQ(0, user_action_tester.GetActionCount(kUserAction1));
-}
-
-// Verify user action counts are tracked properly.
-TEST(UserActionTesterTest, GetActionCountWhenActionsHaveBeenRecorded) {
- UserActionTester user_action_tester;
-
- RecordAction(kUserAction1);
- RecordAction(kUserAction2);
- RecordAction(kUserAction2);
-
- EXPECT_EQ(1, user_action_tester.GetActionCount(kUserAction1));
- EXPECT_EQ(2, user_action_tester.GetActionCount(kUserAction2));
- EXPECT_EQ(0, user_action_tester.GetActionCount(kUserAction3));
-}
-
-// Verify no seg faults occur when resetting action counts when none have been
-// recorded.
-TEST(UserActionTesterTest, ResetCountsWhenNoActionsHaveBeenRecorded) {
- UserActionTester user_action_tester;
- user_action_tester.ResetCounts();
-}
-
-// Verify user action counts are set to zero on a ResetCounts.
-TEST(UserActionTesterTest, ResetCountsWhenActionsHaveBeenRecorded) {
- UserActionTester user_action_tester;
-
- RecordAction(kUserAction1);
- RecordAction(kUserAction1);
- RecordAction(kUserAction2);
- user_action_tester.ResetCounts();
-
- EXPECT_EQ(0, user_action_tester.GetActionCount(kUserAction1));
- EXPECT_EQ(0, user_action_tester.GetActionCount(kUserAction2));
- EXPECT_EQ(0, user_action_tester.GetActionCount(kUserAction3));
-}
-
-// Verify the UserActionsTester is notified when base::RecordAction is called.
-TEST(UserActionTesterTest, VerifyUserActionTesterListensForUserActions) {
- UserActionTester user_action_tester;
-
- base::RecordAction(base::UserMetricsAction(kUserAction1));
-
- EXPECT_EQ(1, user_action_tester.GetActionCount(kUserAction1));
-}
-
-// Verify the UserActionsTester is notified when base::RecordComputedAction is
-// called.
-TEST(UserActionTesterTest,
- VerifyUserActionTesterListensForComputedUserActions) {
- UserActionTester user_action_tester;
-
- base::RecordComputedAction(kUserAction1);
-
- EXPECT_EQ(1, user_action_tester.GetActionCount(kUserAction1));
-}
-
-} // namespace base
diff --git a/base/third_party/dynamic_annotations/BUILD.gn b/base/third_party/dynamic_annotations/BUILD.gn
deleted file mode 100644
index 0fc4bf7..0000000
--- a/base/third_party/dynamic_annotations/BUILD.gn
+++ /dev/null
@@ -1,27 +0,0 @@
-# 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.
-
-if (is_nacl) {
- # Native client doesn't need dynamic annotations, so we provide a
- # dummy target in order for clients to not have to special-case the
- # dependency.
- source_set("dynamic_annotations") {
- sources = [
- "dynamic_annotations.h",
- ]
- }
-} else {
- # Should be static library, see documentation on //base:base for discussion.
- static_library("dynamic_annotations") {
- sources = [
- "../valgrind/valgrind.h",
- "dynamic_annotations.c",
- "dynamic_annotations.h",
- ]
- if (is_android && !is_debug) {
- configs -= [ "//build/config/compiler:default_optimization" ]
- configs += [ "//build/config/compiler:optimize_max" ]
- }
- }
-}
diff --git a/base/third_party/libevent/BUILD.gn b/base/third_party/libevent/BUILD.gn
deleted file mode 100644
index e934454..0000000
--- a/base/third_party/libevent/BUILD.gn
+++ /dev/null
@@ -1,80 +0,0 @@
-# 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.
-
-import("//build/config/nacl/config.gni")
-
-static_library("libevent") {
- sources = [
- "buffer.c",
- "evbuffer.c",
- "evdns.c",
- "evdns.h",
- "event-config.h",
- "event-internal.h",
- "event.c",
- "event.h",
- "event_tagging.c",
- "evhttp.h",
- "evrpc-internal.h",
- "evrpc.c",
- "evrpc.h",
- "evsignal.h",
- "evutil.c",
- "evutil.h",
- "http-internal.h",
- "http.c",
- "log.c",
- "log.h",
- "min_heap.h",
- "poll.c",
- "select.c",
- "signal.c",
- "strlcpy-internal.h",
- "strlcpy.c",
- ]
-
- defines = [ "HAVE_CONFIG_H" ]
-
- if (is_mac || is_ios) {
- sources += [
- "kqueue.c",
- "mac/config.h",
- "mac/event-config.h",
- ]
- include_dirs = [ "mac" ]
- } else if (is_linux) {
- sources += [
- "epoll.c",
- "linux/config.h",
- "linux/event-config.h",
- ]
- include_dirs = [ "linux" ]
- } else if (is_android) {
- sources += [
- "android/config.h",
- "android/event-config.h",
- "epoll.c",
- ]
- include_dirs = [ "android" ]
- } else if (is_nacl_nonsfi) {
- sources -= [
- "evdns.c",
- "event_tagging.c",
- "evrpc.c",
- "http.c",
- "select.c",
- "signal.c",
- ]
- sources += [
- "nacl_nonsfi/config.h",
- "nacl_nonsfi/event-config.h",
- "nacl_nonsfi/random.c",
- "nacl_nonsfi/signal_stub.c",
- ]
- include_dirs = [ "nacl_nonsfi" ]
- }
-
- configs -= [ "//build/config/compiler:chromium_code" ]
- configs += [ "//build/config/compiler:no_chromium_code" ]
-}
diff --git a/base/third_party/symbolize/BUILD.gn b/base/third_party/symbolize/BUILD.gn
deleted file mode 100644
index 0dc7c2f..0000000
--- a/base/third_party/symbolize/BUILD.gn
+++ /dev/null
@@ -1,36 +0,0 @@
-# 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.
-
-import("//build/config/compiler/compiler.gni")
-
-declare_args() {
- # Stack traces will not include function names. Instead they will contain
- # file and offset information that can be used with
- # tools/valgrind/asan/asan_symbolize.py. By piping stderr through this script,
- # and also enabling symbol_level = 2, you can get much more detailed stack
- # traces with file names and line numbers, even in non-ASAN builds.
- print_unsymbolized_stack_traces = is_asan || is_lsan || is_msan || is_tsan
-}
-
-static_library("symbolize") {
- visibility = [ "//base/*" ]
- sources = [
- "config.h",
- "demangle.cc",
- "demangle.h",
- "glog/logging.h",
- "glog/raw_logging.h",
- "symbolize.cc",
- "symbolize.h",
- "utilities.h",
- ]
-
- defines = []
- if (print_unsymbolized_stack_traces) {
- defines += [ "PRINT_UNSYMBOLIZED_STACK_TRACES" ]
- }
-
- configs -= [ "//build/config/compiler:chromium_code" ]
- configs += [ "//build/config/compiler:no_chromium_code" ]
-}
diff --git a/base/third_party/xdg_mime/BUILD.gn b/base/third_party/xdg_mime/BUILD.gn
deleted file mode 100644
index ac9e2c9..0000000
--- a/base/third_party/xdg_mime/BUILD.gn
+++ /dev/null
@@ -1,28 +0,0 @@
-# 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.
-
-static_library("xdg_mime") {
- visibility = [ "//base/*" ]
- sources = [
- "xdgmime.c",
- "xdgmime.h",
- "xdgmimealias.c",
- "xdgmimealias.h",
- "xdgmimecache.c",
- "xdgmimecache.h",
- "xdgmimeglob.c",
- "xdgmimeglob.h",
- "xdgmimeicon.c",
- "xdgmimeicon.h",
- "xdgmimeint.c",
- "xdgmimeint.h",
- "xdgmimemagic.c",
- "xdgmimemagic.h",
- "xdgmimeparent.c",
- "xdgmimeparent.h",
- ]
-
- configs -= [ "//build/config/compiler:chromium_code" ]
- configs += [ "//build/config/compiler:no_chromium_code" ]
-}
diff --git a/base/third_party/xdg_user_dirs/BUILD.gn b/base/third_party/xdg_user_dirs/BUILD.gn
deleted file mode 100644
index a5626e9..0000000
--- a/base/third_party/xdg_user_dirs/BUILD.gn
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-static_library("xdg_user_dirs") {
- visibility = [ "//base/*" ]
- sources = [
- "xdg_user_dir_lookup.cc",
- "xdg_user_dir_lookup.h",
- ]
-}
diff --git a/base/thread_annotations_unittest.cc b/base/thread_annotations_unittest.cc
deleted file mode 100644
index b4aafef..0000000
--- a/base/thread_annotations_unittest.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2018 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 "thread_annotations.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-class LOCKABLE Lock {
- public:
- void Acquire() EXCLUSIVE_LOCK_FUNCTION() {}
- void Release() UNLOCK_FUNCTION() {}
-};
-
-class SCOPED_LOCKABLE AutoLock {
- public:
- AutoLock(Lock& lock) EXCLUSIVE_LOCK_FUNCTION(lock) : lock_(lock) {
- lock.Acquire();
- }
- ~AutoLock() UNLOCK_FUNCTION() { lock_.Release(); }
-
- private:
- Lock& lock_;
-};
-
-class ThreadSafe {
- public:
- void ExplicitIncrement();
- void ImplicitIncrement();
-
- private:
- Lock lock_;
- int counter_ GUARDED_BY(lock_);
-};
-
-void ThreadSafe::ExplicitIncrement() {
- lock_.Acquire();
- ++counter_;
- lock_.Release();
-}
-
-void ThreadSafe::ImplicitIncrement() {
- AutoLock auto_lock(lock_);
- counter_++;
-}
-
-TEST(ThreadAnnotationsTest, ExplicitIncrement) {
- ThreadSafe thread_safe;
- thread_safe.ExplicitIncrement();
-}
-TEST(ThreadAnnotationsTest, ImplicitIncrement) {
- ThreadSafe thread_safe;
- thread_safe.ImplicitIncrement();
-}
-
-} // anonymous namespace
diff --git a/base/thread_annotations_unittest.nc b/base/thread_annotations_unittest.nc
deleted file mode 100644
index ea64a7e..0000000
--- a/base/thread_annotations_unittest.nc
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2018 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 is a "No Compile Test" suite.
-// https://dev.chromium.org/developers/testing/no-compile-tests
-
-#include "base/thread_annotations.h"
-
-namespace {
-
-class LOCKABLE Lock {
- public:
- void Acquire() EXCLUSIVE_LOCK_FUNCTION() {}
- void Release() UNLOCK_FUNCTION() {}
-};
-
-class SCOPED_LOCKABLE AutoLock {
- public:
- AutoLock(Lock& lock) EXCLUSIVE_LOCK_FUNCTION(lock) : lock_(lock) {
- lock.Acquire();
- }
- ~AutoLock() UNLOCK_FUNCTION() { lock_.Release(); }
-
- private:
- Lock& lock_;
-};
-class ThreadSafe {
- public:
- void BuggyIncrement();
- private:
- Lock lock_;
- int counter_ GUARDED_BY(lock_);
-};
-
-#if defined(NCTEST_LOCK_WITHOUT_UNLOCK) // [r"fatal error: mutex 'lock_' is still held at the end of function"]
-
-void ThreadSafe::BuggyIncrement() {
- lock_.Acquire();
- ++counter_;
- // Forgot to release the lock.
-}
-
-#elif defined(NCTEST_ACCESS_WITHOUT_LOCK) // [r"fatal error: writing variable 'counter_' requires holding mutex 'lock_' exclusively"]
-
-void ThreadSafe::BuggyIncrement() {
- // Member access without holding the lock guarding it.
- ++counter_;
-}
-
-#elif defined(NCTEST_ACCESS_WITHOUT_SCOPED_LOCK) // [r"fatal error: writing variable 'counter_' requires holding mutex 'lock_' exclusively"]
-
-void ThreadSafe::BuggyIncrement() {
- {
- AutoLock auto_lock(lock_);
- // The AutoLock will go out of scope before the guarded member access.
- }
- ++counter_;
-}
-
-#elif defined(NCTEST_GUARDED_BY_WRONG_TYPE) // [r"fatal error: 'guarded_by' attribute requires arguments whose type is annotated"]
-
-int not_lockable;
-int global_counter GUARDED_BY(not_lockable);
-
-// Defined to avoid link error.
-void ThreadSafe::BuggyIncrement() { }
-
-#endif
-
-} // anonymous namespace
diff --git a/base/threading/platform_thread_unittest.cc b/base/threading/platform_thread_unittest.cc
deleted file mode 100644
index 968f0e0..0000000
--- a/base/threading/platform_thread_unittest.cc
+++ /dev/null
@@ -1,367 +0,0 @@
-// 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.
-
-#include <stddef.h>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_POSIX)
-#include "base/threading/platform_thread_internal_posix.h"
-#elif defined(OS_WIN)
-#include <windows.h>
-#endif
-
-namespace base {
-
-// Trivial tests that thread runs and doesn't crash on create, join, or detach -
-
-namespace {
-
-class TrivialThread : public PlatformThread::Delegate {
- public:
- TrivialThread() : run_event_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- void ThreadMain() override { run_event_.Signal(); }
-
- WaitableEvent& run_event() { return run_event_; }
-
- private:
- WaitableEvent run_event_;
-
- DISALLOW_COPY_AND_ASSIGN(TrivialThread);
-};
-
-} // namespace
-
-TEST(PlatformThreadTest, TrivialJoin) {
- TrivialThread thread;
- PlatformThreadHandle handle;
-
- ASSERT_FALSE(thread.run_event().IsSignaled());
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
- PlatformThread::Join(handle);
- ASSERT_TRUE(thread.run_event().IsSignaled());
-}
-
-TEST(PlatformThreadTest, TrivialJoinTimesTen) {
- TrivialThread thread[10];
- PlatformThreadHandle handle[arraysize(thread)];
-
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_FALSE(thread[n].run_event().IsSignaled());
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
- for (size_t n = 0; n < arraysize(thread); n++)
- PlatformThread::Join(handle[n]);
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_TRUE(thread[n].run_event().IsSignaled());
-}
-
-// The following detach tests are by nature racy. The run_event approximates the
-// end and termination of the thread, but threads could persist shortly after
-// the test completes.
-TEST(PlatformThreadTest, TrivialDetach) {
- TrivialThread thread;
- PlatformThreadHandle handle;
-
- ASSERT_FALSE(thread.run_event().IsSignaled());
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
- PlatformThread::Detach(handle);
- thread.run_event().Wait();
-}
-
-TEST(PlatformThreadTest, TrivialDetachTimesTen) {
- TrivialThread thread[10];
- PlatformThreadHandle handle[arraysize(thread)];
-
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_FALSE(thread[n].run_event().IsSignaled());
- for (size_t n = 0; n < arraysize(thread); n++) {
- ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
- PlatformThread::Detach(handle[n]);
- }
- for (size_t n = 0; n < arraysize(thread); n++)
- thread[n].run_event().Wait();
-}
-
-// Tests of basic thread functions ---------------------------------------------
-
-namespace {
-
-class FunctionTestThread : public PlatformThread::Delegate {
- public:
- FunctionTestThread()
- : thread_id_(kInvalidThreadId),
- termination_ready_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- terminate_thread_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- done_(false) {}
- ~FunctionTestThread() override {
- EXPECT_TRUE(terminate_thread_.IsSignaled())
- << "Need to mark thread for termination and join the underlying thread "
- << "before destroying a FunctionTestThread as it owns the "
- << "WaitableEvent blocking the underlying thread's main.";
- }
-
- // Grabs |thread_id_|, runs an optional test on that thread, signals
- // |termination_ready_|, and then waits for |terminate_thread_| to be
- // signaled before exiting.
- void ThreadMain() override {
- thread_id_ = PlatformThread::CurrentId();
- EXPECT_NE(thread_id_, kInvalidThreadId);
-
- // Make sure that the thread ID is the same across calls.
- EXPECT_EQ(thread_id_, PlatformThread::CurrentId());
-
- // Run extra tests.
- RunTest();
-
- termination_ready_.Signal();
- terminate_thread_.Wait();
-
- done_ = true;
- }
-
- PlatformThreadId thread_id() const {
- EXPECT_TRUE(termination_ready_.IsSignaled()) << "Thread ID still unknown";
- return thread_id_;
- }
-
- bool IsRunning() const {
- return termination_ready_.IsSignaled() && !done_;
- }
-
- // Blocks until this thread is started and ready to be terminated.
- void WaitForTerminationReady() { termination_ready_.Wait(); }
-
- // Marks this thread for termination (callers must then join this thread to be
- // guaranteed of termination).
- void MarkForTermination() { terminate_thread_.Signal(); }
-
- private:
- // Runs an optional test on the newly created thread.
- virtual void RunTest() {}
-
- PlatformThreadId thread_id_;
-
- mutable WaitableEvent termination_ready_;
- WaitableEvent terminate_thread_;
- bool done_;
-
- DISALLOW_COPY_AND_ASSIGN(FunctionTestThread);
-};
-
-} // namespace
-
-TEST(PlatformThreadTest, Function) {
- PlatformThreadId main_thread_id = PlatformThread::CurrentId();
-
- FunctionTestThread thread;
- PlatformThreadHandle handle;
-
- ASSERT_FALSE(thread.IsRunning());
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
- thread.WaitForTerminationReady();
- ASSERT_TRUE(thread.IsRunning());
- EXPECT_NE(thread.thread_id(), main_thread_id);
-
- thread.MarkForTermination();
- PlatformThread::Join(handle);
- ASSERT_FALSE(thread.IsRunning());
-
- // Make sure that the thread ID is the same across calls.
- EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
-}
-
-TEST(PlatformThreadTest, FunctionTimesTen) {
- PlatformThreadId main_thread_id = PlatformThread::CurrentId();
-
- FunctionTestThread thread[10];
- PlatformThreadHandle handle[arraysize(thread)];
-
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_FALSE(thread[n].IsRunning());
-
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
- for (size_t n = 0; n < arraysize(thread); n++)
- thread[n].WaitForTerminationReady();
-
- for (size_t n = 0; n < arraysize(thread); n++) {
- ASSERT_TRUE(thread[n].IsRunning());
- EXPECT_NE(thread[n].thread_id(), main_thread_id);
-
- // Make sure no two threads get the same ID.
- for (size_t i = 0; i < n; ++i) {
- EXPECT_NE(thread[i].thread_id(), thread[n].thread_id());
- }
- }
-
- for (size_t n = 0; n < arraysize(thread); n++)
- thread[n].MarkForTermination();
- for (size_t n = 0; n < arraysize(thread); n++)
- PlatformThread::Join(handle[n]);
- for (size_t n = 0; n < arraysize(thread); n++)
- ASSERT_FALSE(thread[n].IsRunning());
-
- // Make sure that the thread ID is the same across calls.
- EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
-}
-
-namespace {
-
-const ThreadPriority kThreadPriorityTestValues[] = {
-// The order should be higher to lower to cover as much cases as possible on
-// Linux trybots running without CAP_SYS_NICE permission.
-#if !defined(OS_ANDROID)
- // PlatformThread::GetCurrentThreadPriority() on Android does not support
- // REALTIME_AUDIO case. See http://crbug.com/505474.
- ThreadPriority::REALTIME_AUDIO,
-#endif
- ThreadPriority::DISPLAY,
- // This redundant BACKGROUND priority is to test backgrounding from other
- // priorities, and unbackgrounding.
- ThreadPriority::BACKGROUND,
- ThreadPriority::NORMAL,
- ThreadPriority::BACKGROUND};
-
-class ThreadPriorityTestThread : public FunctionTestThread {
- public:
- explicit ThreadPriorityTestThread(ThreadPriority priority)
- : priority_(priority) {}
- ~ThreadPriorityTestThread() override = default;
-
- private:
- void RunTest() override {
- // Confirm that the current thread's priority is as expected.
- EXPECT_EQ(ThreadPriority::NORMAL,
- PlatformThread::GetCurrentThreadPriority());
-
- // Alter and verify the current thread's priority.
- PlatformThread::SetCurrentThreadPriority(priority_);
- EXPECT_EQ(priority_, PlatformThread::GetCurrentThreadPriority());
- }
-
- const ThreadPriority priority_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadPriorityTestThread);
-};
-
-} // namespace
-
-// Test changing a created thread's priority (which has different semantics on
-// some platforms).
-TEST(PlatformThreadTest, ThreadPriorityCurrentThread) {
- const bool increase_priority_allowed =
- PlatformThread::CanIncreaseCurrentThreadPriority();
-
-// Bump the priority in order to verify that new threads are started with normal
-// priority. Skip this on Mac since this platform doesn't allow changing the
-// priority of the main thread. Also skip this on platforms that don't allow
-// increasing the priority of a thread.
-#if !defined(OS_MACOSX)
- if (increase_priority_allowed)
- PlatformThread::SetCurrentThreadPriority(ThreadPriority::DISPLAY);
-#endif
-
- // Toggle each supported priority on the thread and confirm it affects it.
- for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) {
- if (!increase_priority_allowed &&
- kThreadPriorityTestValues[i] >
- PlatformThread::GetCurrentThreadPriority()) {
- continue;
- }
-
- ThreadPriorityTestThread thread(kThreadPriorityTestValues[i]);
- PlatformThreadHandle handle;
-
- ASSERT_FALSE(thread.IsRunning());
- ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
- thread.WaitForTerminationReady();
- ASSERT_TRUE(thread.IsRunning());
-
- thread.MarkForTermination();
- PlatformThread::Join(handle);
- ASSERT_FALSE(thread.IsRunning());
- }
-}
-
-// This tests internal PlatformThread APIs used under some POSIX platforms,
-// with the exception of Mac OS X, iOS and Fuchsia.
-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_IOS) && \
- !defined(OS_FUCHSIA)
-TEST(PlatformThreadTest, GetNiceValueToThreadPriority) {
- using internal::NiceValueToThreadPriority;
- using internal::kThreadPriorityToNiceValueMap;
-
- EXPECT_EQ(ThreadPriority::BACKGROUND,
- kThreadPriorityToNiceValueMap[0].priority);
- EXPECT_EQ(ThreadPriority::NORMAL,
- kThreadPriorityToNiceValueMap[1].priority);
- EXPECT_EQ(ThreadPriority::DISPLAY,
- kThreadPriorityToNiceValueMap[2].priority);
- EXPECT_EQ(ThreadPriority::REALTIME_AUDIO,
- kThreadPriorityToNiceValueMap[3].priority);
-
- static const int kBackgroundNiceValue =
- kThreadPriorityToNiceValueMap[0].nice_value;
- static const int kNormalNiceValue =
- kThreadPriorityToNiceValueMap[1].nice_value;
- static const int kDisplayNiceValue =
- kThreadPriorityToNiceValueMap[2].nice_value;
- static const int kRealtimeAudioNiceValue =
- kThreadPriorityToNiceValueMap[3].nice_value;
-
- // The tests below assume the nice values specified in the map are within
- // the range below (both ends exclusive).
- static const int kHighestNiceValue = 19;
- static const int kLowestNiceValue = -20;
-
- EXPECT_GT(kHighestNiceValue, kBackgroundNiceValue);
- EXPECT_GT(kBackgroundNiceValue, kNormalNiceValue);
- EXPECT_GT(kNormalNiceValue, kDisplayNiceValue);
- EXPECT_GT(kDisplayNiceValue, kRealtimeAudioNiceValue);
- EXPECT_GT(kRealtimeAudioNiceValue, kLowestNiceValue);
-
- EXPECT_EQ(ThreadPriority::BACKGROUND,
- NiceValueToThreadPriority(kHighestNiceValue));
- EXPECT_EQ(ThreadPriority::BACKGROUND,
- NiceValueToThreadPriority(kBackgroundNiceValue + 1));
- EXPECT_EQ(ThreadPriority::BACKGROUND,
- NiceValueToThreadPriority(kBackgroundNiceValue));
- EXPECT_EQ(ThreadPriority::BACKGROUND,
- NiceValueToThreadPriority(kNormalNiceValue + 1));
- EXPECT_EQ(ThreadPriority::NORMAL,
- NiceValueToThreadPriority(kNormalNiceValue));
- EXPECT_EQ(ThreadPriority::NORMAL,
- NiceValueToThreadPriority(kDisplayNiceValue + 1));
- EXPECT_EQ(ThreadPriority::DISPLAY,
- NiceValueToThreadPriority(kDisplayNiceValue));
- EXPECT_EQ(ThreadPriority::DISPLAY,
- NiceValueToThreadPriority(kRealtimeAudioNiceValue + 1));
- EXPECT_EQ(ThreadPriority::REALTIME_AUDIO,
- NiceValueToThreadPriority(kRealtimeAudioNiceValue));
- EXPECT_EQ(ThreadPriority::REALTIME_AUDIO,
- NiceValueToThreadPriority(kLowestNiceValue));
-}
-#endif // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_IOS) &&
- // !defined(OS_FUCHSIA)
-
-TEST(PlatformThreadTest, SetHugeThreadName) {
- // Construct an excessively long thread name.
- std::string long_name(1024, 'a');
-
- // SetName has no return code, so just verify that implementations
- // don't [D]CHECK().
- PlatformThread::SetName(long_name);
-}
-
-} // namespace base
diff --git a/base/threading/post_task_and_reply_impl_unittest.cc b/base/threading/post_task_and_reply_impl_unittest.cc
deleted file mode 100644
index 319327d..0000000
--- a/base/threading/post_task_and_reply_impl_unittest.cc
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright 2016 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 "base/threading/post_task_and_reply_impl.h"
-
-#include <utility>
-
-#include "base/auto_reset.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::_;
-
-namespace base {
-namespace internal {
-
-namespace {
-
-class PostTaskAndReplyTaskRunner : public internal::PostTaskAndReplyImpl {
- public:
- explicit PostTaskAndReplyTaskRunner(TaskRunner* destination)
- : destination_(destination) {}
-
- private:
- bool PostTask(const Location& from_here, OnceClosure task) override {
- return destination_->PostTask(from_here, std::move(task));
- }
-
- // Non-owning.
- TaskRunner* const destination_;
-};
-
-class ObjectToDelete : public RefCounted<ObjectToDelete> {
- public:
- // |delete_flag| is set to true when this object is deleted
- ObjectToDelete(bool* delete_flag) : delete_flag_(delete_flag) {
- EXPECT_FALSE(*delete_flag_);
- }
-
- private:
- friend class RefCounted<ObjectToDelete>;
- ~ObjectToDelete() { *delete_flag_ = true; }
-
- bool* const delete_flag_;
-
- DISALLOW_COPY_AND_ASSIGN(ObjectToDelete);
-};
-
-class MockObject {
- public:
- MockObject() = default;
-
- MOCK_METHOD1(Task, void(scoped_refptr<ObjectToDelete>));
- MOCK_METHOD1(Reply, void(scoped_refptr<ObjectToDelete>));
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MockObject);
-};
-
-class MockRunsTasksInCurrentSequenceTaskRunner : public TestMockTimeTaskRunner {
- public:
- MockRunsTasksInCurrentSequenceTaskRunner(
- TestMockTimeTaskRunner::Type type =
- TestMockTimeTaskRunner::Type::kStandalone)
- : TestMockTimeTaskRunner(type) {}
-
- void RunUntilIdleWithRunsTasksInCurrentSequence() {
- AutoReset<bool> reset(&runs_tasks_in_current_sequence_, true);
- RunUntilIdle();
- }
-
- void ClearPendingTasksWithRunsTasksInCurrentSequence() {
- AutoReset<bool> reset(&runs_tasks_in_current_sequence_, true);
- ClearPendingTasks();
- }
-
- // TestMockTimeTaskRunner:
- bool RunsTasksInCurrentSequence() const override {
- return runs_tasks_in_current_sequence_;
- }
-
- private:
- ~MockRunsTasksInCurrentSequenceTaskRunner() override = default;
-
- bool runs_tasks_in_current_sequence_ = false;
-
- DISALLOW_COPY_AND_ASSIGN(MockRunsTasksInCurrentSequenceTaskRunner);
-};
-
-class PostTaskAndReplyImplTest : public testing::Test {
- protected:
- PostTaskAndReplyImplTest() = default;
-
- void PostTaskAndReplyToMockObject() {
- // Expect the post to succeed.
- EXPECT_TRUE(
- PostTaskAndReplyTaskRunner(post_runner_.get())
- .PostTaskAndReply(
- FROM_HERE,
- BindOnce(&MockObject::Task, Unretained(&mock_object_),
- MakeRefCounted<ObjectToDelete>(&delete_task_flag_)),
- BindOnce(&MockObject::Reply, Unretained(&mock_object_),
- MakeRefCounted<ObjectToDelete>(&delete_reply_flag_))));
-
- // Expect the first task to be posted to |post_runner_|.
- EXPECT_TRUE(post_runner_->HasPendingTask());
- EXPECT_FALSE(reply_runner_->HasPendingTask());
- EXPECT_FALSE(delete_task_flag_);
- EXPECT_FALSE(delete_reply_flag_);
- }
-
- scoped_refptr<MockRunsTasksInCurrentSequenceTaskRunner> post_runner_ =
- MakeRefCounted<MockRunsTasksInCurrentSequenceTaskRunner>();
- scoped_refptr<MockRunsTasksInCurrentSequenceTaskRunner> reply_runner_ =
- MakeRefCounted<MockRunsTasksInCurrentSequenceTaskRunner>(
- TestMockTimeTaskRunner::Type::kBoundToThread);
- testing::StrictMock<MockObject> mock_object_;
- bool delete_task_flag_ = false;
- bool delete_reply_flag_ = false;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(PostTaskAndReplyImplTest);
-};
-
-} // namespace
-
-TEST_F(PostTaskAndReplyImplTest, PostTaskAndReply) {
- PostTaskAndReplyToMockObject();
-
- EXPECT_CALL(mock_object_, Task(_));
- post_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
- testing::Mock::VerifyAndClear(&mock_object_);
- // The task should have been deleted right after being run.
- EXPECT_TRUE(delete_task_flag_);
- EXPECT_FALSE(delete_reply_flag_);
-
- // Expect the reply to be posted to |reply_runner_|.
- EXPECT_FALSE(post_runner_->HasPendingTask());
- EXPECT_TRUE(reply_runner_->HasPendingTask());
-
- EXPECT_CALL(mock_object_, Reply(_));
- reply_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
- testing::Mock::VerifyAndClear(&mock_object_);
- EXPECT_TRUE(delete_task_flag_);
- // The reply should have been deleted right after being run.
- EXPECT_TRUE(delete_reply_flag_);
-
- // Expect no pending task in |post_runner_| and |reply_runner_|.
- EXPECT_FALSE(post_runner_->HasPendingTask());
- EXPECT_FALSE(reply_runner_->HasPendingTask());
-}
-
-TEST_F(PostTaskAndReplyImplTest, TaskDoesNotRun) {
- PostTaskAndReplyToMockObject();
-
- // Clear the |post_runner_|. Both callbacks should be scheduled for deletion
- // on the |reply_runner_|.
- post_runner_->ClearPendingTasksWithRunsTasksInCurrentSequence();
- EXPECT_FALSE(post_runner_->HasPendingTask());
- EXPECT_TRUE(reply_runner_->HasPendingTask());
- EXPECT_FALSE(delete_task_flag_);
- EXPECT_FALSE(delete_reply_flag_);
-
- // Run the |reply_runner_|. Both callbacks should be deleted.
- reply_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
- EXPECT_TRUE(delete_task_flag_);
- EXPECT_TRUE(delete_reply_flag_);
-}
-
-TEST_F(PostTaskAndReplyImplTest, ReplyDoesNotRun) {
- PostTaskAndReplyToMockObject();
-
- EXPECT_CALL(mock_object_, Task(_));
- post_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
- testing::Mock::VerifyAndClear(&mock_object_);
- // The task should have been deleted right after being run.
- EXPECT_TRUE(delete_task_flag_);
- EXPECT_FALSE(delete_reply_flag_);
-
- // Expect the reply to be posted to |reply_runner_|.
- EXPECT_FALSE(post_runner_->HasPendingTask());
- EXPECT_TRUE(reply_runner_->HasPendingTask());
-
- // Clear the |reply_runner_| queue without running tasks. The reply callback
- // should be deleted.
- reply_runner_->ClearPendingTasksWithRunsTasksInCurrentSequence();
- EXPECT_TRUE(delete_task_flag_);
- EXPECT_TRUE(delete_reply_flag_);
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/threading/scoped_blocking_call_unittest.cc b/base/threading/scoped_blocking_call_unittest.cc
deleted file mode 100644
index 5e030f3..0000000
--- a/base/threading/scoped_blocking_call_unittest.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2017 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 "base/threading/scoped_blocking_call.h"
-
-#include <memory>
-
-#include "base/macros.h"
-#include "base/test/gtest_util.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class MockBlockingObserver : public internal::BlockingObserver {
- public:
- MockBlockingObserver() = default;
-
- MOCK_METHOD1(BlockingStarted, void(BlockingType));
- MOCK_METHOD0(BlockingTypeUpgraded, void());
- MOCK_METHOD0(BlockingEnded, void());
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MockBlockingObserver);
-};
-
-class ScopedBlockingCallTest : public testing::Test {
- protected:
- ScopedBlockingCallTest() {
- internal::SetBlockingObserverForCurrentThread(&observer_);
- }
-
- ~ScopedBlockingCallTest() override {
- internal::ClearBlockingObserverForTesting();
- }
-
- testing::StrictMock<MockBlockingObserver> observer_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(ScopedBlockingCallTest);
-};
-
-} // namespace
-
-TEST_F(ScopedBlockingCallTest, MayBlock) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::MAY_BLOCK));
- ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST_F(ScopedBlockingCallTest, WillBlock) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::WILL_BLOCK));
- ScopedBlockingCall scoped_blocking_call(BlockingType::WILL_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST_F(ScopedBlockingCallTest, MayBlockWillBlock) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::MAY_BLOCK));
- ScopedBlockingCall scoped_blocking_call_a(BlockingType::MAY_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
-
- {
- EXPECT_CALL(observer_, BlockingTypeUpgraded());
- ScopedBlockingCall scoped_blocking_call_b(BlockingType::WILL_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
- }
-
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST_F(ScopedBlockingCallTest, WillBlockMayBlock) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::WILL_BLOCK));
- ScopedBlockingCall scoped_blocking_call_a(BlockingType::WILL_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
-
- { ScopedBlockingCall scoped_blocking_call_b(BlockingType::MAY_BLOCK); }
-
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST_F(ScopedBlockingCallTest, MayBlockMayBlock) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::MAY_BLOCK));
- ScopedBlockingCall scoped_blocking_call_a(BlockingType::MAY_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
-
- { ScopedBlockingCall scoped_blocking_call_b(BlockingType::MAY_BLOCK); }
-
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST_F(ScopedBlockingCallTest, WillBlockWillBlock) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::WILL_BLOCK));
- ScopedBlockingCall scoped_blocking_call_a(BlockingType::WILL_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
-
- { ScopedBlockingCall scoped_blocking_call_b(BlockingType::WILL_BLOCK); }
-
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST_F(ScopedBlockingCallTest, MayBlockWillBlockTwice) {
- EXPECT_CALL(observer_, BlockingStarted(BlockingType::MAY_BLOCK));
- ScopedBlockingCall scoped_blocking_call_a(BlockingType::MAY_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
-
- {
- EXPECT_CALL(observer_, BlockingTypeUpgraded());
- ScopedBlockingCall scoped_blocking_call_b(BlockingType::WILL_BLOCK);
- testing::Mock::VerifyAndClear(&observer_);
-
- {
- ScopedBlockingCall scoped_blocking_call_c(BlockingType::MAY_BLOCK);
- ScopedBlockingCall scoped_blocking_call_d(BlockingType::WILL_BLOCK);
- }
- }
-
- EXPECT_CALL(observer_, BlockingEnded());
-}
-
-TEST(ScopedBlockingCallDestructionOrderTest, InvalidDestructionOrder) {
- auto scoped_blocking_call_a =
- std::make_unique<ScopedBlockingCall>(BlockingType::WILL_BLOCK);
- auto scoped_blocking_call_b =
- std::make_unique<ScopedBlockingCall>(BlockingType::WILL_BLOCK);
-
- EXPECT_DCHECK_DEATH({ scoped_blocking_call_a.reset(); });
-}
-
-} // namespace base
diff --git a/base/threading/sequence_local_storage_map_unittest.cc b/base/threading/sequence_local_storage_map_unittest.cc
deleted file mode 100644
index a45bbc3..0000000
--- a/base/threading/sequence_local_storage_map_unittest.cc
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2017 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 "base/threading/sequence_local_storage_map.h"
-
-#include <memory>
-#include <utility>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-constexpr int kSlotId = 1;
-
-class SetOnDestroy {
- public:
- SetOnDestroy(bool* was_destroyed_ptr)
- : was_destroyed_ptr_(was_destroyed_ptr) {
- DCHECK(was_destroyed_ptr_);
- DCHECK(!(*was_destroyed_ptr_));
- }
- ~SetOnDestroy() {
- DCHECK(!(*was_destroyed_ptr_));
- *was_destroyed_ptr_ = true;
- }
-
- private:
- bool* const was_destroyed_ptr_;
-
- DISALLOW_COPY_AND_ASSIGN(SetOnDestroy);
-};
-
-template <typename T, typename... Args>
-SequenceLocalStorageMap::ValueDestructorPair CreateValueDestructorPair(
- Args... args) {
- T* value = new T(args...);
- SequenceLocalStorageMap::ValueDestructorPair::DestructorFunc* destructor =
- [](void* ptr) { std::default_delete<T>()(static_cast<T*>(ptr)); };
-
- SequenceLocalStorageMap::ValueDestructorPair value_destructor_pair{
- value, destructor};
-
- return value_destructor_pair;
-}
-
-} // namespace
-
-// Verify that setting a value in the SequenceLocalStorageMap, then getting
-// it will yield the same value.
-TEST(SequenceLocalStorageMapTest, SetGet) {
- SequenceLocalStorageMap sequence_local_storage_map;
- ScopedSetSequenceLocalStorageMapForCurrentThread
- scoped_sequence_local_storage_map(&sequence_local_storage_map);
-
- SequenceLocalStorageMap::ValueDestructorPair value_destructor_pair =
- CreateValueDestructorPair<int>(5);
-
- sequence_local_storage_map.Set(kSlotId, std::move(value_destructor_pair));
-
- EXPECT_EQ(*static_cast<int*>(sequence_local_storage_map.Get(kSlotId)), 5);
-}
-
-// Verify that the destructor is called on a value stored in the
-// SequenceLocalStorageMap when SequenceLocalStorageMap is destroyed.
-TEST(SequenceLocalStorageMapTest, Destructor) {
- bool set_on_destruction = false;
-
- {
- SequenceLocalStorageMap sequence_local_storage_map;
- ScopedSetSequenceLocalStorageMapForCurrentThread
- scoped_sequence_local_storage_map(&sequence_local_storage_map);
-
- SequenceLocalStorageMap::ValueDestructorPair value_destructor_pair =
- CreateValueDestructorPair<SetOnDestroy>(&set_on_destruction);
-
- sequence_local_storage_map.Set(kSlotId, std::move(value_destructor_pair));
- }
-
- EXPECT_TRUE(set_on_destruction);
-}
-
-// Verify that overwriting a value already in the SequenceLocalStorageMap
-// calls value's destructor.
-TEST(SequenceLocalStorageMapTest, DestructorCalledOnSetOverwrite) {
- bool set_on_destruction = false;
- bool set_on_destruction2 = false;
- {
- SequenceLocalStorageMap sequence_local_storage_map;
- ScopedSetSequenceLocalStorageMapForCurrentThread
- scoped_sequence_local_storage_map(&sequence_local_storage_map);
-
- SequenceLocalStorageMap::ValueDestructorPair value_destructor_pair =
- CreateValueDestructorPair<SetOnDestroy>(&set_on_destruction);
- SequenceLocalStorageMap::ValueDestructorPair value_destructor_pair2 =
- CreateValueDestructorPair<SetOnDestroy>(&set_on_destruction2);
-
- sequence_local_storage_map.Set(kSlotId, std::move(value_destructor_pair));
-
- ASSERT_FALSE(set_on_destruction);
-
- // Overwrites the old value in the slot.
- sequence_local_storage_map.Set(kSlotId, std::move(value_destructor_pair2));
-
- // Destructor should've been called for the old value in the slot, and not
- // yet called for the new value.
- EXPECT_TRUE(set_on_destruction);
- EXPECT_FALSE(set_on_destruction2);
- }
- EXPECT_TRUE(set_on_destruction2);
-}
-
-} // namespace internal
-} // namespace base
diff --git a/base/threading/sequence_local_storage_slot_unittest.cc b/base/threading/sequence_local_storage_slot_unittest.cc
deleted file mode 100644
index 4a9f6a9..0000000
--- a/base/threading/sequence_local_storage_slot_unittest.cc
+++ /dev/null
@@ -1,143 +0,0 @@
-// Copyright 2017 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 "base/threading/sequence_local_storage_slot.h"
-
-#include <utility>
-
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/threading/sequence_local_storage_map.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class SequenceLocalStorageSlotTest : public testing::Test {
- protected:
- SequenceLocalStorageSlotTest()
- : scoped_sequence_local_storage_(&sequence_local_storage_) {}
-
- internal::SequenceLocalStorageMap sequence_local_storage_;
- internal::ScopedSetSequenceLocalStorageMapForCurrentThread
- scoped_sequence_local_storage_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SequenceLocalStorageSlotTest);
-};
-
-} // namespace
-
-// Verify that a value stored with Set() can be retrieved with Get().
-TEST_F(SequenceLocalStorageSlotTest, GetSet) {
- SequenceLocalStorageSlot<int> slot;
- slot.Set(5);
- EXPECT_EQ(slot.Get(), 5);
-}
-
-// Verify that setting an object in a SequenceLocalStorageSlot creates a copy
-// of that object independent of the original one.
-TEST_F(SequenceLocalStorageSlotTest, SetObjectIsIndependent) {
- bool should_be_false = false;
-
- SequenceLocalStorageSlot<bool> slot;
-
- slot.Set(should_be_false);
-
- EXPECT_FALSE(slot.Get());
- slot.Get() = true;
- EXPECT_TRUE(slot.Get());
-
- EXPECT_NE(should_be_false, slot.Get());
-}
-
-// Verify that multiple slots work and that calling Get after overwriting
-// a value in a slot yields the new value.
-TEST_F(SequenceLocalStorageSlotTest, GetSetMultipleSlots) {
- SequenceLocalStorageSlot<int> slot1;
- SequenceLocalStorageSlot<int> slot2;
- SequenceLocalStorageSlot<int> slot3;
-
- slot1.Set(1);
- slot2.Set(2);
- slot3.Set(3);
-
- EXPECT_EQ(slot1.Get(), 1);
- EXPECT_EQ(slot2.Get(), 2);
- EXPECT_EQ(slot3.Get(), 3);
-
- slot3.Set(4);
- slot2.Set(5);
- slot1.Set(6);
-
- EXPECT_EQ(slot3.Get(), 4);
- EXPECT_EQ(slot2.Get(), 5);
- EXPECT_EQ(slot1.Get(), 6);
-}
-
-// Verify that changing the the value returned by Get() changes the value
-// in sequence local storage.
-TEST_F(SequenceLocalStorageSlotTest, GetReferenceModifiable) {
- SequenceLocalStorageSlot<bool> slot;
- slot.Set(false);
- slot.Get() = true;
- EXPECT_TRUE(slot.Get());
-}
-
-// Verify that a move-only type can be stored in sequence local storage.
-TEST_F(SequenceLocalStorageSlotTest, SetGetWithMoveOnlyType) {
- std::unique_ptr<int> int_unique_ptr = std::make_unique<int>(5);
-
- SequenceLocalStorageSlot<std::unique_ptr<int>> slot;
- slot.Set(std::move(int_unique_ptr));
-
- EXPECT_EQ(*slot.Get(), 5);
-}
-
-// Verify that a Get() without a previous Set() on a slot returns a
-// default-constructed value.
-TEST_F(SequenceLocalStorageSlotTest, GetWithoutSetDefaultConstructs) {
- struct DefaultConstructable {
- int x = 0x12345678;
- };
-
- SequenceLocalStorageSlot<DefaultConstructable> slot;
-
- EXPECT_EQ(slot.Get().x, 0x12345678);
-}
-
-// Verify that a Get() without a previous Set() on a slot with a POD-type
-// returns a default-constructed value.
-// Note: this test could be flaky and give a false pass. If it's flaky, the test
-// might've "passed" because the memory for the slot happened to be zeroed.
-TEST_F(SequenceLocalStorageSlotTest, GetWithoutSetDefaultConstructsPOD) {
- SequenceLocalStorageSlot<void*> slot;
-
- EXPECT_EQ(slot.Get(), nullptr);
-}
-
-// Verify that the value of a slot is specific to a SequenceLocalStorageMap
-TEST(SequenceLocalStorageSlotMultipleMapTest, SetGetMultipleMapsOneSlot) {
- SequenceLocalStorageSlot<unsigned int> slot;
- internal::SequenceLocalStorageMap sequence_local_storage_maps[5];
-
- // Set the value of the slot to be the index of the current
- // SequenceLocalStorageMaps in the vector
- for (unsigned int i = 0; i < arraysize(sequence_local_storage_maps); ++i) {
- internal::ScopedSetSequenceLocalStorageMapForCurrentThread
- scoped_sequence_local_storage(&sequence_local_storage_maps[i]);
-
- slot.Set(i);
- }
-
- for (unsigned int i = 0; i < arraysize(sequence_local_storage_maps); ++i) {
- internal::ScopedSetSequenceLocalStorageMapForCurrentThread
- scoped_sequence_local_storage(&sequence_local_storage_maps[i]);
-
- EXPECT_EQ(slot.Get(), i);
- }
-}
-
-} // namespace base
diff --git a/base/threading/sequenced_task_runner_handle_unittest.cc b/base/threading/sequenced_task_runner_handle_unittest.cc
deleted file mode 100644
index 48394da..0000000
--- a/base/threading/sequenced_task_runner_handle_unittest.cc
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2015 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 "base/threading/sequenced_task_runner_handle.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
-#include "base/sequence_checker_impl.h"
-#include "base/sequenced_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-class SequencedTaskRunnerHandleTest : public ::testing::Test {
- protected:
- // Verifies that the context it runs on has a SequencedTaskRunnerHandle
- // and that posting to it results in the posted task running in that same
- // context (sequence).
- static void VerifyCurrentSequencedTaskRunner() {
- ASSERT_TRUE(SequencedTaskRunnerHandle::IsSet());
- scoped_refptr<SequencedTaskRunner> task_runner =
- SequencedTaskRunnerHandle::Get();
- ASSERT_TRUE(task_runner);
-
- // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds.
- std::unique_ptr<SequenceCheckerImpl> sequence_checker(
- new SequenceCheckerImpl);
- task_runner->PostTask(
- FROM_HERE,
- base::BindOnce(&SequencedTaskRunnerHandleTest::CheckValidSequence,
- std::move(sequence_checker)));
- }
-
- static void CheckValidSequence(
- std::unique_ptr<SequenceCheckerImpl> sequence_checker) {
- EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
- }
-
- base::test::ScopedTaskEnvironment scoped_task_environment_;
-};
-
-TEST_F(SequencedTaskRunnerHandleTest, FromMessageLoop) {
- VerifyCurrentSequencedTaskRunner();
- RunLoop().RunUntilIdle();
-}
-
-TEST_F(SequencedTaskRunnerHandleTest, FromTaskSchedulerSequencedTask) {
- base::CreateSequencedTaskRunnerWithTraits({})->PostTask(
- FROM_HERE,
- base::BindOnce(
- &SequencedTaskRunnerHandleTest::VerifyCurrentSequencedTaskRunner));
- scoped_task_environment_.RunUntilIdle();
-}
-
-TEST_F(SequencedTaskRunnerHandleTest, NoHandleFromUnsequencedTask) {
- base::PostTask(FROM_HERE, base::BindOnce([]() {
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
- }));
- scoped_task_environment_.RunUntilIdle();
-}
-
-TEST(SequencedTaskRunnerHandleTestWithoutMessageLoop, FromHandleInScope) {
- scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- {
- SequencedTaskRunnerHandle handle(test_task_runner);
- EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(test_task_runner, SequencedTaskRunnerHandle::Get());
- }
- EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-} // namespace
-} // namespace base
diff --git a/base/threading/simple_thread_unittest.cc b/base/threading/simple_thread_unittest.cc
deleted file mode 100644
index 4e618f9..0000000
--- a/base/threading/simple_thread_unittest.cc
+++ /dev/null
@@ -1,234 +0,0 @@
-// 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.
-
-#include <memory>
-
-#include "base/atomic_sequence_num.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/gtest_util.h"
-#include "base/threading/simple_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class SetIntRunner : public DelegateSimpleThread::Delegate {
- public:
- SetIntRunner(int* ptr, int val) : ptr_(ptr), val_(val) { }
- ~SetIntRunner() override = default;
-
- private:
- void Run() override { *ptr_ = val_; }
-
- int* ptr_;
- int val_;
-
- DISALLOW_COPY_AND_ASSIGN(SetIntRunner);
-};
-
-// Signals |started_| when Run() is invoked and waits until |released_| is
-// signaled to return, signaling |done_| before doing so. Useful for tests that
-// care to control Run()'s flow.
-class ControlledRunner : public DelegateSimpleThread::Delegate {
- public:
- ControlledRunner()
- : started_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- released_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- done_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- ~ControlledRunner() override { ReleaseAndWaitUntilDone(); }
-
- void WaitUntilStarted() { started_.Wait(); }
-
- void ReleaseAndWaitUntilDone() {
- released_.Signal();
- done_.Wait();
- }
-
- private:
- void Run() override {
- started_.Signal();
- released_.Wait();
- done_.Signal();
- }
-
- WaitableEvent started_;
- WaitableEvent released_;
- WaitableEvent done_;
-
- DISALLOW_COPY_AND_ASSIGN(ControlledRunner);
-};
-
-class WaitEventRunner : public DelegateSimpleThread::Delegate {
- public:
- explicit WaitEventRunner(WaitableEvent* event) : event_(event) { }
- ~WaitEventRunner() override = default;
-
- private:
- void Run() override {
- EXPECT_FALSE(event_->IsSignaled());
- event_->Signal();
- EXPECT_TRUE(event_->IsSignaled());
- }
-
- WaitableEvent* event_;
-
- DISALLOW_COPY_AND_ASSIGN(WaitEventRunner);
-};
-
-class SeqRunner : public DelegateSimpleThread::Delegate {
- public:
- explicit SeqRunner(AtomicSequenceNumber* seq) : seq_(seq) { }
-
- private:
- void Run() override { seq_->GetNext(); }
-
- AtomicSequenceNumber* seq_;
-
- DISALLOW_COPY_AND_ASSIGN(SeqRunner);
-};
-
-// We count up on a sequence number, firing on the event when we've hit our
-// expected amount, otherwise we wait on the event. This will ensure that we
-// have all threads outstanding until we hit our expected thread pool size.
-class VerifyPoolRunner : public DelegateSimpleThread::Delegate {
- public:
- VerifyPoolRunner(AtomicSequenceNumber* seq,
- int total, WaitableEvent* event)
- : seq_(seq), total_(total), event_(event) { }
-
- private:
- void Run() override {
- if (seq_->GetNext() == total_) {
- event_->Signal();
- } else {
- event_->Wait();
- }
- }
-
- AtomicSequenceNumber* seq_;
- int total_;
- WaitableEvent* event_;
-
- DISALLOW_COPY_AND_ASSIGN(VerifyPoolRunner);
-};
-
-} // namespace
-
-TEST(SimpleThreadTest, CreateAndJoin) {
- int stack_int = 0;
-
- SetIntRunner runner(&stack_int, 7);
- EXPECT_EQ(0, stack_int);
-
- DelegateSimpleThread thread(&runner, "int_setter");
- EXPECT_FALSE(thread.HasBeenStarted());
- EXPECT_FALSE(thread.HasBeenJoined());
- EXPECT_EQ(0, stack_int);
-
- thread.Start();
- EXPECT_TRUE(thread.HasBeenStarted());
- EXPECT_FALSE(thread.HasBeenJoined());
-
- thread.Join();
- EXPECT_TRUE(thread.HasBeenStarted());
- EXPECT_TRUE(thread.HasBeenJoined());
- EXPECT_EQ(7, stack_int);
-}
-
-TEST(SimpleThreadTest, WaitForEvent) {
- // Create a thread, and wait for it to signal us.
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- WaitEventRunner runner(&event);
- DelegateSimpleThread thread(&runner, "event_waiter");
-
- EXPECT_FALSE(event.IsSignaled());
- thread.Start();
- event.Wait();
- EXPECT_TRUE(event.IsSignaled());
- thread.Join();
-}
-
-TEST(SimpleThreadTest, NonJoinableStartAndDieOnJoin) {
- ControlledRunner runner;
-
- SimpleThread::Options options;
- options.joinable = false;
- DelegateSimpleThread thread(&runner, "non_joinable", options);
-
- EXPECT_FALSE(thread.HasBeenStarted());
- thread.Start();
- EXPECT_TRUE(thread.HasBeenStarted());
-
- // Note: this is not quite the same as |thread.HasBeenStarted()| which
- // represents ThreadMain() getting ready to invoke Run() whereas
- // |runner.WaitUntilStarted()| ensures Run() was actually invoked.
- runner.WaitUntilStarted();
-
- EXPECT_FALSE(thread.HasBeenJoined());
- EXPECT_DCHECK_DEATH({ thread.Join(); });
-}
-
-TEST(SimpleThreadTest, NonJoinableInactiveDelegateDestructionIsOkay) {
- std::unique_ptr<ControlledRunner> runner(new ControlledRunner);
-
- SimpleThread::Options options;
- options.joinable = false;
- std::unique_ptr<DelegateSimpleThread> thread(
- new DelegateSimpleThread(runner.get(), "non_joinable", options));
-
- thread->Start();
- runner->WaitUntilStarted();
-
- // Deleting a non-joinable SimpleThread after Run() was invoked is okay.
- thread.reset();
-
- runner->WaitUntilStarted();
- runner->ReleaseAndWaitUntilDone();
- // It should be safe to destroy a Delegate after its Run() method completed.
- runner.reset();
-}
-
-TEST(SimpleThreadTest, ThreadPool) {
- AtomicSequenceNumber seq;
- SeqRunner runner(&seq);
- DelegateSimpleThreadPool pool("seq_runner", 10);
-
- // Add work before we're running.
- pool.AddWork(&runner, 300);
-
- EXPECT_EQ(seq.GetNext(), 0);
- pool.Start();
-
- // Add work while we're running.
- pool.AddWork(&runner, 300);
-
- pool.JoinAll();
-
- EXPECT_EQ(seq.GetNext(), 601);
-
- // We can reuse our pool. Verify that all 10 threads can actually run in
- // parallel, so this test will only pass if there are actually 10 threads.
- AtomicSequenceNumber seq2;
- WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- // Changing 9 to 10, for example, would cause us JoinAll() to never return.
- VerifyPoolRunner verifier(&seq2, 9, &event);
- pool.Start();
-
- pool.AddWork(&verifier, 10);
-
- pool.JoinAll();
- EXPECT_EQ(seq2.GetNext(), 10);
-}
-
-} // namespace base
diff --git a/base/threading/thread_checker_unittest.cc b/base/threading/thread_checker_unittest.cc
deleted file mode 100644
index 5fbbc52..0000000
--- a/base/threading/thread_checker_unittest.cc
+++ /dev/null
@@ -1,245 +0,0 @@
-// 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.
-
-#include "base/threading/thread_checker.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/sequence_token.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-// A thread that runs a callback.
-class RunCallbackThread : public SimpleThread {
- public:
- explicit RunCallbackThread(const Closure& callback)
- : SimpleThread("RunCallbackThread"), callback_(callback) {}
-
- private:
- // SimpleThread:
- void Run() override { callback_.Run(); }
-
- const Closure callback_;
-
- DISALLOW_COPY_AND_ASSIGN(RunCallbackThread);
-};
-
-// Runs a callback on a new thread synchronously.
-void RunCallbackOnNewThreadSynchronously(const Closure& callback) {
- RunCallbackThread run_callback_thread(callback);
- run_callback_thread.Start();
- run_callback_thread.Join();
-}
-
-void ExpectCalledOnValidThread(ThreadCheckerImpl* thread_checker) {
- ASSERT_TRUE(thread_checker);
-
- // This should bind |thread_checker| to the current thread if it wasn't
- // already bound to a thread.
- EXPECT_TRUE(thread_checker->CalledOnValidThread());
-
- // Since |thread_checker| is now bound to the current thread, another call to
- // CalledOnValidThread() should return true.
- EXPECT_TRUE(thread_checker->CalledOnValidThread());
-}
-
-void ExpectNotCalledOnValidThread(ThreadCheckerImpl* thread_checker) {
- ASSERT_TRUE(thread_checker);
- EXPECT_FALSE(thread_checker->CalledOnValidThread());
-}
-
-void ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle(
- ThreadCheckerImpl* thread_checker,
- SequenceToken sequence_token) {
- ThreadTaskRunnerHandle thread_task_runner_handle(
- MakeRefCounted<TestSimpleTaskRunner>());
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(sequence_token);
- ExpectNotCalledOnValidThread(thread_checker);
-}
-
-} // namespace
-
-TEST(ThreadCheckerTest, AllowedSameThreadNoSequenceToken) {
- ThreadCheckerImpl thread_checker;
- EXPECT_TRUE(thread_checker.CalledOnValidThread());
-}
-
-TEST(ThreadCheckerTest,
- AllowedSameThreadAndSequenceDifferentTasksWithThreadTaskRunnerHandle) {
- ThreadTaskRunnerHandle thread_task_runner_handle(
- MakeRefCounted<TestSimpleTaskRunner>());
-
- std::unique_ptr<ThreadCheckerImpl> thread_checker;
- const SequenceToken sequence_token = SequenceToken::Create();
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(sequence_token);
- thread_checker.reset(new ThreadCheckerImpl);
- }
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(sequence_token);
- EXPECT_TRUE(thread_checker->CalledOnValidThread());
- }
-}
-
-TEST(ThreadCheckerTest,
- AllowedSameThreadSequenceAndTaskNoThreadTaskRunnerHandle) {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- ThreadCheckerImpl thread_checker;
- EXPECT_TRUE(thread_checker.CalledOnValidThread());
-}
-
-TEST(ThreadCheckerTest,
- DisallowedSameThreadAndSequenceDifferentTasksNoThreadTaskRunnerHandle) {
- std::unique_ptr<ThreadCheckerImpl> thread_checker;
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- thread_checker.reset(new ThreadCheckerImpl);
- }
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- EXPECT_FALSE(thread_checker->CalledOnValidThread());
- }
-}
-
-TEST(ThreadCheckerTest, DisallowedDifferentThreadsNoSequenceToken) {
- ThreadCheckerImpl thread_checker;
- RunCallbackOnNewThreadSynchronously(
- Bind(&ExpectNotCalledOnValidThread, Unretained(&thread_checker)));
-}
-
-TEST(ThreadCheckerTest, DisallowedDifferentThreadsSameSequence) {
- ThreadTaskRunnerHandle thread_task_runner_handle(
- MakeRefCounted<TestSimpleTaskRunner>());
- const SequenceToken sequence_token(SequenceToken::Create());
-
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(sequence_token);
- ThreadCheckerImpl thread_checker;
- EXPECT_TRUE(thread_checker.CalledOnValidThread());
-
- RunCallbackOnNewThreadSynchronously(Bind(
- &ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle,
- Unretained(&thread_checker), sequence_token));
-}
-
-TEST(ThreadCheckerTest, DisallowedSameThreadDifferentSequence) {
- std::unique_ptr<ThreadCheckerImpl> thread_checker;
-
- ThreadTaskRunnerHandle thread_task_runner_handle(
- MakeRefCounted<TestSimpleTaskRunner>());
-
- {
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- thread_checker.reset(new ThreadCheckerImpl);
- }
-
- {
- // Different SequenceToken.
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- EXPECT_FALSE(thread_checker->CalledOnValidThread());
- }
-
- // No SequenceToken.
- EXPECT_FALSE(thread_checker->CalledOnValidThread());
-}
-
-TEST(ThreadCheckerTest, DetachFromThread) {
- ThreadCheckerImpl thread_checker;
- thread_checker.DetachFromThread();
-
- // Verify that CalledOnValidThread() returns true when called on a different
- // thread after a call to DetachFromThread().
- RunCallbackOnNewThreadSynchronously(
- Bind(&ExpectCalledOnValidThread, Unretained(&thread_checker)));
-
- EXPECT_FALSE(thread_checker.CalledOnValidThread());
-}
-
-TEST(ThreadCheckerTest, DetachFromThreadWithSequenceToken) {
- ThreadTaskRunnerHandle thread_task_runner_handle(
- MakeRefCounted<TestSimpleTaskRunner>());
- ScopedSetSequenceTokenForCurrentThread
- scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
- ThreadCheckerImpl thread_checker;
- thread_checker.DetachFromThread();
-
- // Verify that CalledOnValidThread() returns true when called on a different
- // thread after a call to DetachFromThread().
- RunCallbackOnNewThreadSynchronously(
- Bind(&ExpectCalledOnValidThread, Unretained(&thread_checker)));
-
- EXPECT_FALSE(thread_checker.CalledOnValidThread());
-}
-
-namespace {
-
-// This fixture is a helper for unit testing the thread checker macros as it is
-// not possible to inline ExpectDeathOnOtherThread() and
-// ExpectNoDeathOnOtherThreadAfterDetach() as lambdas since binding
-// |Unretained(&my_sequence_checker)| wouldn't compile on non-dcheck builds
-// where it won't be defined.
-class ThreadCheckerMacroTest : public testing::Test {
- public:
- ThreadCheckerMacroTest() = default;
-
- void ExpectDeathOnOtherThread() {
-#if DCHECK_IS_ON()
- EXPECT_DCHECK_DEATH({ DCHECK_CALLED_ON_VALID_THREAD(my_thread_checker_); });
-#else
- // Happily no-ops on non-dcheck builds.
- DCHECK_CALLED_ON_VALID_THREAD(my_thread_checker_);
-#endif
- }
-
- void ExpectNoDeathOnOtherThreadAfterDetach() {
- DCHECK_CALLED_ON_VALID_THREAD(my_thread_checker_);
- DCHECK_CALLED_ON_VALID_THREAD(my_thread_checker_)
- << "Make sure it compiles when DCHECK is off";
- }
-
- protected:
- THREAD_CHECKER(my_thread_checker_);
-
- private:
- DISALLOW_COPY_AND_ASSIGN(ThreadCheckerMacroTest);
-};
-
-} // namespace
-
-TEST_F(ThreadCheckerMacroTest, Macros) {
- THREAD_CHECKER(my_thread_checker);
-
- RunCallbackOnNewThreadSynchronously(Bind(
- &ThreadCheckerMacroTest::ExpectDeathOnOtherThread, Unretained(this)));
-
- DETACH_FROM_THREAD(my_thread_checker_);
-
- RunCallbackOnNewThreadSynchronously(
- Bind(&ThreadCheckerMacroTest::ExpectNoDeathOnOtherThreadAfterDetach,
- Unretained(this)));
-}
-
-} // namespace base
diff --git a/base/threading/thread_collision_warner_unittest.cc b/base/threading/thread_collision_warner_unittest.cc
deleted file mode 100644
index cd56768..0000000
--- a/base/threading/thread_collision_warner_unittest.cc
+++ /dev/null
@@ -1,382 +0,0 @@
-// 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.
-
-#include "base/threading/thread_collision_warner.h"
-
-#include <memory>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/simple_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// '' : local class member function does not have a body
-MSVC_PUSH_DISABLE_WARNING(4822)
-
-
-#if defined(NDEBUG)
-
-// Would cause a memory leak otherwise.
-#undef DFAKE_MUTEX
-#define DFAKE_MUTEX(obj) std::unique_ptr<base::AsserterBase> obj
-
-// In Release, we expect the AsserterBase::warn() to not happen.
-#define EXPECT_NDEBUG_FALSE_DEBUG_TRUE EXPECT_FALSE
-
-#else
-
-// In Debug, we expect the AsserterBase::warn() to happen.
-#define EXPECT_NDEBUG_FALSE_DEBUG_TRUE EXPECT_TRUE
-
-#endif
-
-
-namespace {
-
-// This is the asserter used with ThreadCollisionWarner instead of the default
-// DCheckAsserter. The method fail_state is used to know if a collision took
-// place.
-class AssertReporter : public base::AsserterBase {
- public:
- AssertReporter()
- : failed_(false) {}
-
- void warn() override { failed_ = true; }
-
- ~AssertReporter() override = default;
-
- bool fail_state() const { return failed_; }
- void reset() { failed_ = false; }
-
- private:
- bool failed_;
-};
-
-} // namespace
-
-TEST(ThreadCollisionTest, BookCriticalSection) {
- AssertReporter* local_reporter = new AssertReporter();
-
- base::ThreadCollisionWarner warner(local_reporter);
- EXPECT_FALSE(local_reporter->fail_state());
-
- { // Pin section.
- DFAKE_SCOPED_LOCK_THREAD_LOCKED(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- { // Pin section.
- DFAKE_SCOPED_LOCK_THREAD_LOCKED(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- }
- }
-}
-
-TEST(ThreadCollisionTest, ScopedRecursiveBookCriticalSection) {
- AssertReporter* local_reporter = new AssertReporter();
-
- base::ThreadCollisionWarner warner(local_reporter);
- EXPECT_FALSE(local_reporter->fail_state());
-
- { // Pin section.
- DFAKE_SCOPED_RECURSIVE_LOCK(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- { // Pin section again (allowed by DFAKE_SCOPED_RECURSIVE_LOCK)
- DFAKE_SCOPED_RECURSIVE_LOCK(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- } // Unpin section.
- } // Unpin section.
-
- // Check that section is not pinned
- { // Pin section.
- DFAKE_SCOPED_LOCK(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- } // Unpin section.
-}
-
-TEST(ThreadCollisionTest, ScopedBookCriticalSection) {
- AssertReporter* local_reporter = new AssertReporter();
-
- base::ThreadCollisionWarner warner(local_reporter);
- EXPECT_FALSE(local_reporter->fail_state());
-
- { // Pin section.
- DFAKE_SCOPED_LOCK(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- } // Unpin section.
-
- { // Pin section.
- DFAKE_SCOPED_LOCK(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- {
- // Pin section again (not allowed by DFAKE_SCOPED_LOCK)
- DFAKE_SCOPED_LOCK(warner);
- EXPECT_NDEBUG_FALSE_DEBUG_TRUE(local_reporter->fail_state());
- // Reset the status of warner for further tests.
- local_reporter->reset();
- } // Unpin section.
- } // Unpin section.
-
- {
- // Pin section.
- DFAKE_SCOPED_LOCK(warner);
- EXPECT_FALSE(local_reporter->fail_state());
- } // Unpin section.
-}
-
-TEST(ThreadCollisionTest, MTBookCriticalSectionTest) {
- class NonThreadSafeQueue {
- public:
- explicit NonThreadSafeQueue(base::AsserterBase* asserter)
- : push_pop_(asserter) {
- }
-
- void push(int value) {
- DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_);
- }
-
- int pop() {
- DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_);
- return 0;
- }
-
- private:
- DFAKE_MUTEX(push_pop_);
-
- DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
- };
-
- class QueueUser : public base::DelegateSimpleThread::Delegate {
- public:
- explicit QueueUser(NonThreadSafeQueue* queue) : queue_(queue) {}
-
- void Run() override {
- queue_->push(0);
- queue_->pop();
- }
-
- private:
- NonThreadSafeQueue* queue_;
- };
-
- AssertReporter* local_reporter = new AssertReporter();
-
- NonThreadSafeQueue queue(local_reporter);
-
- QueueUser queue_user_a(&queue);
- QueueUser queue_user_b(&queue);
-
- base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
- base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
-
- thread_a.Start();
- thread_b.Start();
-
- thread_a.Join();
- thread_b.Join();
-
- EXPECT_NDEBUG_FALSE_DEBUG_TRUE(local_reporter->fail_state());
-}
-
-TEST(ThreadCollisionTest, MTScopedBookCriticalSectionTest) {
- // Queue with a 5 seconds push execution time, hopefuly the two used threads
- // in the test will enter the push at same time.
- class NonThreadSafeQueue {
- public:
- explicit NonThreadSafeQueue(base::AsserterBase* asserter)
- : push_pop_(asserter) {
- }
-
- void push(int value) {
- DFAKE_SCOPED_LOCK(push_pop_);
- base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(5));
- }
-
- int pop() {
- DFAKE_SCOPED_LOCK(push_pop_);
- return 0;
- }
-
- private:
- DFAKE_MUTEX(push_pop_);
-
- DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
- };
-
- class QueueUser : public base::DelegateSimpleThread::Delegate {
- public:
- explicit QueueUser(NonThreadSafeQueue* queue) : queue_(queue) {}
-
- void Run() override {
- queue_->push(0);
- queue_->pop();
- }
-
- private:
- NonThreadSafeQueue* queue_;
- };
-
- AssertReporter* local_reporter = new AssertReporter();
-
- NonThreadSafeQueue queue(local_reporter);
-
- QueueUser queue_user_a(&queue);
- QueueUser queue_user_b(&queue);
-
- base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
- base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
-
- thread_a.Start();
- thread_b.Start();
-
- thread_a.Join();
- thread_b.Join();
-
- EXPECT_NDEBUG_FALSE_DEBUG_TRUE(local_reporter->fail_state());
-}
-
-TEST(ThreadCollisionTest, MTSynchedScopedBookCriticalSectionTest) {
- // Queue with a 2 seconds push execution time, hopefuly the two used threads
- // in the test will enter the push at same time.
- class NonThreadSafeQueue {
- public:
- explicit NonThreadSafeQueue(base::AsserterBase* asserter)
- : push_pop_(asserter) {
- }
-
- void push(int value) {
- DFAKE_SCOPED_LOCK(push_pop_);
- base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(2));
- }
-
- int pop() {
- DFAKE_SCOPED_LOCK(push_pop_);
- return 0;
- }
-
- private:
- DFAKE_MUTEX(push_pop_);
-
- DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
- };
-
- // This time the QueueUser class protects the non thread safe queue with
- // a lock.
- class QueueUser : public base::DelegateSimpleThread::Delegate {
- public:
- QueueUser(NonThreadSafeQueue* queue, base::Lock* lock)
- : queue_(queue), lock_(lock) {}
-
- void Run() override {
- {
- base::AutoLock auto_lock(*lock_);
- queue_->push(0);
- }
- {
- base::AutoLock auto_lock(*lock_);
- queue_->pop();
- }
- }
- private:
- NonThreadSafeQueue* queue_;
- base::Lock* lock_;
- };
-
- AssertReporter* local_reporter = new AssertReporter();
-
- NonThreadSafeQueue queue(local_reporter);
-
- base::Lock lock;
-
- QueueUser queue_user_a(&queue, &lock);
- QueueUser queue_user_b(&queue, &lock);
-
- base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
- base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
-
- thread_a.Start();
- thread_b.Start();
-
- thread_a.Join();
- thread_b.Join();
-
- EXPECT_FALSE(local_reporter->fail_state());
-}
-
-TEST(ThreadCollisionTest, MTSynchedScopedRecursiveBookCriticalSectionTest) {
- // Queue with a 2 seconds push execution time, hopefuly the two used threads
- // in the test will enter the push at same time.
- class NonThreadSafeQueue {
- public:
- explicit NonThreadSafeQueue(base::AsserterBase* asserter)
- : push_pop_(asserter) {
- }
-
- void push(int) {
- DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
- bar();
- base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(2));
- }
-
- int pop() {
- DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
- return 0;
- }
-
- void bar() {
- DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
- }
-
- private:
- DFAKE_MUTEX(push_pop_);
-
- DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
- };
-
- // This time the QueueUser class protects the non thread safe queue with
- // a lock.
- class QueueUser : public base::DelegateSimpleThread::Delegate {
- public:
- QueueUser(NonThreadSafeQueue* queue, base::Lock* lock)
- : queue_(queue), lock_(lock) {}
-
- void Run() override {
- {
- base::AutoLock auto_lock(*lock_);
- queue_->push(0);
- }
- {
- base::AutoLock auto_lock(*lock_);
- queue_->bar();
- }
- {
- base::AutoLock auto_lock(*lock_);
- queue_->pop();
- }
- }
- private:
- NonThreadSafeQueue* queue_;
- base::Lock* lock_;
- };
-
- AssertReporter* local_reporter = new AssertReporter();
-
- NonThreadSafeQueue queue(local_reporter);
-
- base::Lock lock;
-
- QueueUser queue_user_a(&queue, &lock);
- QueueUser queue_user_b(&queue, &lock);
-
- base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
- base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
-
- thread_a.Start();
- thread_b.Start();
-
- thread_a.Join();
- thread_b.Join();
-
- EXPECT_FALSE(local_reporter->fail_state());
-}
diff --git a/base/threading/thread_id_name_manager_unittest.cc b/base/threading/thread_id_name_manager_unittest.cc
deleted file mode 100644
index 350dc0f..0000000
--- a/base/threading/thread_id_name_manager_unittest.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-// 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.
-
-#include "base/threading/thread_id_name_manager.h"
-
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-typedef PlatformTest ThreadIdNameManagerTest;
-
-namespace {
-
-const char kAThread[] = "a thread";
-const char kBThread[] = "b thread";
-
-TEST_F(ThreadIdNameManagerTest, AddThreads) {
- base::ThreadIdNameManager* manager = base::ThreadIdNameManager::GetInstance();
- base::Thread thread_a(kAThread);
- base::Thread thread_b(kBThread);
-
- thread_a.StartAndWaitForTesting();
- thread_b.StartAndWaitForTesting();
-
- EXPECT_STREQ(kAThread, manager->GetName(thread_a.GetThreadId()));
- EXPECT_STREQ(kBThread, manager->GetName(thread_b.GetThreadId()));
-
- thread_b.Stop();
- thread_a.Stop();
-}
-
-TEST_F(ThreadIdNameManagerTest, RemoveThreads) {
- base::ThreadIdNameManager* manager = base::ThreadIdNameManager::GetInstance();
- base::Thread thread_a(kAThread);
-
- thread_a.StartAndWaitForTesting();
- {
- base::Thread thread_b(kBThread);
- thread_b.StartAndWaitForTesting();
- thread_b.Stop();
- }
- EXPECT_STREQ(kAThread, manager->GetName(thread_a.GetThreadId()));
-
- thread_a.Stop();
- EXPECT_STREQ("", manager->GetName(thread_a.GetThreadId()));
-}
-
-TEST_F(ThreadIdNameManagerTest, RestartThread) {
- base::ThreadIdNameManager* manager = base::ThreadIdNameManager::GetInstance();
- base::Thread thread_a(kAThread);
-
- thread_a.StartAndWaitForTesting();
- base::PlatformThreadId a_id = thread_a.GetThreadId();
- EXPECT_STREQ(kAThread, manager->GetName(a_id));
- thread_a.Stop();
-
- thread_a.StartAndWaitForTesting();
- EXPECT_STREQ("", manager->GetName(a_id));
- EXPECT_STREQ(kAThread, manager->GetName(thread_a.GetThreadId()));
- thread_a.Stop();
-}
-
-TEST_F(ThreadIdNameManagerTest, ThreadNameInterning) {
- base::ThreadIdNameManager* manager = base::ThreadIdNameManager::GetInstance();
-
- base::PlatformThreadId a_id = base::PlatformThread::CurrentId();
- base::PlatformThread::SetName("First Name");
- std::string version = manager->GetName(a_id);
-
- base::PlatformThread::SetName("New name");
- EXPECT_NE(version, manager->GetName(a_id));
- base::PlatformThread::SetName("");
-}
-
-TEST_F(ThreadIdNameManagerTest, ResettingNameKeepsCorrectInternedValue) {
- base::ThreadIdNameManager* manager = base::ThreadIdNameManager::GetInstance();
-
- base::PlatformThreadId a_id = base::PlatformThread::CurrentId();
- base::PlatformThread::SetName("Test Name");
- std::string version = manager->GetName(a_id);
-
- base::PlatformThread::SetName("New name");
- EXPECT_NE(version, manager->GetName(a_id));
-
- base::PlatformThread::SetName("Test Name");
- EXPECT_EQ(version, manager->GetName(a_id));
-
- base::PlatformThread::SetName("");
-}
-
-} // namespace
diff --git a/base/threading/thread_local_storage_unittest.cc b/base/threading/thread_local_storage_unittest.cc
deleted file mode 100644
index 006f928..0000000
--- a/base/threading/thread_local_storage_unittest.cc
+++ /dev/null
@@ -1,278 +0,0 @@
-// 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.
-
-#include "base/threading/thread_local_storage.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include <process.h>
-#endif
-
-#include "base/macros.h"
-#include "base/no_destructor.h"
-#include "base/threading/simple_thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-// Ignore warnings about ptr->int conversions that we use when
-// storing ints into ThreadLocalStorage.
-#pragma warning(disable : 4311 4312)
-#endif
-
-namespace base {
-
-#if defined(OS_POSIX)
-
-namespace internal {
-
-// This class is friended by ThreadLocalStorage.
-class ThreadLocalStorageTestInternal {
- public:
- static bool HasBeenDestroyed() {
- return ThreadLocalStorage::HasBeenDestroyed();
- }
-};
-
-} // namespace internal
-
-#endif // defined(OS_POSIX)
-
-namespace {
-
-const int kInitialTlsValue = 0x5555;
-const int kFinalTlsValue = 0x7777;
-// How many times must a destructor be called before we really are done.
-const int kNumberDestructorCallRepetitions = 3;
-
-void ThreadLocalStorageCleanup(void* value);
-
-ThreadLocalStorage::Slot& TLSSlot() {
- static NoDestructor<ThreadLocalStorage::Slot> slot(
- &ThreadLocalStorageCleanup);
- return *slot;
-}
-
-class ThreadLocalStorageRunner : public DelegateSimpleThread::Delegate {
- public:
- explicit ThreadLocalStorageRunner(int* tls_value_ptr)
- : tls_value_ptr_(tls_value_ptr) {}
-
- ~ThreadLocalStorageRunner() override = default;
-
- void Run() override {
- *tls_value_ptr_ = kInitialTlsValue;
- TLSSlot().Set(tls_value_ptr_);
-
- int* ptr = static_cast<int*>(TLSSlot().Get());
- EXPECT_EQ(ptr, tls_value_ptr_);
- EXPECT_EQ(*ptr, kInitialTlsValue);
- *tls_value_ptr_ = 0;
-
- ptr = static_cast<int*>(TLSSlot().Get());
- EXPECT_EQ(ptr, tls_value_ptr_);
- EXPECT_EQ(*ptr, 0);
-
- *ptr = kFinalTlsValue + kNumberDestructorCallRepetitions;
- }
-
- private:
- int* tls_value_ptr_;
- DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorageRunner);
-};
-
-
-void ThreadLocalStorageCleanup(void *value) {
- int *ptr = reinterpret_cast<int*>(value);
- // Destructors should never be called with a NULL.
- ASSERT_NE(reinterpret_cast<int*>(NULL), ptr);
- if (*ptr == kFinalTlsValue)
- return; // We've been called enough times.
- ASSERT_LT(kFinalTlsValue, *ptr);
- ASSERT_GE(kFinalTlsValue + kNumberDestructorCallRepetitions, *ptr);
- --*ptr; // Move closer to our target.
- // Tell tls that we're not done with this thread, and still need destruction.
- TLSSlot().Set(value);
-}
-
-#if defined(OS_POSIX)
-constexpr intptr_t kDummyValue = 0xABCD;
-constexpr size_t kKeyCount = 20;
-
-// The order in which pthread keys are destructed is not specified by the POSIX
-// specification. Hopefully, of the 20 keys we create, some of them should be
-// destroyed after the TLS key is destroyed.
-class UseTLSDuringDestructionRunner {
- public:
- UseTLSDuringDestructionRunner() = default;
-
- // The order in which pthread_key destructors are called is not well defined.
- // Hopefully, by creating 10 both before and after initializing TLS on the
- // thread, at least 1 will be called after TLS destruction.
- void Run() {
- ASSERT_FALSE(internal::ThreadLocalStorageTestInternal::HasBeenDestroyed());
-
- // Create 10 pthread keys before initializing TLS on the thread.
- size_t slot_index = 0;
- for (; slot_index < 10; ++slot_index) {
- CreateTlsKeyWithDestructor(slot_index);
- }
-
- // Initialize the Chrome TLS system. It's possible that base::Thread has
- // already initialized Chrome TLS, but we don't rely on that.
- slot_.Set(reinterpret_cast<void*>(kDummyValue));
-
- // Create 10 pthread keys after initializing TLS on the thread.
- for (; slot_index < kKeyCount; ++slot_index) {
- CreateTlsKeyWithDestructor(slot_index);
- }
- }
-
- bool teardown_works_correctly() { return teardown_works_correctly_; }
-
- private:
- struct TLSState {
- pthread_key_t key;
- bool* teardown_works_correctly;
- };
-
- // The POSIX TLS destruction API takes as input a single C-function, which is
- // called with the current |value| of a (key, value) pair. We need this
- // function to do two things: set the |value| to nullptr, which requires
- // knowing the associated |key|, and update the |teardown_works_correctly_|
- // state.
- //
- // To accomplish this, we set the value to an instance of TLSState, which
- // contains |key| as well as a pointer to |teardown_works_correctly|.
- static void ThreadLocalDestructor(void* value) {
- TLSState* state = static_cast<TLSState*>(value);
- int result = pthread_setspecific(state->key, nullptr);
- ASSERT_EQ(result, 0);
-
- // If this path is hit, then the thread local destructor was called after
- // the Chrome-TLS destructor and the internal state was updated correctly.
- // No further checks are necessary.
- if (internal::ThreadLocalStorageTestInternal::HasBeenDestroyed()) {
- *(state->teardown_works_correctly) = true;
- return;
- }
-
- // If this path is hit, then the thread local destructor was called before
- // the Chrome-TLS destructor is hit. The ThreadLocalStorage::Slot should
- // still function correctly.
- ASSERT_EQ(reinterpret_cast<intptr_t>(slot_.Get()), kDummyValue);
- }
-
- void CreateTlsKeyWithDestructor(size_t index) {
- ASSERT_LT(index, kKeyCount);
-
- tls_states_[index].teardown_works_correctly = &teardown_works_correctly_;
- int result = pthread_key_create(
- &(tls_states_[index].key),
- UseTLSDuringDestructionRunner::ThreadLocalDestructor);
- ASSERT_EQ(result, 0);
-
- result = pthread_setspecific(tls_states_[index].key, &tls_states_[index]);
- ASSERT_EQ(result, 0);
- }
-
- static base::ThreadLocalStorage::Slot slot_;
- bool teardown_works_correctly_ = false;
- TLSState tls_states_[kKeyCount];
-
- DISALLOW_COPY_AND_ASSIGN(UseTLSDuringDestructionRunner);
-};
-
-base::ThreadLocalStorage::Slot UseTLSDuringDestructionRunner::slot_;
-
-void* UseTLSTestThreadRun(void* input) {
- UseTLSDuringDestructionRunner* runner =
- static_cast<UseTLSDuringDestructionRunner*>(input);
- runner->Run();
- return nullptr;
-}
-
-#endif // defined(OS_POSIX)
-
-} // namespace
-
-TEST(ThreadLocalStorageTest, Basics) {
- ThreadLocalStorage::Slot slot;
- slot.Set(reinterpret_cast<void*>(123));
- int value = reinterpret_cast<intptr_t>(slot.Get());
- EXPECT_EQ(value, 123);
-}
-
-#if defined(THREAD_SANITIZER) || \
- (defined(OS_WIN) && defined(ARCH_CPU_X86_64) && !defined(NDEBUG))
-// Do not run the test under ThreadSanitizer. Because this test iterates its
-// own TSD destructor for the maximum possible number of times, TSan can't jump
-// in after the last destructor invocation, therefore the destructor remains
-// unsynchronized with the following users of the same TSD slot. This results
-// in race reports between the destructor and functions in other tests.
-//
-// It is disabled on Win x64 with incremental linking (i.e. "Debug") pending
-// resolution of http://crbug.com/251251.
-#define MAYBE_TLSDestructors DISABLED_TLSDestructors
-#else
-#define MAYBE_TLSDestructors TLSDestructors
-#endif
-TEST(ThreadLocalStorageTest, MAYBE_TLSDestructors) {
- // Create a TLS index with a destructor. Create a set of
- // threads that set the TLS, while the destructor cleans it up.
- // After the threads finish, verify that the value is cleaned up.
- const int kNumThreads = 5;
- int values[kNumThreads];
- ThreadLocalStorageRunner* thread_delegates[kNumThreads];
- DelegateSimpleThread* threads[kNumThreads];
-
- // Spawn the threads.
- for (int index = 0; index < kNumThreads; index++) {
- values[index] = kInitialTlsValue;
- thread_delegates[index] = new ThreadLocalStorageRunner(&values[index]);
- threads[index] = new DelegateSimpleThread(thread_delegates[index],
- "tls thread");
- threads[index]->Start();
- }
-
- // Wait for the threads to finish.
- for (int index = 0; index < kNumThreads; index++) {
- threads[index]->Join();
- delete threads[index];
- delete thread_delegates[index];
-
- // Verify that the destructor was called and that we reset.
- EXPECT_EQ(values[index], kFinalTlsValue);
- }
-}
-
-TEST(ThreadLocalStorageTest, TLSReclaim) {
- // Creates and destroys many TLS slots and ensures they all zero-inited.
- for (int i = 0; i < 1000; ++i) {
- ThreadLocalStorage::Slot slot(nullptr);
- EXPECT_EQ(nullptr, slot.Get());
- slot.Set(reinterpret_cast<void*>(0xBAADF00D));
- EXPECT_EQ(reinterpret_cast<void*>(0xBAADF00D), slot.Get());
- }
-}
-
-#if defined(OS_POSIX)
-// Unlike POSIX, Windows does not iterate through the OS TLS to cleanup any
-// values there. Instead a per-module thread destruction function is called.
-// However, it is not possible to perform a check after this point (as the code
-// is detached from the thread), so this check remains POSIX only.
-TEST(ThreadLocalStorageTest, UseTLSDuringDestruction) {
- UseTLSDuringDestructionRunner runner;
- pthread_t thread;
- int result = pthread_create(&thread, nullptr, UseTLSTestThreadRun, &runner);
- ASSERT_EQ(result, 0);
-
- result = pthread_join(thread, nullptr);
- ASSERT_EQ(result, 0);
-
- EXPECT_TRUE(runner.teardown_works_correctly());
-}
-#endif // defined(OS_POSIX)
-
-} // namespace base
diff --git a/base/threading/thread_local_unittest.cc b/base/threading/thread_local_unittest.cc
deleted file mode 100644
index 54f2ad2..0000000
--- a/base/threading/thread_local_unittest.cc
+++ /dev/null
@@ -1,164 +0,0 @@
-// 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.
-
-#include "base/logging.h"
-#include "base/threading/simple_thread.h"
-#include "base/threading/thread_local.h"
-#include "base/synchronization/waitable_event.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class ThreadLocalTesterBase : public base::DelegateSimpleThreadPool::Delegate {
- public:
- typedef base::ThreadLocalPointer<char> TLPType;
-
- ThreadLocalTesterBase(TLPType* tlp, base::WaitableEvent* done)
- : tlp_(tlp),
- done_(done) {
- }
- ~ThreadLocalTesterBase() override = default;
-
- protected:
- TLPType* tlp_;
- base::WaitableEvent* done_;
-};
-
-class SetThreadLocal : public ThreadLocalTesterBase {
- public:
- SetThreadLocal(TLPType* tlp, base::WaitableEvent* done)
- : ThreadLocalTesterBase(tlp, done), val_(nullptr) {}
- ~SetThreadLocal() override = default;
-
- void set_value(char* val) { val_ = val; }
-
- void Run() override {
- DCHECK(!done_->IsSignaled());
- tlp_->Set(val_);
- done_->Signal();
- }
-
- private:
- char* val_;
-};
-
-class GetThreadLocal : public ThreadLocalTesterBase {
- public:
- GetThreadLocal(TLPType* tlp, base::WaitableEvent* done)
- : ThreadLocalTesterBase(tlp, done), ptr_(nullptr) {}
- ~GetThreadLocal() override = default;
-
- void set_ptr(char** ptr) { ptr_ = ptr; }
-
- void Run() override {
- DCHECK(!done_->IsSignaled());
- *ptr_ = tlp_->Get();
- done_->Signal();
- }
-
- private:
- char** ptr_;
-};
-
-} // namespace
-
-// In this test, we start 2 threads which will access a ThreadLocalPointer. We
-// make sure the default is NULL, and the pointers are unique to the threads.
-TEST(ThreadLocalTest, Pointer) {
- base::DelegateSimpleThreadPool tp1("ThreadLocalTest tp1", 1);
- base::DelegateSimpleThreadPool tp2("ThreadLocalTest tp1", 1);
- tp1.Start();
- tp2.Start();
-
- base::ThreadLocalPointer<char> tlp;
-
- static char* const kBogusPointer = reinterpret_cast<char*>(0x1234);
-
- char* tls_val;
- base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
-
- GetThreadLocal getter(&tlp, &done);
- getter.set_ptr(&tls_val);
-
- // Check that both threads defaulted to NULL.
- tls_val = kBogusPointer;
- done.Reset();
- tp1.AddWork(&getter);
- done.Wait();
- EXPECT_EQ(static_cast<char*>(nullptr), tls_val);
-
- tls_val = kBogusPointer;
- done.Reset();
- tp2.AddWork(&getter);
- done.Wait();
- EXPECT_EQ(static_cast<char*>(nullptr), tls_val);
-
- SetThreadLocal setter(&tlp, &done);
- setter.set_value(kBogusPointer);
-
- // Have thread 1 set their pointer value to kBogusPointer.
- done.Reset();
- tp1.AddWork(&setter);
- done.Wait();
-
- tls_val = nullptr;
- done.Reset();
- tp1.AddWork(&getter);
- done.Wait();
- EXPECT_EQ(kBogusPointer, tls_val);
-
- // Make sure thread 2 is still NULL
- tls_val = kBogusPointer;
- done.Reset();
- tp2.AddWork(&getter);
- done.Wait();
- EXPECT_EQ(static_cast<char*>(nullptr), tls_val);
-
- // Set thread 2 to kBogusPointer + 1.
- setter.set_value(kBogusPointer + 1);
-
- done.Reset();
- tp2.AddWork(&setter);
- done.Wait();
-
- tls_val = nullptr;
- done.Reset();
- tp2.AddWork(&getter);
- done.Wait();
- EXPECT_EQ(kBogusPointer + 1, tls_val);
-
- // Make sure thread 1 is still kBogusPointer.
- tls_val = nullptr;
- done.Reset();
- tp1.AddWork(&getter);
- done.Wait();
- EXPECT_EQ(kBogusPointer, tls_val);
-
- tp1.JoinAll();
- tp2.JoinAll();
-}
-
-TEST(ThreadLocalTest, Boolean) {
- {
- base::ThreadLocalBoolean tlb;
- EXPECT_FALSE(tlb.Get());
-
- tlb.Set(false);
- EXPECT_FALSE(tlb.Get());
-
- tlb.Set(true);
- EXPECT_TRUE(tlb.Get());
- }
-
- // Our slot should have been freed, we're all reset.
- {
- base::ThreadLocalBoolean tlb;
- EXPECT_FALSE(tlb.Get());
- }
-}
-
-} // namespace base
diff --git a/base/threading/thread_restrictions_unittest.cc b/base/threading/thread_restrictions_unittest.cc
deleted file mode 100644
index a957a9a..0000000
--- a/base/threading/thread_restrictions_unittest.cc
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2017 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 "base/threading/thread_restrictions.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-class ThreadRestrictionsTest : public testing::Test {
- public:
- ThreadRestrictionsTest() = default;
- ~ThreadRestrictionsTest() override {
- internal::ResetThreadRestrictionsForTesting();
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(ThreadRestrictionsTest);
-};
-
-} // namespace
-
-TEST_F(ThreadRestrictionsTest, BlockingAllowedByDefault) {
- AssertBlockingAllowed();
-}
-
-TEST_F(ThreadRestrictionsTest, ScopedDisallowBlocking) {
- {
- ScopedDisallowBlocking scoped_disallow_blocking;
- EXPECT_DCHECK_DEATH({ AssertBlockingAllowed(); });
- }
- AssertBlockingAllowed();
-}
-
-TEST_F(ThreadRestrictionsTest, ScopedAllowBlocking) {
- ScopedDisallowBlocking scoped_disallow_blocking;
- {
- ScopedAllowBlocking scoped_allow_blocking;
- AssertBlockingAllowed();
- }
- EXPECT_DCHECK_DEATH({ AssertBlockingAllowed(); });
-}
-
-TEST_F(ThreadRestrictionsTest, ScopedAllowBlockingForTesting) {
- ScopedDisallowBlocking scoped_disallow_blocking;
- {
- ScopedAllowBlockingForTesting scoped_allow_blocking_for_testing;
- AssertBlockingAllowed();
- }
- EXPECT_DCHECK_DEATH({ AssertBlockingAllowed(); });
-}
-
-TEST_F(ThreadRestrictionsTest, BaseSyncPrimitivesAllowedByDefault) {}
-
-TEST_F(ThreadRestrictionsTest, DisallowBaseSyncPrimitives) {
- DisallowBaseSyncPrimitives();
- EXPECT_DCHECK_DEATH({ internal::AssertBaseSyncPrimitivesAllowed(); });
-}
-
-TEST_F(ThreadRestrictionsTest, ScopedAllowBaseSyncPrimitives) {
- DisallowBaseSyncPrimitives();
- ScopedAllowBaseSyncPrimitives scoped_allow_base_sync_primitives;
- internal::AssertBaseSyncPrimitivesAllowed();
-}
-
-TEST_F(ThreadRestrictionsTest, ScopedAllowBaseSyncPrimitivesResetsState) {
- DisallowBaseSyncPrimitives();
- { ScopedAllowBaseSyncPrimitives scoped_allow_base_sync_primitives; }
- EXPECT_DCHECK_DEATH({ internal::AssertBaseSyncPrimitivesAllowed(); });
-}
-
-TEST_F(ThreadRestrictionsTest,
- ScopedAllowBaseSyncPrimitivesWithBlockingDisallowed) {
- ScopedDisallowBlocking scoped_disallow_blocking;
- DisallowBaseSyncPrimitives();
-
- // This should DCHECK because blocking is not allowed in this scope
- // and OutsideBlockingScope is not passed to the constructor.
- EXPECT_DCHECK_DEATH(
- { ScopedAllowBaseSyncPrimitives scoped_allow_base_sync_primitives; });
-}
-
-TEST_F(ThreadRestrictionsTest,
- ScopedAllowBaseSyncPrimitivesOutsideBlockingScope) {
- ScopedDisallowBlocking scoped_disallow_blocking;
- DisallowBaseSyncPrimitives();
- ScopedAllowBaseSyncPrimitivesOutsideBlockingScope
- scoped_allow_base_sync_primitives;
- internal::AssertBaseSyncPrimitivesAllowed();
-}
-
-TEST_F(ThreadRestrictionsTest,
- ScopedAllowBaseSyncPrimitivesOutsideBlockingScopeResetsState) {
- DisallowBaseSyncPrimitives();
- {
- ScopedAllowBaseSyncPrimitivesOutsideBlockingScope
- scoped_allow_base_sync_primitives;
- }
- EXPECT_DCHECK_DEATH({ internal::AssertBaseSyncPrimitivesAllowed(); });
-}
-
-TEST_F(ThreadRestrictionsTest, ScopedAllowBaseSyncPrimitivesForTesting) {
- DisallowBaseSyncPrimitives();
- ScopedAllowBaseSyncPrimitivesForTesting
- scoped_allow_base_sync_primitives_for_testing;
- internal::AssertBaseSyncPrimitivesAllowed();
-}
-
-TEST_F(ThreadRestrictionsTest,
- ScopedAllowBaseSyncPrimitivesForTestingResetsState) {
- DisallowBaseSyncPrimitives();
- {
- ScopedAllowBaseSyncPrimitivesForTesting
- scoped_allow_base_sync_primitives_for_testing;
- }
- EXPECT_DCHECK_DEATH({ internal::AssertBaseSyncPrimitivesAllowed(); });
-}
-
-TEST_F(ThreadRestrictionsTest,
- ScopedAllowBaseSyncPrimitivesForTestingWithBlockingDisallowed) {
- ScopedDisallowBlocking scoped_disallow_blocking;
- DisallowBaseSyncPrimitives();
- // This should not DCHECK.
- ScopedAllowBaseSyncPrimitivesForTesting
- scoped_allow_base_sync_primitives_for_testing;
-}
-
-} // namespace base
diff --git a/base/threading/thread_task_runner_handle_unittest.cc b/base/threading/thread_task_runner_handle_unittest.cc
deleted file mode 100644
index 1aa02d1..0000000
--- a/base/threading/thread_task_runner_handle_unittest.cc
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2017 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 "base/threading/thread_task_runner_handle.h"
-
-#include "base/memory/ref_counted.h"
-#include "base/test/gtest_util.h"
-#include "base/test/test_simple_task_runner.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(ThreadTaskRunnerHandleTest, Basic) {
- scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
-
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- {
- ThreadTaskRunnerHandle ttrh1(task_runner);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner, ThreadTaskRunnerHandle::Get());
- }
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-TEST(ThreadTaskRunnerHandleTest, DeathOnImplicitOverride) {
- scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
- scoped_refptr<SingleThreadTaskRunner> overidding_task_runner(
- new TestSimpleTaskRunner);
-
- ThreadTaskRunnerHandle ttrh(task_runner);
- EXPECT_DCHECK_DEATH(
- { ThreadTaskRunnerHandle overriding_ttrh(overidding_task_runner); });
-}
-
-TEST(ThreadTaskRunnerHandleTest, OverrideForTestingExistingTTRH) {
- scoped_refptr<SingleThreadTaskRunner> task_runner_1(new TestSimpleTaskRunner);
- scoped_refptr<SingleThreadTaskRunner> task_runner_2(new TestSimpleTaskRunner);
- scoped_refptr<SingleThreadTaskRunner> task_runner_3(new TestSimpleTaskRunner);
- scoped_refptr<SingleThreadTaskRunner> task_runner_4(new TestSimpleTaskRunner);
-
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- {
- // TTRH in place prior to override.
- ThreadTaskRunnerHandle ttrh1(task_runner_1);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
-
- {
- // Override.
- ScopedClosureRunner undo_override_2 =
- ThreadTaskRunnerHandle::OverrideForTesting(task_runner_2);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_2, ThreadTaskRunnerHandle::Get());
-
- {
- // Nested override.
- ScopedClosureRunner undo_override_3 =
- ThreadTaskRunnerHandle::OverrideForTesting(task_runner_3);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_3, ThreadTaskRunnerHandle::Get());
- }
-
- // Back to single override.
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_2, ThreadTaskRunnerHandle::Get());
-
- {
- // Backup to double override with another TTRH.
- ScopedClosureRunner undo_override_4 =
- ThreadTaskRunnerHandle::OverrideForTesting(task_runner_4);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_4, ThreadTaskRunnerHandle::Get());
- }
- }
-
- // Back to simple TTRH.
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
- }
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-TEST(ThreadTaskRunnerHandleTest, OverrideForTestingNoExistingTTRH) {
- scoped_refptr<SingleThreadTaskRunner> task_runner_1(new TestSimpleTaskRunner);
- scoped_refptr<SingleThreadTaskRunner> task_runner_2(new TestSimpleTaskRunner);
-
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
- {
- // Override with no TTRH in place.
- ScopedClosureRunner undo_override_1 =
- ThreadTaskRunnerHandle::OverrideForTesting(task_runner_1);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
-
- {
- // Nested override works the same.
- ScopedClosureRunner undo_override_2 =
- ThreadTaskRunnerHandle::OverrideForTesting(task_runner_2);
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_2, ThreadTaskRunnerHandle::Get());
- }
-
- // Back to single override.
- EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
- EXPECT_EQ(task_runner_1, ThreadTaskRunnerHandle::Get());
- }
- EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
-}
-
-TEST(ThreadTaskRunnerHandleTest, DeathOnTTRHOverOverride) {
- scoped_refptr<SingleThreadTaskRunner> task_runner(new TestSimpleTaskRunner);
- scoped_refptr<SingleThreadTaskRunner> overidding_task_runner(
- new TestSimpleTaskRunner);
-
- ScopedClosureRunner undo_override =
- ThreadTaskRunnerHandle::OverrideForTesting(task_runner);
- EXPECT_DCHECK_DEATH(
- { ThreadTaskRunnerHandle overriding_ttrh(overidding_task_runner); });
-}
-
-} // namespace base
diff --git a/base/threading/thread_unittest.cc b/base/threading/thread_unittest.cc
deleted file mode 100644
index a1a9ed3..0000000
--- a/base/threading/thread_unittest.cc
+++ /dev/null
@@ -1,579 +0,0 @@
-// 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.
-
-#include "base/threading/thread.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/debug/leak_annotations.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_current.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/gtest_util.h"
-#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-using base::Thread;
-
-typedef PlatformTest ThreadTest;
-
-namespace {
-
-void ToggleValue(bool* value) {
- ANNOTATE_BENIGN_RACE(value, "Test-only data race on boolean "
- "in base/thread_unittest");
- *value = !*value;
-}
-
-class SleepInsideInitThread : public Thread {
- public:
- SleepInsideInitThread() : Thread("none") {
- init_called_ = false;
- ANNOTATE_BENIGN_RACE(
- this, "Benign test-only data race on vptr - http://crbug.com/98219");
- }
- ~SleepInsideInitThread() override { Stop(); }
-
- void Init() override {
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
- init_called_ = true;
- }
- bool InitCalled() { return init_called_; }
-
- private:
- bool init_called_;
-
- DISALLOW_COPY_AND_ASSIGN(SleepInsideInitThread);
-};
-
-enum ThreadEvent {
- // Thread::Init() was called.
- THREAD_EVENT_INIT = 0,
-
- // The MessageLoop for the thread was deleted.
- THREAD_EVENT_MESSAGE_LOOP_DESTROYED,
-
- // Thread::CleanUp() was called.
- THREAD_EVENT_CLEANUP,
-
- // Keep at end of list.
- THREAD_NUM_EVENTS
-};
-
-typedef std::vector<ThreadEvent> EventList;
-
-class CaptureToEventList : public Thread {
- public:
- // This Thread pushes events into the vector |event_list| to show
- // the order they occured in. |event_list| must remain valid for the
- // lifetime of this thread.
- explicit CaptureToEventList(EventList* event_list)
- : Thread("none"),
- event_list_(event_list) {
- }
-
- ~CaptureToEventList() override { Stop(); }
-
- void Init() override { event_list_->push_back(THREAD_EVENT_INIT); }
-
- void CleanUp() override { event_list_->push_back(THREAD_EVENT_CLEANUP); }
-
- private:
- EventList* event_list_;
-
- DISALLOW_COPY_AND_ASSIGN(CaptureToEventList);
-};
-
-// Observer that writes a value into |event_list| when a message loop has been
-// destroyed.
-class CapturingDestructionObserver
- : public base::MessageLoopCurrent::DestructionObserver {
- public:
- // |event_list| must remain valid throughout the observer's lifetime.
- explicit CapturingDestructionObserver(EventList* event_list)
- : event_list_(event_list) {
- }
-
- // DestructionObserver implementation:
- void WillDestroyCurrentMessageLoop() override {
- event_list_->push_back(THREAD_EVENT_MESSAGE_LOOP_DESTROYED);
- event_list_ = nullptr;
- }
-
- private:
- EventList* event_list_;
-
- DISALLOW_COPY_AND_ASSIGN(CapturingDestructionObserver);
-};
-
-// Task that adds a destruction observer to the current message loop.
-void RegisterDestructionObserver(
- base::MessageLoopCurrent::DestructionObserver* observer) {
- base::MessageLoopCurrent::Get()->AddDestructionObserver(observer);
-}
-
-// Task that calls GetThreadId() of |thread|, stores the result into |id|, then
-// signal |event|.
-void ReturnThreadId(base::Thread* thread,
- base::PlatformThreadId* id,
- base::WaitableEvent* event) {
- *id = thread->GetThreadId();
- event->Signal();
-}
-
-} // namespace
-
-TEST_F(ThreadTest, StartWithOptions_StackSize) {
- Thread a("StartWithStackSize");
- // Ensure that the thread can work with only 12 kb and still process a
- // message. At the same time, we should scale with the bitness of the system
- // where 12 kb is definitely not enough.
- // 12 kb = 3072 Slots on a 32-bit system, so we'll scale based off of that.
- Thread::Options options;
-#if defined(ADDRESS_SANITIZER) || !defined(NDEBUG)
- // ASan bloats the stack variables and overflows the 3072 slot stack. Some
- // debug builds also grow the stack too much.
- options.stack_size = 2 * 3072 * sizeof(uintptr_t);
-#else
- options.stack_size = 3072 * sizeof(uintptr_t);
-#endif
- EXPECT_TRUE(a.StartWithOptions(options));
- EXPECT_TRUE(a.message_loop());
- EXPECT_TRUE(a.IsRunning());
-
- base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- a.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&event)));
- event.Wait();
-}
-
-// Intentional test-only race for otherwise untestable code, won't fix.
-// https://crbug.com/634383
-#if !defined(THREAD_SANITIZER)
-TEST_F(ThreadTest, StartWithOptions_NonJoinable) {
- Thread* a = new Thread("StartNonJoinable");
- // Non-joinable threads have to be leaked for now (see
- // Thread::Options::joinable for details).
- ANNOTATE_LEAKING_OBJECT_PTR(a);
-
- Thread::Options options;
- options.joinable = false;
- EXPECT_TRUE(a->StartWithOptions(options));
- EXPECT_TRUE(a->message_loop());
- EXPECT_TRUE(a->IsRunning());
-
- // Without this call this test is racy. The above IsRunning() succeeds because
- // of an early-return condition while between Start() and StopSoon(), after
- // invoking StopSoon() below this early-return condition is no longer
- // satisfied and the real |is_running_| bit has to be checked. It could still
- // be false if the message loop hasn't started for real in practice. This is
- // only a requirement for this test because the non-joinable property forces
- // it to use StopSoon() and not wait for a complete Stop().
- EXPECT_TRUE(a->WaitUntilThreadStarted());
-
- // Make the thread block until |block_event| is signaled.
- base::WaitableEvent block_event(
- base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- a->task_runner()->PostTask(FROM_HERE,
- base::BindOnce(&base::WaitableEvent::Wait,
- base::Unretained(&block_event)));
-
- a->StopSoon();
- EXPECT_TRUE(a->IsRunning());
-
- // Unblock the task and give a bit of extra time to unwind QuitWhenIdle().
- block_event.Signal();
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
-
- // The thread should now have stopped on its own.
- EXPECT_FALSE(a->IsRunning());
-}
-#endif
-
-TEST_F(ThreadTest, TwoTasksOnJoinableThread) {
- bool was_invoked = false;
- {
- Thread a("TwoTasksOnJoinableThread");
- EXPECT_TRUE(a.Start());
- EXPECT_TRUE(a.message_loop());
-
- // Test that all events are dispatched before the Thread object is
- // destroyed. We do this by dispatching a sleep event before the
- // event that will toggle our sentinel value.
- a.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(static_cast<void (*)(base::TimeDelta)>(
- &base::PlatformThread::Sleep),
- base::TimeDelta::FromMilliseconds(20)));
- a.task_runner()->PostTask(FROM_HERE,
- base::BindOnce(&ToggleValue, &was_invoked));
- }
- EXPECT_TRUE(was_invoked);
-}
-
-TEST_F(ThreadTest, DestroyWhileRunningIsSafe) {
- Thread a("DestroyWhileRunningIsSafe");
- EXPECT_TRUE(a.Start());
- EXPECT_TRUE(a.WaitUntilThreadStarted());
-}
-
-// TODO(gab): Enable this test when destroying a non-joinable Thread instance
-// is supported (proposal @ https://crbug.com/629139#c14).
-TEST_F(ThreadTest, DISABLED_DestroyWhileRunningNonJoinableIsSafe) {
- {
- Thread a("DestroyWhileRunningNonJoinableIsSafe");
- Thread::Options options;
- options.joinable = false;
- EXPECT_TRUE(a.StartWithOptions(options));
- EXPECT_TRUE(a.WaitUntilThreadStarted());
- }
-
- // Attempt to catch use-after-frees from the non-joinable thread in the
- // scope of this test if any.
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
-}
-
-TEST_F(ThreadTest, StopSoon) {
- Thread a("StopSoon");
- EXPECT_TRUE(a.Start());
- EXPECT_TRUE(a.message_loop());
- EXPECT_TRUE(a.IsRunning());
- a.StopSoon();
- a.Stop();
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
-}
-
-TEST_F(ThreadTest, StopTwiceNop) {
- Thread a("StopTwiceNop");
- EXPECT_TRUE(a.Start());
- EXPECT_TRUE(a.message_loop());
- EXPECT_TRUE(a.IsRunning());
- a.StopSoon();
- // Calling StopSoon() a second time should be a nop.
- a.StopSoon();
- a.Stop();
- // Same with Stop().
- a.Stop();
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
- // Calling them when not running should also nop.
- a.StopSoon();
- a.Stop();
-}
-
-// TODO(gab): Enable this test in conjunction with re-enabling the sequence
-// check in Thread::Stop() as part of http://crbug.com/629139.
-TEST_F(ThreadTest, DISABLED_StopOnNonOwningThreadIsDeath) {
- Thread a("StopOnNonOwningThreadDeath");
- EXPECT_TRUE(a.StartAndWaitForTesting());
-
- Thread b("NonOwningThread");
- b.Start();
- EXPECT_DCHECK_DEATH({
- // Stopping |a| on |b| isn't allowed.
- b.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&Thread::Stop, base::Unretained(&a)));
- // Block here so the DCHECK on |b| always happens in this scope.
- base::PlatformThread::Sleep(base::TimeDelta::Max());
- });
-}
-
-TEST_F(ThreadTest, TransferOwnershipAndStop) {
- std::unique_ptr<Thread> a =
- std::make_unique<Thread>("TransferOwnershipAndStop");
- EXPECT_TRUE(a->StartAndWaitForTesting());
- EXPECT_TRUE(a->IsRunning());
-
- Thread b("TakingOwnershipThread");
- b.Start();
-
- base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
-
- // a->DetachFromSequence() should allow |b| to use |a|'s Thread API.
- a->DetachFromSequence();
- b.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(
- [](std::unique_ptr<Thread> thread_to_stop,
- base::WaitableEvent* event_to_signal) -> void {
- thread_to_stop->Stop();
- event_to_signal->Signal();
- },
- std::move(a), base::Unretained(&event)));
-
- event.Wait();
-}
-
-TEST_F(ThreadTest, StartTwice) {
- Thread a("StartTwice");
-
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
-
- EXPECT_TRUE(a.Start());
- EXPECT_TRUE(a.message_loop());
- EXPECT_TRUE(a.IsRunning());
-
- a.Stop();
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
-
- EXPECT_TRUE(a.Start());
- EXPECT_TRUE(a.message_loop());
- EXPECT_TRUE(a.IsRunning());
-
- a.Stop();
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
-}
-
-// Intentional test-only race for otherwise untestable code, won't fix.
-// https://crbug.com/634383
-#if !defined(THREAD_SANITIZER)
-TEST_F(ThreadTest, StartTwiceNonJoinableNotAllowed) {
- LOG(ERROR) << __FUNCTION__;
- Thread* a = new Thread("StartTwiceNonJoinable");
- // Non-joinable threads have to be leaked for now (see
- // Thread::Options::joinable for details).
- ANNOTATE_LEAKING_OBJECT_PTR(a);
-
- Thread::Options options;
- options.joinable = false;
- EXPECT_TRUE(a->StartWithOptions(options));
- EXPECT_TRUE(a->message_loop());
- EXPECT_TRUE(a->IsRunning());
-
- // Signaled when last task on |a| is processed.
- base::WaitableEvent last_task_event(
- base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- a->task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&base::WaitableEvent::Signal,
- base::Unretained(&last_task_event)));
-
- // StopSoon() is non-blocking, Yield() to |a|, wait for last task to be
- // processed and a little more for QuitWhenIdle() to unwind before considering
- // the thread "stopped".
- a->StopSoon();
- base::PlatformThread::YieldCurrentThread();
- last_task_event.Wait();
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
-
- // This test assumes that the above was sufficient to let the thread fully
- // stop.
- ASSERT_FALSE(a->IsRunning());
-
- // Restarting it should not be allowed.
- EXPECT_DCHECK_DEATH(a->Start());
-}
-#endif
-
-TEST_F(ThreadTest, ThreadName) {
- Thread a("ThreadName");
- EXPECT_TRUE(a.Start());
- EXPECT_EQ("ThreadName", a.thread_name());
-}
-
-TEST_F(ThreadTest, ThreadId) {
- Thread a("ThreadId0");
- Thread b("ThreadId1");
- a.Start();
- b.Start();
-
- // Post a task that calls GetThreadId() on the created thread.
- base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- base::PlatformThreadId id_from_new_thread;
- a.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(ReturnThreadId, &a, &id_from_new_thread, &event));
-
- // Call GetThreadId() on the current thread before calling event.Wait() so
- // that this test can find a race issue with TSAN.
- base::PlatformThreadId id_from_current_thread = a.GetThreadId();
-
- // Check if GetThreadId() returns consistent value in both threads.
- event.Wait();
- EXPECT_EQ(id_from_current_thread, id_from_new_thread);
-
- // A started thread should have a valid ID.
- EXPECT_NE(base::kInvalidThreadId, a.GetThreadId());
- EXPECT_NE(base::kInvalidThreadId, b.GetThreadId());
-
- // Each thread should have a different thread ID.
- EXPECT_NE(a.GetThreadId(), b.GetThreadId());
-}
-
-TEST_F(ThreadTest, ThreadIdWithRestart) {
- Thread a("ThreadIdWithRestart");
- base::PlatformThreadId previous_id = base::kInvalidThreadId;
-
- for (size_t i = 0; i < 16; ++i) {
- EXPECT_TRUE(a.Start());
- base::PlatformThreadId current_id = a.GetThreadId();
- EXPECT_NE(previous_id, current_id);
- previous_id = current_id;
- a.Stop();
- }
-}
-
-// Make sure Init() is called after Start() and before
-// WaitUntilThreadInitialized() returns.
-TEST_F(ThreadTest, SleepInsideInit) {
- SleepInsideInitThread t;
- EXPECT_FALSE(t.InitCalled());
- t.StartAndWaitForTesting();
- EXPECT_TRUE(t.InitCalled());
-}
-
-// Make sure that the destruction sequence is:
-//
-// (1) Thread::CleanUp()
-// (2) MessageLoop::~MessageLoop()
-// MessageLoopCurrent::DestructionObservers called.
-TEST_F(ThreadTest, CleanUp) {
- EventList captured_events;
- CapturingDestructionObserver loop_destruction_observer(&captured_events);
-
- {
- // Start a thread which writes its event into |captured_events|.
- CaptureToEventList t(&captured_events);
- EXPECT_TRUE(t.Start());
- EXPECT_TRUE(t.message_loop());
- EXPECT_TRUE(t.IsRunning());
-
- // Register an observer that writes into |captured_events| once the
- // thread's message loop is destroyed.
- t.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&RegisterDestructionObserver,
- base::Unretained(&loop_destruction_observer)));
-
- // Upon leaving this scope, the thread is deleted.
- }
-
- // Check the order of events during shutdown.
- ASSERT_EQ(static_cast<size_t>(THREAD_NUM_EVENTS), captured_events.size());
- EXPECT_EQ(THREAD_EVENT_INIT, captured_events[0]);
- EXPECT_EQ(THREAD_EVENT_CLEANUP, captured_events[1]);
- EXPECT_EQ(THREAD_EVENT_MESSAGE_LOOP_DESTROYED, captured_events[2]);
-}
-
-TEST_F(ThreadTest, ThreadNotStarted) {
- Thread a("Inert");
- EXPECT_FALSE(a.task_runner());
-}
-
-TEST_F(ThreadTest, MultipleWaitUntilThreadStarted) {
- Thread a("MultipleWaitUntilThreadStarted");
- EXPECT_TRUE(a.Start());
- // It's OK to call WaitUntilThreadStarted() multiple times.
- EXPECT_TRUE(a.WaitUntilThreadStarted());
- EXPECT_TRUE(a.WaitUntilThreadStarted());
-}
-
-TEST_F(ThreadTest, FlushForTesting) {
- Thread a("FlushForTesting");
-
- // Flushing a non-running thread should be a no-op.
- a.FlushForTesting();
-
- ASSERT_TRUE(a.Start());
-
- // Flushing a thread with no tasks shouldn't block.
- a.FlushForTesting();
-
- constexpr base::TimeDelta kSleepPerTestTask =
- base::TimeDelta::FromMilliseconds(50);
- constexpr size_t kNumSleepTasks = 5;
-
- const base::TimeTicks ticks_before_post = base::TimeTicks::Now();
-
- for (size_t i = 0; i < kNumSleepTasks; ++i) {
- a.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&base::PlatformThread::Sleep, kSleepPerTestTask));
- }
-
- // All tasks should have executed, as reflected by the elapsed time.
- a.FlushForTesting();
- EXPECT_GE(base::TimeTicks::Now() - ticks_before_post,
- kNumSleepTasks * kSleepPerTestTask);
-
- a.Stop();
-
- // Flushing a stopped thread should be a no-op.
- a.FlushForTesting();
-}
-
-namespace {
-
-// A Thread which uses a MessageLoop on the stack. It won't start a real
-// underlying thread (instead its messages can be processed by a RunLoop on the
-// stack).
-class ExternalMessageLoopThread : public Thread {
- public:
- ExternalMessageLoopThread() : Thread("ExternalMessageLoopThread") {}
-
- ~ExternalMessageLoopThread() override { Stop(); }
-
- void InstallMessageLoop() { SetMessageLoop(&external_message_loop_); }
-
- void VerifyUsingExternalMessageLoop(
- bool expected_using_external_message_loop) {
- EXPECT_EQ(expected_using_external_message_loop,
- using_external_message_loop());
- }
-
- private:
- base::MessageLoop external_message_loop_;
-
- DISALLOW_COPY_AND_ASSIGN(ExternalMessageLoopThread);
-};
-
-} // namespace
-
-TEST_F(ThreadTest, ExternalMessageLoop) {
- ExternalMessageLoopThread a;
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
- a.VerifyUsingExternalMessageLoop(false);
-
- a.InstallMessageLoop();
- EXPECT_TRUE(a.message_loop());
- EXPECT_TRUE(a.IsRunning());
- a.VerifyUsingExternalMessageLoop(true);
-
- bool ran = false;
- a.task_runner()->PostTask(
- FROM_HERE, base::BindOnce([](bool* toggled) { *toggled = true; }, &ran));
- base::RunLoop().RunUntilIdle();
- EXPECT_TRUE(ran);
-
- a.Stop();
- EXPECT_FALSE(a.message_loop());
- EXPECT_FALSE(a.IsRunning());
- a.VerifyUsingExternalMessageLoop(true);
-
- // Confirm that running any remaining tasks posted from Stop() goes smoothly
- // (e.g. https://codereview.chromium.org/2135413003/#ps300001 crashed if
- // StopSoon() posted Thread::ThreadQuitHelper() while |run_loop_| was null).
- base::RunLoop().RunUntilIdle();
-}
diff --git a/base/threading/watchdog_unittest.cc b/base/threading/watchdog_unittest.cc
deleted file mode 100644
index f534a86..0000000
--- a/base/threading/watchdog_unittest.cc
+++ /dev/null
@@ -1,141 +0,0 @@
-// 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.
-
-#include "base/threading/watchdog.h"
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/synchronization/spin_wait.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-//------------------------------------------------------------------------------
-// Provide a derived class to facilitate testing.
-
-class WatchdogCounter : public Watchdog {
- public:
- WatchdogCounter(const TimeDelta& duration,
- const std::string& thread_watched_name,
- bool enabled)
- : Watchdog(duration, thread_watched_name, enabled),
- alarm_counter_(0) {
- }
-
- ~WatchdogCounter() override = default;
-
- void Alarm() override {
- alarm_counter_++;
- Watchdog::Alarm();
- }
-
- int alarm_counter() { return alarm_counter_; }
-
- private:
- int alarm_counter_;
-
- DISALLOW_COPY_AND_ASSIGN(WatchdogCounter);
-};
-
-class WatchdogTest : public testing::Test {
- public:
- void SetUp() override { Watchdog::ResetStaticData(); }
-};
-
-} // namespace
-
-//------------------------------------------------------------------------------
-// Actual tests
-
-// Minimal constructor/destructor test.
-TEST_F(WatchdogTest, StartupShutdownTest) {
- Watchdog watchdog1(TimeDelta::FromMilliseconds(300), "Disabled", false);
- Watchdog watchdog2(TimeDelta::FromMilliseconds(300), "Enabled", true);
-}
-
-// Test ability to call Arm and Disarm repeatedly.
-TEST_F(WatchdogTest, ArmDisarmTest) {
- Watchdog watchdog1(TimeDelta::FromMilliseconds(300), "Disabled", false);
- watchdog1.Arm();
- watchdog1.Disarm();
- watchdog1.Arm();
- watchdog1.Disarm();
-
- Watchdog watchdog2(TimeDelta::FromMilliseconds(300), "Enabled", true);
- watchdog2.Arm();
- watchdog2.Disarm();
- watchdog2.Arm();
- watchdog2.Disarm();
-}
-
-// Make sure a basic alarm fires when the time has expired.
-TEST_F(WatchdogTest, AlarmTest) {
- WatchdogCounter watchdog(TimeDelta::FromMilliseconds(10), "Enabled", true);
- watchdog.Arm();
- SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
- watchdog.alarm_counter() > 0);
- EXPECT_EQ(1, watchdog.alarm_counter());
-}
-
-// Make sure a basic alarm fires when the time has expired.
-TEST_F(WatchdogTest, AlarmPriorTimeTest) {
- WatchdogCounter watchdog(TimeDelta(), "Enabled2", true);
- // Set a time in the past.
- watchdog.ArmSomeTimeDeltaAgo(TimeDelta::FromSeconds(2));
- // It should instantly go off, but certainly in less than 5 minutes.
- SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
- watchdog.alarm_counter() > 0);
-
- EXPECT_EQ(1, watchdog.alarm_counter());
-}
-
-// Make sure a disable alarm does nothing, even if we arm it.
-TEST_F(WatchdogTest, ConstructorDisabledTest) {
- WatchdogCounter watchdog(TimeDelta::FromMilliseconds(10), "Disabled", false);
- watchdog.Arm();
- // Alarm should not fire, as it was disabled.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
- EXPECT_EQ(0, watchdog.alarm_counter());
-}
-
-// Make sure Disarming will prevent firing, even after Arming.
-TEST_F(WatchdogTest, DisarmTest) {
- WatchdogCounter watchdog(TimeDelta::FromSeconds(1), "Enabled3", true);
-
- TimeTicks start = TimeTicks::Now();
- watchdog.Arm();
- // Sleep a bit, but not past the alarm point.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- watchdog.Disarm();
- TimeTicks end = TimeTicks::Now();
-
- if (end - start > TimeDelta::FromMilliseconds(500)) {
- LOG(WARNING) << "100ms sleep took over 500ms, making the results of this "
- << "timing-sensitive test suspicious. Aborting now.";
- return;
- }
-
- // Alarm should not have fired before it was disarmed.
- EXPECT_EQ(0, watchdog.alarm_counter());
-
- // Sleep past the point where it would have fired if it wasn't disarmed,
- // and verify that it didn't fire.
- PlatformThread::Sleep(TimeDelta::FromSeconds(1));
- EXPECT_EQ(0, watchdog.alarm_counter());
-
- // ...but even after disarming, we can still use the alarm...
- // Set a time greater than the timeout into the past.
- watchdog.ArmSomeTimeDeltaAgo(TimeDelta::FromSeconds(10));
- // It should almost instantly go off, but certainly in less than 5 minutes.
- SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
- watchdog.alarm_counter() > 0);
-
- EXPECT_EQ(1, watchdog.alarm_counter());
-}
-
-} // namespace base
diff --git a/base/time/pr_time_unittest.cc b/base/time/pr_time_unittest.cc
deleted file mode 100644
index 341d778..0000000
--- a/base/time/pr_time_unittest.cc
+++ /dev/null
@@ -1,289 +0,0 @@
-// 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.
-
-#include <stdint.h>
-#include <time.h>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/third_party/nspr/prtime.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::Time;
-
-namespace {
-
-// time_t representation of 15th Oct 2007 12:45:00 PDT
-PRTime comparison_time_pdt = 1192477500 * Time::kMicrosecondsPerSecond;
-
-// Time with positive tz offset and fractional seconds:
-// 2013-07-08T11:28:12.441381+02:00
-PRTime comparison_time_2 = INT64_C(1373275692441381); // represented as GMT
-
-// Specialized test fixture allowing time strings without timezones to be
-// tested by comparing them to a known time in the local zone.
-class PRTimeTest : public testing::Test {
- protected:
- void SetUp() override {
- // Use mktime to get a time_t, and turn it into a PRTime by converting
- // seconds to microseconds. Use 15th Oct 2007 12:45:00 local. This
- // must be a time guaranteed to be outside of a DST fallback hour in
- // any timezone.
- struct tm local_comparison_tm = {
- 0, // second
- 45, // minute
- 12, // hour
- 15, // day of month
- 10 - 1, // month
- 2007 - 1900, // year
- 0, // day of week (ignored, output only)
- 0, // day of year (ignored, output only)
- -1 // DST in effect, -1 tells mktime to figure it out
- };
- comparison_time_local_ =
- mktime(&local_comparison_tm) * Time::kMicrosecondsPerSecond;
- ASSERT_GT(comparison_time_local_, 0);
-
- const int microseconds = 441381;
- struct tm local_comparison_tm_2 = {
- 12, // second
- 28, // minute
- 11, // hour
- 8, // day of month
- 7 - 1, // month
- 2013 - 1900, // year
- 0, // day of week (ignored, output only)
- 0, // day of year (ignored, output only)
- -1 // DST in effect, -1 tells mktime to figure it out
- };
- comparison_time_local_2_ =
- mktime(&local_comparison_tm_2) * Time::kMicrosecondsPerSecond;
- ASSERT_GT(comparison_time_local_2_, 0);
- comparison_time_local_2_ += microseconds;
- }
-
- PRTime comparison_time_local_;
- PRTime comparison_time_local_2_;
-};
-
-// Tests the PR_ParseTimeString nspr helper function for
-// a variety of time strings.
-TEST_F(PRTimeTest, ParseTimeTest1) {
- time_t current_time = 0;
- time(¤t_time);
-
- struct tm local_time = {};
- char time_buf[64] = {};
-#if defined(OS_WIN)
- localtime_s(&local_time, ¤t_time);
- asctime_s(time_buf, arraysize(time_buf), &local_time);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- localtime_r(¤t_time, &local_time);
- asctime_r(&local_time, time_buf);
-#endif
-
- PRTime current_time64 = static_cast<PRTime>(current_time) * PR_USEC_PER_SEC;
-
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString(time_buf, PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(current_time64, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest2) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("Mon, 15 Oct 2007 19:45:00 GMT",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_pdt, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest3) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("15 Oct 07 12:45:00", PR_FALSE,
- &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest4) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("15 Oct 07 19:45 GMT", PR_FALSE,
- &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_pdt, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest5) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("Mon Oct 15 12:45 PDT 2007",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_pdt, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest6) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("Monday, Oct 15, 2007 12:45 PM",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest7) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("10/15/07 12:45:00 PM", PR_FALSE,
- &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest8) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("10/15/07 12:45:00. PM", PR_FALSE,
- &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest9) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("10/15/07 12:45:00.0 PM", PR_FALSE,
- &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest10) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("15-OCT-2007 12:45pm", PR_FALSE,
- &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTest11) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("16 Oct 2007 4:45-JST (Tuesday)",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_pdt, parsed_time);
-}
-
-// hh:mm timezone offset.
-TEST_F(PRTimeTest, ParseTimeTest12) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08T11:28:12.441381+02:00",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_2, parsed_time);
-}
-
-// hhmm timezone offset.
-TEST_F(PRTimeTest, ParseTimeTest13) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08T11:28:12.441381+0200",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_2, parsed_time);
-}
-
-// hh timezone offset.
-TEST_F(PRTimeTest, ParseTimeTest14) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08T11:28:12.4413819+02",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_2, parsed_time);
-}
-
-// 5 digits fractional second.
-TEST_F(PRTimeTest, ParseTimeTest15) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08T09:28:12.44138Z",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_2-1, parsed_time);
-}
-
-// Fractional seconds, local timezone.
-TEST_F(PRTimeTest, ParseTimeTest16) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08T11:28:12.441381",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_local_2_, parsed_time);
-}
-
-// "Z" (=GMT) timezone.
-TEST_F(PRTimeTest, ParseTimeTest17) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08T09:28:12.441381Z",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_2, parsed_time);
-}
-
-// "T" delimiter replaced by space.
-TEST_F(PRTimeTest, ParseTimeTest18) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-08 09:28:12.441381Z",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_2, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTestInvalid1) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("201-07-08T09:28:12.441381Z",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_FAILURE, result);
-}
-
-TEST_F(PRTimeTest, ParseTimeTestInvalid2) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-007-08T09:28:12.441381Z",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_FAILURE, result);
-}
-
-TEST_F(PRTimeTest, ParseTimeTestInvalid3) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("2013-07-008T09:28:12.441381Z",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_FAILURE, result);
-}
-
-// This test should not crash when compiled with Visual C++ 2005 (see
-// http://crbug.com/4387).
-TEST_F(PRTimeTest, ParseTimeTestOutOfRange) {
- PRTime parsed_time = 0;
- // Note the lack of timezone in the time string. The year has to be 3001.
- // The date has to be after 23:59:59, December 31, 3000, US Pacific Time, so
- // we use January 2, 3001 to make sure it's after the magic maximum in any
- // timezone.
- PRStatus result = PR_ParseTimeString("Sun Jan 2 00:00:00 3001",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
-}
-
-TEST_F(PRTimeTest, ParseTimeTestNotNormalized1) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("Mon Oct 15 12:44:60 PDT 2007",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_pdt, parsed_time);
-}
-
-TEST_F(PRTimeTest, ParseTimeTestNotNormalized2) {
- PRTime parsed_time = 0;
- PRStatus result = PR_ParseTimeString("Sun Oct 14 36:45 PDT 2007",
- PR_FALSE, &parsed_time);
- EXPECT_EQ(PR_SUCCESS, result);
- EXPECT_EQ(comparison_time_pdt, parsed_time);
-}
-
-} // namespace
diff --git a/base/time/time_unittest.cc b/base/time/time_unittest.cc
deleted file mode 100644
index 0471dd4..0000000
--- a/base/time/time_unittest.cc
+++ /dev/null
@@ -1,1588 +0,0 @@
-// 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.
-
-#include "base/time/time.h"
-
-#include <stdint.h>
-#include <time.h>
-#include <limits>
-#include <string>
-
-#include "base/build_time.h"
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/stringprintf.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time_override.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_ANDROID)
-#include "base/android/jni_android.h"
-#elif defined(OS_IOS)
-#include "base/ios/ios_util.h"
-#elif defined(OS_WIN)
-#include <windows.h>
-#endif
-
-namespace base {
-
-namespace {
-
-TEST(TimeTestOutOfBounds, FromExplodedOutOfBoundsTime) {
- // FromUTCExploded must set time to Time(0) and failure, if the day is set to
- // 31 on a 28-30 day month. Test |exploded| returns Time(0) on 31st of
- // February and 31st of April. New implementation handles this.
-
- const struct DateTestData {
- Time::Exploded explode;
- bool is_valid;
- } kDateTestData[] = {
- // 31st of February
- {{2016, 2, 0, 31, 12, 30, 0, 0}, true},
- // 31st of April
- {{2016, 4, 0, 31, 8, 43, 0, 0}, true},
- // Negative month
- {{2016, -5, 0, 2, 4, 10, 0, 0}, false},
- // Negative date of month
- {{2016, 6, 0, -15, 2, 50, 0, 0}, false},
- // Negative hours
- {{2016, 7, 0, 10, -11, 29, 0, 0}, false},
- // Negative minutes
- {{2016, 3, 0, 14, 10, -29, 0, 0}, false},
- // Negative seconds
- {{2016, 10, 0, 25, 7, 47, -30, 0}, false},
- // Negative milliseconds
- {{2016, 10, 0, 25, 7, 47, 20, -500}, false},
- // Hours are too large
- {{2016, 7, 0, 10, 26, 29, 0, 0}, false},
- // Minutes are too large
- {{2016, 3, 0, 14, 10, 78, 0, 0}, false},
- // Seconds are too large
- {{2016, 10, 0, 25, 7, 47, 234, 0}, false},
- // Milliseconds are too large
- {{2016, 10, 0, 25, 6, 31, 23, 1643}, false},
- // Test overflow. Time is valid, but overflow case
- // results in Time(0).
- {{9840633, 1, 0, 1, 1, 1, 0, 0}, true},
- // Underflow will fail as well.
- {{-9840633, 1, 0, 1, 1, 1, 0, 0}, true},
- // Test integer overflow and underflow cases for the values themselves.
- {{std::numeric_limits<int>::min(), 1, 0, 1, 1, 1, 0, 0}, true},
- {{std::numeric_limits<int>::max(), 1, 0, 1, 1, 1, 0, 0}, true},
- {{2016, std::numeric_limits<int>::min(), 0, 1, 1, 1, 0, 0}, false},
- {{2016, std::numeric_limits<int>::max(), 0, 1, 1, 1, 0, 0}, false},
- };
-
- for (const auto& test : kDateTestData) {
- EXPECT_EQ(test.explode.HasValidValues(), test.is_valid);
-
- base::Time result;
- EXPECT_FALSE(base::Time::FromUTCExploded(test.explode, &result));
- EXPECT_TRUE(result.is_null());
- EXPECT_FALSE(base::Time::FromLocalExploded(test.explode, &result));
- EXPECT_TRUE(result.is_null());
- }
-}
-
-// Specialized test fixture allowing time strings without timezones to be
-// tested by comparing them to a known time in the local zone.
-// See also pr_time_unittests.cc
-class TimeTest : public testing::Test {
- protected:
- void SetUp() override {
- // Use mktime to get a time_t, and turn it into a PRTime by converting
- // seconds to microseconds. Use 15th Oct 2007 12:45:00 local. This
- // must be a time guaranteed to be outside of a DST fallback hour in
- // any timezone.
- struct tm local_comparison_tm = {
- 0, // second
- 45, // minute
- 12, // hour
- 15, // day of month
- 10 - 1, // month
- 2007 - 1900, // year
- 0, // day of week (ignored, output only)
- 0, // day of year (ignored, output only)
- -1 // DST in effect, -1 tells mktime to figure it out
- };
-
- time_t converted_time = mktime(&local_comparison_tm);
- ASSERT_GT(converted_time, 0);
- comparison_time_local_ = Time::FromTimeT(converted_time);
-
- // time_t representation of 15th Oct 2007 12:45:00 PDT
- comparison_time_pdt_ = Time::FromTimeT(1192477500);
- }
-
- Time comparison_time_local_;
- Time comparison_time_pdt_;
-};
-
-// Test conversion to/from TimeDeltas elapsed since the Windows epoch.
-// Conversions should be idempotent and non-lossy.
-TEST_F(TimeTest, DeltaSinceWindowsEpoch) {
- const TimeDelta delta = TimeDelta::FromMicroseconds(123);
- EXPECT_EQ(delta,
- Time::FromDeltaSinceWindowsEpoch(delta).ToDeltaSinceWindowsEpoch());
-
- const Time now = Time::Now();
- const Time actual =
- Time::FromDeltaSinceWindowsEpoch(now.ToDeltaSinceWindowsEpoch());
- EXPECT_EQ(now, actual);
-
- // Null times should remain null after a round-trip conversion. This is an
- // important invariant for the common use case of serialization +
- // deserialization.
- const Time should_be_null =
- Time::FromDeltaSinceWindowsEpoch(Time().ToDeltaSinceWindowsEpoch());
- EXPECT_TRUE(should_be_null.is_null());
-}
-
-// Test conversion to/from time_t.
-TEST_F(TimeTest, TimeT) {
- EXPECT_EQ(10, Time().FromTimeT(10).ToTimeT());
- EXPECT_EQ(10.0, Time().FromTimeT(10).ToDoubleT());
-
- // Conversions of 0 should stay 0.
- EXPECT_EQ(0, Time().ToTimeT());
- EXPECT_EQ(0, Time::FromTimeT(0).ToInternalValue());
-}
-
-// Test conversions to/from time_t and exploding/unexploding (utc time).
-TEST_F(TimeTest, UTCTimeT) {
- // C library time and exploded time.
- time_t now_t_1 = time(nullptr);
- struct tm tms;
-#if defined(OS_WIN)
- gmtime_s(&tms, &now_t_1);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- gmtime_r(&now_t_1, &tms);
-#endif
-
- // Convert to ours.
- Time our_time_1 = Time::FromTimeT(now_t_1);
- Time::Exploded exploded;
- our_time_1.UTCExplode(&exploded);
-
- // This will test both our exploding and our time_t -> Time conversion.
- EXPECT_EQ(tms.tm_year + 1900, exploded.year);
- EXPECT_EQ(tms.tm_mon + 1, exploded.month);
- EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
- EXPECT_EQ(tms.tm_hour, exploded.hour);
- EXPECT_EQ(tms.tm_min, exploded.minute);
- EXPECT_EQ(tms.tm_sec, exploded.second);
-
- // Convert exploded back to the time struct.
- Time our_time_2;
- EXPECT_TRUE(Time::FromUTCExploded(exploded, &our_time_2));
- EXPECT_TRUE(our_time_1 == our_time_2);
-
- time_t now_t_2 = our_time_2.ToTimeT();
- EXPECT_EQ(now_t_1, now_t_2);
-}
-
-// Test conversions to/from time_t and exploding/unexploding (local time).
-TEST_F(TimeTest, LocalTimeT) {
-#if defined(OS_IOS) && TARGET_OS_SIMULATOR
- // The function CFTimeZoneCopySystem() fails to determine the system timezone
- // when running iOS 11.0 simulator on an host running High Sierra and return
- // the "GMT" timezone. This causes Time::LocalExplode and localtime_r values
- // to differ by the local timezone offset. Disable the test if simulating
- // iOS 10.0 as it is not possible to check the version of the host mac.
- // TODO(crbug.com/782033): remove this once support for iOS pre-11.0 is
- // dropped or when the bug in CFTimeZoneCopySystem() is fixed.
- if (ios::IsRunningOnIOS10OrLater() && !ios::IsRunningOnIOS11OrLater()) {
- return;
- }
-#endif
-
- // C library time and exploded time.
- time_t now_t_1 = time(nullptr);
- struct tm tms;
-#if defined(OS_WIN)
- localtime_s(&tms, &now_t_1);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- localtime_r(&now_t_1, &tms);
-#endif
-
- // Convert to ours.
- Time our_time_1 = Time::FromTimeT(now_t_1);
- Time::Exploded exploded;
- our_time_1.LocalExplode(&exploded);
-
- // This will test both our exploding and our time_t -> Time conversion.
- EXPECT_EQ(tms.tm_year + 1900, exploded.year);
- EXPECT_EQ(tms.tm_mon + 1, exploded.month);
- EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
- EXPECT_EQ(tms.tm_hour, exploded.hour);
- EXPECT_EQ(tms.tm_min, exploded.minute);
- EXPECT_EQ(tms.tm_sec, exploded.second);
-
- // Convert exploded back to the time struct.
- Time our_time_2;
- EXPECT_TRUE(Time::FromLocalExploded(exploded, &our_time_2));
- EXPECT_TRUE(our_time_1 == our_time_2);
-
- time_t now_t_2 = our_time_2.ToTimeT();
- EXPECT_EQ(now_t_1, now_t_2);
-}
-
-// Test conversions to/from javascript time.
-TEST_F(TimeTest, JsTime) {
- Time epoch = Time::FromJsTime(0.0);
- EXPECT_EQ(epoch, Time::UnixEpoch());
- Time t = Time::FromJsTime(700000.3);
- EXPECT_EQ(700.0003, t.ToDoubleT());
- t = Time::FromDoubleT(800.73);
- EXPECT_EQ(800730.0, t.ToJsTime());
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-TEST_F(TimeTest, FromTimeVal) {
- Time now = Time::Now();
- Time also_now = Time::FromTimeVal(now.ToTimeVal());
- EXPECT_EQ(now, also_now);
-}
-#endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-TEST_F(TimeTest, FromExplodedWithMilliseconds) {
- // Some platform implementations of FromExploded are liable to drop
- // milliseconds if we aren't careful.
- Time now = Time::NowFromSystemTime();
- Time::Exploded exploded1 = {0};
- now.UTCExplode(&exploded1);
- exploded1.millisecond = 500;
- Time time;
- EXPECT_TRUE(Time::FromUTCExploded(exploded1, &time));
- Time::Exploded exploded2 = {0};
- time.UTCExplode(&exploded2);
- EXPECT_EQ(exploded1.millisecond, exploded2.millisecond);
-}
-
-TEST_F(TimeTest, ZeroIsSymmetric) {
- Time zero_time(Time::FromTimeT(0));
- EXPECT_EQ(0, zero_time.ToTimeT());
-
- EXPECT_EQ(0.0, zero_time.ToDoubleT());
-}
-
-TEST_F(TimeTest, LocalExplode) {
- Time a = Time::Now();
- Time::Exploded exploded;
- a.LocalExplode(&exploded);
-
- Time b;
- EXPECT_TRUE(Time::FromLocalExploded(exploded, &b));
-
- // The exploded structure doesn't have microseconds, and on Mac & Linux, the
- // internal OS conversion uses seconds, which will cause truncation. So we
- // can only make sure that the delta is within one second.
- EXPECT_TRUE((a - b) < TimeDelta::FromSeconds(1));
-}
-
-TEST_F(TimeTest, UTCExplode) {
- Time a = Time::Now();
- Time::Exploded exploded;
- a.UTCExplode(&exploded);
-
- Time b;
- EXPECT_TRUE(Time::FromUTCExploded(exploded, &b));
- EXPECT_TRUE((a - b) < TimeDelta::FromSeconds(1));
-}
-
-TEST_F(TimeTest, LocalMidnight) {
- Time::Exploded exploded;
- Time::Now().LocalMidnight().LocalExplode(&exploded);
- EXPECT_EQ(0, exploded.hour);
- EXPECT_EQ(0, exploded.minute);
- EXPECT_EQ(0, exploded.second);
- EXPECT_EQ(0, exploded.millisecond);
-}
-
-TEST_F(TimeTest, ParseTimeTest1) {
- time_t current_time = 0;
- time(¤t_time);
-
- struct tm local_time = {};
- char time_buf[64] = {};
-#if defined(OS_WIN)
- localtime_s(&local_time, ¤t_time);
- asctime_s(time_buf, arraysize(time_buf), &local_time);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- localtime_r(¤t_time, &local_time);
- asctime_r(&local_time, time_buf);
-#endif
-
- Time parsed_time;
- EXPECT_TRUE(Time::FromString(time_buf, &parsed_time));
- EXPECT_EQ(current_time, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, DayOfWeekSunday) {
- Time time;
- EXPECT_TRUE(Time::FromString("Sun, 06 May 2012 12:00:00 GMT", &time));
- Time::Exploded exploded;
- time.UTCExplode(&exploded);
- EXPECT_EQ(0, exploded.day_of_week);
-}
-
-TEST_F(TimeTest, DayOfWeekWednesday) {
- Time time;
- EXPECT_TRUE(Time::FromString("Wed, 09 May 2012 12:00:00 GMT", &time));
- Time::Exploded exploded;
- time.UTCExplode(&exploded);
- EXPECT_EQ(3, exploded.day_of_week);
-}
-
-TEST_F(TimeTest, DayOfWeekSaturday) {
- Time time;
- EXPECT_TRUE(Time::FromString("Sat, 12 May 2012 12:00:00 GMT", &time));
- Time::Exploded exploded;
- time.UTCExplode(&exploded);
- EXPECT_EQ(6, exploded.day_of_week);
-}
-
-TEST_F(TimeTest, ParseTimeTest2) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("Mon, 15 Oct 2007 19:45:00 GMT", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest3) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15 Oct 07 12:45:00", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest4) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15 Oct 07 19:45 GMT", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest5) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("Mon Oct 15 12:45 PDT 2007", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest6) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("Monday, Oct 15, 2007 12:45 PM", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest7) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("10/15/07 12:45:00 PM", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest8) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15-OCT-2007 12:45pm", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest9) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("16 Oct 2007 4:45-JST (Tuesday)", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest10) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15/10/07 12:45", &parsed_time));
- EXPECT_EQ(parsed_time, comparison_time_local_);
-}
-
-// Test some of edge cases around epoch, etc.
-TEST_F(TimeTest, ParseTimeTestEpoch0) {
- Time parsed_time;
-
- // time_t == epoch == 0
- EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:00 +0100 1970",
- &parsed_time));
- EXPECT_EQ(0, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:00 GMT 1970",
- &parsed_time));
- EXPECT_EQ(0, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpoch1) {
- Time parsed_time;
-
- // time_t == 1 second after epoch == 1
- EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:01 +0100 1970",
- &parsed_time));
- EXPECT_EQ(1, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:01 GMT 1970",
- &parsed_time));
- EXPECT_EQ(1, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpoch2) {
- Time parsed_time;
-
- // time_t == 2 seconds after epoch == 2
- EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:02 +0100 1970",
- &parsed_time));
- EXPECT_EQ(2, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:02 GMT 1970",
- &parsed_time));
- EXPECT_EQ(2, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpochNeg1) {
- Time parsed_time;
-
- // time_t == 1 second before epoch == -1
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:59 +0100 1970",
- &parsed_time));
- EXPECT_EQ(-1, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 1969",
- &parsed_time));
- EXPECT_EQ(-1, parsed_time.ToTimeT());
-}
-
-// If time_t is 32 bits, a date after year 2038 will overflow time_t and
-// cause timegm() to return -1. The parsed time should not be 1 second
-// before epoch.
-TEST_F(TimeTest, ParseTimeTestEpochNotNeg1) {
- Time parsed_time;
-
- EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 2100",
- &parsed_time));
- EXPECT_NE(-1, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpochNeg2) {
- Time parsed_time;
-
- // time_t == 2 seconds before epoch == -2
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:58 +0100 1970",
- &parsed_time));
- EXPECT_EQ(-2, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:58 GMT 1969",
- &parsed_time));
- EXPECT_EQ(-2, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpoch1960) {
- Time parsed_time;
-
- // time_t before Epoch, in 1960
- EXPECT_TRUE(Time::FromString("Wed Jun 29 19:40:01 +0100 1960",
- &parsed_time));
- EXPECT_EQ(-299999999, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Jun 29 18:40:01 GMT 1960",
- &parsed_time));
- EXPECT_EQ(-299999999, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Jun 29 17:40:01 GMT 1960",
- &parsed_time));
- EXPECT_EQ(-300003599, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEmpty) {
- Time parsed_time;
- EXPECT_FALSE(Time::FromString("", &parsed_time));
-}
-
-TEST_F(TimeTest, ParseTimeTestInvalidString) {
- Time parsed_time;
- EXPECT_FALSE(Time::FromString("Monday morning 2000", &parsed_time));
-}
-
-TEST_F(TimeTest, ExplodeBeforeUnixEpoch) {
- static const int kUnixEpochYear = 1970; // In case this changes (ha!).
- Time t;
- Time::Exploded exploded;
-
- t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(1);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1969-12-31 23:59:59 999 milliseconds (and 999 microseconds).
- EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
- EXPECT_EQ(12, exploded.month);
- EXPECT_EQ(31, exploded.day_of_month);
- EXPECT_EQ(23, exploded.hour);
- EXPECT_EQ(59, exploded.minute);
- EXPECT_EQ(59, exploded.second);
- EXPECT_EQ(999, exploded.millisecond);
-
- t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(1000);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1969-12-31 23:59:59 999 milliseconds.
- EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
- EXPECT_EQ(12, exploded.month);
- EXPECT_EQ(31, exploded.day_of_month);
- EXPECT_EQ(23, exploded.hour);
- EXPECT_EQ(59, exploded.minute);
- EXPECT_EQ(59, exploded.second);
- EXPECT_EQ(999, exploded.millisecond);
-
- t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(1001);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1969-12-31 23:59:59 998 milliseconds (and 999 microseconds).
- EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
- EXPECT_EQ(12, exploded.month);
- EXPECT_EQ(31, exploded.day_of_month);
- EXPECT_EQ(23, exploded.hour);
- EXPECT_EQ(59, exploded.minute);
- EXPECT_EQ(59, exploded.second);
- EXPECT_EQ(998, exploded.millisecond);
-
- t = Time::UnixEpoch() - TimeDelta::FromMilliseconds(1000);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1969-12-31 23:59:59.
- EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
- EXPECT_EQ(12, exploded.month);
- EXPECT_EQ(31, exploded.day_of_month);
- EXPECT_EQ(23, exploded.hour);
- EXPECT_EQ(59, exploded.minute);
- EXPECT_EQ(59, exploded.second);
- EXPECT_EQ(0, exploded.millisecond);
-
- t = Time::UnixEpoch() - TimeDelta::FromMilliseconds(1001);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1969-12-31 23:59:58 999 milliseconds.
- EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
- EXPECT_EQ(12, exploded.month);
- EXPECT_EQ(31, exploded.day_of_month);
- EXPECT_EQ(23, exploded.hour);
- EXPECT_EQ(59, exploded.minute);
- EXPECT_EQ(58, exploded.second);
- EXPECT_EQ(999, exploded.millisecond);
-
- // Make sure we still handle at/after Unix epoch correctly.
- t = Time::UnixEpoch();
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1970-12-31 00:00:00 0 milliseconds.
- EXPECT_EQ(kUnixEpochYear, exploded.year);
- EXPECT_EQ(1, exploded.month);
- EXPECT_EQ(1, exploded.day_of_month);
- EXPECT_EQ(0, exploded.hour);
- EXPECT_EQ(0, exploded.minute);
- EXPECT_EQ(0, exploded.second);
- EXPECT_EQ(0, exploded.millisecond);
-
- t = Time::UnixEpoch() + TimeDelta::FromMicroseconds(1);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1970-01-01 00:00:00 0 milliseconds (and 1 microsecond).
- EXPECT_EQ(kUnixEpochYear, exploded.year);
- EXPECT_EQ(1, exploded.month);
- EXPECT_EQ(1, exploded.day_of_month);
- EXPECT_EQ(0, exploded.hour);
- EXPECT_EQ(0, exploded.minute);
- EXPECT_EQ(0, exploded.second);
- EXPECT_EQ(0, exploded.millisecond);
-
- t = Time::UnixEpoch() + TimeDelta::FromMicroseconds(1000);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1970-01-01 00:00:00 1 millisecond.
- EXPECT_EQ(kUnixEpochYear, exploded.year);
- EXPECT_EQ(1, exploded.month);
- EXPECT_EQ(1, exploded.day_of_month);
- EXPECT_EQ(0, exploded.hour);
- EXPECT_EQ(0, exploded.minute);
- EXPECT_EQ(0, exploded.second);
- EXPECT_EQ(1, exploded.millisecond);
-
- t = Time::UnixEpoch() + TimeDelta::FromMilliseconds(1000);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1970-01-01 00:00:01.
- EXPECT_EQ(kUnixEpochYear, exploded.year);
- EXPECT_EQ(1, exploded.month);
- EXPECT_EQ(1, exploded.day_of_month);
- EXPECT_EQ(0, exploded.hour);
- EXPECT_EQ(0, exploded.minute);
- EXPECT_EQ(1, exploded.second);
- EXPECT_EQ(0, exploded.millisecond);
-
- t = Time::UnixEpoch() + TimeDelta::FromMilliseconds(1001);
- t.UTCExplode(&exploded);
- EXPECT_TRUE(exploded.HasValidValues());
- // Should be 1970-01-01 00:00:01 1 millisecond.
- EXPECT_EQ(kUnixEpochYear, exploded.year);
- EXPECT_EQ(1, exploded.month);
- EXPECT_EQ(1, exploded.day_of_month);
- EXPECT_EQ(0, exploded.hour);
- EXPECT_EQ(0, exploded.minute);
- EXPECT_EQ(1, exploded.second);
- EXPECT_EQ(1, exploded.millisecond);
-}
-
-TEST_F(TimeTest, Max) {
- Time max = Time::Max();
- EXPECT_TRUE(max.is_max());
- EXPECT_EQ(max, Time::Max());
- EXPECT_GT(max, Time::Now());
- EXPECT_GT(max, Time());
-}
-
-TEST_F(TimeTest, MaxConversions) {
- Time t = Time::Max();
- EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.ToInternalValue());
-
- t = Time::FromDoubleT(std::numeric_limits<double>::infinity());
- EXPECT_TRUE(t.is_max());
- EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToDoubleT());
-
- t = Time::FromJsTime(std::numeric_limits<double>::infinity());
- EXPECT_TRUE(t.is_max());
- EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToJsTime());
-
- t = Time::FromTimeT(std::numeric_limits<time_t>::max());
- EXPECT_TRUE(t.is_max());
- EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
- struct timeval tval;
- tval.tv_sec = std::numeric_limits<time_t>::max();
- tval.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
- t = Time::FromTimeVal(tval);
- EXPECT_TRUE(t.is_max());
- tval = t.ToTimeVal();
- EXPECT_EQ(std::numeric_limits<time_t>::max(), tval.tv_sec);
- EXPECT_EQ(static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1,
- tval.tv_usec);
-#endif
-
-#if defined(OS_MACOSX)
- t = Time::FromCFAbsoluteTime(std::numeric_limits<CFAbsoluteTime>::infinity());
- EXPECT_TRUE(t.is_max());
- EXPECT_EQ(std::numeric_limits<CFAbsoluteTime>::infinity(),
- t.ToCFAbsoluteTime());
-#endif
-
-#if defined(OS_WIN)
- FILETIME ftime;
- ftime.dwHighDateTime = std::numeric_limits<DWORD>::max();
- ftime.dwLowDateTime = std::numeric_limits<DWORD>::max();
- t = Time::FromFileTime(ftime);
- EXPECT_TRUE(t.is_max());
- ftime = t.ToFileTime();
- EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwHighDateTime);
- EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwLowDateTime);
-#endif
-}
-
-#if defined(OS_MACOSX)
-TEST_F(TimeTest, TimeTOverflow) {
- Time t = Time::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
- EXPECT_FALSE(t.is_max());
- EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
-}
-#endif
-
-#if defined(OS_ANDROID)
-TEST_F(TimeTest, FromLocalExplodedCrashOnAndroid) {
- // This crashed inside Time:: FromLocalExploded() on Android 4.1.2.
- // See http://crbug.com/287821
- Time::Exploded midnight = {2013, // year
- 10, // month
- 0, // day_of_week
- 13, // day_of_month
- 0, // hour
- 0, // minute
- 0, // second
- };
- // The string passed to putenv() must be a char* and the documentation states
- // that it 'becomes part of the environment', so use a static buffer.
- static char buffer[] = "TZ=America/Santiago";
- putenv(buffer);
- tzset();
- Time t;
- EXPECT_TRUE(Time::FromLocalExploded(midnight, &t));
- EXPECT_EQ(1381633200, t.ToTimeT());
-}
-#endif // OS_ANDROID
-
-TEST_F(TimeTest, FromExploded_MinMax) {
- Time::Exploded exploded = {0};
- exploded.month = 1;
- exploded.day_of_month = 1;
-
- Time parsed_time;
-
- if (Time::kExplodedMinYear != std::numeric_limits<int>::min()) {
- exploded.year = Time::kExplodedMinYear;
- EXPECT_TRUE(Time::FromUTCExploded(exploded, &parsed_time));
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
- // On Windows, January 1, 1601 00:00:00 is actually the null time.
- EXPECT_FALSE(parsed_time.is_null());
-#endif
-
-#if !defined(OS_ANDROID) && !defined(OS_MACOSX)
- // The dates earlier than |kExplodedMinYear| that don't work are OS version
- // dependent on Android and Mac (for example, macOS 10.13 seems to support
- // dates before 1902).
- exploded.year--;
- EXPECT_FALSE(Time::FromUTCExploded(exploded, &parsed_time));
- EXPECT_TRUE(parsed_time.is_null());
-#endif
- }
-
- if (Time::kExplodedMaxYear != std::numeric_limits<int>::max()) {
- exploded.year = Time::kExplodedMaxYear;
- exploded.month = 12;
- exploded.day_of_month = 31;
- exploded.hour = 23;
- exploded.minute = 59;
- exploded.second = 59;
- exploded.millisecond = 999;
- EXPECT_TRUE(Time::FromUTCExploded(exploded, &parsed_time));
- EXPECT_FALSE(parsed_time.is_null());
-
- exploded.year++;
- EXPECT_FALSE(Time::FromUTCExploded(exploded, &parsed_time));
- EXPECT_TRUE(parsed_time.is_null());
- }
-}
-
-class TimeOverride {
- public:
- static Time Now() {
- now_time_ += TimeDelta::FromSeconds(1);
- return now_time_;
- }
-
- static Time now_time_;
-};
-
-// static
-Time TimeOverride::now_time_;
-
-TEST_F(TimeTest, NowOverride) {
- TimeOverride::now_time_ = Time::UnixEpoch();
-
- // Choose a reference time that we know to be in the past but close to now.
- Time build_time = GetBuildTime();
-
- // Override is not active. All Now() methods should return a time greater than
- // the build time.
- EXPECT_LT(build_time, Time::Now());
- EXPECT_GT(Time::Max(), Time::Now());
- EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
- EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
- EXPECT_LT(build_time, Time::NowFromSystemTime());
- EXPECT_GT(Time::Max(), Time::NowFromSystemTime());
- EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
- EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
-
- {
- // Set override.
- subtle::ScopedTimeClockOverrides overrides(&TimeOverride::Now, nullptr,
- nullptr);
-
- // Overridden value is returned and incremented when Now() or
- // NowFromSystemTime() is called.
- EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(1), Time::Now());
- EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(2), Time::Now());
- EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(3),
- Time::NowFromSystemTime());
- EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(4),
- Time::NowFromSystemTime());
-
- // IgnoringOverride methods still return real time.
- EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
- EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
- EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
- EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
-
- // IgnoringOverride methods didn't call NowOverrideClock::Now().
- EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(5), Time::Now());
- EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(6),
- Time::NowFromSystemTime());
- }
-
- // All methods return real time again.
- EXPECT_LT(build_time, Time::Now());
- EXPECT_GT(Time::Max(), Time::Now());
- EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
- EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
- EXPECT_LT(build_time, Time::NowFromSystemTime());
- EXPECT_GT(Time::Max(), Time::NowFromSystemTime());
- EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
- EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
-}
-
-TEST(TimeTicks, Deltas) {
- for (int index = 0; index < 50; index++) {
- TimeTicks ticks_start = TimeTicks::Now();
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
- TimeTicks ticks_stop = TimeTicks::Now();
- TimeDelta delta = ticks_stop - ticks_start;
- // Note: Although we asked for a 10ms sleep, if the
- // time clock has a finer granularity than the Sleep()
- // clock, it is quite possible to wakeup early. Here
- // is how that works:
- // Time(ms timer) Time(us timer)
- // 5 5010
- // 6 6010
- // 7 7010
- // 8 8010
- // 9 9000
- // Elapsed 4ms 3990us
- //
- // Unfortunately, our InMilliseconds() function truncates
- // rather than rounds. We should consider fixing this
- // so that our averages come out better.
- EXPECT_GE(delta.InMilliseconds(), 9);
- EXPECT_GE(delta.InMicroseconds(), 9000);
- EXPECT_EQ(delta.InSeconds(), 0);
- }
-}
-
-static void HighResClockTest(TimeTicks (*GetTicks)()) {
- // IsHighResolution() is false on some systems. Since the product still works
- // even if it's false, it makes this entire test questionable.
- if (!TimeTicks::IsHighResolution())
- return;
-
- // Why do we loop here?
- // We're trying to measure that intervals increment in a VERY small amount
- // of time -- less than 15ms. Unfortunately, if we happen to have a
- // context switch in the middle of our test, the context switch could easily
- // exceed our limit. So, we iterate on this several times. As long as we're
- // able to detect the fine-granularity timers at least once, then the test
- // has succeeded.
-
- const int kTargetGranularityUs = 15000; // 15ms
-
- bool success = false;
- int retries = 100; // Arbitrary.
- TimeDelta delta;
- while (!success && retries--) {
- TimeTicks ticks_start = GetTicks();
- // Loop until we can detect that the clock has changed. Non-HighRes timers
- // will increment in chunks, e.g. 15ms. By spinning until we see a clock
- // change, we detect the minimum time between measurements.
- do {
- delta = GetTicks() - ticks_start;
- } while (delta.InMilliseconds() == 0);
-
- if (delta.InMicroseconds() <= kTargetGranularityUs)
- success = true;
- }
-
- // In high resolution mode, we expect to see the clock increment
- // in intervals less than 15ms.
- EXPECT_TRUE(success);
-}
-
-TEST(TimeTicks, HighRes) {
- HighResClockTest(&TimeTicks::Now);
-}
-
-class TimeTicksOverride {
- public:
- static TimeTicks Now() {
- now_ticks_ += TimeDelta::FromSeconds(1);
- return now_ticks_;
- }
-
- static TimeTicks now_ticks_;
-};
-
-// static
-TimeTicks TimeTicksOverride::now_ticks_;
-
-TEST(TimeTicks, NowOverride) {
- TimeTicksOverride::now_ticks_ = TimeTicks::Min();
-
- // Override is not active. All Now() methods should return a sensible value.
- EXPECT_LT(TimeTicks::Min(), TimeTicks::UnixEpoch());
- EXPECT_LT(TimeTicks::UnixEpoch(), TimeTicks::Now());
- EXPECT_GT(TimeTicks::Max(), TimeTicks::Now());
- EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
- EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
-
- {
- // Set override.
- subtle::ScopedTimeClockOverrides overrides(nullptr, &TimeTicksOverride::Now,
- nullptr);
-
- // Overridden value is returned and incremented when Now() is called.
- EXPECT_EQ(TimeTicks::Min() + TimeDelta::FromSeconds(1), TimeTicks::Now());
- EXPECT_EQ(TimeTicks::Min() + TimeDelta::FromSeconds(2), TimeTicks::Now());
-
- // NowIgnoringOverride() still returns real ticks.
- EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
- EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
-
- // IgnoringOverride methods didn't call NowOverrideTickClock::NowTicks().
- EXPECT_EQ(TimeTicks::Min() + TimeDelta::FromSeconds(3), TimeTicks::Now());
- }
-
- // All methods return real ticks again.
- EXPECT_LT(TimeTicks::UnixEpoch(), TimeTicks::Now());
- EXPECT_GT(TimeTicks::Max(), TimeTicks::Now());
- EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
- EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
-}
-
-class ThreadTicksOverride {
- public:
- static ThreadTicks Now() {
- now_ticks_ += TimeDelta::FromSeconds(1);
- return now_ticks_;
- }
-
- static ThreadTicks now_ticks_;
-};
-
-// static
-ThreadTicks ThreadTicksOverride::now_ticks_;
-
-// IOS doesn't support ThreadTicks::Now().
-#if defined(OS_IOS)
-#define MAYBE_NowOverride DISABLED_NowOverride
-#else
-#define MAYBE_NowOverride NowOverride
-#endif
-TEST(ThreadTicks, MAYBE_NowOverride) {
- ThreadTicksOverride::now_ticks_ = ThreadTicks::Min();
-
- // Override is not active. All Now() methods should return a sensible value.
- ThreadTicks initial_thread_ticks = ThreadTicks::Now();
- EXPECT_LE(initial_thread_ticks, ThreadTicks::Now());
- EXPECT_GT(ThreadTicks::Max(), ThreadTicks::Now());
- EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
- EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
-
- {
- // Set override.
- subtle::ScopedTimeClockOverrides overrides(nullptr, nullptr,
- &ThreadTicksOverride::Now);
-
- // Overridden value is returned and incremented when Now() is called.
- EXPECT_EQ(ThreadTicks::Min() + TimeDelta::FromSeconds(1),
- ThreadTicks::Now());
- EXPECT_EQ(ThreadTicks::Min() + TimeDelta::FromSeconds(2),
- ThreadTicks::Now());
-
- // NowIgnoringOverride() still returns real ticks.
- EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
- EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
-
- // IgnoringOverride methods didn't call NowOverrideTickClock::NowTicks().
- EXPECT_EQ(ThreadTicks::Min() + TimeDelta::FromSeconds(3),
- ThreadTicks::Now());
- }
-
- // All methods return real ticks again.
- EXPECT_LE(initial_thread_ticks, ThreadTicks::Now());
- EXPECT_GT(ThreadTicks::Max(), ThreadTicks::Now());
- EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
- EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
-}
-
-// Fails frequently on Android http://crbug.com/352633 with:
-// Expected: (delta_thread.InMicroseconds()) > (0), actual: 0 vs 0
-#if defined(OS_ANDROID)
-#define MAYBE_ThreadNow DISABLED_ThreadNow
-#else
-#define MAYBE_ThreadNow ThreadNow
-#endif
-TEST(ThreadTicks, MAYBE_ThreadNow) {
- if (ThreadTicks::IsSupported()) {
- ThreadTicks::WaitUntilInitialized();
- TimeTicks begin = TimeTicks::Now();
- ThreadTicks begin_thread = ThreadTicks::Now();
- // Make sure that ThreadNow value is non-zero.
- EXPECT_GT(begin_thread, ThreadTicks());
- // Sleep for 10 milliseconds to get the thread de-scheduled.
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
- ThreadTicks end_thread = ThreadTicks::Now();
- TimeTicks end = TimeTicks::Now();
- TimeDelta delta = end - begin;
- TimeDelta delta_thread = end_thread - begin_thread;
- // Make sure that some thread time have elapsed.
- EXPECT_GT(delta_thread.InMicroseconds(), 0);
- // But the thread time is at least 9ms less than clock time.
- TimeDelta difference = delta - delta_thread;
- EXPECT_GE(difference.InMicroseconds(), 9000);
- }
-}
-
-TEST(TimeTicks, SnappedToNextTickBasic) {
- base::TimeTicks phase = base::TimeTicks::FromInternalValue(4000);
- base::TimeDelta interval = base::TimeDelta::FromMicroseconds(1000);
- base::TimeTicks timestamp;
-
- // Timestamp in previous interval.
- timestamp = base::TimeTicks::FromInternalValue(3500);
- EXPECT_EQ(4000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-
- // Timestamp in next interval.
- timestamp = base::TimeTicks::FromInternalValue(4500);
- EXPECT_EQ(5000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-
- // Timestamp multiple intervals before.
- timestamp = base::TimeTicks::FromInternalValue(2500);
- EXPECT_EQ(3000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-
- // Timestamp multiple intervals after.
- timestamp = base::TimeTicks::FromInternalValue(6500);
- EXPECT_EQ(7000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-
- // Timestamp on previous interval.
- timestamp = base::TimeTicks::FromInternalValue(3000);
- EXPECT_EQ(3000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-
- // Timestamp on next interval.
- timestamp = base::TimeTicks::FromInternalValue(5000);
- EXPECT_EQ(5000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-
- // Timestamp equal to phase.
- timestamp = base::TimeTicks::FromInternalValue(4000);
- EXPECT_EQ(4000,
- timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
-}
-
-TEST(TimeTicks, SnappedToNextTickOverflow) {
- // int(big_timestamp / interval) < 0, so this causes a crash if the number of
- // intervals elapsed is attempted to be stored in an int.
- base::TimeTicks phase = base::TimeTicks::FromInternalValue(0);
- base::TimeDelta interval = base::TimeDelta::FromMicroseconds(4000);
- base::TimeTicks big_timestamp =
- base::TimeTicks::FromInternalValue(8635916564000);
-
- EXPECT_EQ(8635916564000,
- big_timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
- EXPECT_EQ(8635916564000,
- big_timestamp.SnappedToNextTick(big_timestamp, interval)
- .ToInternalValue());
-}
-
-#if defined(OS_ANDROID)
-TEST(TimeTicks, Android_FromUptimeMillis_ClocksMatch) {
- JNIEnv* const env = android::AttachCurrentThread();
- android::ScopedJavaLocalRef<jclass> clazz(
- android::GetClass(env, "android/os/SystemClock"));
- ASSERT_TRUE(clazz.obj());
- const jmethodID method_id =
- android::MethodID::Get<android::MethodID::TYPE_STATIC>(
- env, clazz.obj(), "uptimeMillis", "()J");
- ASSERT_FALSE(!method_id);
- // Subtract 1ms from the expected lower bound to allow millisecon-level
- // truncation performed in uptimeMillis().
- const TimeTicks lower_bound_ticks =
- TimeTicks::Now() - TimeDelta::FromMilliseconds(1);
- const TimeTicks converted_ticks = TimeTicks::FromUptimeMillis(
- env->CallStaticLongMethod(clazz.obj(), method_id));
- const TimeTicks upper_bound_ticks = TimeTicks::Now();
- EXPECT_LE(lower_bound_ticks, converted_ticks);
- EXPECT_GE(upper_bound_ticks, converted_ticks);
-}
-#endif // OS_ANDROID
-
-TEST(TimeDelta, FromAndIn) {
- // static_assert also checks that the contained expression is a constant
- // expression, meaning all its components are suitable for initializing global
- // variables.
- static_assert(TimeDelta::FromDays(2) == TimeDelta::FromHours(48), "");
- static_assert(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180), "");
- static_assert(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120), "");
- static_assert(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000),
- "");
- static_assert(
- TimeDelta::FromMilliseconds(2) == TimeDelta::FromMicroseconds(2000), "");
- static_assert(
- TimeDelta::FromSecondsD(2.3) == TimeDelta::FromMilliseconds(2300), "");
- static_assert(
- TimeDelta::FromMillisecondsD(2.5) == TimeDelta::FromMicroseconds(2500),
- "");
- EXPECT_EQ(TimeDelta::FromDays(13).InDays(), 13);
- EXPECT_EQ(TimeDelta::FromHours(13).InHours(), 13);
- EXPECT_EQ(TimeDelta::FromMinutes(13).InMinutes(), 13);
- EXPECT_EQ(TimeDelta::FromSeconds(13).InSeconds(), 13);
- EXPECT_EQ(TimeDelta::FromSeconds(13).InSecondsF(), 13.0);
- EXPECT_EQ(TimeDelta::FromMilliseconds(13).InMilliseconds(), 13);
- EXPECT_EQ(TimeDelta::FromMilliseconds(13).InMillisecondsF(), 13.0);
- EXPECT_EQ(TimeDelta::FromSecondsD(13.1).InSeconds(), 13);
- EXPECT_EQ(TimeDelta::FromSecondsD(13.1).InSecondsF(), 13.1);
- EXPECT_EQ(TimeDelta::FromMillisecondsD(13.3).InMilliseconds(), 13);
- EXPECT_EQ(TimeDelta::FromMillisecondsD(13.3).InMillisecondsF(), 13.3);
- EXPECT_EQ(TimeDelta::FromMicroseconds(13).InMicroseconds(), 13);
- EXPECT_EQ(TimeDelta::FromMicrosecondsD(13.3).InMicroseconds(), 13);
- EXPECT_EQ(TimeDelta::FromMillisecondsD(3.45678).InMillisecondsF(), 3.456);
- EXPECT_EQ(TimeDelta::FromNanoseconds(12345).InNanoseconds(), 12000);
- EXPECT_EQ(TimeDelta::FromNanosecondsD(12345.678).InNanoseconds(), 12000);
-}
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-TEST(TimeDelta, TimeSpecConversion) {
- TimeDelta delta = TimeDelta::FromSeconds(0);
- struct timespec result = delta.ToTimeSpec();
- EXPECT_EQ(result.tv_sec, 0);
- EXPECT_EQ(result.tv_nsec, 0);
- EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
-
- delta = TimeDelta::FromSeconds(1);
- result = delta.ToTimeSpec();
- EXPECT_EQ(result.tv_sec, 1);
- EXPECT_EQ(result.tv_nsec, 0);
- EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
-
- delta = TimeDelta::FromMicroseconds(1);
- result = delta.ToTimeSpec();
- EXPECT_EQ(result.tv_sec, 0);
- EXPECT_EQ(result.tv_nsec, 1000);
- EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
-
- delta = TimeDelta::FromMicroseconds(Time::kMicrosecondsPerSecond + 1);
- result = delta.ToTimeSpec();
- EXPECT_EQ(result.tv_sec, 1);
- EXPECT_EQ(result.tv_nsec, 1000);
- EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
-}
-#endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-// Our internal time format is serialized in things like databases, so it's
-// important that it's consistent across all our platforms. We use the 1601
-// Windows epoch as the internal format across all platforms.
-TEST(TimeDelta, WindowsEpoch) {
- Time::Exploded exploded;
- exploded.year = 1970;
- exploded.month = 1;
- exploded.day_of_week = 0; // Should be unusued.
- exploded.day_of_month = 1;
- exploded.hour = 0;
- exploded.minute = 0;
- exploded.second = 0;
- exploded.millisecond = 0;
- Time t;
- EXPECT_TRUE(Time::FromUTCExploded(exploded, &t));
- // Unix 1970 epoch.
- EXPECT_EQ(INT64_C(11644473600000000), t.ToInternalValue());
-
- // We can't test 1601 epoch, since the system time functions on Linux
- // only compute years starting from 1900.
-}
-
-// We could define this separately for Time, TimeTicks and TimeDelta but the
-// definitions would be identical anyway.
-template <class Any>
-std::string AnyToString(Any any) {
- std::ostringstream oss;
- oss << any;
- return oss.str();
-}
-
-TEST(TimeDelta, Magnitude) {
- constexpr int64_t zero = 0;
- static_assert(TimeDelta::FromMicroseconds(zero) ==
- TimeDelta::FromMicroseconds(zero).magnitude(),
- "");
-
- constexpr int64_t one = 1;
- constexpr int64_t negative_one = -1;
- static_assert(TimeDelta::FromMicroseconds(one) ==
- TimeDelta::FromMicroseconds(one).magnitude(),
- "");
- static_assert(TimeDelta::FromMicroseconds(one) ==
- TimeDelta::FromMicroseconds(negative_one).magnitude(),
- "");
-
- constexpr int64_t max_int64_minus_one =
- std::numeric_limits<int64_t>::max() - 1;
- constexpr int64_t min_int64_plus_two =
- std::numeric_limits<int64_t>::min() + 2;
- static_assert(
- TimeDelta::FromMicroseconds(max_int64_minus_one) ==
- TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude(),
- "");
- static_assert(TimeDelta::FromMicroseconds(max_int64_minus_one) ==
- TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude(),
- "");
-}
-
-TEST(TimeDelta, ZeroMinMax) {
- constexpr TimeDelta kZero;
- static_assert(kZero.is_zero(), "");
-
- constexpr TimeDelta kMax = TimeDelta::Max();
- static_assert(kMax.is_max(), "");
- static_assert(kMax == TimeDelta::Max(), "");
- static_assert(kMax > TimeDelta::FromDays(100 * 365), "");
- static_assert(kMax > kZero, "");
-
- constexpr TimeDelta kMin = TimeDelta::Min();
- static_assert(kMin.is_min(), "");
- static_assert(kMin == TimeDelta::Min(), "");
- static_assert(kMin < TimeDelta::FromDays(-100 * 365), "");
- static_assert(kMin < kZero, "");
-}
-
-TEST(TimeDelta, MaxConversions) {
- // static_assert also confirms constexpr works as intended.
- constexpr TimeDelta kMax = TimeDelta::Max();
- static_assert(kMax.ToInternalValue() == std::numeric_limits<int64_t>::max(),
- "");
- EXPECT_EQ(kMax.InDays(), std::numeric_limits<int>::max());
- EXPECT_EQ(kMax.InHours(), std::numeric_limits<int>::max());
- EXPECT_EQ(kMax.InMinutes(), std::numeric_limits<int>::max());
- EXPECT_EQ(kMax.InSecondsF(), std::numeric_limits<double>::infinity());
- EXPECT_EQ(kMax.InSeconds(), std::numeric_limits<int64_t>::max());
- EXPECT_EQ(kMax.InMillisecondsF(), std::numeric_limits<double>::infinity());
- EXPECT_EQ(kMax.InMilliseconds(), std::numeric_limits<int64_t>::max());
- EXPECT_EQ(kMax.InMillisecondsRoundedUp(), std::numeric_limits<int64_t>::max());
-
- static_assert(TimeDelta::FromDays(std::numeric_limits<int>::max()).is_max(),
- "");
-
- static_assert(TimeDelta::FromHours(std::numeric_limits<int>::max()).is_max(),
- "");
-
- static_assert(
- TimeDelta::FromMinutes(std::numeric_limits<int>::max()).is_max(), "");
-
- constexpr int64_t max_int = std::numeric_limits<int64_t>::max();
- constexpr int64_t min_int = std::numeric_limits<int64_t>::min();
-
- static_assert(
- TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1)
- .is_max(),
- "");
-
- static_assert(
- TimeDelta::FromMilliseconds(max_int / Time::kMillisecondsPerSecond + 1)
- .is_max(),
- "");
-
- static_assert(TimeDelta::FromMicroseconds(max_int).is_max(), "");
-
- static_assert(
- TimeDelta::FromSeconds(min_int / Time::kMicrosecondsPerSecond - 1)
- .is_min(),
- "");
-
- static_assert(
- TimeDelta::FromMilliseconds(min_int / Time::kMillisecondsPerSecond - 1)
- .is_min(),
- "");
-
- static_assert(TimeDelta::FromMicroseconds(min_int).is_min(), "");
-
- static_assert(
- TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min()).is_min(),
- "");
-
- // Floating point arithmetic resulting in infinity isn't constexpr in C++14.
- EXPECT_TRUE(TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity())
- .is_max());
-
- // Note that max_int/min_int will be rounded when converted to doubles - they
- // can't be exactly represented.
- constexpr double max_d = static_cast<double>(max_int);
- constexpr double min_d = static_cast<double>(min_int);
-
- static_assert(
- TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond + 1)
- .is_max(),
- "");
-
- // Floating point arithmetic resulting in infinity isn't constexpr in C++14.
- EXPECT_TRUE(
- TimeDelta::FromMillisecondsD(std::numeric_limits<double>::infinity())
- .is_max());
-
- static_assert(
- TimeDelta::FromMillisecondsD(max_d / Time::kMillisecondsPerSecond * 2)
- .is_max(),
- "");
-
- static_assert(
- TimeDelta::FromSecondsD(min_d / Time::kMicrosecondsPerSecond - 1)
- .is_min(),
- "");
-
- static_assert(
- TimeDelta::FromMillisecondsD(min_d / Time::kMillisecondsPerSecond * 2)
- .is_min(),
- "");
-}
-
-TEST(TimeDelta, NumericOperators) {
- constexpr double d = 0.5;
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (TimeDelta::FromMilliseconds(1000) * d));
- static_assert(TimeDelta::FromMilliseconds(2000) ==
- (TimeDelta::FromMilliseconds(1000) / d),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (TimeDelta::FromMilliseconds(1000) *= d));
- static_assert(TimeDelta::FromMilliseconds(2000) ==
- (TimeDelta::FromMilliseconds(1000) /= d),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (d * TimeDelta::FromMilliseconds(1000)));
-
- constexpr float f = 0.5;
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (TimeDelta::FromMilliseconds(1000) * f));
- static_assert(TimeDelta::FromMilliseconds(2000) ==
- (TimeDelta::FromMilliseconds(1000) / f),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (TimeDelta::FromMilliseconds(1000) *= f));
- static_assert(TimeDelta::FromMilliseconds(2000) ==
- (TimeDelta::FromMilliseconds(1000) /= f),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (f * TimeDelta::FromMilliseconds(1000)));
-
- constexpr int i = 2;
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (TimeDelta::FromMilliseconds(1000) * i));
- static_assert(TimeDelta::FromMilliseconds(500) ==
- (TimeDelta::FromMilliseconds(1000) / i),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (TimeDelta::FromMilliseconds(1000) *= i));
- static_assert(TimeDelta::FromMilliseconds(500) ==
- (TimeDelta::FromMilliseconds(1000) /= i),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (i * TimeDelta::FromMilliseconds(1000)));
-
- constexpr int64_t i64 = 2;
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (TimeDelta::FromMilliseconds(1000) * i64));
- static_assert(TimeDelta::FromMilliseconds(500) ==
- (TimeDelta::FromMilliseconds(1000) / i64),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (TimeDelta::FromMilliseconds(1000) *= i64));
- static_assert(TimeDelta::FromMilliseconds(500) ==
- (TimeDelta::FromMilliseconds(1000) /= i64),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (i64 * TimeDelta::FromMilliseconds(1000)));
-
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (TimeDelta::FromMilliseconds(1000) * 0.5));
- static_assert(TimeDelta::FromMilliseconds(2000) ==
- (TimeDelta::FromMilliseconds(1000) / 0.5),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (TimeDelta::FromMilliseconds(1000) *= 0.5));
- static_assert(TimeDelta::FromMilliseconds(2000) ==
- (TimeDelta::FromMilliseconds(1000) /= 0.5),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(500),
- (0.5 * TimeDelta::FromMilliseconds(1000)));
-
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (TimeDelta::FromMilliseconds(1000) * 2));
- static_assert(TimeDelta::FromMilliseconds(500) ==
- (TimeDelta::FromMilliseconds(1000) / 2),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (TimeDelta::FromMilliseconds(1000) *= 2));
- static_assert(TimeDelta::FromMilliseconds(500) ==
- (TimeDelta::FromMilliseconds(1000) /= 2),
- "");
- EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
- (2 * TimeDelta::FromMilliseconds(1000)));
-}
-
-// Basic test of operators between TimeDeltas (without overflow -- next test
-// handles overflow).
-TEST(TimeDelta, TimeDeltaOperators) {
- constexpr TimeDelta kElevenSeconds = TimeDelta::FromSeconds(11);
- constexpr TimeDelta kThreeSeconds = TimeDelta::FromSeconds(3);
-
- EXPECT_EQ(TimeDelta::FromSeconds(14), kElevenSeconds + kThreeSeconds);
- EXPECT_EQ(TimeDelta::FromSeconds(14), kThreeSeconds + kElevenSeconds);
- EXPECT_EQ(TimeDelta::FromSeconds(8), kElevenSeconds - kThreeSeconds);
- EXPECT_EQ(TimeDelta::FromSeconds(-8), kThreeSeconds - kElevenSeconds);
- static_assert(3 == kElevenSeconds / kThreeSeconds, "");
- static_assert(0 == kThreeSeconds / kElevenSeconds, "");
- static_assert(TimeDelta::FromSeconds(2) == kElevenSeconds % kThreeSeconds,
- "");
-}
-
-TEST(TimeDelta, Overflows) {
- // Some sanity checks. static_assert's used were possible to verify constexpr
- // evaluation at the same time.
- static_assert(TimeDelta::Max().is_max(), "");
- static_assert(-TimeDelta::Max() < TimeDelta(), "");
- static_assert(-TimeDelta::Max() > TimeDelta::Min(), "");
- static_assert(TimeDelta() > -TimeDelta::Max(), "");
-
- TimeDelta large_delta = TimeDelta::Max() - TimeDelta::FromMilliseconds(1);
- TimeDelta large_negative = -large_delta;
- EXPECT_GT(TimeDelta(), large_negative);
- EXPECT_FALSE(large_delta.is_max());
- EXPECT_FALSE((-large_negative).is_min());
- constexpr TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
-
- // Test +, -, * and / operators.
- EXPECT_TRUE((large_delta + kOneSecond).is_max());
- EXPECT_TRUE((large_negative + (-kOneSecond)).is_min());
- EXPECT_TRUE((large_negative - kOneSecond).is_min());
- EXPECT_TRUE((large_delta - (-kOneSecond)).is_max());
- EXPECT_TRUE((large_delta * 2).is_max());
- EXPECT_TRUE((large_delta * -2).is_min());
- EXPECT_TRUE((large_delta / 0.5).is_max());
- EXPECT_TRUE((large_delta / -0.5).is_min());
-
- // Test that double conversions overflow to infinity.
- EXPECT_EQ((large_delta + kOneSecond).InSecondsF(),
- std::numeric_limits<double>::infinity());
- EXPECT_EQ((large_delta + kOneSecond).InMillisecondsF(),
- std::numeric_limits<double>::infinity());
- EXPECT_EQ((large_delta + kOneSecond).InMicrosecondsF(),
- std::numeric_limits<double>::infinity());
-
- // Test +=, -=, *= and /= operators.
- TimeDelta delta = large_delta;
- delta += kOneSecond;
- EXPECT_TRUE(delta.is_max());
- delta = large_negative;
- delta += -kOneSecond;
- EXPECT_TRUE((delta).is_min());
-
- delta = large_negative;
- delta -= kOneSecond;
- EXPECT_TRUE((delta).is_min());
- delta = large_delta;
- delta -= -kOneSecond;
- EXPECT_TRUE(delta.is_max());
-
- delta = large_delta;
- delta *= 2;
- EXPECT_TRUE(delta.is_max());
- delta = large_negative;
- delta *= 1.5;
- EXPECT_TRUE((delta).is_min());
-
- delta = large_delta;
- delta /= 0.5;
- EXPECT_TRUE(delta.is_max());
- delta = large_negative;
- delta /= 0.5;
- EXPECT_TRUE((delta).is_min());
-
- // Test operations with Time and TimeTicks.
- EXPECT_TRUE((large_delta + Time::Now()).is_max());
- EXPECT_TRUE((large_delta + TimeTicks::Now()).is_max());
- EXPECT_TRUE((Time::Now() + large_delta).is_max());
- EXPECT_TRUE((TimeTicks::Now() + large_delta).is_max());
-
- Time time_now = Time::Now();
- EXPECT_EQ(kOneSecond, (time_now + kOneSecond) - time_now);
- EXPECT_EQ(-kOneSecond, (time_now - kOneSecond) - time_now);
-
- TimeTicks ticks_now = TimeTicks::Now();
- EXPECT_EQ(-kOneSecond, (ticks_now - kOneSecond) - ticks_now);
- EXPECT_EQ(kOneSecond, (ticks_now + kOneSecond) - ticks_now);
-}
-
-TEST(TimeDeltaLogging, DCheckEqCompiles) {
- DCHECK_EQ(TimeDelta(), TimeDelta());
-}
-
-TEST(TimeDeltaLogging, EmptyIsZero) {
- constexpr TimeDelta kZero;
- EXPECT_EQ("0 s", AnyToString(kZero));
-}
-
-TEST(TimeDeltaLogging, FiveHundredMs) {
- constexpr TimeDelta kFiveHundredMs = TimeDelta::FromMilliseconds(500);
- EXPECT_EQ("0.5 s", AnyToString(kFiveHundredMs));
-}
-
-TEST(TimeDeltaLogging, MinusTenSeconds) {
- constexpr TimeDelta kMinusTenSeconds = TimeDelta::FromSeconds(-10);
- EXPECT_EQ("-10 s", AnyToString(kMinusTenSeconds));
-}
-
-TEST(TimeDeltaLogging, DoesNotMessUpFormattingFlags) {
- std::ostringstream oss;
- std::ios_base::fmtflags flags_before = oss.flags();
- oss << TimeDelta();
- EXPECT_EQ(flags_before, oss.flags());
-}
-
-TEST(TimeDeltaLogging, DoesNotMakeStreamBad) {
- std::ostringstream oss;
- oss << TimeDelta();
- EXPECT_TRUE(oss.good());
-}
-
-TEST(TimeLogging, DCheckEqCompiles) {
- DCHECK_EQ(Time(), Time());
-}
-
-TEST(TimeLogging, ChromeBirthdate) {
- Time birthdate;
- ASSERT_TRUE(Time::FromString("Tue, 02 Sep 2008 09:42:18 GMT", &birthdate));
- EXPECT_EQ("2008-09-02 09:42:18.000 UTC", AnyToString(birthdate));
-}
-
-TEST(TimeLogging, DoesNotMessUpFormattingFlags) {
- std::ostringstream oss;
- std::ios_base::fmtflags flags_before = oss.flags();
- oss << Time();
- EXPECT_EQ(flags_before, oss.flags());
-}
-
-TEST(TimeLogging, DoesNotMakeStreamBad) {
- std::ostringstream oss;
- oss << Time();
- EXPECT_TRUE(oss.good());
-}
-
-TEST(TimeTicksLogging, DCheckEqCompiles) {
- DCHECK_EQ(TimeTicks(), TimeTicks());
-}
-
-TEST(TimeTicksLogging, ZeroTime) {
- TimeTicks zero;
- EXPECT_EQ("0 bogo-microseconds", AnyToString(zero));
-}
-
-TEST(TimeTicksLogging, FortyYearsLater) {
- TimeTicks forty_years_later =
- TimeTicks() + TimeDelta::FromDays(365.25 * 40);
- EXPECT_EQ("1262304000000000 bogo-microseconds",
- AnyToString(forty_years_later));
-}
-
-TEST(TimeTicksLogging, DoesNotMessUpFormattingFlags) {
- std::ostringstream oss;
- std::ios_base::fmtflags flags_before = oss.flags();
- oss << TimeTicks();
- EXPECT_EQ(flags_before, oss.flags());
-}
-
-TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
- std::ostringstream oss;
- oss << TimeTicks();
- EXPECT_TRUE(oss.good());
-}
-
-} // namespace
-
-} // namespace base
diff --git a/base/time/time_win_unittest.cc b/base/time/time_win_unittest.cc
deleted file mode 100644
index 24cd731..0000000
--- a/base/time/time_win_unittest.cc
+++ /dev/null
@@ -1,365 +0,0 @@
-// 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.
-
-#include <windows.h>
-#include <mmsystem.h>
-#include <process.h>
-#include <stdint.h>
-
-#include <cmath>
-#include <limits>
-#include <vector>
-
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "base/win/registry.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-// For TimeDelta::ConstexprInitialization
-constexpr int kExpectedDeltaInMilliseconds = 10;
-constexpr TimeDelta kConstexprTimeDelta =
- TimeDelta::FromMilliseconds(kExpectedDeltaInMilliseconds);
-
-class MockTimeTicks : public TimeTicks {
- public:
- static DWORD Ticker() {
- return static_cast<int>(InterlockedIncrement(&ticker_));
- }
-
- static void InstallTicker() {
- old_tick_function_ = SetMockTickFunction(&Ticker);
- ticker_ = -5;
- }
-
- static void UninstallTicker() {
- SetMockTickFunction(old_tick_function_);
- }
-
- private:
- static volatile LONG ticker_;
- static TickFunctionType old_tick_function_;
-};
-
-volatile LONG MockTimeTicks::ticker_;
-MockTimeTicks::TickFunctionType MockTimeTicks::old_tick_function_;
-
-HANDLE g_rollover_test_start;
-
-unsigned __stdcall RolloverTestThreadMain(void* param) {
- int64_t counter = reinterpret_cast<int64_t>(param);
- DWORD rv = WaitForSingleObject(g_rollover_test_start, INFINITE);
- EXPECT_EQ(rv, WAIT_OBJECT_0);
-
- TimeTicks last = TimeTicks::Now();
- for (int index = 0; index < counter; index++) {
- TimeTicks now = TimeTicks::Now();
- int64_t milliseconds = (now - last).InMilliseconds();
- // This is a tight loop; we could have looped faster than our
- // measurements, so the time might be 0 millis.
- EXPECT_GE(milliseconds, 0);
- EXPECT_LT(milliseconds, 250);
- last = now;
- }
- return 0;
-}
-
-} // namespace
-
-// This test spawns many threads, and can occasionally fail due to resource
-// exhaustion in the presence of ASan.
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_WinRollover DISABLED_WinRollover
-#else
-#define MAYBE_WinRollover WinRollover
-#endif
-TEST(TimeTicks, MAYBE_WinRollover) {
- // The internal counter rolls over at ~49days. We'll use a mock
- // timer to test this case.
- // Basic test algorithm:
- // 1) Set clock to rollover - N
- // 2) Create N threads
- // 3) Start the threads
- // 4) Each thread loops through TimeTicks() N times
- // 5) Each thread verifies integrity of result.
-
- const int kThreads = 8;
- // Use int64_t so we can cast into a void* without a compiler warning.
- const int64_t kChecks = 10;
-
- // It takes a lot of iterations to reproduce the bug!
- // (See bug 1081395)
- for (int loop = 0; loop < 4096; loop++) {
- // Setup
- MockTimeTicks::InstallTicker();
- g_rollover_test_start = CreateEvent(0, TRUE, FALSE, 0);
- HANDLE threads[kThreads];
-
- for (int index = 0; index < kThreads; index++) {
- void* argument = reinterpret_cast<void*>(kChecks);
- unsigned thread_id;
- threads[index] = reinterpret_cast<HANDLE>(
- _beginthreadex(NULL, 0, RolloverTestThreadMain, argument, 0,
- &thread_id));
- EXPECT_NE((HANDLE)NULL, threads[index]);
- }
-
- // Start!
- SetEvent(g_rollover_test_start);
-
- // Wait for threads to finish
- for (int index = 0; index < kThreads; index++) {
- DWORD rv = WaitForSingleObject(threads[index], INFINITE);
- EXPECT_EQ(rv, WAIT_OBJECT_0);
- // Since using _beginthreadex() (as opposed to _beginthread),
- // an explicit CloseHandle() is supposed to be called.
- CloseHandle(threads[index]);
- }
-
- CloseHandle(g_rollover_test_start);
-
- // Teardown
- MockTimeTicks::UninstallTicker();
- }
-}
-
-TEST(TimeTicks, SubMillisecondTimers) {
- // IsHighResolution() is false on some systems. Since the product still works
- // even if it's false, it makes this entire test questionable.
- if (!TimeTicks::IsHighResolution())
- return;
-
- const int kRetries = 1000;
- bool saw_submillisecond_timer = false;
-
- // Run kRetries attempts to see a sub-millisecond timer.
- for (int index = 0; index < kRetries; index++) {
- TimeTicks last_time = TimeTicks::Now();
- TimeDelta delta;
- // Spin until the clock has detected a change.
- do {
- delta = TimeTicks::Now() - last_time;
- } while (delta.InMicroseconds() == 0);
- if (delta.InMicroseconds() < 1000) {
- saw_submillisecond_timer = true;
- break;
- }
- }
- EXPECT_TRUE(saw_submillisecond_timer);
-}
-
-TEST(TimeTicks, TimeGetTimeCaps) {
- // Test some basic assumptions that we expect about how timeGetDevCaps works.
-
- TIMECAPS caps;
- MMRESULT status = timeGetDevCaps(&caps, sizeof(caps));
- ASSERT_EQ(static_cast<MMRESULT>(MMSYSERR_NOERROR), status);
-
- EXPECT_GE(static_cast<int>(caps.wPeriodMin), 1);
- EXPECT_GT(static_cast<int>(caps.wPeriodMax), 1);
- EXPECT_GE(static_cast<int>(caps.wPeriodMin), 1);
- EXPECT_GT(static_cast<int>(caps.wPeriodMax), 1);
- printf("timeGetTime range is %d to %dms\n", caps.wPeriodMin,
- caps.wPeriodMax);
-}
-
-TEST(TimeTicks, QueryPerformanceFrequency) {
- // Test some basic assumptions that we expect about QPC.
-
- LARGE_INTEGER frequency;
- BOOL rv = QueryPerformanceFrequency(&frequency);
- EXPECT_EQ(TRUE, rv);
- EXPECT_GT(frequency.QuadPart, 1000000); // Expect at least 1MHz
- printf("QueryPerformanceFrequency is %5.2fMHz\n",
- frequency.QuadPart / 1000000.0);
-}
-
-TEST(TimeTicks, TimerPerformance) {
- // Verify that various timer mechanisms can always complete quickly.
- // Note: This is a somewhat arbitrary test.
- const int kLoops = 10000;
-
- typedef TimeTicks (*TestFunc)();
- struct TestCase {
- TestFunc func;
- const char *description;
- };
- // Cheating a bit here: assumes sizeof(TimeTicks) == sizeof(Time)
- // in order to create a single test case list.
- static_assert(sizeof(TimeTicks) == sizeof(Time),
- "TimeTicks and Time must be the same size");
- std::vector<TestCase> cases;
- cases.push_back({reinterpret_cast<TestFunc>(&Time::Now), "Time::Now"});
- cases.push_back({&TimeTicks::Now, "TimeTicks::Now"});
-
- if (ThreadTicks::IsSupported()) {
- ThreadTicks::WaitUntilInitialized();
- cases.push_back(
- {reinterpret_cast<TestFunc>(&ThreadTicks::Now), "ThreadTicks::Now"});
- }
-
- for (const auto& test_case : cases) {
- TimeTicks start = TimeTicks::Now();
- for (int index = 0; index < kLoops; index++)
- test_case.func();
- TimeTicks stop = TimeTicks::Now();
- // Turning off the check for acceptible delays. Without this check,
- // the test really doesn't do much other than measure. But the
- // measurements are still useful for testing timers on various platforms.
- // The reason to remove the check is because the tests run on many
- // buildbots, some of which are VMs. These machines can run horribly
- // slow, and there is really no value for checking against a max timer.
- //const int kMaxTime = 35; // Maximum acceptible milliseconds for test.
- //EXPECT_LT((stop - start).InMilliseconds(), kMaxTime);
- printf("%s: %1.2fus per call\n", test_case.description,
- (stop - start).InMillisecondsF() * 1000 / kLoops);
- }
-}
-
-TEST(TimeTicks, TSCTicksPerSecond) {
- if (ThreadTicks::IsSupported()) {
- ThreadTicks::WaitUntilInitialized();
-
- // Read the CPU frequency from the registry.
- base::win::RegKey processor_key(
- HKEY_LOCAL_MACHINE,
- L"Hardware\\Description\\System\\CentralProcessor\\0", KEY_QUERY_VALUE);
- ASSERT_TRUE(processor_key.Valid());
- DWORD processor_mhz_from_registry;
- ASSERT_EQ(ERROR_SUCCESS,
- processor_key.ReadValueDW(L"~MHz", &processor_mhz_from_registry));
-
- // Expect the measured TSC frequency to be similar to the processor
- // frequency from the registry (0.5% error).
- double tsc_mhz_measured = ThreadTicks::TSCTicksPerSecond() / 1e6;
- EXPECT_NEAR(tsc_mhz_measured, processor_mhz_from_registry,
- 0.005 * processor_mhz_from_registry);
- }
-}
-
-TEST(TimeTicks, FromQPCValue) {
- if (!TimeTicks::IsHighResolution())
- return;
-
- LARGE_INTEGER frequency;
- ASSERT_TRUE(QueryPerformanceFrequency(&frequency));
- const int64_t ticks_per_second = frequency.QuadPart;
- ASSERT_GT(ticks_per_second, 0);
-
- // Generate the tick values to convert, advancing the tick count by varying
- // amounts. These values will ensure that both the fast and overflow-safe
- // conversion logic in FromQPCValue() is tested, and across the entire range
- // of possible QPC tick values.
- std::vector<int64_t> test_cases;
- test_cases.push_back(0);
- const int kNumAdvancements = 100;
- int64_t ticks = 0;
- int64_t ticks_increment = 10;
- for (int i = 0; i < kNumAdvancements; ++i) {
- test_cases.push_back(ticks);
- ticks += ticks_increment;
- ticks_increment = ticks_increment * 6 / 5;
- }
- test_cases.push_back(Time::kQPCOverflowThreshold - 1);
- test_cases.push_back(Time::kQPCOverflowThreshold);
- test_cases.push_back(Time::kQPCOverflowThreshold + 1);
- ticks = Time::kQPCOverflowThreshold + 10;
- ticks_increment = 10;
- for (int i = 0; i < kNumAdvancements; ++i) {
- test_cases.push_back(ticks);
- ticks += ticks_increment;
- ticks_increment = ticks_increment * 6 / 5;
- }
- test_cases.push_back(std::numeric_limits<int64_t>::max());
-
- // Test that the conversions using FromQPCValue() match those computed here
- // using simple floating-point arithmetic. The floating-point math provides
- // enough precision for all reasonable values to confirm that the
- // implementation is correct to the microsecond, and for "very large" values
- // it confirms that the answer is very close to correct.
- for (int64_t ticks : test_cases) {
- const double expected_microseconds_since_origin =
- (static_cast<double>(ticks) * Time::kMicrosecondsPerSecond) /
- ticks_per_second;
- const TimeTicks converted_value = TimeTicks::FromQPCValue(ticks);
- const double converted_microseconds_since_origin =
- static_cast<double>((converted_value - TimeTicks()).InMicroseconds());
- // When we test with very large numbers we end up in a range where adjacent
- // double values are far apart - 512.0 apart in one test failure. In that
- // situation it makes no sense for our epsilon to be 1.0 - it should be
- // the difference between adjacent doubles.
- double epsilon = nextafter(expected_microseconds_since_origin, INFINITY) -
- expected_microseconds_since_origin;
- // Epsilon must be at least 1.0 because converted_microseconds_since_origin
- // comes from an integral value and the rounding is not perfect.
- if (epsilon < 1.0)
- epsilon = 1.0;
- EXPECT_NEAR(expected_microseconds_since_origin,
- converted_microseconds_since_origin, epsilon)
- << "ticks=" << ticks << ", to be converted via logic path: "
- << (ticks < Time::kQPCOverflowThreshold ? "FAST" : "SAFE");
- }
-}
-
-TEST(TimeDelta, ConstexprInitialization) {
- // Make sure that TimeDelta works around crbug.com/635974
- EXPECT_EQ(kExpectedDeltaInMilliseconds, kConstexprTimeDelta.InMilliseconds());
-}
-
-TEST(TimeDelta, FromFileTime) {
- FILETIME ft;
- ft.dwLowDateTime = 1001;
- ft.dwHighDateTime = 0;
-
- // 100100 ns ~= 100 us.
- EXPECT_EQ(TimeDelta::FromMicroseconds(100), TimeDelta::FromFileTime(ft));
-
- ft.dwLowDateTime = 0;
- ft.dwHighDateTime = 1;
-
- // 2^32 * 100 ns ~= 2^32 * 10 us.
- EXPECT_EQ(TimeDelta::FromMicroseconds((1ull << 32) / 10),
- TimeDelta::FromFileTime(ft));
-}
-
-TEST(HighResolutionTimer, GetUsage) {
- EXPECT_EQ(0.0, Time::GetHighResolutionTimerUsage());
-
- Time::ResetHighResolutionTimerUsage();
-
- // 0% usage since the timer isn't activated regardless of how much time has
- // elapsed.
- EXPECT_EQ(0.0, Time::GetHighResolutionTimerUsage());
- Sleep(10);
- EXPECT_EQ(0.0, Time::GetHighResolutionTimerUsage());
-
- Time::ActivateHighResolutionTimer(true);
- Time::ResetHighResolutionTimerUsage();
-
- Sleep(20);
- // 100% usage since the timer has been activated entire time.
- EXPECT_EQ(100.0, Time::GetHighResolutionTimerUsage());
-
- Time::ActivateHighResolutionTimer(false);
- Sleep(20);
- double usage1 = Time::GetHighResolutionTimerUsage();
- // usage1 should be about 50%.
- EXPECT_LT(usage1, 100.0);
- EXPECT_GT(usage1, 0.0);
-
- Time::ActivateHighResolutionTimer(true);
- Sleep(10);
- Time::ActivateHighResolutionTimer(false);
- double usage2 = Time::GetHighResolutionTimerUsage();
- // usage2 should be about 60%.
- EXPECT_LT(usage2, 100.0);
- EXPECT_GT(usage2, usage1);
-
- Time::ResetHighResolutionTimerUsage();
- EXPECT_EQ(0.0, Time::GetHighResolutionTimerUsage());
-}
-
-} // namespace base
diff --git a/base/timer/hi_res_timer_manager_unittest.cc b/base/timer/hi_res_timer_manager_unittest.cc
deleted file mode 100644
index 3860c09..0000000
--- a/base/timer/hi_res_timer_manager_unittest.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-// 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.
-
-#include "base/timer/hi_res_timer_manager.h"
-
-#include <memory>
-#include <utility>
-
-#include "base/power_monitor/power_monitor.h"
-#include "base/power_monitor/power_monitor_device_source.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-#if defined(OS_WIN)
-TEST(HiResTimerManagerTest, ToggleOnOff) {
- // The power monitor creates Window to receive power notifications from
- // Windows, which makes this test flaky if you run while the machine
- // goes in or out of AC power.
- test::ScopedTaskEnvironment scoped_task_environment(
- test::ScopedTaskEnvironment::MainThreadType::UI);
- std::unique_ptr<base::PowerMonitorSource> power_monitor_source(
- new base::PowerMonitorDeviceSource());
- std::unique_ptr<base::PowerMonitor> power_monitor(
- new base::PowerMonitor(std::move(power_monitor_source)));
-
- HighResolutionTimerManager manager;
- // Simulate a on-AC power event to get to a known initial state.
- manager.OnPowerStateChange(false);
-
- // Loop a few times to test power toggling.
- for (int times = 0; times != 3; ++times) {
- // The manager has the high resolution clock enabled now.
- EXPECT_TRUE(manager.hi_res_clock_available());
- // But the Time class has it off, because it hasn't been activated.
- EXPECT_FALSE(base::Time::IsHighResolutionTimerInUse());
-
- // Activate the high resolution timer.
- base::Time::ActivateHighResolutionTimer(true);
- EXPECT_TRUE(base::Time::IsHighResolutionTimerInUse());
-
- // Simulate a on-battery power event.
- manager.OnPowerStateChange(true);
- EXPECT_FALSE(manager.hi_res_clock_available());
- EXPECT_FALSE(base::Time::IsHighResolutionTimerInUse());
-
- // Back to on-AC power.
- manager.OnPowerStateChange(false);
- EXPECT_TRUE(manager.hi_res_clock_available());
- EXPECT_TRUE(base::Time::IsHighResolutionTimerInUse());
-
- // De-activate the high resolution timer.
- base::Time::ActivateHighResolutionTimer(false);
- }
-}
-#endif // defined(OS_WIN)
-
-} // namespace base
diff --git a/base/timer/mock_timer_unittest.cc b/base/timer/mock_timer_unittest.cc
deleted file mode 100644
index 61716a4..0000000
--- a/base/timer/mock_timer_unittest.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2014 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 "base/timer/mock_timer.h"
-
-#include "base/macros.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-void CallMeMaybe(int *number) {
- (*number)++;
-}
-
-TEST(MockTimerTest, FiresOnce) {
- int calls = 0;
- base::MockTimer timer(false, false);
- base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
- timer.Start(FROM_HERE, delay,
- base::Bind(&CallMeMaybe,
- base::Unretained(&calls)));
- EXPECT_EQ(delay, timer.GetCurrentDelay());
- EXPECT_TRUE(timer.IsRunning());
- timer.Fire();
- EXPECT_FALSE(timer.IsRunning());
- EXPECT_EQ(1, calls);
-}
-
-TEST(MockTimerTest, FiresRepeatedly) {
- int calls = 0;
- base::MockTimer timer(true, true);
- base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
- timer.Start(FROM_HERE, delay,
- base::Bind(&CallMeMaybe,
- base::Unretained(&calls)));
- timer.Fire();
- EXPECT_TRUE(timer.IsRunning());
- timer.Fire();
- timer.Fire();
- EXPECT_TRUE(timer.IsRunning());
- EXPECT_EQ(3, calls);
-}
-
-TEST(MockTimerTest, Stops) {
- int calls = 0;
- base::MockTimer timer(true, true);
- base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
- timer.Start(FROM_HERE, delay,
- base::Bind(&CallMeMaybe,
- base::Unretained(&calls)));
- EXPECT_TRUE(timer.IsRunning());
- timer.Stop();
- EXPECT_FALSE(timer.IsRunning());
-}
-
-class HasWeakPtr : public base::SupportsWeakPtr<HasWeakPtr> {
- public:
- HasWeakPtr() = default;
- virtual ~HasWeakPtr() = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(HasWeakPtr);
-};
-
-TEST(MockTimerTest, DoesNotRetainClosure) {
- HasWeakPtr *has_weak_ptr = new HasWeakPtr();
- base::WeakPtr<HasWeakPtr> weak_ptr(has_weak_ptr->AsWeakPtr());
- base::MockTimer timer(false, false);
- base::TimeDelta delay = base::TimeDelta::FromSeconds(2);
- ASSERT_TRUE(weak_ptr.get());
- timer.Start(FROM_HERE, delay,
- base::Bind(base::DoNothing::Repeatedly<HasWeakPtr*>(),
- base::Owned(has_weak_ptr)));
- ASSERT_TRUE(weak_ptr.get());
- timer.Fire();
- ASSERT_FALSE(weak_ptr.get());
-}
-
-} // namespace
diff --git a/base/timer/timer_unittest.cc b/base/timer/timer_unittest.cc
deleted file mode 100644
index ae587bf..0000000
--- a/base/timer/timer_unittest.cc
+++ /dev/null
@@ -1,904 +0,0 @@
-// 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.
-
-#include "base/timer/timer.h"
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/sequenced_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread.h"
-#include "base/time/tick_clock.h"
-#include "base/time/time.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-// The message loops on which each timer should be tested.
-const MessageLoop::Type testing_message_loops[] = {
- MessageLoop::TYPE_DEFAULT, MessageLoop::TYPE_IO,
-#if !defined(OS_IOS) // iOS does not allow direct running of the UI loop.
- MessageLoop::TYPE_UI,
-#endif
-};
-
-const int kNumTestingMessageLoops = arraysize(testing_message_loops);
-
-class Receiver {
- public:
- Receiver() : count_(0) {}
- void OnCalled() { count_++; }
- bool WasCalled() { return count_ > 0; }
- int TimesCalled() { return count_; }
-
- private:
- int count_;
-};
-
-// A basic helper class that can start a one-shot timer and signal a
-// WaitableEvent when this timer fires.
-class OneShotTimerTesterBase {
- public:
- // |did_run|, if provided, will be signaled when Run() fires.
- explicit OneShotTimerTesterBase(
- WaitableEvent* did_run = nullptr,
- const TimeDelta& delay = TimeDelta::FromMilliseconds(10))
- : did_run_(did_run), delay_(delay) {}
-
- virtual ~OneShotTimerTesterBase() = default;
-
- void Start() {
- started_time_ = TimeTicks::Now();
- timer_->Start(FROM_HERE, delay_, this, &OneShotTimerTesterBase::Run);
- }
-
- bool IsRunning() { return timer_->IsRunning(); }
-
- TimeTicks started_time() const { return started_time_; }
- TimeDelta delay() const { return delay_; }
-
- protected:
- virtual void Run() {
- if (did_run_) {
- EXPECT_FALSE(did_run_->IsSignaled());
- did_run_->Signal();
- }
- }
-
- std::unique_ptr<OneShotTimer> timer_ = std::make_unique<OneShotTimer>();
-
- private:
- WaitableEvent* const did_run_;
- const TimeDelta delay_;
- TimeTicks started_time_;
-
- DISALLOW_COPY_AND_ASSIGN(OneShotTimerTesterBase);
-};
-
-// Extends functionality of OneShotTimerTesterBase with the abilities to wait
-// until the timer fires and to change task runner for the timer.
-class OneShotTimerTester : public OneShotTimerTesterBase {
- public:
- // |did_run|, if provided, will be signaled when Run() fires.
- explicit OneShotTimerTester(
- WaitableEvent* did_run = nullptr,
- const TimeDelta& delay = TimeDelta::FromMilliseconds(10))
- : OneShotTimerTesterBase(did_run, delay),
- quit_closure_(run_loop_.QuitClosure()) {}
-
- ~OneShotTimerTester() override = default;
-
- void SetTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner) {
- timer_->SetTaskRunner(std::move(task_runner));
-
- // Run() will be invoked on |task_runner| but |run_loop_|'s QuitClosure
- // needs to run on this thread (where the MessageLoop lives).
- quit_closure_ = Bind(IgnoreResult(&SequencedTaskRunner::PostTask),
- SequencedTaskRunnerHandle::Get(), FROM_HERE,
- run_loop_.QuitClosure());
- }
-
- // Blocks until Run() executes and confirms that Run() didn't fire before
- // |delay_| expired.
- void WaitAndConfirmTimerFiredAfterDelay() {
- run_loop_.Run();
-
- EXPECT_NE(TimeTicks(), started_time());
- EXPECT_GE(TimeTicks::Now() - started_time(), delay());
- }
-
- protected:
- // Overridable method to do things on Run() before signaling events/closures
- // managed by this helper.
- virtual void OnRun() {}
-
- private:
- void Run() override {
- OnRun();
- OneShotTimerTesterBase::Run();
- quit_closure_.Run();
- }
-
- RunLoop run_loop_;
- Closure quit_closure_;
-
- DISALLOW_COPY_AND_ASSIGN(OneShotTimerTester);
-};
-
-class OneShotSelfDeletingTimerTester : public OneShotTimerTester {
- protected:
- void OnRun() override { timer_.reset(); }
-};
-
-constexpr int kNumRepeats = 10;
-
-class RepeatingTimerTester {
- public:
- explicit RepeatingTimerTester(WaitableEvent* did_run, const TimeDelta& delay)
- : counter_(kNumRepeats),
- quit_closure_(run_loop_.QuitClosure()),
- did_run_(did_run),
- delay_(delay) {}
-
- void Start() {
- started_time_ = TimeTicks::Now();
- timer_.Start(FROM_HERE, delay_, this, &RepeatingTimerTester::Run);
- }
-
- void WaitAndConfirmTimerFiredRepeatedlyAfterDelay() {
- run_loop_.Run();
-
- EXPECT_NE(TimeTicks(), started_time_);
- EXPECT_GE(TimeTicks::Now() - started_time_, kNumRepeats * delay_);
- }
-
- private:
- void Run() {
- if (--counter_ == 0) {
- if (did_run_) {
- EXPECT_FALSE(did_run_->IsSignaled());
- did_run_->Signal();
- }
- timer_.Stop();
- quit_closure_.Run();
- }
- }
-
- RepeatingTimer timer_;
- int counter_;
-
- RunLoop run_loop_;
- Closure quit_closure_;
- WaitableEvent* const did_run_;
-
- const TimeDelta delay_;
- TimeTicks started_time_;
-
- DISALLOW_COPY_AND_ASSIGN(RepeatingTimerTester);
-};
-
-// Basic test with same setup as RunTest_OneShotTimers_Cancel below to confirm
-// that |did_run_a| would be signaled in that test if it wasn't for the
-// deletion.
-void RunTest_OneShotTimers(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- WaitableEvent did_run_a(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- OneShotTimerTester a(&did_run_a);
- a.Start();
-
- OneShotTimerTester b;
- b.Start();
-
- b.WaitAndConfirmTimerFiredAfterDelay();
-
- EXPECT_TRUE(did_run_a.IsSignaled());
-}
-
-void RunTest_OneShotTimers_Cancel(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- WaitableEvent did_run_a(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- OneShotTimerTester* a = new OneShotTimerTester(&did_run_a);
-
- // This should run before the timer expires.
- SequencedTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
-
- // Now start the timer.
- a->Start();
-
- OneShotTimerTester b;
- b.Start();
-
- b.WaitAndConfirmTimerFiredAfterDelay();
-
- EXPECT_FALSE(did_run_a.IsSignaled());
-}
-
-void RunTest_OneShotSelfDeletingTimer(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- OneShotSelfDeletingTimerTester f;
- f.Start();
- f.WaitAndConfirmTimerFiredAfterDelay();
-}
-
-void RunTest_RepeatingTimer(MessageLoop::Type message_loop_type,
- const TimeDelta& delay) {
- MessageLoop loop(message_loop_type);
-
- RepeatingTimerTester f(nullptr, delay);
- f.Start();
- f.WaitAndConfirmTimerFiredRepeatedlyAfterDelay();
-}
-
-void RunTest_RepeatingTimer_Cancel(MessageLoop::Type message_loop_type,
- const TimeDelta& delay) {
- MessageLoop loop(message_loop_type);
-
- WaitableEvent did_run_a(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- RepeatingTimerTester* a = new RepeatingTimerTester(&did_run_a, delay);
-
- // This should run before the timer expires.
- SequencedTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
-
- // Now start the timer.
- a->Start();
-
- RepeatingTimerTester b(nullptr, delay);
- b.Start();
-
- b.WaitAndConfirmTimerFiredRepeatedlyAfterDelay();
-
- // |a| should not have fired despite |b| starting after it on the same
- // sequence and being complete by now.
- EXPECT_FALSE(did_run_a.IsSignaled());
-}
-
-class DelayTimerTarget {
- public:
- bool signaled() const { return signaled_; }
-
- void Signal() {
- ASSERT_FALSE(signaled_);
- signaled_ = true;
- }
-
- private:
- bool signaled_ = false;
-};
-
-void RunTest_DelayTimer_NoCall(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- // If Delay is never called, the timer shouldn't go off.
- DelayTimerTarget target;
- DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target,
- &DelayTimerTarget::Signal);
-
- OneShotTimerTester tester;
- tester.Start();
- tester.WaitAndConfirmTimerFiredAfterDelay();
-
- ASSERT_FALSE(target.signaled());
-}
-
-void RunTest_DelayTimer_OneCall(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- DelayTimerTarget target;
- DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target,
- &DelayTimerTarget::Signal);
- timer.Reset();
-
- OneShotTimerTester tester(nullptr, TimeDelta::FromMilliseconds(100));
- tester.Start();
- tester.WaitAndConfirmTimerFiredAfterDelay();
-
- ASSERT_TRUE(target.signaled());
-}
-
-struct ResetHelper {
- ResetHelper(DelayTimer* timer, DelayTimerTarget* target)
- : timer_(timer), target_(target) {}
-
- void Reset() {
- ASSERT_FALSE(target_->signaled());
- timer_->Reset();
- }
-
- private:
- DelayTimer* const timer_;
- DelayTimerTarget* const target_;
-};
-
-void RunTest_DelayTimer_Reset(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- // If Delay is never called, the timer shouldn't go off.
- DelayTimerTarget target;
- DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
- &DelayTimerTarget::Signal);
- timer.Reset();
-
- ResetHelper reset_helper(&timer, &target);
-
- OneShotTimer timers[20];
- for (size_t i = 0; i < arraysize(timers); ++i) {
- timers[i].Start(FROM_HERE, TimeDelta::FromMilliseconds(i * 10),
- &reset_helper, &ResetHelper::Reset);
- }
-
- OneShotTimerTester tester(nullptr, TimeDelta::FromMilliseconds(300));
- tester.Start();
- tester.WaitAndConfirmTimerFiredAfterDelay();
-
- ASSERT_TRUE(target.signaled());
-}
-
-class DelayTimerFatalTarget {
- public:
- void Signal() {
- ASSERT_TRUE(false);
- }
-};
-
-void RunTest_DelayTimer_Deleted(MessageLoop::Type message_loop_type) {
- MessageLoop loop(message_loop_type);
-
- DelayTimerFatalTarget target;
-
- {
- DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
- &DelayTimerFatalTarget::Signal);
- timer.Reset();
- }
-
- // When the timer is deleted, the DelayTimerFatalTarget should never be
- // called.
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
-}
-
-} // namespace
-
-//-----------------------------------------------------------------------------
-// Each test is run against each type of MessageLoop. That way we are sure
-// that timers work properly in all configurations.
-
-TEST(TimerTest, OneShotTimers) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_OneShotTimers(testing_message_loops[i]);
- }
-}
-
-TEST(TimerTest, OneShotTimers_Cancel) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_OneShotTimers_Cancel(testing_message_loops[i]);
- }
-}
-
-// If underline timer does not handle properly, we will crash or fail
-// in full page heap environment.
-TEST(TimerTest, OneShotSelfDeletingTimer) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_OneShotSelfDeletingTimer(testing_message_loops[i]);
- }
-}
-
-TEST(TimerTest, OneShotTimer_CustomTaskRunner) {
- // A MessageLoop is required for the timer events on the other thread to
- // communicate back to the Timer under test.
- MessageLoop loop;
-
- Thread other_thread("OneShotTimer_CustomTaskRunner");
- other_thread.Start();
-
- WaitableEvent did_run(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- OneShotTimerTester f(&did_run);
- f.SetTaskRunner(other_thread.task_runner());
- f.Start();
- EXPECT_TRUE(f.IsRunning() || did_run.IsSignaled());
-
- f.WaitAndConfirmTimerFiredAfterDelay();
- EXPECT_TRUE(did_run.IsSignaled());
-
- // |f| should already have communicated back to this |loop| before invoking
- // Run() and as such this thread should already be aware that |f| is no longer
- // running.
- EXPECT_TRUE(loop.IsIdleForTesting());
- EXPECT_FALSE(f.IsRunning());
-}
-
-TEST(TimerTest, OneShotTimerWithTickClock) {
- scoped_refptr<TestMockTimeTaskRunner> task_runner(
- new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
- MessageLoop message_loop;
- message_loop.SetTaskRunner(task_runner);
- Receiver receiver;
- OneShotTimer timer(task_runner->GetMockTickClock());
- timer.Start(FROM_HERE, TimeDelta::FromSeconds(1),
- Bind(&Receiver::OnCalled, Unretained(&receiver)));
- task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
- EXPECT_TRUE(receiver.WasCalled());
-}
-
-TEST(TimerTest, RepeatingTimer) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_RepeatingTimer(testing_message_loops[i],
- TimeDelta::FromMilliseconds(10));
- }
-}
-
-TEST(TimerTest, RepeatingTimer_Cancel) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_RepeatingTimer_Cancel(testing_message_loops[i],
- TimeDelta::FromMilliseconds(10));
- }
-}
-
-TEST(TimerTest, RepeatingTimerZeroDelay) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_RepeatingTimer(testing_message_loops[i],
- TimeDelta::FromMilliseconds(0));
- }
-}
-
-TEST(TimerTest, RepeatingTimerZeroDelay_Cancel) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_RepeatingTimer_Cancel(testing_message_loops[i],
- TimeDelta::FromMilliseconds(0));
- }
-}
-
-TEST(TimerTest, RepeatingTimerWithTickClock) {
- scoped_refptr<TestMockTimeTaskRunner> task_runner(
- new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
- MessageLoop message_loop;
- message_loop.SetTaskRunner(task_runner);
- Receiver receiver;
- const int expected_times_called = 10;
- RepeatingTimer timer(task_runner->GetMockTickClock());
- timer.Start(FROM_HERE, TimeDelta::FromSeconds(1),
- Bind(&Receiver::OnCalled, Unretained(&receiver)));
- task_runner->FastForwardBy(TimeDelta::FromSeconds(expected_times_called));
- timer.Stop();
- EXPECT_EQ(expected_times_called, receiver.TimesCalled());
-}
-
-TEST(TimerTest, DelayTimer_NoCall) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_DelayTimer_NoCall(testing_message_loops[i]);
- }
-}
-
-TEST(TimerTest, DelayTimer_OneCall) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_DelayTimer_OneCall(testing_message_loops[i]);
- }
-}
-
-// It's flaky on the buildbot, http://crbug.com/25038.
-TEST(TimerTest, DISABLED_DelayTimer_Reset) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_DelayTimer_Reset(testing_message_loops[i]);
- }
-}
-
-TEST(TimerTest, DelayTimer_Deleted) {
- for (int i = 0; i < kNumTestingMessageLoops; i++) {
- RunTest_DelayTimer_Deleted(testing_message_loops[i]);
- }
-}
-
-TEST(TimerTest, DelayTimerWithTickClock) {
- scoped_refptr<TestMockTimeTaskRunner> task_runner(
- new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
- MessageLoop message_loop;
- message_loop.SetTaskRunner(task_runner);
- Receiver receiver;
- DelayTimer timer(FROM_HERE, TimeDelta::FromSeconds(1), &receiver,
- &Receiver::OnCalled, task_runner->GetMockTickClock());
- task_runner->FastForwardBy(TimeDelta::FromMilliseconds(999));
- EXPECT_FALSE(receiver.WasCalled());
- timer.Reset();
- task_runner->FastForwardBy(TimeDelta::FromMilliseconds(999));
- EXPECT_FALSE(receiver.WasCalled());
- timer.Reset();
- task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
- EXPECT_TRUE(receiver.WasCalled());
-}
-
-TEST(TimerTest, MessageLoopShutdown) {
- // This test is designed to verify that shutdown of the
- // message loop does not cause crashes if there were pending
- // timers not yet fired. It may only trigger exceptions
- // if debug heap checking is enabled.
- WaitableEvent did_run(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- {
- OneShotTimerTesterBase a(&did_run);
- OneShotTimerTesterBase b(&did_run);
- OneShotTimerTesterBase c(&did_run);
- OneShotTimerTesterBase d(&did_run);
- {
- MessageLoop loop;
- a.Start();
- b.Start();
- } // MessageLoop destructs by falling out of scope.
- } // OneShotTimers destruct. SHOULD NOT CRASH, of course.
-
- EXPECT_FALSE(did_run.IsSignaled());
-}
-
-// Ref counted class which owns a Timer. The class passes a reference to itself
-// via the |user_task| parameter in Timer::Start(). |Timer::user_task_| might
-// end up holding the last reference to the class.
-class OneShotSelfOwningTimerTester
- : public RefCounted<OneShotSelfOwningTimerTester> {
- public:
- OneShotSelfOwningTimerTester() = default;
-
- void StartTimer() {
- // Start timer with long delay in order to test the timer getting destroyed
- // while a timer task is still pending.
- timer_.Start(FROM_HERE, TimeDelta::FromDays(1),
- base::Bind(&OneShotSelfOwningTimerTester::Run, this));
- }
-
- private:
- friend class RefCounted<OneShotSelfOwningTimerTester>;
- ~OneShotSelfOwningTimerTester() = default;
-
- void Run() {
- ADD_FAILURE() << "Timer unexpectedly fired.";
- }
-
- OneShotTimer timer_;
-
- DISALLOW_COPY_AND_ASSIGN(OneShotSelfOwningTimerTester);
-};
-
-TEST(TimerTest, MessageLoopShutdownSelfOwningTimer) {
- // This test verifies that shutdown of the message loop does not cause crashes
- // if there is a pending timer not yet fired and |Timer::user_task_| owns the
- // timer. The test may only trigger exceptions if debug heap checking is
- // enabled.
-
- MessageLoop loop;
- scoped_refptr<OneShotSelfOwningTimerTester> tester =
- new OneShotSelfOwningTimerTester();
-
- std::move(tester)->StartTimer();
- // |Timer::user_task_| owns sole reference to |tester|.
-
- // MessageLoop destructs by falling out of scope. SHOULD NOT CRASH.
-}
-
-void TimerTestCallback() {
-}
-
-TEST(TimerTest, NonRepeatIsRunning) {
- {
- MessageLoop loop;
- Timer timer(false, false);
- EXPECT_FALSE(timer.IsRunning());
- timer.Start(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback));
- EXPECT_TRUE(timer.IsRunning());
- timer.Stop();
- EXPECT_FALSE(timer.IsRunning());
- EXPECT_TRUE(timer.user_task().is_null());
- }
-
- {
- Timer timer(true, false);
- MessageLoop loop;
- EXPECT_FALSE(timer.IsRunning());
- timer.Start(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback));
- EXPECT_TRUE(timer.IsRunning());
- timer.Stop();
- EXPECT_FALSE(timer.IsRunning());
- ASSERT_FALSE(timer.user_task().is_null());
- timer.Reset();
- EXPECT_TRUE(timer.IsRunning());
- }
-}
-
-TEST(TimerTest, NonRepeatMessageLoopDeath) {
- Timer timer(false, false);
- {
- MessageLoop loop;
- EXPECT_FALSE(timer.IsRunning());
- timer.Start(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback));
- EXPECT_TRUE(timer.IsRunning());
- }
- EXPECT_FALSE(timer.IsRunning());
- EXPECT_TRUE(timer.user_task().is_null());
-}
-
-TEST(TimerTest, RetainRepeatIsRunning) {
- MessageLoop loop;
- Timer timer(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback),
- true);
- EXPECT_FALSE(timer.IsRunning());
- timer.Reset();
- EXPECT_TRUE(timer.IsRunning());
- timer.Stop();
- EXPECT_FALSE(timer.IsRunning());
- timer.Reset();
- EXPECT_TRUE(timer.IsRunning());
-}
-
-TEST(TimerTest, RetainNonRepeatIsRunning) {
- MessageLoop loop;
- Timer timer(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback),
- false);
- EXPECT_FALSE(timer.IsRunning());
- timer.Reset();
- EXPECT_TRUE(timer.IsRunning());
- timer.Stop();
- EXPECT_FALSE(timer.IsRunning());
- timer.Reset();
- EXPECT_TRUE(timer.IsRunning());
-}
-
-//-----------------------------------------------------------------------------
-
-namespace {
-
-bool g_callback_happened1 = false;
-bool g_callback_happened2 = false;
-
-void ClearAllCallbackHappened() {
- g_callback_happened1 = false;
- g_callback_happened2 = false;
-}
-
-void SetCallbackHappened1() {
- g_callback_happened1 = true;
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-void SetCallbackHappened2() {
- g_callback_happened2 = true;
- RunLoop::QuitCurrentWhenIdleDeprecated();
-}
-
-} // namespace
-
-TEST(TimerTest, ContinuationStopStart) {
- {
- ClearAllCallbackHappened();
- MessageLoop loop;
- Timer timer(false, false);
- timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
- Bind(&SetCallbackHappened1));
- timer.Stop();
- timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(40),
- Bind(&SetCallbackHappened2));
- RunLoop().Run();
- EXPECT_FALSE(g_callback_happened1);
- EXPECT_TRUE(g_callback_happened2);
- }
-}
-
-TEST(TimerTest, ContinuationReset) {
- {
- ClearAllCallbackHappened();
- MessageLoop loop;
- Timer timer(false, false);
- timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
- Bind(&SetCallbackHappened1));
- timer.Reset();
- // Since Reset happened before task ran, the user_task must not be cleared:
- ASSERT_FALSE(timer.user_task().is_null());
- RunLoop().Run();
- EXPECT_TRUE(g_callback_happened1);
- }
-}
-
-namespace {
-
-// Fixture for tests requiring ScopedTaskEnvironment. Includes a WaitableEvent
-// so that cases may Wait() on one thread and Signal() (explicitly, or
-// implicitly via helper methods) on another.
-class TimerSequenceTest : public testing::Test {
- public:
- TimerSequenceTest()
- : event_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED) {}
-
- // Block until Signal() is called on another thread.
- void Wait() { event_.Wait(); }
-
- void Signal() { event_.Signal(); }
-
- // Helper to augment a task with a subsequent call to Signal().
- Closure TaskWithSignal(const Closure& task) {
- return Bind(&TimerSequenceTest::RunTaskAndSignal, Unretained(this), task);
- }
-
- // Create the timer.
- void CreateTimer() { timer_.reset(new OneShotTimer); }
-
- // Schedule an event on the timer.
- void StartTimer(TimeDelta delay, const Closure& task) {
- timer_->Start(FROM_HERE, delay, task);
- }
-
- void SetTaskRunnerForTimer(scoped_refptr<SequencedTaskRunner> task_runner) {
- timer_->SetTaskRunner(std::move(task_runner));
- }
-
- // Tell the timer to abandon the task.
- void AbandonTask() {
- EXPECT_TRUE(timer_->IsRunning());
- // Reset() to call Timer::AbandonScheduledTask()
- timer_->Reset();
- EXPECT_TRUE(timer_->IsRunning());
- timer_->Stop();
- EXPECT_FALSE(timer_->IsRunning());
- }
-
- static void VerifyAffinity(const SequencedTaskRunner* task_runner) {
- EXPECT_TRUE(task_runner->RunsTasksInCurrentSequence());
- }
-
- // Delete the timer.
- void DeleteTimer() { timer_.reset(); }
-
- private:
- void RunTaskAndSignal(const Closure& task) {
- task.Run();
- Signal();
- }
-
- base::test::ScopedTaskEnvironment scoped_task_environment_;
- WaitableEvent event_;
- std::unique_ptr<OneShotTimer> timer_;
-
- DISALLOW_COPY_AND_ASSIGN(TimerSequenceTest);
-};
-
-} // namespace
-
-TEST_F(TimerSequenceTest, OneShotTimerTaskOnPoolSequence) {
- scoped_refptr<SequencedTaskRunner> task_runner =
- base::CreateSequencedTaskRunnerWithTraits({});
-
- base::RunLoop run_loop_;
-
- // Timer is created on this thread.
- CreateTimer();
-
- // Task will execute on a pool thread.
- SetTaskRunnerForTimer(task_runner);
- StartTimer(TimeDelta::FromMilliseconds(1),
- Bind(IgnoreResult(&SequencedTaskRunner::PostTask),
- SequencedTaskRunnerHandle::Get(), FROM_HERE,
- run_loop_.QuitClosure()));
-
- // Spin the loop so that the delayed task fires on it, which will forward it
- // to |task_runner|. And since the Timer's task is one that posts back to this
- // MessageLoop to quit, we finally unblock.
- run_loop_.Run();
-
- // Timer will be destroyed on this thread.
- DeleteTimer();
-}
-
-TEST_F(TimerSequenceTest, OneShotTimerUsedOnPoolSequence) {
- scoped_refptr<SequencedTaskRunner> task_runner =
- base::CreateSequencedTaskRunnerWithTraits({});
-
- // Timer is created on this thread.
- CreateTimer();
-
- // Task will be scheduled from a pool thread.
- task_runner->PostTask(
- FROM_HERE, BindOnce(&TimerSequenceTest::StartTimer, Unretained(this),
- TimeDelta::FromMilliseconds(1),
- Bind(&TimerSequenceTest::Signal, Unretained(this))));
- Wait();
-
- // Timer must be destroyed on pool thread, too.
- task_runner->PostTask(
- FROM_HERE,
- TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
- Wait();
-}
-
-TEST_F(TimerSequenceTest, OneShotTimerTwoSequencesAbandonTask) {
- scoped_refptr<SequencedTaskRunner> task_runner1 =
- base::CreateSequencedTaskRunnerWithTraits({});
- scoped_refptr<SequencedTaskRunner> task_runner2 =
- base::CreateSequencedTaskRunnerWithTraits({});
-
- // Create timer on sequence #1.
- task_runner1->PostTask(
- FROM_HERE,
- TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this))));
- Wait();
-
- // And tell it to execute on a different sequence (#2).
- task_runner1->PostTask(
- FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer,
- Unretained(this), task_runner2)));
- Wait();
-
- // Task will be scheduled from sequence #1.
- task_runner1->PostTask(
- FROM_HERE, BindOnce(&TimerSequenceTest::StartTimer, Unretained(this),
- TimeDelta::FromHours(1), DoNothing()));
-
- // Abandon task - must be called from scheduling sequence (#1).
- task_runner1->PostTask(
- FROM_HERE,
- TaskWithSignal(Bind(&TimerSequenceTest::AbandonTask, Unretained(this))));
- Wait();
-
- // Timer must be destroyed on the sequence it was scheduled from (#1).
- task_runner1->PostTask(
- FROM_HERE,
- TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
- Wait();
-}
-
-TEST_F(TimerSequenceTest, OneShotTimerUsedAndTaskedOnDifferentSequences) {
- scoped_refptr<SequencedTaskRunner> task_runner1 =
- base::CreateSequencedTaskRunnerWithTraits({});
- scoped_refptr<SequencedTaskRunner> task_runner2 =
- base::CreateSequencedTaskRunnerWithTraits({});
-
- // Create timer on sequence #1.
- task_runner1->PostTask(
- FROM_HERE,
- TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this))));
- Wait();
-
- // And tell it to execute on a different sequence (#2).
- task_runner1->PostTask(
- FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer,
- Unretained(this), task_runner2)));
- Wait();
-
- // Task will be scheduled from sequence #1.
- task_runner1->PostTask(
- FROM_HERE,
- BindOnce(&TimerSequenceTest::StartTimer, Unretained(this),
- TimeDelta::FromMilliseconds(1),
- TaskWithSignal(Bind(&TimerSequenceTest::VerifyAffinity,
- Unretained(task_runner2.get())))));
-
- Wait();
-
- // Timer must be destroyed on the sequence it was scheduled from (#1).
- task_runner1->PostTask(
- FROM_HERE,
- TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this))));
- Wait();
-}
-
-} // namespace base
diff --git a/base/tools_sanity_unittest.cc b/base/tools_sanity_unittest.cc
deleted file mode 100644
index 761559e..0000000
--- a/base/tools_sanity_unittest.cc
+++ /dev/null
@@ -1,387 +0,0 @@
-// 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 file contains intentional memory errors, some of which may lead to
-// crashes if the test is ran without special memory testing tools. We use these
-// errors to verify the sanity of the tools.
-
-#include <stddef.h>
-
-#include "base/atomicops.h"
-#include "base/debug/asan_invalid_access.h"
-#include "base/debug/profiler.h"
-#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
-#include "base/threading/thread.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-const base::subtle::Atomic32 kMagicValue = 42;
-
-// Helper for memory accesses that can potentially corrupt memory or cause a
-// crash during a native run.
-#if defined(ADDRESS_SANITIZER)
-#if defined(OS_IOS)
-// EXPECT_DEATH is not supported on IOS.
-#define HARMFUL_ACCESS(action,error_regexp) do { action; } while (0)
-#else
-#define HARMFUL_ACCESS(action,error_regexp) EXPECT_DEATH(action,error_regexp)
-#endif // !OS_IOS
-#else
-#define HARMFUL_ACCESS(action, error_regexp)
-#define HARMFUL_ACCESS_IS_NOOP
-#endif
-
-void DoReadUninitializedValue(char *ptr) {
- // Comparison with 64 is to prevent clang from optimizing away the
- // jump -- valgrind only catches jumps and conditional moves, but clang uses
- // the borrow flag if the condition is just `*ptr == '\0'`. We no longer
- // support valgrind, but this constant should be fine to keep as-is.
- if (*ptr == 64) {
- VLOG(1) << "Uninit condition is true";
- } else {
- VLOG(1) << "Uninit condition is false";
- }
-}
-
-void ReadUninitializedValue(char *ptr) {
-#if defined(MEMORY_SANITIZER)
- EXPECT_DEATH(DoReadUninitializedValue(ptr),
- "use-of-uninitialized-value");
-#else
- DoReadUninitializedValue(ptr);
-#endif
-}
-
-#ifndef HARMFUL_ACCESS_IS_NOOP
-void ReadValueOutOfArrayBoundsLeft(char *ptr) {
- char c = ptr[-2];
- VLOG(1) << "Reading a byte out of bounds: " << c;
-}
-
-void ReadValueOutOfArrayBoundsRight(char *ptr, size_t size) {
- char c = ptr[size + 1];
- VLOG(1) << "Reading a byte out of bounds: " << c;
-}
-
-void WriteValueOutOfArrayBoundsLeft(char *ptr) {
- ptr[-1] = kMagicValue;
-}
-
-void WriteValueOutOfArrayBoundsRight(char *ptr, size_t size) {
- ptr[size] = kMagicValue;
-}
-#endif // HARMFUL_ACCESS_IS_NOOP
-
-void MakeSomeErrors(char *ptr, size_t size) {
- ReadUninitializedValue(ptr);
-
- HARMFUL_ACCESS(ReadValueOutOfArrayBoundsLeft(ptr),
- "2 bytes to the left");
- HARMFUL_ACCESS(ReadValueOutOfArrayBoundsRight(ptr, size),
- "1 bytes to the right");
- HARMFUL_ACCESS(WriteValueOutOfArrayBoundsLeft(ptr),
- "1 bytes to the left");
- HARMFUL_ACCESS(WriteValueOutOfArrayBoundsRight(ptr, size),
- "0 bytes to the right");
-}
-
-} // namespace
-
-// A memory leak detector should report an error in this test.
-TEST(ToolsSanityTest, MemoryLeak) {
- // Without the |volatile|, clang optimizes away the next two lines.
- int* volatile leak = new int[256]; // Leak some memory intentionally.
- leak[4] = 1; // Make sure the allocated memory is used.
-}
-
-#if (defined(ADDRESS_SANITIZER) && defined(OS_IOS))
-// Because iOS doesn't support death tests, each of the following tests will
-// crash the whole program under Asan.
-#define MAYBE_AccessesToNewMemory DISABLED_AccessesToNewMemory
-#define MAYBE_AccessesToMallocMemory DISABLED_AccessesToMallocMemory
-#else
-#define MAYBE_AccessesToNewMemory AccessesToNewMemory
-#define MAYBE_AccessesToMallocMemory AccessesToMallocMemory
-#endif // (defined(ADDRESS_SANITIZER) && defined(OS_IOS))
-
-// The following tests pass with Clang r170392, but not r172454, which
-// makes AddressSanitizer detect errors in them. We disable these tests under
-// AddressSanitizer until we fully switch to Clang r172454. After that the
-// tests should be put back under the (defined(OS_IOS) || defined(OS_WIN))
-// clause above.
-// See also http://crbug.com/172614.
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_SingleElementDeletedWithBraces \
- DISABLED_SingleElementDeletedWithBraces
-#define MAYBE_ArrayDeletedWithoutBraces DISABLED_ArrayDeletedWithoutBraces
-#else
-#define MAYBE_ArrayDeletedWithoutBraces ArrayDeletedWithoutBraces
-#define MAYBE_SingleElementDeletedWithBraces SingleElementDeletedWithBraces
-#endif // defined(ADDRESS_SANITIZER)
-
-TEST(ToolsSanityTest, MAYBE_AccessesToNewMemory) {
- char *foo = new char[10];
- MakeSomeErrors(foo, 10);
- delete [] foo;
- // Use after delete.
- HARMFUL_ACCESS(foo[5] = 0, "heap-use-after-free");
-}
-
-TEST(ToolsSanityTest, MAYBE_AccessesToMallocMemory) {
- char *foo = reinterpret_cast<char*>(malloc(10));
- MakeSomeErrors(foo, 10);
- free(foo);
- // Use after free.
- HARMFUL_ACCESS(foo[5] = 0, "heap-use-after-free");
-}
-
-#if defined(ADDRESS_SANITIZER)
-
-static int* allocateArray() {
- // Clang warns about the mismatched new[]/delete if they occur in the same
- // function.
- return new int[10];
-}
-
-// This test may corrupt memory if not compiled with AddressSanitizer.
-TEST(ToolsSanityTest, MAYBE_ArrayDeletedWithoutBraces) {
- // Without the |volatile|, clang optimizes away the next two lines.
- int* volatile foo = allocateArray();
- delete foo;
-}
-#endif
-
-#if defined(ADDRESS_SANITIZER)
-static int* allocateScalar() {
- // Clang warns about the mismatched new/delete[] if they occur in the same
- // function.
- return new int;
-}
-
-// This test may corrupt memory if not compiled with AddressSanitizer.
-TEST(ToolsSanityTest, MAYBE_SingleElementDeletedWithBraces) {
- // Without the |volatile|, clang optimizes away the next two lines.
- int* volatile foo = allocateScalar();
- (void) foo;
- delete [] foo;
-}
-#endif
-
-#if defined(ADDRESS_SANITIZER)
-
-TEST(ToolsSanityTest, DISABLED_AddressSanitizerNullDerefCrashTest) {
- // Intentionally crash to make sure AddressSanitizer is running.
- // This test should not be ran on bots.
- int* volatile zero = NULL;
- *zero = 0;
-}
-
-TEST(ToolsSanityTest, DISABLED_AddressSanitizerLocalOOBCrashTest) {
- // Intentionally crash to make sure AddressSanitizer is instrumenting
- // the local variables.
- // This test should not be ran on bots.
- int array[5];
- // Work around the OOB warning reported by Clang.
- int* volatile access = &array[5];
- *access = 43;
-}
-
-namespace {
-int g_asan_test_global_array[10];
-} // namespace
-
-TEST(ToolsSanityTest, DISABLED_AddressSanitizerGlobalOOBCrashTest) {
- // Intentionally crash to make sure AddressSanitizer is instrumenting
- // the global variables.
- // This test should not be ran on bots.
-
- // Work around the OOB warning reported by Clang.
- int* volatile access = g_asan_test_global_array - 1;
- *access = 43;
-}
-
-#ifndef HARMFUL_ACCESS_IS_NOOP
-TEST(ToolsSanityTest, AsanHeapOverflow) {
- HARMFUL_ACCESS(debug::AsanHeapOverflow() ,"to the right");
-}
-
-TEST(ToolsSanityTest, AsanHeapUnderflow) {
- HARMFUL_ACCESS(debug::AsanHeapUnderflow(), "to the left");
-}
-
-TEST(ToolsSanityTest, AsanHeapUseAfterFree) {
- HARMFUL_ACCESS(debug::AsanHeapUseAfterFree(), "heap-use-after-free");
-}
-
-#if defined(OS_WIN)
-// The ASAN runtime doesn't detect heap corruption, this needs fixing before
-// ASAN builds can ship to the wild. See https://crbug.com/818747.
-TEST(ToolsSanityTest, DISABLED_AsanCorruptHeapBlock) {
- HARMFUL_ACCESS(debug::AsanCorruptHeapBlock(), "");
-}
-
-TEST(ToolsSanityTest, DISABLED_AsanCorruptHeap) {
- // This test will kill the process by raising an exception, there's no
- // particular string to look for in the stack trace.
- EXPECT_DEATH(debug::AsanCorruptHeap(), "");
-}
-#endif // OS_WIN
-#endif // !HARMFUL_ACCESS_IS_NOOP
-
-#endif // ADDRESS_SANITIZER
-
-namespace {
-
-// We use caps here just to ensure that the method name doesn't interfere with
-// the wildcarded suppressions.
-class TOOLS_SANITY_TEST_CONCURRENT_THREAD : public PlatformThread::Delegate {
- public:
- explicit TOOLS_SANITY_TEST_CONCURRENT_THREAD(bool *value) : value_(value) {}
- ~TOOLS_SANITY_TEST_CONCURRENT_THREAD() override = default;
- void ThreadMain() override {
- *value_ = true;
-
- // Sleep for a few milliseconds so the two threads are more likely to live
- // simultaneously. Otherwise we may miss the report due to mutex
- // lock/unlock's inside thread creation code in pure-happens-before mode...
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- }
- private:
- bool *value_;
-};
-
-class ReleaseStoreThread : public PlatformThread::Delegate {
- public:
- explicit ReleaseStoreThread(base::subtle::Atomic32 *value) : value_(value) {}
- ~ReleaseStoreThread() override = default;
- void ThreadMain() override {
- base::subtle::Release_Store(value_, kMagicValue);
-
- // Sleep for a few milliseconds so the two threads are more likely to live
- // simultaneously. Otherwise we may miss the report due to mutex
- // lock/unlock's inside thread creation code in pure-happens-before mode...
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- }
- private:
- base::subtle::Atomic32 *value_;
-};
-
-class AcquireLoadThread : public PlatformThread::Delegate {
- public:
- explicit AcquireLoadThread(base::subtle::Atomic32 *value) : value_(value) {}
- ~AcquireLoadThread() override = default;
- void ThreadMain() override {
- // Wait for the other thread to make Release_Store
- PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
- base::subtle::Acquire_Load(value_);
- }
- private:
- base::subtle::Atomic32 *value_;
-};
-
-void RunInParallel(PlatformThread::Delegate *d1, PlatformThread::Delegate *d2) {
- PlatformThreadHandle a;
- PlatformThreadHandle b;
- PlatformThread::Create(0, d1, &a);
- PlatformThread::Create(0, d2, &b);
- PlatformThread::Join(a);
- PlatformThread::Join(b);
-}
-
-#if defined(THREAD_SANITIZER)
-void DataRace() {
- bool *shared = new bool(false);
- TOOLS_SANITY_TEST_CONCURRENT_THREAD thread1(shared), thread2(shared);
- RunInParallel(&thread1, &thread2);
- EXPECT_TRUE(*shared);
- delete shared;
- // We're in a death test - crash.
- CHECK(0);
-}
-#endif
-
-} // namespace
-
-#if defined(THREAD_SANITIZER)
-// A data race detector should report an error in this test.
-TEST(ToolsSanityTest, DataRace) {
- // The suppression regexp must match that in base/debug/tsan_suppressions.cc.
- EXPECT_DEATH(DataRace(), "1 race:base/tools_sanity_unittest.cc");
-}
-#endif
-
-TEST(ToolsSanityTest, AnnotateBenignRace) {
- bool shared = false;
- ANNOTATE_BENIGN_RACE(&shared, "Intentional race - make sure doesn't show up");
- TOOLS_SANITY_TEST_CONCURRENT_THREAD thread1(&shared), thread2(&shared);
- RunInParallel(&thread1, &thread2);
- EXPECT_TRUE(shared);
-}
-
-TEST(ToolsSanityTest, AtomicsAreIgnored) {
- base::subtle::Atomic32 shared = 0;
- ReleaseStoreThread thread1(&shared);
- AcquireLoadThread thread2(&shared);
- RunInParallel(&thread1, &thread2);
- EXPECT_EQ(kMagicValue, shared);
-}
-
-#if defined(CFI_ERROR_MSG)
-class A {
- public:
- A(): n_(0) {}
- virtual void f() { n_++; }
- protected:
- int n_;
-};
-
-class B: public A {
- public:
- void f() override { n_--; }
-};
-
-class C: public B {
- public:
- void f() override { n_ += 2; }
-};
-
-NOINLINE void KillVptrAndCall(A *obj) {
- *reinterpret_cast<void **>(obj) = 0;
- obj->f();
-}
-
-TEST(ToolsSanityTest, BadVirtualCallNull) {
- A a;
- B b;
- EXPECT_DEATH({ KillVptrAndCall(&a); KillVptrAndCall(&b); }, CFI_ERROR_MSG);
-}
-
-NOINLINE void OverwriteVptrAndCall(B *obj, A *vptr) {
- *reinterpret_cast<void **>(obj) = *reinterpret_cast<void **>(vptr);
- obj->f();
-}
-
-TEST(ToolsSanityTest, BadVirtualCallWrongType) {
- A a;
- B b;
- C c;
- EXPECT_DEATH({ OverwriteVptrAndCall(&b, &a); OverwriteVptrAndCall(&b, &c); },
- CFI_ERROR_MSG);
-}
-
-#endif // CFI_ERROR_MSG
-
-#undef CFI_ERROR_MSG
-#undef MAYBE_AccessesToNewMemory
-#undef MAYBE_AccessesToMallocMemory
-#undef MAYBE_ArrayDeletedWithoutBraces
-#undef MAYBE_SingleElementDeletedWithBraces
-#undef HARMFUL_ACCESS
-#undef HARMFUL_ACCESS_IS_NOOP
-
-} // namespace base
diff --git a/base/trace_event/blame_context_unittest.cc b/base/trace_event/blame_context_unittest.cc
deleted file mode 100644
index 12e7857..0000000
--- a/base/trace_event/blame_context_unittest.cc
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2016 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 "base/trace_event/blame_context.h"
-
-#include "base/json/json_writer.h"
-#include "base/message_loop/message_loop.h"
-#include "base/test/trace_event_analyzer.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-namespace {
-
-const char kTestBlameContextCategory[] = "test";
-const char kDisabledTestBlameContextCategory[] = "disabled-by-default-test";
-const char kTestBlameContextName[] = "TestBlameContext";
-const char kTestBlameContextType[] = "TestBlameContextType";
-const char kTestBlameContextScope[] = "TestBlameContextScope";
-
-class TestBlameContext : public BlameContext {
- public:
- explicit TestBlameContext(int id)
- : BlameContext(kTestBlameContextCategory,
- kTestBlameContextName,
- kTestBlameContextType,
- kTestBlameContextScope,
- id,
- nullptr) {}
-
- TestBlameContext(int id, const TestBlameContext& parent)
- : BlameContext(kTestBlameContextCategory,
- kTestBlameContextName,
- kTestBlameContextType,
- kTestBlameContextScope,
- id,
- &parent) {}
-
- protected:
- void AsValueInto(trace_event::TracedValue* state) override {
- BlameContext::AsValueInto(state);
- state->SetBoolean("crossStreams", false);
- }
-};
-
-class DisabledTestBlameContext : public BlameContext {
- public:
- explicit DisabledTestBlameContext(int id)
- : BlameContext(kDisabledTestBlameContextCategory,
- kTestBlameContextName,
- kTestBlameContextType,
- kTestBlameContextScope,
- id,
- nullptr) {}
-};
-
-class BlameContextTest : public testing::Test {
- protected:
- MessageLoop loop_;
-};
-
-TEST_F(BlameContextTest, EnterAndLeave) {
- using trace_analyzer::Query;
- trace_analyzer::Start("*");
- {
- TestBlameContext blame_context(0x1234);
- blame_context.Initialize();
- blame_context.Enter();
- blame_context.Leave();
- }
- auto analyzer = trace_analyzer::Stop();
-
- trace_analyzer::TraceEventVector events;
- Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) ||
- Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT);
- analyzer->FindEvents(q, &events);
-
- EXPECT_EQ(2u, events.size());
- EXPECT_EQ(TRACE_EVENT_PHASE_ENTER_CONTEXT, events[0]->phase);
- EXPECT_EQ(kTestBlameContextCategory, events[0]->category);
- EXPECT_EQ(kTestBlameContextName, events[0]->name);
- EXPECT_EQ("0x1234", events[0]->id);
- EXPECT_EQ(TRACE_EVENT_PHASE_LEAVE_CONTEXT, events[1]->phase);
- EXPECT_EQ(kTestBlameContextCategory, events[1]->category);
- EXPECT_EQ(kTestBlameContextName, events[1]->name);
- EXPECT_EQ("0x1234", events[1]->id);
-}
-
-TEST_F(BlameContextTest, DifferentCategories) {
- // Ensure there is no cross talk between blame contexts from different
- // categories.
- using trace_analyzer::Query;
- trace_analyzer::Start("*");
- {
- TestBlameContext blame_context(0x1234);
- DisabledTestBlameContext disabled_blame_context(0x5678);
- blame_context.Initialize();
- blame_context.Enter();
- blame_context.Leave();
- disabled_blame_context.Initialize();
- disabled_blame_context.Enter();
- disabled_blame_context.Leave();
- }
- auto analyzer = trace_analyzer::Stop();
-
- trace_analyzer::TraceEventVector events;
- Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) ||
- Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT);
- analyzer->FindEvents(q, &events);
-
- // None of the events from the disabled-by-default category should show up.
- EXPECT_EQ(2u, events.size());
- EXPECT_EQ(TRACE_EVENT_PHASE_ENTER_CONTEXT, events[0]->phase);
- EXPECT_EQ(kTestBlameContextCategory, events[0]->category);
- EXPECT_EQ(kTestBlameContextName, events[0]->name);
- EXPECT_EQ("0x1234", events[0]->id);
- EXPECT_EQ(TRACE_EVENT_PHASE_LEAVE_CONTEXT, events[1]->phase);
- EXPECT_EQ(kTestBlameContextCategory, events[1]->category);
- EXPECT_EQ(kTestBlameContextName, events[1]->name);
- EXPECT_EQ("0x1234", events[1]->id);
-}
-
-TEST_F(BlameContextTest, TakeSnapshot) {
- using trace_analyzer::Query;
- trace_analyzer::Start("*");
- {
- TestBlameContext parent_blame_context(0x5678);
- TestBlameContext blame_context(0x1234, parent_blame_context);
- parent_blame_context.Initialize();
- blame_context.Initialize();
- blame_context.TakeSnapshot();
- }
- auto analyzer = trace_analyzer::Stop();
-
- trace_analyzer::TraceEventVector events;
- Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_SNAPSHOT_OBJECT);
- analyzer->FindEvents(q, &events);
-
- // We should have 3 snapshots: one for both calls to Initialize() and one from
- // the explicit call to TakeSnapshot().
- EXPECT_EQ(3u, events.size());
- EXPECT_EQ(kTestBlameContextCategory, events[0]->category);
- EXPECT_EQ(kTestBlameContextType, events[0]->name);
- EXPECT_EQ("0x5678", events[0]->id);
- EXPECT_TRUE(events[0]->HasArg("snapshot"));
-
- EXPECT_EQ(kTestBlameContextCategory, events[1]->category);
- EXPECT_EQ(kTestBlameContextType, events[1]->name);
- EXPECT_EQ("0x1234", events[1]->id);
- EXPECT_TRUE(events[0]->HasArg("snapshot"));
-
- EXPECT_EQ(kTestBlameContextCategory, events[2]->category);
- EXPECT_EQ(kTestBlameContextType, events[2]->name);
- EXPECT_EQ("0x1234", events[2]->id);
- EXPECT_TRUE(events[0]->HasArg("snapshot"));
-
- const char kExpectedSnapshotJson[] =
- "{"
- "\"crossStreams\":false,"
- "\"parent\":{"
- "\"id_ref\":\"0x5678\","
- "\"scope\":\"TestBlameContextScope\""
- "}"
- "}";
-
- std::string snapshot_json;
- JSONWriter::Write(*events[2]->GetKnownArgAsValue("snapshot"), &snapshot_json);
- EXPECT_EQ(kExpectedSnapshotJson, snapshot_json);
-}
-
-} // namepace
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/etw_manifest/BUILD.gn b/base/trace_event/etw_manifest/BUILD.gn
deleted file mode 100644
index 19c4ecf..0000000
--- a/base/trace_event/etw_manifest/BUILD.gn
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright 2015 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.
-
-import("//build/win/message_compiler.gni")
-
-assert(is_win, "This only runs on Windows.")
-
-message_compiler("chrome_events_win") {
- visibility = [
- "//base/*",
- "//chrome:main_dll",
- ]
-
- sources = [
- "chrome_events_win.man",
- ]
-
- user_mode_logging = true
-
- # The only code generated from chrome_events_win.man is a header file that
- # is included by trace_event_etw_export_win.cc, so there is no need to
- # compile any generated code. The other thing which compile_generated_code
- # controls in this context is linking in the .res file generated from the
- # manifest. However this is only needed for ETW provider registration which
- # is done by UIforETW (https://github.com/google/UIforETW) and therefore the
- # manifest resource can be skipped in Chrome.
- compile_generated_code = false
-}
diff --git a/base/trace_event/event_name_filter_unittest.cc b/base/trace_event/event_name_filter_unittest.cc
deleted file mode 100644
index 134be0d..0000000
--- a/base/trace_event/event_name_filter_unittest.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2015 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 "base/trace_event/event_name_filter.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/trace_event/trace_event_impl.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-const TraceEvent& MakeTraceEvent(const char* name) {
- static TraceEvent event;
- event.Reset();
- event.Initialize(0, TimeTicks(), ThreadTicks(), 'b', nullptr, name, "", 0, 0,
- 0, nullptr, nullptr, nullptr, nullptr, 0);
- return event;
-}
-
-TEST(TraceEventNameFilterTest, Whitelist) {
- auto empty_whitelist =
- std::make_unique<EventNameFilter::EventNamesWhitelist>();
- auto filter = std::make_unique<EventNameFilter>(std::move(empty_whitelist));
-
- // No events should be filtered if the whitelist is empty.
- EXPECT_FALSE(filter->FilterTraceEvent(MakeTraceEvent("foo")));
-
- auto whitelist = std::make_unique<EventNameFilter::EventNamesWhitelist>();
- whitelist->insert("foo");
- whitelist->insert("bar");
- filter = std::make_unique<EventNameFilter>(std::move(whitelist));
- EXPECT_TRUE(filter->FilterTraceEvent(MakeTraceEvent("foo")));
- EXPECT_FALSE(filter->FilterTraceEvent(MakeTraceEvent("fooz")));
- EXPECT_FALSE(filter->FilterTraceEvent(MakeTraceEvent("afoo")));
- EXPECT_TRUE(filter->FilterTraceEvent(MakeTraceEvent("bar")));
- EXPECT_FALSE(filter->FilterTraceEvent(MakeTraceEvent("foobar")));
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/heap_profiler_allocation_context_tracker_unittest.cc b/base/trace_event/heap_profiler_allocation_context_tracker_unittest.cc
deleted file mode 100644
index c26149e..0000000
--- a/base/trace_event/heap_profiler_allocation_context_tracker_unittest.cc
+++ /dev/null
@@ -1,350 +0,0 @@
-// Copyright 2015 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 <stddef.h>
-
-#include <iterator>
-
-#include "base/memory/ref_counted.h"
-#include "base/pending_task.h"
-#include "base/trace_event/heap_profiler.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-#include "base/trace_event/heap_profiler_allocation_context_tracker.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/trace_event.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-// Define all strings once, because the pseudo stack requires pointer equality,
-// and string interning is unreliable.
-const char kThreadName[] = "TestThread";
-const char kCupcake[] = "Cupcake";
-const char kDonut[] = "Donut";
-const char kEclair[] = "Eclair";
-const char kFroyo[] = "Froyo";
-const char kGingerbread[] = "Gingerbread";
-
-const char kFilteringTraceConfig[] =
- "{"
- " \"event_filters\": ["
- " {"
- " \"excluded_categories\": [],"
- " \"filter_args\": {},"
- " \"filter_predicate\": \"heap_profiler_predicate\","
- " \"included_categories\": ["
- " \"*\","
- " \"" TRACE_DISABLED_BY_DEFAULT("Testing") "\"]"
- " }"
- " ]"
- "}";
-
-// Asserts that the fixed-size array |expected_backtrace| matches the backtrace
-// in |AllocationContextTracker::GetContextSnapshot|.
-template <size_t N>
-void AssertBacktraceEquals(const StackFrame(&expected_backtrace)[N]) {
- AllocationContext ctx;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx));
-
- auto* actual = std::begin(ctx.backtrace.frames);
- auto* actual_bottom = actual + ctx.backtrace.frame_count;
- auto expected = std::begin(expected_backtrace);
- auto expected_bottom = std::end(expected_backtrace);
-
- // Note that this requires the pointers to be equal, this is not doing a deep
- // string comparison.
- for (; actual != actual_bottom && expected != expected_bottom;
- actual++, expected++)
- ASSERT_EQ(*expected, *actual);
-
- // Ensure that the height of the stacks is the same.
- ASSERT_EQ(actual, actual_bottom);
- ASSERT_EQ(expected, expected_bottom);
-}
-
-void AssertBacktraceContainsOnlyThreadName() {
- StackFrame t = StackFrame::FromThreadName(kThreadName);
- AllocationContext ctx;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx));
-
- ASSERT_EQ(1u, ctx.backtrace.frame_count);
- ASSERT_EQ(t, ctx.backtrace.frames[0]);
-}
-
-class AllocationContextTrackerTest : public testing::Test {
- public:
- void SetUp() override {
- AllocationContextTracker::SetCaptureMode(
- AllocationContextTracker::CaptureMode::PSEUDO_STACK);
- // Enabling memory-infra category sets default memory dump config which
- // includes filters for capturing pseudo stack.
- TraceConfig config(kFilteringTraceConfig);
- TraceLog::GetInstance()->SetEnabled(config, TraceLog::FILTERING_MODE);
- AllocationContextTracker::SetCurrentThreadName(kThreadName);
- }
-
- void TearDown() override {
- AllocationContextTracker::SetCaptureMode(
- AllocationContextTracker::CaptureMode::DISABLED);
- TraceLog::GetInstance()->SetDisabled(TraceLog::FILTERING_MODE);
- }
-};
-
-// Check that |TRACE_EVENT| macros push and pop to the pseudo stack correctly.
-TEST_F(AllocationContextTrackerTest, PseudoStackScopedTrace) {
- StackFrame t = StackFrame::FromThreadName(kThreadName);
- StackFrame c = StackFrame::FromTraceEventName(kCupcake);
- StackFrame d = StackFrame::FromTraceEventName(kDonut);
- StackFrame e = StackFrame::FromTraceEventName(kEclair);
- StackFrame f = StackFrame::FromTraceEventName(kFroyo);
-
- AssertBacktraceContainsOnlyThreadName();
-
- {
- TRACE_EVENT0("Testing", kCupcake);
- StackFrame frame_c[] = {t, c};
- AssertBacktraceEquals(frame_c);
-
- {
- TRACE_EVENT0("Testing", kDonut);
- StackFrame frame_cd[] = {t, c, d};
- AssertBacktraceEquals(frame_cd);
- }
-
- AssertBacktraceEquals(frame_c);
-
- {
- TRACE_EVENT0("Testing", kEclair);
- StackFrame frame_ce[] = {t, c, e};
- AssertBacktraceEquals(frame_ce);
- }
-
- {
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("NotTesting"), kDonut);
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("Testing"), kCupcake);
- StackFrame frame_cc[] = {t, c, c};
- AssertBacktraceEquals(frame_cc);
- }
-
- AssertBacktraceEquals(frame_c);
- }
-
- AssertBacktraceContainsOnlyThreadName();
-
- {
- TRACE_EVENT0("Testing", kFroyo);
- StackFrame frame_f[] = {t, f};
- AssertBacktraceEquals(frame_f);
- }
-
- AssertBacktraceContainsOnlyThreadName();
-}
-
-// Same as |PseudoStackScopedTrace|, but now test the |TRACE_EVENT_BEGIN| and
-// |TRACE_EVENT_END| macros.
-TEST_F(AllocationContextTrackerTest, PseudoStackBeginEndTrace) {
- StackFrame t = StackFrame::FromThreadName(kThreadName);
- StackFrame c = StackFrame::FromTraceEventName(kCupcake);
- StackFrame d = StackFrame::FromTraceEventName(kDonut);
- StackFrame e = StackFrame::FromTraceEventName(kEclair);
- StackFrame f = StackFrame::FromTraceEventName(kFroyo);
-
- StackFrame frame_c[] = {t, c};
- StackFrame frame_cd[] = {t, c, d};
- StackFrame frame_ce[] = {t, c, e};
- StackFrame frame_f[] = {t, f};
-
- AssertBacktraceContainsOnlyThreadName();
-
- TRACE_EVENT_BEGIN0("Testing", kCupcake);
- AssertBacktraceEquals(frame_c);
-
- TRACE_EVENT_BEGIN0("Testing", kDonut);
- AssertBacktraceEquals(frame_cd);
- TRACE_EVENT_END0("Testing", kDonut);
-
- AssertBacktraceEquals(frame_c);
-
- TRACE_EVENT_BEGIN0("Testing", kEclair);
- AssertBacktraceEquals(frame_ce);
- TRACE_EVENT_END0("Testing", kEclair);
-
- AssertBacktraceEquals(frame_c);
- TRACE_EVENT_END0("Testing", kCupcake);
-
- AssertBacktraceContainsOnlyThreadName();
-
- TRACE_EVENT_BEGIN0("Testing", kFroyo);
- AssertBacktraceEquals(frame_f);
- TRACE_EVENT_END0("Testing", kFroyo);
-
- AssertBacktraceContainsOnlyThreadName();
-}
-
-TEST_F(AllocationContextTrackerTest, PseudoStackMixedTrace) {
- StackFrame t = StackFrame::FromThreadName(kThreadName);
- StackFrame c = StackFrame::FromTraceEventName(kCupcake);
- StackFrame d = StackFrame::FromTraceEventName(kDonut);
- StackFrame e = StackFrame::FromTraceEventName(kEclair);
- StackFrame f = StackFrame::FromTraceEventName(kFroyo);
-
- StackFrame frame_c[] = {t, c};
- StackFrame frame_cd[] = {t, c, d};
- StackFrame frame_e[] = {t, e};
- StackFrame frame_ef[] = {t, e, f};
-
- AssertBacktraceContainsOnlyThreadName();
-
- TRACE_EVENT_BEGIN0("Testing", kCupcake);
- AssertBacktraceEquals(frame_c);
-
- {
- TRACE_EVENT0("Testing", kDonut);
- AssertBacktraceEquals(frame_cd);
- }
-
- AssertBacktraceEquals(frame_c);
- TRACE_EVENT_END0("Testing", kCupcake);
- AssertBacktraceContainsOnlyThreadName();
-
- {
- TRACE_EVENT0("Testing", kEclair);
- AssertBacktraceEquals(frame_e);
-
- TRACE_EVENT_BEGIN0("Testing", kFroyo);
- AssertBacktraceEquals(frame_ef);
- TRACE_EVENT_END0("Testing", kFroyo);
- AssertBacktraceEquals(frame_e);
- }
-
- AssertBacktraceContainsOnlyThreadName();
-}
-
-TEST_F(AllocationContextTrackerTest, MixedStackWithProgramCounter) {
- StackFrame t = StackFrame::FromThreadName(kThreadName);
- StackFrame c = StackFrame::FromTraceEventName(kCupcake);
- StackFrame f = StackFrame::FromTraceEventName(kFroyo);
- const void* pc1 = reinterpret_cast<void*>(0x1000);
- const void* pc2 = reinterpret_cast<void*>(0x2000);
- StackFrame n1 = StackFrame::FromProgramCounter(pc1);
- StackFrame n2 = StackFrame::FromProgramCounter(pc2);
-
- StackFrame frame_c[] = {t, c};
- StackFrame frame_cd[] = {t, c, n1};
- StackFrame frame_e[] = {t, n2, n1};
- StackFrame frame_ef[] = {t, n2, n1, f};
-
- AssertBacktraceContainsOnlyThreadName();
-
- AllocationContextTracker::SetCaptureMode(
- AllocationContextTracker::CaptureMode::MIXED_STACK);
-
- TRACE_EVENT_BEGIN0("Testing", kCupcake);
- AssertBacktraceEquals(frame_c);
-
- {
- TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER e1(pc1);
- AssertBacktraceEquals(frame_cd);
- }
-
- AssertBacktraceEquals(frame_c);
- TRACE_EVENT_END0("Testing", kCupcake);
- AssertBacktraceContainsOnlyThreadName();
-
- {
- TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER e1(pc2);
- TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER e2(pc1);
- AssertBacktraceEquals(frame_e);
-
- TRACE_EVENT0("Testing", kFroyo);
- AssertBacktraceEquals(frame_ef);
- }
-
- AssertBacktraceContainsOnlyThreadName();
- AllocationContextTracker::SetCaptureMode(
- AllocationContextTracker::CaptureMode::DISABLED);
-}
-
-TEST_F(AllocationContextTrackerTest, BacktraceTakesTop) {
- StackFrame t = StackFrame::FromThreadName(kThreadName);
- StackFrame c = StackFrame::FromTraceEventName(kCupcake);
- StackFrame f = StackFrame::FromTraceEventName(kFroyo);
-
- // Push 11 events onto the pseudo stack.
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kCupcake);
-
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kCupcake);
-
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kDonut);
- TRACE_EVENT0("Testing", kEclair);
- TRACE_EVENT0("Testing", kFroyo);
-
- {
- TRACE_EVENT0("Testing", kGingerbread);
- AllocationContext ctx;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx));
-
- // The pseudo stack relies on pointer equality, not deep string comparisons.
- ASSERT_EQ(t, ctx.backtrace.frames[0]);
- ASSERT_EQ(c, ctx.backtrace.frames[1]);
- ASSERT_EQ(f, ctx.backtrace.frames[11]);
- }
-
- {
- AllocationContext ctx;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx));
- ASSERT_EQ(t, ctx.backtrace.frames[0]);
- ASSERT_EQ(c, ctx.backtrace.frames[1]);
- ASSERT_EQ(f, ctx.backtrace.frames[11]);
- }
-}
-
-TEST_F(AllocationContextTrackerTest, TrackCategoryName) {
- const char kContext1[] = "context1";
- const char kContext2[] = "context2";
- {
- // The context from the scoped task event should be used as type name.
- TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION event1(kContext1);
- AllocationContext ctx1;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx1));
- ASSERT_EQ(kContext1, ctx1.type_name);
-
- // In case of nested events, the last event's context should be used.
- TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION event2(kContext2);
- AllocationContext ctx2;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx2));
- ASSERT_EQ(kContext2, ctx2.type_name);
- }
-
- // Type should be nullptr without task event.
- AllocationContext ctx;
- ASSERT_TRUE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx));
- ASSERT_FALSE(ctx.type_name);
-}
-
-TEST_F(AllocationContextTrackerTest, IgnoreAllocationTest) {
- TRACE_EVENT0("Testing", kCupcake);
- TRACE_EVENT0("Testing", kDonut);
- HEAP_PROFILER_SCOPED_IGNORE;
- AllocationContext ctx;
- ASSERT_FALSE(AllocationContextTracker::GetInstanceForCurrentThread()
- ->GetContextSnapshot(&ctx));
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/heap_profiler_heap_dump_writer_unittest.cc b/base/trace_event/heap_profiler_heap_dump_writer_unittest.cc
deleted file mode 100644
index 93e8fee..0000000
--- a/base/trace_event/heap_profiler_heap_dump_writer_unittest.cc
+++ /dev/null
@@ -1,330 +0,0 @@
-// Copyright 2015 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 "base/trace_event/heap_profiler_heap_dump_writer.h"
-
-#include <stddef.h>
-
-#include <memory>
-#include <set>
-#include <string>
-
-#include "base/json/json_reader.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-#include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
-#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-using base::trace_event::StackFrame;
-
-// Define all strings once, because the deduplicator requires pointer equality,
-// and string interning is unreliable.
-StackFrame kBrowserMain = StackFrame::FromTraceEventName("BrowserMain");
-StackFrame kRendererMain = StackFrame::FromTraceEventName("RendererMain");
-StackFrame kCreateWidget = StackFrame::FromTraceEventName("CreateWidget");
-StackFrame kInitialize = StackFrame::FromTraceEventName("Initialize");
-StackFrame kGetBitmap = StackFrame::FromTraceEventName("GetBitmap");
-
-const char kInt[] = "int";
-const char kBool[] = "bool";
-const char kString[] = "string";
-
-} // namespace
-
-namespace base {
-namespace trace_event {
-namespace internal {
-
-std::unique_ptr<const Value> WriteAndReadBack(const std::set<Entry>& entries) {
- std::unique_ptr<TracedValue> traced_value = Serialize(entries);
- std::string json;
- traced_value->AppendAsTraceFormat(&json);
- return JSONReader::Read(json);
-}
-
-std::unique_ptr<const DictionaryValue> WriteAndReadBackEntry(Entry entry) {
- std::set<Entry> input_entries;
- input_entries.insert(entry);
-
- std::unique_ptr<const Value> json_dict = WriteAndReadBack(input_entries);
-
- // Note: Ideally these should use |ASSERT_TRUE| instead of |EXPECT_TRUE|, but
- // |ASSERT_TRUE| can only be used in void functions.
- const DictionaryValue* dictionary;
- EXPECT_TRUE(json_dict->GetAsDictionary(&dictionary));
-
- const ListValue* json_entries;
- EXPECT_TRUE(dictionary->GetList("entries", &json_entries));
-
- const DictionaryValue* json_entry;
- EXPECT_TRUE(json_entries->GetDictionary(0, &json_entry));
-
- return json_entry->CreateDeepCopy();
-}
-
-// Given a desired stack frame ID and type ID, looks up the entry in the set and
-// asserts that it is present and has the expected size and count.
-void AssertSizeAndCountEq(const std::set<Entry>& entries,
- int stack_frame_id,
- int type_id,
- const AllocationMetrics& expected) {
- // The comparison operator for |Entry| does not take size into account, so by
- // setting only stack frame ID and type ID, the real entry can be found.
- Entry entry;
- entry.stack_frame_id = stack_frame_id;
- entry.type_id = type_id;
- auto it = entries.find(entry);
-
- ASSERT_NE(entries.end(), it) << "No entry found for sf = " << stack_frame_id
- << ", type = " << type_id << ".";
- ASSERT_EQ(expected.size, it->size) << "Wrong size for sf = " << stack_frame_id
- << ", type = " << type_id << ".";
- ASSERT_EQ(expected.count, it->count)
- << "Wrong count for sf = " << stack_frame_id << ", type = " << type_id
- << ".";
-}
-
-// Given a desired stack frame ID and type ID, asserts that no entry was dumped
-// for that that particular combination of stack frame and type.
-void AssertNotDumped(const std::set<Entry>& entries,
- int stack_frame_id,
- int type_id) {
- // The comparison operator for |Entry| does not take size into account, so by
- // setting only stack frame ID and type ID, the real entry can be found.
- Entry entry;
- entry.stack_frame_id = stack_frame_id;
- entry.type_id = type_id;
- auto it = entries.find(entry);
- ASSERT_EQ(entries.end(), it)
- << "Entry should not be present for sf = " << stack_frame_id
- << ", type = " << type_id << ".";
-}
-
-TEST(HeapDumpWriterTest, BacktraceIndex) {
- Entry entry;
- entry.stack_frame_id = -1; // -1 means empty backtrace.
- entry.type_id = 0;
- entry.size = 1;
- entry.count = 1;
-
- std::unique_ptr<const DictionaryValue> json_entry =
- WriteAndReadBackEntry(entry);
-
- // For an empty backtrace, the "bt" key cannot reference a stack frame.
- // Instead it should be set to the empty string.
- std::string backtrace_index;
- ASSERT_TRUE(json_entry->GetString("bt", &backtrace_index));
- ASSERT_EQ("", backtrace_index);
-
- // Also verify that a non-negative backtrace index is dumped properly.
- entry.stack_frame_id = 2;
- json_entry = WriteAndReadBackEntry(entry);
- ASSERT_TRUE(json_entry->GetString("bt", &backtrace_index));
- ASSERT_EQ("2", backtrace_index);
-}
-
-TEST(HeapDumpWriterTest, TypeId) {
- Entry entry;
- entry.type_id = -1; // -1 means sum over all types.
- entry.stack_frame_id = 0;
- entry.size = 1;
- entry.count = 1;
-
- std::unique_ptr<const DictionaryValue> json_entry =
- WriteAndReadBackEntry(entry);
-
- // Entries for the cumulative size of all types should not have the "type"
- // key set.
- ASSERT_FALSE(json_entry->HasKey("type"));
-
- // Also verify that a non-negative type ID is dumped properly.
- entry.type_id = 2;
- json_entry = WriteAndReadBackEntry(entry);
- std::string type_id;
- ASSERT_TRUE(json_entry->GetString("type", &type_id));
- ASSERT_EQ("2", type_id);
-}
-
-TEST(HeapDumpWriterTest, SizeAndCountAreHexadecimal) {
- // Take a number between 2^63 and 2^64 (or between 2^31 and 2^32 if |size_t|
- // is not 64 bits).
- const size_t large_value =
- sizeof(size_t) == 8 ? 0xffffffffffffffc5 : 0xffffff9d;
- const char* large_value_str =
- sizeof(size_t) == 8 ? "ffffffffffffffc5" : "ffffff9d";
- Entry entry;
- entry.type_id = 0;
- entry.stack_frame_id = 0;
- entry.size = large_value;
- entry.count = large_value;
-
- std::unique_ptr<const DictionaryValue> json_entry =
- WriteAndReadBackEntry(entry);
-
- std::string size;
- ASSERT_TRUE(json_entry->GetString("size", &size));
- ASSERT_EQ(large_value_str, size);
-
- std::string count;
- ASSERT_TRUE(json_entry->GetString("count", &count));
- ASSERT_EQ(large_value_str, count);
-}
-
-TEST(HeapDumpWriterTest, BacktraceTypeNameTable) {
- std::unordered_map<AllocationContext, AllocationMetrics> metrics_by_context;
-
- AllocationContext ctx;
- ctx.backtrace.frames[0] = kBrowserMain;
- ctx.backtrace.frames[1] = kCreateWidget;
- ctx.backtrace.frame_count = 2;
- ctx.type_name = kInt;
-
- // 10 bytes with context { type: int, bt: [BrowserMain, CreateWidget] }.
- metrics_by_context[ctx] = {10, 5};
-
- ctx.type_name = kBool;
-
- // 18 bytes with context { type: bool, bt: [BrowserMain, CreateWidget] }.
- metrics_by_context[ctx] = {18, 18};
-
- ctx.backtrace.frames[0] = kRendererMain;
- ctx.backtrace.frames[1] = kInitialize;
- ctx.backtrace.frame_count = 2;
-
- // 30 bytes with context { type: bool, bt: [RendererMain, Initialize] }.
- metrics_by_context[ctx] = {30, 30};
-
- ctx.type_name = kString;
-
- // 19 bytes with context { type: string, bt: [RendererMain, Initialize] }.
- metrics_by_context[ctx] = {19, 4};
-
- // At this point the heap looks like this:
- //
- // | | CrWidget <- BrMain | Init <- RenMain | Sum |
- // +--------+--------------------+-----------------+-------------+
- // | | size count | size count | size count |
- // | int | 10 5 | 0 0 | 10 5 |
- // | bool | 18 18 | 30 30 | 48 48 |
- // | string | 0 0 | 19 4 | 19 4 |
- // +--------+--------------------+-----------------+-------------+
- // | Sum | 28 23 | 49 34 | 77 57 |
-
- auto stack_frame_deduplicator = WrapUnique(new StackFrameDeduplicator);
- auto type_name_deduplicator = WrapUnique(new TypeNameDeduplicator);
- HeapDumpWriter writer(stack_frame_deduplicator.get(),
- type_name_deduplicator.get(), 10u);
- const std::set<Entry>& dump = writer.Summarize(metrics_by_context);
-
- // Get the indices of the backtraces and types by adding them again to the
- // deduplicator. Because they were added before, the same number is returned.
- StackFrame bt0[] = {kRendererMain, kInitialize};
- StackFrame bt1[] = {kBrowserMain, kCreateWidget};
- int bt_renderer_main = stack_frame_deduplicator->Insert(bt0, bt0 + 1);
- int bt_browser_main = stack_frame_deduplicator->Insert(bt1, bt1 + 1);
- int bt_renderer_main_initialize =
- stack_frame_deduplicator->Insert(bt0, bt0 + 2);
- int bt_browser_main_create_widget =
- stack_frame_deduplicator->Insert(bt1, bt1 + 2);
- int type_id_int = type_name_deduplicator->Insert(kInt);
- int type_id_bool = type_name_deduplicator->Insert(kBool);
- int type_id_string = type_name_deduplicator->Insert(kString);
-
- // Full heap should have size 77.
- AssertSizeAndCountEq(dump, -1, -1, {77, 57});
-
- // 49 bytes in 34 chunks were allocated in RendererMain and children. Also
- // check the type breakdown.
- AssertSizeAndCountEq(dump, bt_renderer_main, -1, {49, 34});
- AssertSizeAndCountEq(dump, bt_renderer_main, type_id_bool, {30, 30});
- AssertSizeAndCountEq(dump, bt_renderer_main, type_id_string, {19, 4});
-
- // 28 bytes in 23 chunks were allocated in BrowserMain and children. Also
- // check the type breakdown.
- AssertSizeAndCountEq(dump, bt_browser_main, -1, {28, 23});
- AssertSizeAndCountEq(dump, bt_browser_main, type_id_int, {10, 5});
- AssertSizeAndCountEq(dump, bt_browser_main, type_id_bool, {18, 18});
-
- // In this test all bytes are allocated in leaf nodes, so check again one
- // level deeper.
- AssertSizeAndCountEq(dump, bt_renderer_main_initialize, -1, {49, 34});
- AssertSizeAndCountEq(dump, bt_renderer_main_initialize, type_id_bool,
- {30, 30});
- AssertSizeAndCountEq(dump, bt_renderer_main_initialize, type_id_string,
- {19, 4});
- AssertSizeAndCountEq(dump, bt_browser_main_create_widget, -1, {28, 23});
- AssertSizeAndCountEq(dump, bt_browser_main_create_widget, type_id_int,
- {10, 5});
- AssertSizeAndCountEq(dump, bt_browser_main_create_widget, type_id_bool,
- {18, 18});
-
- // The type breakdown of the entrie heap should have been dumped as well.
- AssertSizeAndCountEq(dump, -1, type_id_int, {10, 5});
- AssertSizeAndCountEq(dump, -1, type_id_bool, {48, 48});
- AssertSizeAndCountEq(dump, -1, type_id_string, {19, 4});
-}
-
-TEST(HeapDumpWriterTest, InsignificantValuesNotDumped) {
- std::unordered_map<AllocationContext, AllocationMetrics> metrics_by_context;
-
- AllocationContext ctx;
- ctx.backtrace.frames[0] = kBrowserMain;
- ctx.backtrace.frames[1] = kCreateWidget;
- ctx.backtrace.frame_count = 2;
-
- // 0.5 KiB and 1 chunk in BrowserMain -> CreateWidget itself.
- metrics_by_context[ctx] = {512, 1};
-
- // 1 MiB and 1 chunk in BrowserMain -> CreateWidget -> GetBitmap.
- ctx.backtrace.frames[2] = kGetBitmap;
- ctx.backtrace.frame_count = 3;
- metrics_by_context[ctx] = {1024 * 1024, 1};
-
- // 400B and 1 chunk in BrowserMain -> CreateWidget -> Initialize.
- ctx.backtrace.frames[2] = kInitialize;
- ctx.backtrace.frame_count = 3;
- metrics_by_context[ctx] = {400, 1};
-
- auto stack_frame_deduplicator = WrapUnique(new StackFrameDeduplicator);
- auto type_name_deduplicator = WrapUnique(new TypeNameDeduplicator);
- HeapDumpWriter writer(stack_frame_deduplicator.get(),
- type_name_deduplicator.get(), 512u);
- const std::set<Entry>& dump = writer.Summarize(metrics_by_context);
-
- // Get the indices of the backtraces and types by adding them again to the
- // deduplicator. Because they were added before, the same number is returned.
- StackFrame bt0[] = {kBrowserMain, kCreateWidget, kGetBitmap};
- StackFrame bt1[] = {kBrowserMain, kCreateWidget, kInitialize};
- int bt_browser_main = stack_frame_deduplicator->Insert(bt0, bt0 + 1);
- int bt_create_widget = stack_frame_deduplicator->Insert(bt0, bt0 + 2);
- int bt_get_bitmap = stack_frame_deduplicator->Insert(bt0, bt0 + 3);
- int bt_initialize = stack_frame_deduplicator->Insert(bt1, bt1 + 3);
-
- // Full heap should have size of 1 MiB + .9 KiB and 3 chunks.
- AssertSizeAndCountEq(dump, -1, -1 /* No type specified */,
- {1024 * 1024 + 512 + 400, 3});
-
- // |GetBitmap| allocated 1 MiB and 1 chunk.
- AssertSizeAndCountEq(dump, bt_get_bitmap, -1, {1024 * 1024, 1});
-
- // Because |GetBitmap| was dumped, all of its parent nodes should have been
- // dumped too. |CreateWidget| has 1 MiB in |GetBitmap|, 400 bytes in
- // |Initialize|, and 512 bytes of its own and each in 1 chunk.
- AssertSizeAndCountEq(dump, bt_create_widget, -1,
- {1024 * 1024 + 400 + 512, 3});
- AssertSizeAndCountEq(dump, bt_browser_main, -1, {1024 * 1024 + 400 + 512, 3});
-
- // Initialize was not significant, it should not have been dumped.
- AssertNotDumped(dump, bt_initialize, -1);
-}
-
-} // namespace internal
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/heap_profiler_stack_frame_deduplicator_unittest.cc b/base/trace_event/heap_profiler_stack_frame_deduplicator_unittest.cc
deleted file mode 100644
index 194c7aa..0000000
--- a/base/trace_event/heap_profiler_stack_frame_deduplicator_unittest.cc
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright 2015 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 "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
-
-#include <iterator>
-#include <memory>
-
-#include "base/macros.h"
-#include "base/trace_event/heap_profiler_allocation_context.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-// Define all strings once, because the deduplicator requires pointer equality,
-// and string interning is unreliable.
-StackFrame kBrowserMain = StackFrame::FromTraceEventName("BrowserMain");
-StackFrame kRendererMain = StackFrame::FromTraceEventName("RendererMain");
-StackFrame kCreateWidget = StackFrame::FromTraceEventName("CreateWidget");
-StackFrame kInitialize = StackFrame::FromTraceEventName("Initialize");
-StackFrame kMalloc = StackFrame::FromTraceEventName("malloc");
-
-TEST(StackFrameDeduplicatorTest, SingleBacktrace) {
- StackFrame bt[] = {kBrowserMain, kCreateWidget, kMalloc};
-
- // The call tree should look like this (index in brackets).
- //
- // BrowserMain [0]
- // CreateWidget [1]
- // malloc [2]
-
- std::unique_ptr<StackFrameDeduplicator> dedup(new StackFrameDeduplicator);
- ASSERT_EQ(2, dedup->Insert(std::begin(bt), std::end(bt)));
-
- auto iter = dedup->begin();
- ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
- ASSERT_EQ(-1, (iter + 0)->parent_frame_index);
-
- ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
- ASSERT_EQ(0, (iter + 1)->parent_frame_index);
-
- ASSERT_EQ(kMalloc, (iter + 2)->frame);
- ASSERT_EQ(1, (iter + 2)->parent_frame_index);
-
- ASSERT_TRUE(iter + 3 == dedup->end());
-}
-
-TEST(StackFrameDeduplicatorTest, SingleBacktraceWithNull) {
- StackFrame null_frame = StackFrame::FromTraceEventName(nullptr);
- StackFrame bt[] = {kBrowserMain, null_frame, kMalloc};
-
- // Deduplicator doesn't care about what's inside StackFrames,
- // and handles nullptr StackFrame values as any other.
- //
- // So the call tree should look like this (index in brackets).
- //
- // BrowserMain [0]
- // (null) [1]
- // malloc [2]
-
- std::unique_ptr<StackFrameDeduplicator> dedup(new StackFrameDeduplicator);
- ASSERT_EQ(2, dedup->Insert(std::begin(bt), std::end(bt)));
-
- auto iter = dedup->begin();
- ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
- ASSERT_EQ(-1, (iter + 0)->parent_frame_index);
-
- ASSERT_EQ(null_frame, (iter + 1)->frame);
- ASSERT_EQ(0, (iter + 1)->parent_frame_index);
-
- ASSERT_EQ(kMalloc, (iter + 2)->frame);
- ASSERT_EQ(1, (iter + 2)->parent_frame_index);
-
- ASSERT_TRUE(iter + 3 == dedup->end());
-}
-
-// Test that there can be different call trees (there can be multiple bottom
-// frames). Also verify that frames with the same name but a different caller
-// are represented as distinct nodes.
-TEST(StackFrameDeduplicatorTest, MultipleRoots) {
- StackFrame bt0[] = {kBrowserMain, kCreateWidget};
- StackFrame bt1[] = {kRendererMain, kCreateWidget};
-
- // The call tree should look like this (index in brackets).
- //
- // BrowserMain [0]
- // CreateWidget [1]
- // RendererMain [2]
- // CreateWidget [3]
- //
- // Note that there will be two instances of CreateWidget,
- // with different parents.
-
- std::unique_ptr<StackFrameDeduplicator> dedup(new StackFrameDeduplicator);
- ASSERT_EQ(1, dedup->Insert(std::begin(bt0), std::end(bt0)));
- ASSERT_EQ(3, dedup->Insert(std::begin(bt1), std::end(bt1)));
-
- auto iter = dedup->begin();
- ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
- ASSERT_EQ(-1, (iter + 0)->parent_frame_index);
-
- ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
- ASSERT_EQ(0, (iter + 1)->parent_frame_index);
-
- ASSERT_EQ(kRendererMain, (iter + 2)->frame);
- ASSERT_EQ(-1, (iter + 2)->parent_frame_index);
-
- ASSERT_EQ(kCreateWidget, (iter + 3)->frame);
- ASSERT_EQ(2, (iter + 3)->parent_frame_index);
-
- ASSERT_TRUE(iter + 4 == dedup->end());
-}
-
-TEST(StackFrameDeduplicatorTest, Deduplication) {
- StackFrame bt0[] = {kBrowserMain, kCreateWidget};
- StackFrame bt1[] = {kBrowserMain, kInitialize};
-
- // The call tree should look like this (index in brackets).
- //
- // BrowserMain [0]
- // CreateWidget [1]
- // Initialize [2]
- //
- // Note that BrowserMain will be re-used.
-
- std::unique_ptr<StackFrameDeduplicator> dedup(new StackFrameDeduplicator);
- ASSERT_EQ(1, dedup->Insert(std::begin(bt0), std::end(bt0)));
- ASSERT_EQ(2, dedup->Insert(std::begin(bt1), std::end(bt1)));
-
- auto iter = dedup->begin();
- ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
- ASSERT_EQ(-1, (iter + 0)->parent_frame_index);
-
- ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
- ASSERT_EQ(0, (iter + 1)->parent_frame_index);
-
- ASSERT_EQ(kInitialize, (iter + 2)->frame);
- ASSERT_EQ(0, (iter + 2)->parent_frame_index);
-
- ASSERT_TRUE(iter + 3 == dedup->end());
-
- // Inserting the same backtrace again should return the index of the existing
- // node.
- ASSERT_EQ(1, dedup->Insert(std::begin(bt0), std::end(bt0)));
- ASSERT_EQ(2, dedup->Insert(std::begin(bt1), std::end(bt1)));
- ASSERT_TRUE(dedup->begin() + 3 == dedup->end());
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/heap_profiler_type_name_deduplicator_unittest.cc b/base/trace_event/heap_profiler_type_name_deduplicator_unittest.cc
deleted file mode 100644
index f97808b..0000000
--- a/base/trace_event/heap_profiler_type_name_deduplicator_unittest.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2015 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 <memory>
-#include <string>
-
-#include "base/json/json_reader.h"
-#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// Define all strings once, because the deduplicator requires pointer equality,
-// and string interning is unreliable.
-const char kInt[] = "int";
-const char kBool[] = "bool";
-const char kString[] = "string";
-const char kNeedsEscape[] = "\"quotes\"";
-
-std::unique_ptr<Value> DumpAndReadBack(
- const TypeNameDeduplicator& deduplicator) {
- std::string json;
- deduplicator.AppendAsTraceFormat(&json);
- return JSONReader::Read(json);
-}
-
-// Inserts a single type name into a new TypeNameDeduplicator instance and
-// checks if the value gets inserted and the exported value for |type_name| is
-// the same as |expected_value|.
-void TestInsertTypeAndReadback(const char* type_name,
- const char* expected_value) {
- std::unique_ptr<TypeNameDeduplicator> dedup(new TypeNameDeduplicator);
- ASSERT_EQ(1, dedup->Insert(type_name));
-
- std::unique_ptr<Value> type_names = DumpAndReadBack(*dedup);
- ASSERT_NE(nullptr, type_names);
-
- const DictionaryValue* dictionary;
- ASSERT_TRUE(type_names->GetAsDictionary(&dictionary));
-
- // When the type name was inserted, it got ID 1. The exported key "1"
- // should be equal to |expected_value|.
- std::string value;
- ASSERT_TRUE(dictionary->GetString("1", &value));
- ASSERT_EQ(expected_value, value);
-}
-
-} // namespace
-
-TEST(TypeNameDeduplicatorTest, Deduplication) {
- // The type IDs should be like this:
- // 0: [unknown]
- // 1: int
- // 2: bool
- // 3: string
-
- std::unique_ptr<TypeNameDeduplicator> dedup(new TypeNameDeduplicator);
- ASSERT_EQ(1, dedup->Insert(kInt));
- ASSERT_EQ(2, dedup->Insert(kBool));
- ASSERT_EQ(3, dedup->Insert(kString));
-
- // Inserting again should return the same IDs.
- ASSERT_EQ(2, dedup->Insert(kBool));
- ASSERT_EQ(1, dedup->Insert(kInt));
- ASSERT_EQ(3, dedup->Insert(kString));
-
- // A null pointer should yield type ID 0.
- ASSERT_EQ(0, dedup->Insert(nullptr));
-}
-
-TEST(TypeNameDeduplicatorTest, EscapeTypeName) {
- // Reading json should not fail, because the type name should have been
- // escaped properly and exported value should contain quotes.
- TestInsertTypeAndReadback(kNeedsEscape, kNeedsEscape);
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/java_heap_dump_provider_android_unittest.cc b/base/trace_event/java_heap_dump_provider_android_unittest.cc
deleted file mode 100644
index 9b9eb17..0000000
--- a/base/trace_event/java_heap_dump_provider_android_unittest.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2015 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 "base/trace_event/java_heap_dump_provider_android.h"
-
-#include "base/trace_event/process_memory_dump.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-TEST(JavaHeapDumpProviderTest, JavaHeapDump) {
- auto* jhdp = JavaHeapDumpProvider::GetInstance();
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
- std::unique_ptr<ProcessMemoryDump> pmd(
- new ProcessMemoryDump(nullptr, dump_args));
-
- jhdp->OnMemoryDump(dump_args, pmd.get());
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/memory_allocator_dump_unittest.cc b/base/trace_event/memory_allocator_dump_unittest.cc
deleted file mode 100644
index 3818629..0000000
--- a/base/trace_event/memory_allocator_dump_unittest.cc
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright 2015 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 "base/trace_event/memory_allocator_dump.h"
-
-#include <stdint.h>
-
-#include "base/format_macros.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/heap_profiler_serialization_state.h"
-#include "base/trace_event/memory_allocator_dump_guid.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/values.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::ElementsAre;
-using testing::Eq;
-using testing::ByRef;
-using testing::IsEmpty;
-using testing::Contains;
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-class FakeMemoryAllocatorDumpProvider : public MemoryDumpProvider {
- public:
- bool OnMemoryDump(const MemoryDumpArgs& args,
- ProcessMemoryDump* pmd) override {
- MemoryAllocatorDump* root_heap =
- pmd->CreateAllocatorDump("foobar_allocator");
-
- root_heap->AddScalar(MemoryAllocatorDump::kNameSize,
- MemoryAllocatorDump::kUnitsBytes, 4096);
- root_heap->AddScalar(MemoryAllocatorDump::kNameObjectCount,
- MemoryAllocatorDump::kUnitsObjects, 42);
- root_heap->AddScalar("attr1", "units1", 1234);
- root_heap->AddString("attr2", "units2", "string_value");
-
- MemoryAllocatorDump* sub_heap =
- pmd->CreateAllocatorDump("foobar_allocator/sub_heap");
- sub_heap->AddScalar(MemoryAllocatorDump::kNameSize,
- MemoryAllocatorDump::kUnitsBytes, 1);
- sub_heap->AddScalar(MemoryAllocatorDump::kNameObjectCount,
- MemoryAllocatorDump::kUnitsObjects, 3);
-
- pmd->CreateAllocatorDump("foobar_allocator/sub_heap/empty");
- // Leave the rest of sub heap deliberately uninitialized, to check that
- // CreateAllocatorDump returns a properly zero-initialized object.
-
- return true;
- }
-};
-
-void CheckString(const MemoryAllocatorDump* dump,
- const std::string& name,
- const char* expected_units,
- const std::string& expected_value) {
- MemoryAllocatorDump::Entry expected(name, expected_units, expected_value);
- EXPECT_THAT(dump->entries(), Contains(Eq(ByRef(expected))));
-}
-
-void CheckScalar(const MemoryAllocatorDump* dump,
- const std::string& name,
- const char* expected_units,
- uint64_t expected_value) {
- MemoryAllocatorDump::Entry expected(name, expected_units, expected_value);
- EXPECT_THAT(dump->entries(), Contains(Eq(ByRef(expected))));
-}
-
-} // namespace
-
-TEST(MemoryAllocatorDumpTest, GuidGeneration) {
- std::unique_ptr<MemoryAllocatorDump> mad(new MemoryAllocatorDump(
- "foo", MemoryDumpLevelOfDetail::FIRST, MemoryAllocatorDumpGuid(0x42u)));
- ASSERT_EQ("42", mad->guid().ToString());
-}
-
-TEST(MemoryAllocatorDumpTest, DumpIntoProcessMemoryDump) {
- FakeMemoryAllocatorDumpProvider fmadp;
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
- ProcessMemoryDump pmd(new HeapProfilerSerializationState, dump_args);
-
- fmadp.OnMemoryDump(dump_args, &pmd);
-
- ASSERT_EQ(3u, pmd.allocator_dumps().size());
-
- const MemoryAllocatorDump* root_heap =
- pmd.GetAllocatorDump("foobar_allocator");
- ASSERT_NE(nullptr, root_heap);
- EXPECT_EQ("foobar_allocator", root_heap->absolute_name());
- CheckScalar(root_heap, MemoryAllocatorDump::kNameSize,
- MemoryAllocatorDump::kUnitsBytes, 4096);
- CheckScalar(root_heap, MemoryAllocatorDump::kNameObjectCount,
- MemoryAllocatorDump::kUnitsObjects, 42);
- CheckScalar(root_heap, "attr1", "units1", 1234);
- CheckString(root_heap, "attr2", "units2", "string_value");
-
- const MemoryAllocatorDump* sub_heap =
- pmd.GetAllocatorDump("foobar_allocator/sub_heap");
- ASSERT_NE(nullptr, sub_heap);
- EXPECT_EQ("foobar_allocator/sub_heap", sub_heap->absolute_name());
- CheckScalar(sub_heap, MemoryAllocatorDump::kNameSize,
- MemoryAllocatorDump::kUnitsBytes, 1);
- CheckScalar(sub_heap, MemoryAllocatorDump::kNameObjectCount,
- MemoryAllocatorDump::kUnitsObjects, 3);
- const MemoryAllocatorDump* empty_sub_heap =
- pmd.GetAllocatorDump("foobar_allocator/sub_heap/empty");
- ASSERT_NE(nullptr, empty_sub_heap);
- EXPECT_EQ("foobar_allocator/sub_heap/empty", empty_sub_heap->absolute_name());
-
- EXPECT_THAT(empty_sub_heap->entries(), IsEmpty());
-
- // Check that calling serialization routines doesn't cause a crash.
- std::unique_ptr<TracedValue> traced_value(new TracedValue);
- pmd.SerializeAllocatorDumpsInto(traced_value.get());
- pmd.SerializeHeapProfilerDumpsInto(traced_value.get());
-}
-
-TEST(MemoryAllocatorDumpTest, GetSize) {
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
- ProcessMemoryDump pmd(new HeapProfilerSerializationState, dump_args);
- MemoryAllocatorDump* dump = pmd.CreateAllocatorDump("allocator_for_size");
- dump->AddScalar(MemoryAllocatorDump::kNameSize,
- MemoryAllocatorDump::kUnitsBytes, 1);
- dump->AddScalar("foo", MemoryAllocatorDump::kUnitsBytes, 2);
- EXPECT_EQ(1u, dump->GetSizeInternal());
-}
-
-TEST(MemoryAllocatorDumpTest, ReadValues) {
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
- ProcessMemoryDump pmd(new HeapProfilerSerializationState, dump_args);
- MemoryAllocatorDump* dump = pmd.CreateAllocatorDump("allocator_for_size");
- dump->AddScalar("one", "byte", 1);
- dump->AddString("one", "object", "one");
-
- MemoryAllocatorDump::Entry expected_scalar("one", "byte", 1);
- MemoryAllocatorDump::Entry expected_string("one", "object", "one");
- EXPECT_THAT(dump->entries(), ElementsAre(Eq(ByRef(expected_scalar)),
- Eq(ByRef(expected_string))));
-}
-
-TEST(MemoryAllocatorDumpTest, MovingAnEntry) {
- MemoryAllocatorDump::Entry expected_entry("one", "byte", 1);
- MemoryAllocatorDump::Entry from_entry("one", "byte", 1);
- MemoryAllocatorDump::Entry to_entry = std::move(from_entry);
- EXPECT_EQ(expected_entry, to_entry);
-}
-
-// DEATH tests are not supported in Android/iOS/Fuchsia.
-#if !defined(NDEBUG) && !defined(OS_ANDROID) && !defined(OS_IOS) && \
- !defined(OS_FUCHSIA)
-TEST(MemoryAllocatorDumpTest, ForbidDuplicatesDeathTest) {
- FakeMemoryAllocatorDumpProvider fmadp;
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
- ProcessMemoryDump pmd(new HeapProfilerSerializationState, dump_args);
- pmd.CreateAllocatorDump("foo_allocator");
- pmd.CreateAllocatorDump("bar_allocator/heap");
- ASSERT_DEATH(pmd.CreateAllocatorDump("foo_allocator"), "");
- ASSERT_DEATH(pmd.CreateAllocatorDump("bar_allocator/heap"), "");
- ASSERT_DEATH(pmd.CreateAllocatorDump(""), "");
-}
-
-TEST(MemoryAllocatorDumpTest, ForbidStringsInBackgroundModeDeathTest) {
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::BACKGROUND};
- ProcessMemoryDump pmd(new HeapProfilerSerializationState, dump_args);
- MemoryAllocatorDump* dump = pmd.CreateAllocatorDump("malloc");
- ASSERT_DEATH(dump->AddString("foo", "bar", "baz"), "");
-}
-#endif
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/memory_dump_manager_unittest.cc b/base/trace_event/memory_dump_manager_unittest.cc
deleted file mode 100644
index 8ed5fb3..0000000
--- a/base/trace_event/memory_dump_manager_unittest.cc
+++ /dev/null
@@ -1,884 +0,0 @@
-// Copyright 2015 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 "base/trace_event/memory_dump_manager.h"
-
-#include <stdint.h>
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/base_switches.h"
-#include "base/callback.h"
-#include "base/command_line.h"
-#include "base/debug/thread_heap_usage_tracker.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/test/scoped_task_environment.h"
-#include "base/test/test_io_thread.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/trace_event/memory_dump_manager_test_utils.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/memory_dump_request_args.h"
-#include "base/trace_event/memory_dump_scheduler.h"
-#include "base/trace_event/memory_infra_background_whitelist.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "build_config.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::_;
-using testing::AtMost;
-using testing::Between;
-using testing::Invoke;
-using testing::Return;
-
-namespace base {
-namespace trace_event {
-
-// GTest matchers for MemoryDumpRequestArgs arguments.
-MATCHER(IsDetailedDump, "") {
- return arg.level_of_detail == MemoryDumpLevelOfDetail::DETAILED;
-}
-
-MATCHER(IsLightDump, "") {
- return arg.level_of_detail == MemoryDumpLevelOfDetail::LIGHT;
-}
-
-namespace {
-
-const char* kMDPName = "TestDumpProvider";
-const char* kWhitelistedMDPName = "WhitelistedTestDumpProvider";
-const char* const kTestMDPWhitelist[] = {kWhitelistedMDPName, nullptr};
-
-void RegisterDumpProvider(
- MemoryDumpProvider* mdp,
- scoped_refptr<base::SingleThreadTaskRunner> task_runner,
- const MemoryDumpProvider::Options& options,
- const char* name = kMDPName) {
- MemoryDumpManager* mdm = MemoryDumpManager::GetInstance();
- mdm->set_dumper_registrations_ignored_for_testing(false);
- mdm->RegisterDumpProvider(mdp, name, std::move(task_runner), options);
- mdm->set_dumper_registrations_ignored_for_testing(true);
-}
-
-void RegisterDumpProvider(
- MemoryDumpProvider* mdp,
- scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
- RegisterDumpProvider(mdp, task_runner, MemoryDumpProvider::Options());
-}
-
-void RegisterDumpProviderWithSequencedTaskRunner(
- MemoryDumpProvider* mdp,
- scoped_refptr<base::SequencedTaskRunner> task_runner,
- const MemoryDumpProvider::Options& options) {
- MemoryDumpManager* mdm = MemoryDumpManager::GetInstance();
- mdm->set_dumper_registrations_ignored_for_testing(false);
- mdm->RegisterDumpProviderWithSequencedTaskRunner(mdp, kMDPName, task_runner,
- options);
- mdm->set_dumper_registrations_ignored_for_testing(true);
-}
-
-// Posts |task| to |task_runner| and blocks until it is executed.
-void PostTaskAndWait(const Location& from_here,
- SequencedTaskRunner* task_runner,
- base::OnceClosure task) {
- base::WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- task_runner->PostTask(from_here, std::move(task));
- task_runner->PostTask(FROM_HERE, base::BindOnce(&WaitableEvent::Signal,
- base::Unretained(&event)));
- // The SequencedTaskRunner guarantees that |event| will only be signaled after
- // |task| is executed.
- event.Wait();
-}
-
-class MockMemoryDumpProvider : public MemoryDumpProvider {
- public:
- MOCK_METHOD0(Destructor, void());
- MOCK_METHOD2(OnMemoryDump,
- bool(const MemoryDumpArgs& args, ProcessMemoryDump* pmd));
- MOCK_METHOD1(OnHeapProfilingEnabled, void(bool enabled));
- MOCK_METHOD1(PollFastMemoryTotal, void(uint64_t* memory_total));
- MOCK_METHOD0(SuspendFastMemoryPolling, void());
-
- MockMemoryDumpProvider() : enable_mock_destructor(false) {
- ON_CALL(*this, OnMemoryDump(_, _))
- .WillByDefault(
- Invoke([](const MemoryDumpArgs&, ProcessMemoryDump* pmd) -> bool {
- return true;
- }));
-
- ON_CALL(*this, PollFastMemoryTotal(_))
- .WillByDefault(
- Invoke([](uint64_t* memory_total) -> void { NOTREACHED(); }));
- }
- ~MockMemoryDumpProvider() override {
- if (enable_mock_destructor)
- Destructor();
- }
-
- bool enable_mock_destructor;
-};
-
-class TestSequencedTaskRunner : public SequencedTaskRunner {
- public:
- TestSequencedTaskRunner() = default;
-
- void set_enabled(bool value) { enabled_ = value; }
- unsigned no_of_post_tasks() const { return num_of_post_tasks_; }
-
- bool PostNonNestableDelayedTask(const Location& from_here,
- OnceClosure task,
- TimeDelta delay) override {
- NOTREACHED();
- return false;
- }
-
- bool PostDelayedTask(const Location& from_here,
- OnceClosure task,
- TimeDelta delay) override {
- num_of_post_tasks_++;
- if (enabled_) {
- return task_runner_->PostDelayedTask(from_here, std::move(task), delay);
- }
- return false;
- }
-
- bool RunsTasksInCurrentSequence() const override {
- return task_runner_->RunsTasksInCurrentSequence();
- }
-
- private:
- ~TestSequencedTaskRunner() override = default;
-
- const scoped_refptr<SequencedTaskRunner> task_runner_ =
- CreateSequencedTaskRunnerWithTraits({});
- bool enabled_ = true;
- unsigned num_of_post_tasks_ = 0;
-};
-
-class TestingThreadHeapUsageTracker : public debug::ThreadHeapUsageTracker {
- public:
- using ThreadHeapUsageTracker::DisableHeapTrackingForTesting;
-};
-
-} // namespace
-
-class MemoryDumpManagerTest : public testing::Test {
- public:
- MemoryDumpManagerTest(bool is_coordinator = false)
- : is_coordinator_(is_coordinator) {}
-
- void SetUp() override {
- // Bring up and initialize MemoryDumpManager while single-threaded (before
- // instantiating ScopedTaskEnvironment) to avoid data races if worker
- // threads use tracing globals early.
- mdm_ = MemoryDumpManager::CreateInstanceForTesting();
- ASSERT_EQ(mdm_.get(), MemoryDumpManager::GetInstance());
-
- InitializeMemoryDumpManagerForInProcessTesting(is_coordinator_);
-
- scoped_task_environment_ = std::make_unique<test::ScopedTaskEnvironment>();
- }
-
- void TearDown() override {
- scoped_task_environment_.reset();
-
- // Tear down the MemoryDumpManager while single-threaded to mirror logic in
- // SetUp().
- mdm_.reset();
- TraceLog::ResetForTesting();
- }
-
- protected:
- // Blocks the current thread (spinning a nested message loop) until the
- // memory dump is complete. Returns:
- // - return value: the |success| from the CreateProcessDump() callback.
- bool RequestProcessDumpAndWait(MemoryDumpType dump_type,
- MemoryDumpLevelOfDetail level_of_detail) {
- RunLoop run_loop;
- bool success = false;
- static uint64_t test_guid = 1;
- test_guid++;
- MemoryDumpRequestArgs request_args{test_guid, dump_type, level_of_detail};
-
- // The signature of the callback delivered by MemoryDumpManager is:
- // void ProcessMemoryDumpCallback(
- // uint64_t dump_guid,
- // bool success,
- // std::unique_ptr<ProcessMemoryDump> pmd)
- // The extra arguments prepended to the |callback| below (the ones with the
- // "curried_" prefix) are just passed from the Bind(). This is just to get
- // around the limitation of Bind() in supporting only capture-less lambdas.
- ProcessMemoryDumpCallback callback = Bind(
- [](bool* curried_success, Closure curried_quit_closure,
- uint64_t curried_expected_guid, bool success, uint64_t dump_guid,
- std::unique_ptr<ProcessMemoryDump> pmd) {
- *curried_success = success;
- EXPECT_EQ(curried_expected_guid, dump_guid);
- ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- curried_quit_closure);
- },
- Unretained(&success), run_loop.QuitClosure(), test_guid);
-
- mdm_->CreateProcessDump(request_args, callback);
- run_loop.Run();
- return success;
- }
-
- void EnableForTracing() {
- mdm_->SetupForTracing(TraceConfig::MemoryDumpConfig());
- }
-
- void EnableForTracingWithTraceConfig(const std::string trace_config_string) {
- TraceConfig trace_config(trace_config_string);
- mdm_->SetupForTracing(trace_config.memory_dump_config());
- }
-
- void DisableTracing() { mdm_->TeardownForTracing(); }
-
- int GetMaxConsecutiveFailuresCount() const {
- return MemoryDumpManager::kMaxConsecutiveFailuresCount;
- }
-
- const MemoryDumpProvider::Options kDefaultOptions;
- std::unique_ptr<MemoryDumpManager> mdm_;
-
- private:
- // To tear down the singleton instance after each test.
- ShadowingAtExitManager at_exit_manager_;
-
- std::unique_ptr<test::ScopedTaskEnvironment> scoped_task_environment_;
-
- // Whether the test MemoryDumpManager should be initialized as the
- // coordinator.
- const bool is_coordinator_;
-
- DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerTest);
-};
-
-class MemoryDumpManagerTestAsCoordinator : public MemoryDumpManagerTest {
- public:
- MemoryDumpManagerTestAsCoordinator() : MemoryDumpManagerTest(true) {}
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerTestAsCoordinator);
-};
-
-// Basic sanity checks. Registers a memory dump provider and checks that it is
-// called.
-TEST_F(MemoryDumpManagerTest, SingleDumper) {
- MockMemoryDumpProvider mdp;
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
-
- // Now repeat enabling the memory category and check that the dumper is
- // invoked this time.
- EnableForTracing();
- EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3);
- for (int i = 0; i < 3; ++i) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
- DisableTracing();
-
- mdm_->UnregisterDumpProvider(&mdp);
-
- // Finally check the unregister logic: the global dump handler will be invoked
- // but not the dump provider, as it has been unregistered.
- EnableForTracing();
- EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
- for (int i = 0; i < 3; ++i) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
- DisableTracing();
-}
-
-// Checks that requesting dumps with high level of detail actually propagates
-// the level of the detail properly to OnMemoryDump() call on dump providers.
-TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
- MockMemoryDumpProvider mdp;
-
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
- EnableForTracing();
- EXPECT_CALL(mdp, OnMemoryDump(IsDetailedDump(), _));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
- mdm_->UnregisterDumpProvider(&mdp);
-
- // Check that requesting dumps with low level of detail actually propagates to
- // OnMemoryDump() call on dump providers.
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
- EnableForTracing();
- EXPECT_CALL(mdp, OnMemoryDump(IsLightDump(), _));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::LIGHT));
- DisableTracing();
- mdm_->UnregisterDumpProvider(&mdp);
-}
-
-// Checks that the HeapProfilerSerializationState object is actually
-// shared over time.
-TEST_F(MemoryDumpManagerTest, HeapProfilerSerializationState) {
- MockMemoryDumpProvider mdp1;
- MockMemoryDumpProvider mdp2;
- RegisterDumpProvider(&mdp1, nullptr);
- RegisterDumpProvider(&mdp2, nullptr);
-
- EnableForTracing();
- const HeapProfilerSerializationState* heap_profiler_serialization_state =
- mdm_->heap_profiler_serialization_state_for_testing().get();
- EXPECT_CALL(mdp1, OnMemoryDump(_, _))
- .Times(2)
- .WillRepeatedly(
- Invoke([heap_profiler_serialization_state](
- const MemoryDumpArgs&, ProcessMemoryDump* pmd) -> bool {
- EXPECT_EQ(heap_profiler_serialization_state,
- pmd->heap_profiler_serialization_state().get());
- return true;
- }));
- EXPECT_CALL(mdp2, OnMemoryDump(_, _))
- .Times(2)
- .WillRepeatedly(
- Invoke([heap_profiler_serialization_state](
- const MemoryDumpArgs&, ProcessMemoryDump* pmd) -> bool {
- EXPECT_EQ(heap_profiler_serialization_state,
- pmd->heap_profiler_serialization_state().get());
- return true;
- }));
-
- for (int i = 0; i < 2; ++i) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
-
- DisableTracing();
-}
-
-// Checks that the (Un)RegisterDumpProvider logic behaves sanely.
-TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
- MockMemoryDumpProvider mdp1;
- MockMemoryDumpProvider mdp2;
-
- // Enable only mdp1.
- RegisterDumpProvider(&mdp1, ThreadTaskRunnerHandle::Get());
- EnableForTracing();
- EXPECT_CALL(mdp1, OnMemoryDump(_, _));
- EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0);
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
-
- // Invert: enable mdp2 and disable mdp1.
- mdm_->UnregisterDumpProvider(&mdp1);
- RegisterDumpProvider(&mdp2, nullptr);
- EnableForTracing();
- EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
- EXPECT_CALL(mdp2, OnMemoryDump(_, _));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
-
- // Enable both mdp1 and mdp2.
- RegisterDumpProvider(&mdp1, nullptr);
- EnableForTracing();
- EXPECT_CALL(mdp1, OnMemoryDump(_, _));
- EXPECT_CALL(mdp2, OnMemoryDump(_, _));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
-}
-
-// Checks that the dump provider invocations depend only on the current
-// registration state and not on previous registrations and dumps.
-// Flaky on iOS, see crbug.com/706874
-#if defined(OS_IOS)
-#define MAYBE_RegistrationConsistency DISABLED_RegistrationConsistency
-#else
-#define MAYBE_RegistrationConsistency RegistrationConsistency
-#endif
-TEST_F(MemoryDumpManagerTest, MAYBE_RegistrationConsistency) {
- MockMemoryDumpProvider mdp;
-
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
-
- {
- EXPECT_CALL(mdp, OnMemoryDump(_, _));
- EnableForTracing();
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
- }
-
- mdm_->UnregisterDumpProvider(&mdp);
-
- {
- EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
- EnableForTracing();
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
- }
-
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
- mdm_->UnregisterDumpProvider(&mdp);
-
- {
- EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
- EnableForTracing();
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
- }
-
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
- mdm_->UnregisterDumpProvider(&mdp);
- RegisterDumpProvider(&mdp, ThreadTaskRunnerHandle::Get());
-
- {
- EXPECT_CALL(mdp, OnMemoryDump(_, _));
- EnableForTracing();
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- DisableTracing();
- }
-}
-
-// Checks that the MemoryDumpManager respects the thread affinity when a
-// MemoryDumpProvider specifies a task_runner(). The test starts creating 8
-// threads and registering a MemoryDumpProvider on each of them. At each
-// iteration, one thread is removed, to check the live unregistration logic.
-TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) {
- const uint32_t kNumInitialThreads = 8;
-
- std::vector<std::unique_ptr<Thread>> threads;
- std::vector<std::unique_ptr<MockMemoryDumpProvider>> mdps;
-
- // Create the threads and setup the expectations. Given that at each iteration
- // we will pop out one thread/MemoryDumpProvider, each MDP is supposed to be
- // invoked a number of times equal to its index.
- for (uint32_t i = kNumInitialThreads; i > 0; --i) {
- threads.push_back(WrapUnique(new Thread("test thread")));
- auto* thread = threads.back().get();
- thread->Start();
- scoped_refptr<SingleThreadTaskRunner> task_runner = thread->task_runner();
- mdps.push_back(WrapUnique(new MockMemoryDumpProvider()));
- auto* mdp = mdps.back().get();
- RegisterDumpProvider(mdp, task_runner, kDefaultOptions);
- EXPECT_CALL(*mdp, OnMemoryDump(_, _))
- .Times(i)
- .WillRepeatedly(Invoke(
- [task_runner](const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
- EXPECT_TRUE(task_runner->RunsTasksInCurrentSequence());
- return true;
- }));
- }
- EnableForTracing();
-
- while (!threads.empty()) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
-
- // Unregister a MDP and destroy one thread at each iteration to check the
- // live unregistration logic. The unregistration needs to happen on the same
- // thread the MDP belongs to.
- {
- RunLoop run_loop;
- Closure unregistration =
- Bind(&MemoryDumpManager::UnregisterDumpProvider,
- Unretained(mdm_.get()), Unretained(mdps.back().get()));
- threads.back()->task_runner()->PostTaskAndReply(FROM_HERE, unregistration,
- run_loop.QuitClosure());
- run_loop.Run();
- }
- mdps.pop_back();
- threads.back()->Stop();
- threads.pop_back();
- }
-
- DisableTracing();
-}
-
-// Check that the memory dump calls are always posted on task runner for
-// SequencedTaskRunner case and that the dump provider gets disabled when
-// PostTask fails, but the dump still succeeds.
-TEST_F(MemoryDumpManagerTest, PostTaskForSequencedTaskRunner) {
- std::vector<MockMemoryDumpProvider> mdps(3);
- scoped_refptr<TestSequencedTaskRunner> task_runner1(
- MakeRefCounted<TestSequencedTaskRunner>());
- scoped_refptr<TestSequencedTaskRunner> task_runner2(
- MakeRefCounted<TestSequencedTaskRunner>());
- RegisterDumpProviderWithSequencedTaskRunner(&mdps[0], task_runner1,
- kDefaultOptions);
- RegisterDumpProviderWithSequencedTaskRunner(&mdps[1], task_runner2,
- kDefaultOptions);
- RegisterDumpProviderWithSequencedTaskRunner(&mdps[2], task_runner2,
- kDefaultOptions);
- // |mdps[0]| should be disabled permanently after first dump.
- EXPECT_CALL(mdps[0], OnMemoryDump(_, _)).Times(0);
- EXPECT_CALL(mdps[1], OnMemoryDump(_, _)).Times(2);
- EXPECT_CALL(mdps[2], OnMemoryDump(_, _)).Times(2);
-
- EnableForTracing();
-
- task_runner1->set_enabled(false);
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- EXPECT_EQ(1u, task_runner1->no_of_post_tasks());
- EXPECT_EQ(1u, task_runner2->no_of_post_tasks());
-
- task_runner1->set_enabled(true);
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- EXPECT_EQ(2u, task_runner1->no_of_post_tasks());
- EXPECT_EQ(2u, task_runner2->no_of_post_tasks());
- DisableTracing();
-}
-
-// Checks that providers get disabled after 3 consecutive failures, but not
-// otherwise (e.g., if interleaved).
-TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) {
- MockMemoryDumpProvider mdp1;
- MockMemoryDumpProvider mdp2;
-
- RegisterDumpProvider(&mdp1, nullptr);
- RegisterDumpProvider(&mdp2, nullptr);
- EnableForTracing();
-
- EXPECT_CALL(mdp1, OnMemoryDump(_, _))
- .Times(GetMaxConsecutiveFailuresCount())
- .WillRepeatedly(Return(false));
-
- EXPECT_CALL(mdp2, OnMemoryDump(_, _))
- .WillOnce(Return(false))
- .WillOnce(Return(true))
- .WillOnce(Return(false))
- .WillOnce(Return(false))
- .WillOnce(Return(true))
- .WillOnce(Return(false));
-
- const int kNumDumps = 2 * GetMaxConsecutiveFailuresCount();
- for (int i = 0; i < kNumDumps; i++) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
-
- DisableTracing();
-}
-
-// Sneakily registers an extra memory dump provider while an existing one is
-// dumping and expect it to take part in the already active tracing session.
-TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) {
- MockMemoryDumpProvider mdp1;
- MockMemoryDumpProvider mdp2;
-
- RegisterDumpProvider(&mdp1, nullptr);
- EnableForTracing();
-
- EXPECT_CALL(mdp1, OnMemoryDump(_, _))
- .Times(4)
- .WillOnce(Return(true))
- .WillOnce(
- Invoke([&mdp2](const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
- RegisterDumpProvider(&mdp2, nullptr);
- return true;
- }))
- .WillRepeatedly(Return(true));
-
- // Depending on the insertion order (before or after mdp1), mdp2 might be
- // called also immediately after it gets registered.
- EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(Between(2, 3));
-
- for (int i = 0; i < 4; i++) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
-
- DisableTracing();
-}
-
-// Like RegisterDumperWhileDumping, but unregister the dump provider instead.
-TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) {
- MockMemoryDumpProvider mdp1;
- MockMemoryDumpProvider mdp2;
-
- RegisterDumpProvider(&mdp1, ThreadTaskRunnerHandle::Get(), kDefaultOptions);
- RegisterDumpProvider(&mdp2, ThreadTaskRunnerHandle::Get(), kDefaultOptions);
- EnableForTracing();
-
- EXPECT_CALL(mdp1, OnMemoryDump(_, _))
- .Times(4)
- .WillOnce(Return(true))
- .WillOnce(
- Invoke([&mdp2](const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
- MemoryDumpManager::GetInstance()->UnregisterDumpProvider(&mdp2);
- return true;
- }))
- .WillRepeatedly(Return(true));
-
- // Depending on the insertion order (before or after mdp1), mdp2 might have
- // been already called when UnregisterDumpProvider happens.
- EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(Between(1, 2));
-
- for (int i = 0; i < 4; i++) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
-
- DisableTracing();
-}
-
-// Checks that the dump does not abort when unregistering a provider while
-// dumping from a different thread than the dumping thread.
-TEST_F(MemoryDumpManagerTest, UnregisterDumperFromThreadWhileDumping) {
- std::vector<std::unique_ptr<TestIOThread>> threads;
- std::vector<std::unique_ptr<MockMemoryDumpProvider>> mdps;
-
- for (int i = 0; i < 2; i++) {
- threads.push_back(
- WrapUnique(new TestIOThread(TestIOThread::kAutoStart)));
- mdps.push_back(WrapUnique(new MockMemoryDumpProvider()));
- RegisterDumpProvider(mdps.back().get(), threads.back()->task_runner(),
- kDefaultOptions);
- }
-
- int on_memory_dump_call_count = 0;
-
- // When OnMemoryDump is called on either of the dump providers, it will
- // unregister the other one.
- for (const std::unique_ptr<MockMemoryDumpProvider>& mdp : mdps) {
- int other_idx = (mdps.front() == mdp);
- // TestIOThread's task runner must be obtained from the main thread but can
- // then be used from other threads.
- scoped_refptr<SingleThreadTaskRunner> other_runner =
- threads[other_idx]->task_runner();
- MockMemoryDumpProvider* other_mdp = mdps[other_idx].get();
- auto on_dump = [this, other_runner, other_mdp, &on_memory_dump_call_count](
- const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
- PostTaskAndWait(FROM_HERE, other_runner.get(),
- base::BindOnce(&MemoryDumpManager::UnregisterDumpProvider,
- base::Unretained(&*mdm_), other_mdp));
- on_memory_dump_call_count++;
- return true;
- };
-
- // OnMemoryDump is called once for the provider that dumps first, and zero
- // times for the other provider.
- EXPECT_CALL(*mdp, OnMemoryDump(_, _))
- .Times(AtMost(1))
- .WillOnce(Invoke(on_dump));
- }
-
- EnableForTracing();
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- ASSERT_EQ(1, on_memory_dump_call_count);
-
- DisableTracing();
-}
-
-// If a thread (with a dump provider living on it) is torn down during a dump
-// its dump provider should be skipped but the dump itself should succeed.
-TEST_F(MemoryDumpManagerTest, TearDownThreadWhileDumping) {
- std::vector<std::unique_ptr<TestIOThread>> threads;
- std::vector<std::unique_ptr<MockMemoryDumpProvider>> mdps;
-
- for (int i = 0; i < 2; i++) {
- threads.push_back(
- WrapUnique(new TestIOThread(TestIOThread::kAutoStart)));
- mdps.push_back(WrapUnique(new MockMemoryDumpProvider()));
- RegisterDumpProvider(mdps.back().get(), threads.back()->task_runner(),
- kDefaultOptions);
- }
-
- int on_memory_dump_call_count = 0;
-
- // When OnMemoryDump is called on either of the dump providers, it will
- // tear down the thread of the other one.
- for (const std::unique_ptr<MockMemoryDumpProvider>& mdp : mdps) {
- int other_idx = (mdps.front() == mdp);
- TestIOThread* other_thread = threads[other_idx].get();
- // TestIOThread isn't thread-safe and must be stopped on the |main_runner|.
- scoped_refptr<SequencedTaskRunner> main_runner =
- SequencedTaskRunnerHandle::Get();
- auto on_dump = [other_thread, main_runner, &on_memory_dump_call_count](
- const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
- PostTaskAndWait(
- FROM_HERE, main_runner.get(),
- base::BindOnce(&TestIOThread::Stop, base::Unretained(other_thread)));
- on_memory_dump_call_count++;
- return true;
- };
-
- // OnMemoryDump is called once for the provider that dumps first, and zero
- // times for the other provider.
- EXPECT_CALL(*mdp, OnMemoryDump(_, _))
- .Times(AtMost(1))
- .WillOnce(Invoke(on_dump));
- }
-
- EnableForTracing();
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- ASSERT_EQ(1, on_memory_dump_call_count);
-
- DisableTracing();
-}
-
-// Checks that the callback is invoked if CreateProcessDump() is called when
-// tracing is not enabled.
-TEST_F(MemoryDumpManagerTest, TriggerDumpWithoutTracing) {
- MockMemoryDumpProvider mdp;
- RegisterDumpProvider(&mdp, nullptr);
- EXPECT_CALL(mdp, OnMemoryDump(_, _));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
-}
-
-TEST_F(MemoryDumpManagerTest, BackgroundWhitelisting) {
- SetDumpProviderWhitelistForTesting(kTestMDPWhitelist);
-
- // Standard provider with default options (create dump for current process).
- MockMemoryDumpProvider backgroundMdp;
- RegisterDumpProvider(&backgroundMdp, nullptr, kDefaultOptions,
- kWhitelistedMDPName);
-
- EnableForTracing();
-
- EXPECT_CALL(backgroundMdp, OnMemoryDump(_, _)).Times(1);
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
- MemoryDumpLevelOfDetail::BACKGROUND));
- DisableTracing();
-}
-
-// Tests the basics of the UnregisterAndDeleteDumpProviderSoon(): the
-// unregistration should actually delete the providers and not leak them.
-TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoon) {
- static const int kNumProviders = 3;
- int dtor_count = 0;
- std::vector<std::unique_ptr<MemoryDumpProvider>> mdps;
- for (int i = 0; i < kNumProviders; ++i) {
- std::unique_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
- mdp->enable_mock_destructor = true;
- EXPECT_CALL(*mdp, Destructor())
- .WillOnce(Invoke([&dtor_count]() { dtor_count++; }));
- RegisterDumpProvider(mdp.get(), nullptr, kDefaultOptions);
- mdps.push_back(std::move(mdp));
- }
-
- while (!mdps.empty()) {
- mdm_->UnregisterAndDeleteDumpProviderSoon(std::move(mdps.back()));
- mdps.pop_back();
- }
-
- ASSERT_EQ(kNumProviders, dtor_count);
-}
-
-// This test checks against races when unregistering an unbound dump provider
-// from another thread while dumping. It registers one MDP and, when
-// OnMemoryDump() is called, it invokes UnregisterAndDeleteDumpProviderSoon()
-// from another thread. The OnMemoryDump() and the dtor call are expected to
-// happen on the same thread (the MemoryDumpManager utility thread).
-TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoonDuringDump) {
- std::unique_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
- mdp->enable_mock_destructor = true;
- RegisterDumpProvider(mdp.get(), nullptr, kDefaultOptions);
-
- base::PlatformThreadRef thread_ref;
- auto self_unregister_from_another_thread = [&mdp, &thread_ref](
- const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
- thread_ref = PlatformThread::CurrentRef();
- TestIOThread thread_for_unregistration(TestIOThread::kAutoStart);
- PostTaskAndWait(
- FROM_HERE, thread_for_unregistration.task_runner().get(),
- base::BindOnce(&MemoryDumpManager::UnregisterAndDeleteDumpProviderSoon,
- base::Unretained(MemoryDumpManager::GetInstance()),
- std::move(mdp)));
- thread_for_unregistration.Stop();
- return true;
- };
- EXPECT_CALL(*mdp, OnMemoryDump(_, _))
- .Times(1)
- .WillOnce(Invoke(self_unregister_from_another_thread));
- EXPECT_CALL(*mdp, Destructor())
- .Times(1)
- .WillOnce(Invoke([&thread_ref]() {
- EXPECT_EQ(thread_ref, PlatformThread::CurrentRef());
- }));
-
- EnableForTracing();
- for (int i = 0; i < 2; ++i) {
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- }
- DisableTracing();
-}
-
-// Mock MDP class that tests if the number of OnMemoryDump() calls are expected.
-// It is implemented without gmocks since EXPECT_CALL implementation is slow
-// when there are 1000s of instances, as required in
-// NoStackOverflowWithTooManyMDPs test.
-class SimpleMockMemoryDumpProvider : public MemoryDumpProvider {
- public:
- SimpleMockMemoryDumpProvider(int expected_num_dump_calls)
- : expected_num_dump_calls_(expected_num_dump_calls), num_dump_calls_(0) {}
-
- ~SimpleMockMemoryDumpProvider() override {
- EXPECT_EQ(expected_num_dump_calls_, num_dump_calls_);
- }
-
- bool OnMemoryDump(const MemoryDumpArgs& args,
- ProcessMemoryDump* pmd) override {
- ++num_dump_calls_;
- return true;
- }
-
- private:
- int expected_num_dump_calls_;
- int num_dump_calls_;
-};
-
-TEST_F(MemoryDumpManagerTest, NoStackOverflowWithTooManyMDPs) {
- SetDumpProviderWhitelistForTesting(kTestMDPWhitelist);
-
- int kMDPCount = 1000;
- std::vector<std::unique_ptr<SimpleMockMemoryDumpProvider>> mdps;
- for (int i = 0; i < kMDPCount; ++i) {
- mdps.push_back(std::make_unique<SimpleMockMemoryDumpProvider>(1));
- RegisterDumpProvider(mdps.back().get(), nullptr);
- }
- for (int i = 0; i < kMDPCount; ++i) {
- mdps.push_back(std::make_unique<SimpleMockMemoryDumpProvider>(3));
- RegisterDumpProvider(mdps.back().get(), nullptr, kDefaultOptions,
- kWhitelistedMDPName);
- }
- std::unique_ptr<Thread> stopped_thread(new Thread("test thread"));
- stopped_thread->Start();
- for (int i = 0; i < kMDPCount; ++i) {
- mdps.push_back(std::make_unique<SimpleMockMemoryDumpProvider>(0));
- RegisterDumpProvider(mdps.back().get(), stopped_thread->task_runner(),
- kDefaultOptions, kWhitelistedMDPName);
- }
- stopped_thread->Stop();
-
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::DETAILED));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
- MemoryDumpLevelOfDetail::BACKGROUND));
- EXPECT_TRUE(RequestProcessDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
- MemoryDumpLevelOfDetail::BACKGROUND));
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/memory_dump_scheduler_unittest.cc b/base/trace_event/memory_dump_scheduler_unittest.cc
deleted file mode 100644
index d5993b6..0000000
--- a/base/trace_event/memory_dump_scheduler_unittest.cc
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2017 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 "base/trace_event/memory_dump_scheduler.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::AtMost;
-using ::testing::Invoke;
-using ::testing::_;
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// Wrapper to use gmock on a callback.
-struct CallbackWrapper {
- MOCK_METHOD1(OnTick, void(MemoryDumpLevelOfDetail));
-};
-
-} // namespace
-
-class MemoryDumpSchedulerTest : public testing::Test {
- public:
- MemoryDumpSchedulerTest()
- : testing::Test(),
- evt_(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED),
- bg_thread_("MemoryDumpSchedulerTest Thread") {
- bg_thread_.Start();
- }
-
- protected:
- MemoryDumpScheduler scheduler_;
- WaitableEvent evt_;
- CallbackWrapper on_tick_;
- Thread bg_thread_;
-};
-
-TEST_F(MemoryDumpSchedulerTest, SingleTrigger) {
- const uint32_t kPeriodMs = 1;
- const auto kLevelOfDetail = MemoryDumpLevelOfDetail::DETAILED;
- const uint32_t kTicks = 5;
- MemoryDumpScheduler::Config config;
- config.triggers.push_back({kLevelOfDetail, kPeriodMs});
- config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
-
- testing::InSequence sequence;
- EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
- EXPECT_CALL(on_tick_, OnTick(_))
- .WillRepeatedly(Invoke(
- [this, kLevelOfDetail](MemoryDumpLevelOfDetail level_of_detail) {
- EXPECT_EQ(kLevelOfDetail, level_of_detail);
- this->evt_.Signal();
- }));
-
- // Check that Stop() before Start() doesn't cause any error.
- scheduler_.Stop();
-
- const TimeTicks tstart = TimeTicks::Now();
- scheduler_.Start(config, bg_thread_.task_runner());
- evt_.Wait();
- const double time_ms = (TimeTicks::Now() - tstart).InMillisecondsF();
-
- // It takes N-1 ms to perform N ticks of 1ms each.
- EXPECT_GE(time_ms, kPeriodMs * (kTicks - 1));
-
- // Check that stopping twice doesn't cause any problems.
- scheduler_.Stop();
- scheduler_.Stop();
-}
-
-TEST_F(MemoryDumpSchedulerTest, MultipleTriggers) {
- const uint32_t kPeriodLightMs = 3;
- const uint32_t kPeriodDetailedMs = 9;
- MemoryDumpScheduler::Config config;
- const MemoryDumpLevelOfDetail kLight = MemoryDumpLevelOfDetail::LIGHT;
- const MemoryDumpLevelOfDetail kDetailed = MemoryDumpLevelOfDetail::DETAILED;
- config.triggers.push_back({kLight, kPeriodLightMs});
- config.triggers.push_back({kDetailed, kPeriodDetailedMs});
- config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
-
- TimeTicks t1, t2, t3;
-
- testing::InSequence sequence;
- EXPECT_CALL(on_tick_, OnTick(kDetailed))
- .WillOnce(
- Invoke([&t1](MemoryDumpLevelOfDetail) { t1 = TimeTicks::Now(); }));
- EXPECT_CALL(on_tick_, OnTick(kLight)).Times(1);
- EXPECT_CALL(on_tick_, OnTick(kLight)).Times(1);
- EXPECT_CALL(on_tick_, OnTick(kDetailed))
- .WillOnce(
- Invoke([&t2](MemoryDumpLevelOfDetail) { t2 = TimeTicks::Now(); }));
- EXPECT_CALL(on_tick_, OnTick(kLight))
- .WillOnce(
- Invoke([&t3](MemoryDumpLevelOfDetail) { t3 = TimeTicks::Now(); }));
-
- // Rationale for WillRepeatedly and not just WillOnce: Extra ticks might
- // happen if the Stop() takes time. Not an interesting case, but we need to
- // avoid gmock to shout in that case.
- EXPECT_CALL(on_tick_, OnTick(_))
- .WillRepeatedly(
- Invoke([this](MemoryDumpLevelOfDetail) { this->evt_.Signal(); }));
-
- scheduler_.Start(config, bg_thread_.task_runner());
- evt_.Wait();
- scheduler_.Stop();
- EXPECT_GE((t2 - t1).InMillisecondsF(), kPeriodDetailedMs);
- EXPECT_GE((t3 - t2).InMillisecondsF(), kPeriodLightMs);
-}
-
-TEST_F(MemoryDumpSchedulerTest, StartStopQuickly) {
- const uint32_t kPeriodMs = 3;
- const uint32_t kQuickIterations = 5;
- const uint32_t kDetailedTicks = 10;
-
- MemoryDumpScheduler::Config light_config;
- light_config.triggers.push_back({MemoryDumpLevelOfDetail::LIGHT, kPeriodMs});
- light_config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
-
- MemoryDumpScheduler::Config detailed_config;
- detailed_config.triggers.push_back(
- {MemoryDumpLevelOfDetail::DETAILED, kPeriodMs});
- detailed_config.callback =
- Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
-
- testing::InSequence sequence;
- EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::LIGHT))
- .Times(AtMost(kQuickIterations));
- EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::DETAILED))
- .Times(kDetailedTicks - 1);
- EXPECT_CALL(on_tick_, OnTick(MemoryDumpLevelOfDetail::DETAILED))
- .WillRepeatedly(
- Invoke([this](MemoryDumpLevelOfDetail) { this->evt_.Signal(); }));
-
- const TimeTicks tstart = TimeTicks::Now();
- for (unsigned int i = 0; i < kQuickIterations; i++) {
- scheduler_.Start(light_config, bg_thread_.task_runner());
- scheduler_.Stop();
- }
-
- scheduler_.Start(detailed_config, bg_thread_.task_runner());
-
- evt_.Wait();
- const double time_ms = (TimeTicks::Now() - tstart).InMillisecondsF();
- scheduler_.Stop();
-
- // It takes N-1 ms to perform N ticks of 1ms each.
- EXPECT_GE(time_ms, kPeriodMs * (kDetailedTicks - 1));
-}
-
-TEST_F(MemoryDumpSchedulerTest, StopAndStartOnAnotherThread) {
- const uint32_t kPeriodMs = 1;
- const uint32_t kTicks = 3;
- MemoryDumpScheduler::Config config;
- config.triggers.push_back({MemoryDumpLevelOfDetail::DETAILED, kPeriodMs});
- config.callback = Bind(&CallbackWrapper::OnTick, Unretained(&on_tick_));
-
- scoped_refptr<TaskRunner> expected_task_runner = bg_thread_.task_runner();
- testing::InSequence sequence;
- EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
- EXPECT_CALL(on_tick_, OnTick(_))
- .WillRepeatedly(
- Invoke([this, expected_task_runner](MemoryDumpLevelOfDetail) {
- EXPECT_TRUE(expected_task_runner->RunsTasksInCurrentSequence());
- this->evt_.Signal();
- }));
-
- scheduler_.Start(config, bg_thread_.task_runner());
- evt_.Wait();
- scheduler_.Stop();
- bg_thread_.Stop();
-
- Thread bg_thread_2("MemoryDumpSchedulerTest Thread 2");
- bg_thread_2.Start();
- evt_.Reset();
- expected_task_runner = bg_thread_2.task_runner();
- EXPECT_CALL(on_tick_, OnTick(_)).Times(kTicks - 1);
- EXPECT_CALL(on_tick_, OnTick(_))
- .WillRepeatedly(
- Invoke([this, expected_task_runner](MemoryDumpLevelOfDetail) {
- EXPECT_TRUE(expected_task_runner->RunsTasksInCurrentSequence());
- this->evt_.Signal();
- }));
- scheduler_.Start(config, bg_thread_2.task_runner());
- evt_.Wait();
- scheduler_.Stop();
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/memory_peak_detector_unittest.cc b/base/trace_event/memory_peak_detector_unittest.cc
deleted file mode 100644
index bc10c80..0000000
--- a/base/trace_event/memory_peak_detector_unittest.cc
+++ /dev/null
@@ -1,564 +0,0 @@
-// Copyright 2017 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 "base/trace_event/memory_peak_detector.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/run_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/trace_event/memory_dump_provider.h"
-#include "base/trace_event/memory_dump_provider_info.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Return;
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-const TimeDelta kMs = TimeDelta::FromMilliseconds(1);
-const MemoryPeakDetector::Config kConfigNoCallbacks(
- 1 /* polling_interval_ms */,
- 60000 /* min_time_between_peaks_ms */,
- false /* enable_verbose_poll_tracing */
- );
-
-class MockMemoryDumpProvider : public MemoryDumpProvider {
- public:
- bool OnMemoryDump(const MemoryDumpArgs&, ProcessMemoryDump*) override {
- NOTREACHED();
- return true;
- }
-
- MOCK_METHOD1(PollFastMemoryTotal, void(uint64_t*));
-};
-
-// Wrapper to use gmock on a callback.
-struct OnPeakDetectedWrapper {
- MOCK_METHOD0(OnPeak, void());
-};
-
-} // namespace
-
-class MemoryPeakDetectorTest : public testing::Test {
- public:
- struct FriendDeleter {
- void operator()(MemoryPeakDetector* inst) { delete inst; }
- };
-
- MemoryPeakDetectorTest() : testing::Test() {}
- static const uint64_t kSlidingWindowNumSamples =
- MemoryPeakDetector::kSlidingWindowNumSamples;
-
- std::unique_ptr<MemoryPeakDetector, FriendDeleter> NewInstance() {
- return std::unique_ptr<MemoryPeakDetector, FriendDeleter>(
- new MemoryPeakDetector());
- }
-
- void RestartThreadAndReinitializePeakDetector() {
- bg_thread_.reset(new Thread("Peak Detector Test Thread"));
- bg_thread_->Start();
- peak_detector_ = NewInstance();
- peak_detector_->Setup(
- Bind(&MemoryPeakDetectorTest::MockGetDumpProviders, Unretained(this)),
- bg_thread_->task_runner(),
- Bind(&OnPeakDetectedWrapper::OnPeak, Unretained(&on_peak_callback_)));
- }
-
- void SetUp() override {
- get_mdp_call_count_ = 0;
- RestartThreadAndReinitializePeakDetector();
- }
-
- void TearDown() override {
- peak_detector_->TearDown();
- bg_thread_->FlushForTesting();
- EXPECT_EQ(MemoryPeakDetector::NOT_INITIALIZED, GetPeakDetectorState());
- bg_thread_.reset();
- dump_providers_.clear();
- }
-
- // Calls MemoryPeakDetector::state_for_testing() on the bg thread and returns
- // the result on the current thread.
- MemoryPeakDetector::State GetPeakDetectorState() {
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- MemoryPeakDetector::State res = MemoryPeakDetector::NOT_INITIALIZED;
- auto get_fn = [](MemoryPeakDetector* peak_detector, WaitableEvent* evt,
- MemoryPeakDetector::State* res) {
- *res = peak_detector->state_for_testing();
- evt->Signal();
- };
- bg_thread_->task_runner()->PostTask(
- FROM_HERE, BindOnce(get_fn, Unretained(&*peak_detector_),
- Unretained(&evt), Unretained(&res)));
- evt.Wait();
- return res;
- }
-
- // Calls MemoryPeakDetector::poll_tasks_count_for_testing() on the bg thread
- // and returns the result on the current thread.
- uint32_t GetNumPollingTasksRan() {
- uint32_t res = 0;
- auto get_fn = [](MemoryPeakDetector* peak_detector, WaitableEvent* evt,
- uint32_t* res) {
- *res = peak_detector->poll_tasks_count_for_testing();
- evt->Signal();
- };
-
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- bg_thread_->task_runner()->PostTask(
- FROM_HERE, BindOnce(get_fn, Unretained(&*peak_detector_),
- Unretained(&evt), Unretained(&res)));
- evt.Wait();
- return res;
- }
-
- // Runs the peak detector with a mock MDP with the given
- // |config|. The mock MDP will invoke the |poll_function| on any call to
- // PollFastMemoryTotal(), until |num_samples| have been polled.
- // It returns the number of peaks detected.
- uint32_t RunWithCustomPollFunction(
- MemoryPeakDetector::Config config,
- uint32_t num_samples,
- RepeatingCallback<uint64_t(uint32_t)> poll_function) {
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp = CreateMockDumpProvider();
- dump_providers_.push_back(mdp);
- uint32_t cur_sample_idx = 0;
- EXPECT_CALL(GetMockMDP(mdp), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke(
- [&cur_sample_idx, &evt, poll_function, num_samples](uint64_t* mem) {
- if (cur_sample_idx >= num_samples) {
- *mem = 1;
- evt.Signal();
- } else {
- *mem = poll_function.Run(cur_sample_idx++);
- }
- }));
-
- uint32_t num_peaks = 0;
- EXPECT_CALL(on_peak_callback_, OnPeak())
- .WillRepeatedly(Invoke([&num_peaks] { num_peaks++; }));
- peak_detector_->Start(config);
- evt.Wait(); // Wait for |num_samples| invocations of PollFastMemoryTotal().
- peak_detector_->Stop();
- EXPECT_EQ(num_samples, cur_sample_idx);
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- return num_peaks;
- }
-
- // Called on the |bg_thread_|.
- void MockGetDumpProviders(MemoryPeakDetector::DumpProvidersList* mdps) {
- get_mdp_call_count_++;
- *mdps = dump_providers_;
- }
-
- uint32_t GetNumGetDumpProvidersCalls() {
- bg_thread_->FlushForTesting();
- return get_mdp_call_count_;
- }
-
- scoped_refptr<MemoryDumpProviderInfo> CreateMockDumpProvider() {
- std::unique_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider());
- MemoryDumpProvider::Options opt;
- opt.is_fast_polling_supported = true;
- scoped_refptr<MemoryDumpProviderInfo> mdp_info(new MemoryDumpProviderInfo(
- mdp.get(), "Mock MDP", nullptr, opt,
- false /* whitelisted_for_background_mode */));
-
- // The |mdp| instance will be destroyed together with the |mdp_info|.
- mdp_info->owned_dump_provider = std::move(mdp);
- return mdp_info;
- }
-
- static MockMemoryDumpProvider& GetMockMDP(
- const scoped_refptr<MemoryDumpProviderInfo>& mdp_info) {
- return *static_cast<MockMemoryDumpProvider*>(mdp_info->dump_provider);
- }
-
- static uint64_t PollFunctionThatCausesPeakViaStdDev(uint32_t sample_idx) {
- // Start with a baseline of 50 MB.
- if (sample_idx < kSlidingWindowNumSamples)
- return 50000 + (sample_idx % 3) * 100;
-
- // Then 10 samples around 80 MB
- if (sample_idx < 10 + kSlidingWindowNumSamples)
- return 80000 + (sample_idx % 3) * 200;
-
- // Than back to 60 MB.
- if (sample_idx < 2 * kSlidingWindowNumSamples)
- return 60000 + (sample_idx % 3) * 100;
-
- // Then 20 samples around 120 MB.
- if (sample_idx < 20 + 2 * kSlidingWindowNumSamples)
- return 120000 + (sample_idx % 3) * 200;
-
- // Then back to idle to around 50 MB until the end.
- return 50000 + (sample_idx % 3) * 100;
- }
-
- protected:
- MemoryPeakDetector::DumpProvidersList dump_providers_;
- uint32_t get_mdp_call_count_;
- std::unique_ptr<MemoryPeakDetector, FriendDeleter> peak_detector_;
- std::unique_ptr<Thread> bg_thread_;
- OnPeakDetectedWrapper on_peak_callback_;
-};
-
-const uint64_t MemoryPeakDetectorTest::kSlidingWindowNumSamples;
-
-TEST_F(MemoryPeakDetectorTest, GetDumpProvidersFunctionCalled) {
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(1u, GetNumGetDumpProvidersCalls());
- EXPECT_EQ(MemoryPeakDetector::ENABLED, GetPeakDetectorState());
-
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- EXPECT_EQ(0u, GetNumPollingTasksRan());
-}
-
-TEST_F(MemoryPeakDetectorTest, ThrottleAndNotifyBeforeInitialize) {
- peak_detector_->TearDown();
-
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp = CreateMockDumpProvider();
- EXPECT_CALL(GetMockMDP(mdp), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&evt](uint64_t*) { evt.Signal(); }));
- dump_providers_.push_back(mdp);
- peak_detector_->Throttle();
- peak_detector_->NotifyMemoryDumpProvidersChanged();
- EXPECT_EQ(MemoryPeakDetector::NOT_INITIALIZED, GetPeakDetectorState());
- RestartThreadAndReinitializePeakDetector();
-
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
- evt.Wait(); // Wait for a PollFastMemoryTotal() call.
-
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- EXPECT_EQ(1u, GetNumGetDumpProvidersCalls());
- EXPECT_GE(GetNumPollingTasksRan(), 1u);
-}
-
-TEST_F(MemoryPeakDetectorTest, DoubleStop) {
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(MemoryPeakDetector::ENABLED, GetPeakDetectorState());
-
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
-
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
-
- EXPECT_EQ(1u, GetNumGetDumpProvidersCalls());
- EXPECT_EQ(0u, GetNumPollingTasksRan());
-}
-
-TEST_F(MemoryPeakDetectorTest, OneDumpProviderRegisteredBeforeStart) {
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp = CreateMockDumpProvider();
- EXPECT_CALL(GetMockMDP(mdp), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&evt](uint64_t*) { evt.Signal(); }));
- dump_providers_.push_back(mdp);
-
- peak_detector_->Start(kConfigNoCallbacks);
- evt.Wait(); // Signaled when PollFastMemoryTotal() is called on the MockMDP.
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
-
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- EXPECT_EQ(1u, GetNumGetDumpProvidersCalls());
- EXPECT_GT(GetNumPollingTasksRan(), 0u);
-}
-
-TEST_F(MemoryPeakDetectorTest, ReInitializeAndRebindToNewThread) {
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp = CreateMockDumpProvider();
- EXPECT_CALL(GetMockMDP(mdp), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&evt](uint64_t*) { evt.Signal(); }));
- dump_providers_.push_back(mdp);
-
- for (int i = 0; i < 5; ++i) {
- evt.Reset();
- peak_detector_->Start(kConfigNoCallbacks);
- evt.Wait(); // Wait for a PollFastMemoryTotal() call.
- // Check that calling TearDown implicitly does a Stop().
- peak_detector_->TearDown();
-
- // Reinitialize and re-bind to a new task runner.
- RestartThreadAndReinitializePeakDetector();
- }
-}
-
-TEST_F(MemoryPeakDetectorTest, OneDumpProviderRegisteredOutOfBand) {
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(MemoryPeakDetector::ENABLED, GetPeakDetectorState());
- EXPECT_EQ(1u, GetNumGetDumpProvidersCalls());
-
- // Check that no poll tasks are posted before any dump provider is registered.
- PlatformThread::Sleep(5 * kConfigNoCallbacks.polling_interval_ms * kMs);
- EXPECT_EQ(0u, GetNumPollingTasksRan());
-
- // Registed the MDP After Start() has been issued and expect that the
- // PeakDetector transitions ENABLED -> RUNNING on the next
- // NotifyMemoryDumpProvidersChanged() call.
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp = CreateMockDumpProvider();
- EXPECT_CALL(GetMockMDP(mdp), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&evt](uint64_t*) { evt.Signal(); }));
- dump_providers_.push_back(mdp);
- peak_detector_->NotifyMemoryDumpProvidersChanged();
-
- evt.Wait(); // Signaled when PollFastMemoryTotal() is called on the MockMDP.
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
- EXPECT_EQ(2u, GetNumGetDumpProvidersCalls());
-
- // Now simulate the unregisration and expect that the PeakDetector transitions
- // back to ENABLED.
- dump_providers_.clear();
- peak_detector_->NotifyMemoryDumpProvidersChanged();
- EXPECT_EQ(MemoryPeakDetector::ENABLED, GetPeakDetectorState());
- EXPECT_EQ(3u, GetNumGetDumpProvidersCalls());
- uint32_t num_poll_tasks = GetNumPollingTasksRan();
- EXPECT_GT(num_poll_tasks, 0u);
-
- // At this point, no more polling tasks should be posted.
- PlatformThread::Sleep(5 * kConfigNoCallbacks.polling_interval_ms * kMs);
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- EXPECT_EQ(num_poll_tasks, GetNumPollingTasksRan());
-}
-
-// Test that a sequence of Start()/Stop() back-to-back doesn't end up creating
-// several outstanding timer tasks and instead respects the polling_interval_ms.
-TEST_F(MemoryPeakDetectorTest, StartStopQuickly) {
- WaitableEvent evt(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp = CreateMockDumpProvider();
- dump_providers_.push_back(mdp);
- const uint32_t kNumPolls = 20;
- uint32_t polls_done = 0;
- EXPECT_CALL(GetMockMDP(mdp), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&polls_done, &evt, kNumPolls](uint64_t*) {
- if (++polls_done == kNumPolls)
- evt.Signal();
- }));
-
- const TimeTicks tstart = TimeTicks::Now();
- for (int i = 0; i < 5; i++) {
- peak_detector_->Start(kConfigNoCallbacks);
- peak_detector_->Stop();
- }
-
- bg_thread_->task_runner()->PostTask(
- FROM_HERE, base::BindOnce([](uint32_t* polls_done) { *polls_done = 0; },
- &polls_done));
-
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
- evt.Wait(); // Wait for kNumPolls.
- const double time_ms = (TimeTicks::Now() - tstart).InMillisecondsF();
-
- EXPECT_GE(time_ms, (kNumPolls - 1) * kConfigNoCallbacks.polling_interval_ms);
- peak_detector_->Stop();
-}
-
-TEST_F(MemoryPeakDetectorTest, RegisterAndUnregisterTwoDumpProviders) {
- WaitableEvent evt1(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent evt2(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- scoped_refptr<MemoryDumpProviderInfo> mdp1 = CreateMockDumpProvider();
- scoped_refptr<MemoryDumpProviderInfo> mdp2 = CreateMockDumpProvider();
- EXPECT_CALL(GetMockMDP(mdp1), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&evt1](uint64_t*) { evt1.Signal(); }));
- EXPECT_CALL(GetMockMDP(mdp2), PollFastMemoryTotal(_))
- .WillRepeatedly(Invoke([&evt2](uint64_t*) { evt2.Signal(); }));
-
- // Register only one MDP and start the detector.
- dump_providers_.push_back(mdp1);
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
-
- // Wait for one poll task and then register also the other one.
- evt1.Wait();
- dump_providers_.push_back(mdp2);
- peak_detector_->NotifyMemoryDumpProvidersChanged();
- evt2.Wait();
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
-
- // Now unregister the first MDP and check that everything is still running.
- dump_providers_.erase(dump_providers_.begin());
- peak_detector_->NotifyMemoryDumpProvidersChanged();
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
-
- // Now unregister both and check that the detector goes to idle.
- dump_providers_.clear();
- peak_detector_->NotifyMemoryDumpProvidersChanged();
- EXPECT_EQ(MemoryPeakDetector::ENABLED, GetPeakDetectorState());
-
- // Now re-register both and check that the detector re-activates posting
- // new polling tasks.
- uint32_t num_poll_tasks = GetNumPollingTasksRan();
- evt1.Reset();
- evt2.Reset();
- dump_providers_.push_back(mdp1);
- dump_providers_.push_back(mdp2);
- peak_detector_->NotifyMemoryDumpProvidersChanged();
- evt1.Wait();
- evt2.Wait();
- EXPECT_EQ(MemoryPeakDetector::RUNNING, GetPeakDetectorState());
- EXPECT_GT(GetNumPollingTasksRan(), num_poll_tasks);
-
- // Stop everything, tear down the MDPs, restart the detector and check that
- // it detector doesn't accidentally try to re-access them.
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- dump_providers_.clear();
- mdp1 = nullptr;
- mdp2 = nullptr;
-
- num_poll_tasks = GetNumPollingTasksRan();
- peak_detector_->Start(kConfigNoCallbacks);
- EXPECT_EQ(MemoryPeakDetector::ENABLED, GetPeakDetectorState());
- PlatformThread::Sleep(5 * kConfigNoCallbacks.polling_interval_ms * kMs);
-
- peak_detector_->Stop();
- EXPECT_EQ(MemoryPeakDetector::DISABLED, GetPeakDetectorState());
- EXPECT_EQ(num_poll_tasks, GetNumPollingTasksRan());
-
- EXPECT_EQ(6u, GetNumGetDumpProvidersCalls());
-}
-
-// Tests the behavior of the static threshold detector, which is supposed to
-// detect a peak whenever an increase >= threshold is detected.
-TEST_F(MemoryPeakDetectorTest, StaticThreshold) {
- const uint32_t kNumSamples = 2 * kSlidingWindowNumSamples;
- constexpr uint32_t kNumSamplesPerStep = 10;
- constexpr uint64_t kThreshold = 1000000;
- peak_detector_->SetStaticThresholdForTesting(kThreshold);
- const MemoryPeakDetector::Config kConfig(
- 1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
- false /* enable_verbose_poll_tracing */
- );
-
- // The mocked PollFastMemoryTotal() will return a step function,
- // e.g. (1, 1, 1, 5, 5, 5, ...) where the steps are 2x threshold, in order to
- // trigger only the static threshold logic.
- auto poll_fn = Bind(
- [](const uint32_t kNumSamplesPerStep, const uint64_t kThreshold,
- uint32_t sample_idx) -> uint64_t {
- return (1 + sample_idx / kNumSamplesPerStep) * 2 * kThreshold;
- },
- kNumSamplesPerStep, kThreshold);
- uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
- EXPECT_EQ(kNumSamples / kNumSamplesPerStep - 1, num_peaks);
-}
-
-// Checks the throttling logic of Config's |min_time_between_peaks_ms|.
-TEST_F(MemoryPeakDetectorTest, PeakCallbackThrottling) {
- const size_t kNumSamples = 2 * kSlidingWindowNumSamples;
- constexpr uint64_t kThreshold = 1000000;
- peak_detector_->SetStaticThresholdForTesting(kThreshold);
- const MemoryPeakDetector::Config kConfig(
- 1 /* polling_interval_ms */, 4 /* min_time_between_peaks_ms */,
- false /* enable_verbose_poll_tracing */
- );
-
- // Each mock value returned is N * 2 * threshold, so all of them would be
- // eligible to be a peak if throttling wasn't enabled.
- auto poll_fn = Bind(
- [](uint64_t kThreshold, uint32_t sample_idx) -> uint64_t {
- return (sample_idx + 1) * 2 * kThreshold;
- },
- kThreshold);
- uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
- const uint32_t kExpectedThrottlingRate =
- kConfig.min_time_between_peaks_ms / kConfig.polling_interval_ms;
- EXPECT_LT(num_peaks, kNumSamples / kExpectedThrottlingRate);
-}
-
-TEST_F(MemoryPeakDetectorTest, StdDev) {
- // Set the threshold to some arbitrarily high value, so that the static
- // threshold logic is not hit in this test.
- constexpr uint64_t kThreshold = 1024 * 1024 * 1024;
- peak_detector_->SetStaticThresholdForTesting(kThreshold);
- const size_t kNumSamples = 3 * kSlidingWindowNumSamples;
- const MemoryPeakDetector::Config kConfig(
- 1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
- false /* enable_verbose_poll_tracing */
- );
-
- auto poll_fn = Bind(&PollFunctionThatCausesPeakViaStdDev);
- uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
- EXPECT_EQ(2u, num_peaks); // 80 MB, 120 MB.
-}
-
-// Tests that Throttle() actually holds back peak notifications.
-TEST_F(MemoryPeakDetectorTest, Throttle) {
- constexpr uint64_t kThreshold = 1024 * 1024 * 1024;
- const uint32_t kNumSamples = 3 * kSlidingWindowNumSamples;
- peak_detector_->SetStaticThresholdForTesting(kThreshold);
- const MemoryPeakDetector::Config kConfig(
- 1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
- false /* enable_verbose_poll_tracing */
- );
-
- auto poll_fn = Bind(
- [](MemoryPeakDetector* peak_detector, uint32_t sample_idx) -> uint64_t {
- if (sample_idx % 20 == 20 - 1)
- peak_detector->Throttle();
- return PollFunctionThatCausesPeakViaStdDev(sample_idx);
- },
- Unretained(&*peak_detector_));
- uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
- EXPECT_EQ(0u, num_peaks);
-}
-
-// Tests that the windows stddev state is not carried over through
-// Stop() -> Start() sequences.
-TEST_F(MemoryPeakDetectorTest, RestartClearsState) {
- constexpr uint64_t kThreshold = 1024 * 1024 * 1024;
- peak_detector_->SetStaticThresholdForTesting(kThreshold);
- const size_t kNumSamples = 3 * kSlidingWindowNumSamples;
- const MemoryPeakDetector::Config kConfig(
- 1 /* polling_interval_ms */, 0 /* min_time_between_peaks_ms */,
- false /* enable_verbose_poll_tracing */
- );
- auto poll_fn = Bind(
- [](MemoryPeakDetector* peak_detector,
- const uint32_t kSlidingWindowNumSamples,
- MemoryPeakDetector::Config kConfig, uint32_t sample_idx) -> uint64_t {
- if (sample_idx % kSlidingWindowNumSamples ==
- kSlidingWindowNumSamples - 1) {
- peak_detector->Stop();
- peak_detector->Start(kConfig);
- }
- return PollFunctionThatCausesPeakViaStdDev(sample_idx);
- },
- Unretained(&*peak_detector_), kSlidingWindowNumSamples, kConfig);
- uint32_t num_peaks = RunWithCustomPollFunction(kConfig, kNumSamples, poll_fn);
- EXPECT_EQ(0u, num_peaks);
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/memory_usage_estimator_unittest.cc b/base/trace_event/memory_usage_estimator_unittest.cc
deleted file mode 100644
index 7f8efc7..0000000
--- a/base/trace_event/memory_usage_estimator_unittest.cc
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright 2016 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 "base/trace_event/memory_usage_estimator.h"
-
-#include <stdlib.h>
-
-#include "base/memory/ptr_util.h"
-#include "base/strings/string16.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(ARCH_CPU_64_BITS)
-#define EXPECT_EQ_32_64(_, e, a) EXPECT_EQ(e, a)
-#else
-#define EXPECT_EQ_32_64(e, _, a) EXPECT_EQ(e, a)
-#endif
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// Test class with predictable memory usage.
-class Data {
- public:
- explicit Data(size_t size = 17): size_(size) {
- }
-
- size_t size() const { return size_; }
-
- size_t EstimateMemoryUsage() const {
- return size_;
- }
-
- bool operator < (const Data& other) const {
- return size_ < other.size_;
- }
- bool operator == (const Data& other) const {
- return size_ == other.size_;
- }
-
- struct Hasher {
- size_t operator () (const Data& data) const {
- return data.size();
- }
- };
-
- private:
- size_t size_;
-};
-
-} // namespace
-
-namespace internal {
-
-// This kills variance of bucket_count across STL implementations.
-template <>
-size_t HashMapBucketCountForTesting<Data>(size_t) {
- return 10;
-}
-template <>
-size_t HashMapBucketCountForTesting<std::pair<const Data, short>>(size_t) {
- return 10;
-}
-
-} // namespace internal
-
-TEST(EstimateMemoryUsageTest, String) {
- std::string string(777, 'a');
- EXPECT_EQ(string.capacity() + 1, EstimateMemoryUsage(string));
-}
-
-TEST(EstimateMemoryUsageTest, String16) {
- string16 string(777, 'a');
- EXPECT_EQ(sizeof(char16) * (string.capacity() + 1),
- EstimateMemoryUsage(string));
-}
-
-TEST(EstimateMemoryUsageTest, Arrays) {
- // std::array
- {
- std::array<Data, 10> array;
- EXPECT_EQ(170u, EstimateMemoryUsage(array));
- }
-
- // T[N]
- {
- Data array[10];
- EXPECT_EQ(170u, EstimateMemoryUsage(array));
- }
-
- // C array
- {
- struct Item {
- char payload[10];
- };
- Item* array = new Item[7];
- EXPECT_EQ(70u, EstimateMemoryUsage(array, 7));
- delete[] array;
- }
-}
-
-TEST(EstimateMemoryUsageTest, UniquePtr) {
- // Empty
- {
- std::unique_ptr<Data> ptr;
- EXPECT_EQ(0u, EstimateMemoryUsage(ptr));
- }
-
- // Not empty
- {
- std::unique_ptr<Data> ptr(new Data());
- EXPECT_EQ_32_64(21u, 25u, EstimateMemoryUsage(ptr));
- }
-
- // With a pointer
- {
- std::unique_ptr<Data*> ptr(new Data*());
- EXPECT_EQ(sizeof(void*), EstimateMemoryUsage(ptr));
- }
-
- // With an array
- {
- struct Item {
- uint32_t payload[10];
- };
- std::unique_ptr<Item[]> ptr(new Item[7]);
- EXPECT_EQ(280u, EstimateMemoryUsage(ptr, 7));
- }
-}
-
-TEST(EstimateMemoryUsageTest, Vector) {
- std::vector<Data> vector;
- vector.reserve(1000);
-
- // For an empty vector we should return memory usage of its buffer
- size_t capacity = vector.capacity();
- size_t expected_size = capacity * sizeof(Data);
- EXPECT_EQ(expected_size, EstimateMemoryUsage(vector));
-
- // If vector is not empty, its size should also include memory usages
- // of all elements.
- for (size_t i = 0; i != capacity / 2; ++i) {
- vector.push_back(Data(i));
- expected_size += EstimateMemoryUsage(vector.back());
- }
- EXPECT_EQ(expected_size, EstimateMemoryUsage(vector));
-}
-
-TEST(EstimateMemoryUsageTest, List) {
- struct POD {
- short data;
- };
- std::list<POD> list;
- for (int i = 0; i != 1000; ++i) {
- list.push_back(POD());
- }
- EXPECT_EQ_32_64(12000u, 24000u, EstimateMemoryUsage(list));
-}
-
-TEST(EstimateMemoryUsageTest, Set) {
- std::set<std::pair<int, Data>> set;
- for (int i = 0; i != 1000; ++i) {
- set.insert({i, Data(i)});
- }
- EXPECT_EQ_32_64(523500u, 547500u, EstimateMemoryUsage(set));
-}
-
-TEST(EstimateMemoryUsageTest, MultiSet) {
- std::multiset<bool> set;
- for (int i = 0; i != 1000; ++i) {
- set.insert((i & 1) != 0);
- }
- EXPECT_EQ_32_64(16000u, 32000u, EstimateMemoryUsage(set));
-}
-
-TEST(EstimateMemoryUsageTest, Map) {
- std::map<Data, int> map;
- for (int i = 0; i != 1000; ++i) {
- map.insert({Data(i), i});
- }
- EXPECT_EQ_32_64(523500u, 547500u, EstimateMemoryUsage(map));
-}
-
-TEST(EstimateMemoryUsageTest, MultiMap) {
- std::multimap<char, Data> map;
- for (int i = 0; i != 1000; ++i) {
- map.insert({static_cast<char>(i), Data(i)});
- }
- EXPECT_EQ_32_64(523500u, 547500u, EstimateMemoryUsage(map));
-}
-
-TEST(EstimateMemoryUsageTest, UnorderedSet) {
- std::unordered_set<Data, Data::Hasher> set;
- for (int i = 0; i != 1000; ++i) {
- set.insert(Data(i));
- }
- EXPECT_EQ_32_64(511540u, 523580u, EstimateMemoryUsage(set));
-}
-
-TEST(EstimateMemoryUsageTest, UnorderedMultiSet) {
- std::unordered_multiset<Data, Data::Hasher> set;
- for (int i = 0; i != 500; ++i) {
- set.insert(Data(i));
- set.insert(Data(i));
- }
- EXPECT_EQ_32_64(261540u, 273580u, EstimateMemoryUsage(set));
-}
-
-TEST(EstimateMemoryUsageTest, UnorderedMap) {
- std::unordered_map<Data, short, Data::Hasher> map;
- for (int i = 0; i != 1000; ++i) {
- map.insert({Data(i), static_cast<short>(i)});
- }
- EXPECT_EQ_32_64(515540u, 531580u, EstimateMemoryUsage(map));
-}
-
-TEST(EstimateMemoryUsageTest, UnorderedMultiMap) {
- std::unordered_multimap<Data, short, Data::Hasher> map;
- for (int i = 0; i != 1000; ++i) {
- map.insert({Data(i), static_cast<short>(i)});
- }
- EXPECT_EQ_32_64(515540u, 531580u, EstimateMemoryUsage(map));
-}
-
-TEST(EstimateMemoryUsageTest, Deque) {
- std::deque<Data> deque;
-
- // Pick a large value so that platform-specific accounting
- // for deque's blocks is small compared to usage of all items.
- constexpr size_t kDataSize = 100000;
- for (int i = 0; i != 1500; ++i) {
- deque.push_back(Data(kDataSize));
- }
-
- // Compare against a reasonable minimum (i.e. no overhead).
- size_t min_expected_usage = deque.size() * (sizeof(Data) + kDataSize);
- EXPECT_LE(min_expected_usage, EstimateMemoryUsage(deque));
-}
-
-TEST(EstimateMemoryUsageTest, IsStandardContainerComplexIteratorTest) {
- struct abstract {
- virtual void method() = 0;
- };
-
- static_assert(
- internal::IsStandardContainerComplexIterator<std::list<int>::iterator>(),
- "");
- static_assert(internal::IsStandardContainerComplexIterator<
- std::list<int>::const_iterator>(),
- "");
- static_assert(internal::IsStandardContainerComplexIterator<
- std::list<int>::reverse_iterator>(),
- "");
- static_assert(internal::IsStandardContainerComplexIterator<
- std::list<int>::const_reverse_iterator>(),
- "");
- static_assert(!internal::IsStandardContainerComplexIterator<int>(), "");
- static_assert(!internal::IsStandardContainerComplexIterator<abstract*>(), "");
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/process_memory_dump_unittest.cc b/base/trace_event/process_memory_dump_unittest.cc
deleted file mode 100644
index b33a39e..0000000
--- a/base/trace_event/process_memory_dump_unittest.cc
+++ /dev/null
@@ -1,584 +0,0 @@
-// Copyright 2015 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 "base/trace_event/process_memory_dump.h"
-
-#include <stddef.h>
-
-#include "base/memory/aligned_memory.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/shared_memory_tracker.h"
-#include "base/process/process_metrics.h"
-#include "base/trace_event/memory_allocator_dump_guid.h"
-#include "base/trace_event/memory_infra_background_whitelist.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "base/trace_event/trace_log.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include "winbase.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/mman.h>
-#endif
-
-#if defined(OS_IOS)
-#include "base/ios/ios_util.h"
-#endif
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-const MemoryDumpArgs kDetailedDumpArgs = {MemoryDumpLevelOfDetail::DETAILED};
-const char* const kTestDumpNameWhitelist[] = {
- "Whitelisted/TestName", "Whitelisted/TestName_0x?",
- "Whitelisted/0x?/TestName", "Whitelisted/0x?", nullptr};
-
-TracedValue* GetHeapDump(const ProcessMemoryDump& pmd, const char* name) {
- auto it = pmd.heap_dumps().find(name);
- return it == pmd.heap_dumps().end() ? nullptr : it->second.get();
-}
-
-void* Map(size_t size) {
-#if defined(OS_WIN)
- return ::VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT,
- PAGE_READWRITE);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- return ::mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON,
- 0, 0);
-#endif
-}
-
-void Unmap(void* addr, size_t size) {
-#if defined(OS_WIN)
- ::VirtualFree(addr, 0, MEM_DECOMMIT);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- ::munmap(addr, size);
-#else
-#error This architecture is not (yet) supported.
-#endif
-}
-
-} // namespace
-
-TEST(ProcessMemoryDumpTest, MoveConstructor) {
- auto heap_state = MakeRefCounted<HeapProfilerSerializationState>();
- heap_state->SetStackFrameDeduplicator(
- std::make_unique<StackFrameDeduplicator>());
- heap_state->SetTypeNameDeduplicator(std::make_unique<TypeNameDeduplicator>());
-
- ProcessMemoryDump pmd1 = ProcessMemoryDump(heap_state, kDetailedDumpArgs);
- pmd1.CreateAllocatorDump("mad1");
- pmd1.CreateAllocatorDump("mad2");
- pmd1.AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
- MemoryAllocatorDumpGuid(4242));
-
- ProcessMemoryDump pmd2(std::move(pmd1));
-
- EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad1"));
- EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad2"));
- EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
- pmd2.dump_args().level_of_detail);
- EXPECT_EQ(1u, pmd2.allocator_dumps_edges().size());
- EXPECT_EQ(heap_state.get(), pmd2.heap_profiler_serialization_state().get());
-
- // Check that calling serialization routines doesn't cause a crash.
- auto traced_value = std::make_unique<TracedValue>();
- pmd2.SerializeAllocatorDumpsInto(traced_value.get());
- pmd2.SerializeHeapProfilerDumpsInto(traced_value.get());
-}
-
-TEST(ProcessMemoryDumpTest, MoveAssignment) {
- auto heap_state = MakeRefCounted<HeapProfilerSerializationState>();
- heap_state->SetStackFrameDeduplicator(
- std::make_unique<StackFrameDeduplicator>());
- heap_state->SetTypeNameDeduplicator(std::make_unique<TypeNameDeduplicator>());
-
- ProcessMemoryDump pmd1 = ProcessMemoryDump(heap_state, kDetailedDumpArgs);
- pmd1.CreateAllocatorDump("mad1");
- pmd1.CreateAllocatorDump("mad2");
- pmd1.AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
- MemoryAllocatorDumpGuid(4242));
-
- ProcessMemoryDump pmd2(nullptr, {MemoryDumpLevelOfDetail::BACKGROUND});
- pmd2.CreateAllocatorDump("malloc");
-
- pmd2 = std::move(pmd1);
- EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad1"));
- EXPECT_EQ(1u, pmd2.allocator_dumps().count("mad2"));
- EXPECT_EQ(0u, pmd2.allocator_dumps().count("mad3"));
- EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
- pmd2.dump_args().level_of_detail);
- EXPECT_EQ(1u, pmd2.allocator_dumps_edges().size());
- EXPECT_EQ(heap_state.get(), pmd2.heap_profiler_serialization_state().get());
-
- // Check that calling serialization routines doesn't cause a crash.
- auto traced_value = std::make_unique<TracedValue>();
- pmd2.SerializeAllocatorDumpsInto(traced_value.get());
- pmd2.SerializeHeapProfilerDumpsInto(traced_value.get());
-}
-
-TEST(ProcessMemoryDumpTest, Clear) {
- std::unique_ptr<ProcessMemoryDump> pmd1(
- new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
- pmd1->CreateAllocatorDump("mad1");
- pmd1->CreateAllocatorDump("mad2");
- ASSERT_FALSE(pmd1->allocator_dumps().empty());
-
- pmd1->AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
- MemoryAllocatorDumpGuid(4242));
-
- MemoryAllocatorDumpGuid shared_mad_guid1(1);
- MemoryAllocatorDumpGuid shared_mad_guid2(2);
- pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
- pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid2);
-
- pmd1->Clear();
- ASSERT_TRUE(pmd1->allocator_dumps().empty());
- ASSERT_TRUE(pmd1->allocator_dumps_edges().empty());
- ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad1"));
- ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad2"));
- ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
- ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
-
- // Check that calling serialization routines doesn't cause a crash.
- auto traced_value = std::make_unique<TracedValue>();
- pmd1->SerializeAllocatorDumpsInto(traced_value.get());
- pmd1->SerializeHeapProfilerDumpsInto(traced_value.get());
-
- // Check that the pmd can be reused and behaves as expected.
- auto* mad1 = pmd1->CreateAllocatorDump("mad1");
- auto* mad3 = pmd1->CreateAllocatorDump("mad3");
- auto* shared_mad1 = pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
- auto* shared_mad2 =
- pmd1->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
- ASSERT_EQ(4u, pmd1->allocator_dumps().size());
- ASSERT_EQ(mad1, pmd1->GetAllocatorDump("mad1"));
- ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad2"));
- ASSERT_EQ(mad3, pmd1->GetAllocatorDump("mad3"));
- ASSERT_EQ(shared_mad1, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
- ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
- ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
- ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad2->flags());
-
- traced_value.reset(new TracedValue);
- pmd1->SerializeAllocatorDumpsInto(traced_value.get());
- pmd1->SerializeHeapProfilerDumpsInto(traced_value.get());
-
- pmd1.reset();
-}
-
-TEST(ProcessMemoryDumpTest, TakeAllDumpsFrom) {
- std::unique_ptr<TracedValue> traced_value(new TracedValue);
- std::unordered_map<AllocationContext, AllocationMetrics> metrics_by_context;
- metrics_by_context[AllocationContext()] = {1, 1};
- TraceEventMemoryOverhead overhead;
-
- scoped_refptr<HeapProfilerSerializationState>
- heap_profiler_serialization_state = new HeapProfilerSerializationState;
- heap_profiler_serialization_state->SetStackFrameDeduplicator(
- WrapUnique(new StackFrameDeduplicator));
- heap_profiler_serialization_state->SetTypeNameDeduplicator(
- WrapUnique(new TypeNameDeduplicator));
- std::unique_ptr<ProcessMemoryDump> pmd1(new ProcessMemoryDump(
- heap_profiler_serialization_state.get(), kDetailedDumpArgs));
- auto* mad1_1 = pmd1->CreateAllocatorDump("pmd1/mad1");
- auto* mad1_2 = pmd1->CreateAllocatorDump("pmd1/mad2");
- pmd1->AddOwnershipEdge(mad1_1->guid(), mad1_2->guid());
- pmd1->DumpHeapUsage(metrics_by_context, overhead, "pmd1/heap_dump1");
- pmd1->DumpHeapUsage(metrics_by_context, overhead, "pmd1/heap_dump2");
-
- std::unique_ptr<ProcessMemoryDump> pmd2(new ProcessMemoryDump(
- heap_profiler_serialization_state.get(), kDetailedDumpArgs));
- auto* mad2_1 = pmd2->CreateAllocatorDump("pmd2/mad1");
- auto* mad2_2 = pmd2->CreateAllocatorDump("pmd2/mad2");
- pmd2->AddOwnershipEdge(mad2_1->guid(), mad2_2->guid());
- pmd2->DumpHeapUsage(metrics_by_context, overhead, "pmd2/heap_dump1");
- pmd2->DumpHeapUsage(metrics_by_context, overhead, "pmd2/heap_dump2");
-
- MemoryAllocatorDumpGuid shared_mad_guid1(1);
- MemoryAllocatorDumpGuid shared_mad_guid2(2);
- auto* shared_mad1 = pmd2->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
- auto* shared_mad2 =
- pmd2->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
-
- pmd1->TakeAllDumpsFrom(pmd2.get());
-
- // Make sure that pmd2 is empty but still usable after it has been emptied.
- ASSERT_TRUE(pmd2->allocator_dumps().empty());
- ASSERT_TRUE(pmd2->allocator_dumps_edges().empty());
- ASSERT_TRUE(pmd2->heap_dumps().empty());
- pmd2->CreateAllocatorDump("pmd2/this_mad_stays_with_pmd2");
- ASSERT_EQ(1u, pmd2->allocator_dumps().size());
- ASSERT_EQ(1u, pmd2->allocator_dumps().count("pmd2/this_mad_stays_with_pmd2"));
- pmd2->AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
- MemoryAllocatorDumpGuid(4242));
-
- // Check that calling serialization routines doesn't cause a crash.
- pmd2->SerializeAllocatorDumpsInto(traced_value.get());
- pmd2->SerializeHeapProfilerDumpsInto(traced_value.get());
-
- // Free the |pmd2| to check that the memory ownership of the two MAD(s)
- // has been transferred to |pmd1|.
- pmd2.reset();
-
- // Now check that |pmd1| has been effectively merged.
- ASSERT_EQ(6u, pmd1->allocator_dumps().size());
- ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad1"));
- ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad2"));
- ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd2/mad1"));
- ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad2"));
- ASSERT_EQ(2u, pmd1->allocator_dumps_edges().size());
- ASSERT_EQ(shared_mad1, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
- ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
- ASSERT_TRUE(MemoryAllocatorDump::Flags::WEAK & shared_mad2->flags());
- ASSERT_EQ(4u, pmd1->heap_dumps().size());
- ASSERT_TRUE(GetHeapDump(*pmd1, "pmd1/heap_dump1") != nullptr);
- ASSERT_TRUE(GetHeapDump(*pmd1, "pmd1/heap_dump2") != nullptr);
- ASSERT_TRUE(GetHeapDump(*pmd1, "pmd2/heap_dump1") != nullptr);
- ASSERT_TRUE(GetHeapDump(*pmd1, "pmd2/heap_dump2") != nullptr);
-
- // Check that calling serialization routines doesn't cause a crash.
- traced_value.reset(new TracedValue);
- pmd1->SerializeAllocatorDumpsInto(traced_value.get());
- pmd1->SerializeHeapProfilerDumpsInto(traced_value.get());
-
- pmd1.reset();
-}
-
-TEST(ProcessMemoryDumpTest, OverrideOwnershipEdge) {
- std::unique_ptr<ProcessMemoryDump> pmd(
- new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
-
- auto* shm_dump1 = pmd->CreateAllocatorDump("shared_mem/seg1");
- auto* shm_dump2 = pmd->CreateAllocatorDump("shared_mem/seg2");
- auto* shm_dump3 = pmd->CreateAllocatorDump("shared_mem/seg3");
- auto* shm_dump4 = pmd->CreateAllocatorDump("shared_mem/seg4");
-
- // Create one allocation with an auto-assigned guid and mark it as a
- // suballocation of "fakealloc/allocated_objects".
- auto* child1_dump = pmd->CreateAllocatorDump("shared_mem/child/seg1");
- pmd->AddOverridableOwnershipEdge(child1_dump->guid(), shm_dump1->guid(),
- 0 /* importance */);
- auto* child2_dump = pmd->CreateAllocatorDump("shared_mem/child/seg2");
- pmd->AddOwnershipEdge(child2_dump->guid(), shm_dump2->guid(),
- 3 /* importance */);
- MemoryAllocatorDumpGuid shared_mad_guid(1);
- pmd->CreateSharedGlobalAllocatorDump(shared_mad_guid);
- pmd->AddOverridableOwnershipEdge(shm_dump3->guid(), shared_mad_guid,
- 0 /* importance */);
- auto* child4_dump = pmd->CreateAllocatorDump("shared_mem/child/seg4");
- pmd->AddOverridableOwnershipEdge(child4_dump->guid(), shm_dump4->guid(),
- 4 /* importance */);
-
- const ProcessMemoryDump::AllocatorDumpEdgesMap& edges =
- pmd->allocator_dumps_edges();
- EXPECT_EQ(4u, edges.size());
- EXPECT_EQ(shm_dump1->guid(), edges.find(child1_dump->guid())->second.target);
- EXPECT_EQ(0, edges.find(child1_dump->guid())->second.importance);
- EXPECT_TRUE(edges.find(child1_dump->guid())->second.overridable);
- EXPECT_EQ(shm_dump2->guid(), edges.find(child2_dump->guid())->second.target);
- EXPECT_EQ(3, edges.find(child2_dump->guid())->second.importance);
- EXPECT_FALSE(edges.find(child2_dump->guid())->second.overridable);
- EXPECT_EQ(shared_mad_guid, edges.find(shm_dump3->guid())->second.target);
- EXPECT_EQ(0, edges.find(shm_dump3->guid())->second.importance);
- EXPECT_TRUE(edges.find(shm_dump3->guid())->second.overridable);
- EXPECT_EQ(shm_dump4->guid(), edges.find(child4_dump->guid())->second.target);
- EXPECT_EQ(4, edges.find(child4_dump->guid())->second.importance);
- EXPECT_TRUE(edges.find(child4_dump->guid())->second.overridable);
-
- // These should override old edges:
- pmd->AddOwnershipEdge(child1_dump->guid(), shm_dump1->guid(),
- 1 /* importance */);
- pmd->AddOwnershipEdge(shm_dump3->guid(), shared_mad_guid, 2 /* importance */);
- // This should not change the old edges.
- pmd->AddOverridableOwnershipEdge(child2_dump->guid(), shm_dump2->guid(),
- 0 /* importance */);
- pmd->AddOwnershipEdge(child4_dump->guid(), shm_dump4->guid(),
- 0 /* importance */);
-
- EXPECT_EQ(4u, edges.size());
- EXPECT_EQ(shm_dump1->guid(), edges.find(child1_dump->guid())->second.target);
- EXPECT_EQ(1, edges.find(child1_dump->guid())->second.importance);
- EXPECT_FALSE(edges.find(child1_dump->guid())->second.overridable);
- EXPECT_EQ(shm_dump2->guid(), edges.find(child2_dump->guid())->second.target);
- EXPECT_EQ(3, edges.find(child2_dump->guid())->second.importance);
- EXPECT_FALSE(edges.find(child2_dump->guid())->second.overridable);
- EXPECT_EQ(shared_mad_guid, edges.find(shm_dump3->guid())->second.target);
- EXPECT_EQ(2, edges.find(shm_dump3->guid())->second.importance);
- EXPECT_FALSE(edges.find(shm_dump3->guid())->second.overridable);
- EXPECT_EQ(shm_dump4->guid(), edges.find(child4_dump->guid())->second.target);
- EXPECT_EQ(4, edges.find(child4_dump->guid())->second.importance);
- EXPECT_FALSE(edges.find(child4_dump->guid())->second.overridable);
-}
-
-TEST(ProcessMemoryDumpTest, Suballocations) {
- std::unique_ptr<ProcessMemoryDump> pmd(
- new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
- const std::string allocator_dump_name = "fakealloc/allocated_objects";
- pmd->CreateAllocatorDump(allocator_dump_name);
-
- // Create one allocation with an auto-assigned guid and mark it as a
- // suballocation of "fakealloc/allocated_objects".
- auto* pic1_dump = pmd->CreateAllocatorDump("picturemanager/picture1");
- pmd->AddSuballocation(pic1_dump->guid(), allocator_dump_name);
-
- // Same here, but this time create an allocation with an explicit guid.
- auto* pic2_dump = pmd->CreateAllocatorDump("picturemanager/picture2",
- MemoryAllocatorDumpGuid(0x42));
- pmd->AddSuballocation(pic2_dump->guid(), allocator_dump_name);
-
- // Now check that AddSuballocation() has created anonymous child dumps under
- // "fakealloc/allocated_objects".
- auto anon_node_1_it = pmd->allocator_dumps().find(
- allocator_dump_name + "/__" + pic1_dump->guid().ToString());
- ASSERT_NE(pmd->allocator_dumps().end(), anon_node_1_it);
-
- auto anon_node_2_it =
- pmd->allocator_dumps().find(allocator_dump_name + "/__42");
- ASSERT_NE(pmd->allocator_dumps().end(), anon_node_2_it);
-
- // Finally check that AddSuballocation() has created also the
- // edges between the pictures and the anonymous allocator child dumps.
- bool found_edge[2]{false, false};
- for (const auto& e : pmd->allocator_dumps_edges()) {
- found_edge[0] |= (e.first == pic1_dump->guid() &&
- e.second.target == anon_node_1_it->second->guid());
- found_edge[1] |= (e.first == pic2_dump->guid() &&
- e.second.target == anon_node_2_it->second->guid());
- }
- ASSERT_TRUE(found_edge[0]);
- ASSERT_TRUE(found_edge[1]);
-
- // Check that calling serialization routines doesn't cause a crash.
- std::unique_ptr<TracedValue> traced_value(new TracedValue);
- pmd->SerializeAllocatorDumpsInto(traced_value.get());
- pmd->SerializeHeapProfilerDumpsInto(traced_value.get());
-
- pmd.reset();
-}
-
-TEST(ProcessMemoryDumpTest, GlobalAllocatorDumpTest) {
- std::unique_ptr<ProcessMemoryDump> pmd(
- new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
- MemoryAllocatorDumpGuid shared_mad_guid(1);
- auto* shared_mad1 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
- ASSERT_EQ(shared_mad_guid, shared_mad1->guid());
- ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
-
- auto* shared_mad2 = pmd->GetSharedGlobalAllocatorDump(shared_mad_guid);
- ASSERT_EQ(shared_mad1, shared_mad2);
- ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
-
- auto* shared_mad3 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
- ASSERT_EQ(shared_mad1, shared_mad3);
- ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
-
- auto* shared_mad4 = pmd->CreateSharedGlobalAllocatorDump(shared_mad_guid);
- ASSERT_EQ(shared_mad1, shared_mad4);
- ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
-
- auto* shared_mad5 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
- ASSERT_EQ(shared_mad1, shared_mad5);
- ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
-}
-
-TEST(ProcessMemoryDumpTest, SharedMemoryOwnershipTest) {
- std::unique_ptr<ProcessMemoryDump> pmd(
- new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
- const ProcessMemoryDump::AllocatorDumpEdgesMap& edges =
- pmd->allocator_dumps_edges();
-
- auto* client_dump2 = pmd->CreateAllocatorDump("discardable/segment2");
- auto shm_token2 = UnguessableToken::Create();
- MemoryAllocatorDumpGuid shm_local_guid2 =
- pmd->GetDumpId(SharedMemoryTracker::GetDumpNameForTracing(shm_token2));
- MemoryAllocatorDumpGuid shm_global_guid2 =
- SharedMemoryTracker::GetGlobalDumpIdForTracing(shm_token2);
- pmd->AddOverridableOwnershipEdge(shm_local_guid2, shm_global_guid2,
- 0 /* importance */);
-
- pmd->CreateSharedMemoryOwnershipEdge(client_dump2->guid(), shm_token2,
- 1 /* importance */);
- EXPECT_EQ(2u, edges.size());
-
- EXPECT_EQ(shm_global_guid2, edges.find(shm_local_guid2)->second.target);
- EXPECT_EQ(1, edges.find(shm_local_guid2)->second.importance);
- EXPECT_FALSE(edges.find(shm_local_guid2)->second.overridable);
- EXPECT_EQ(shm_local_guid2, edges.find(client_dump2->guid())->second.target);
- EXPECT_EQ(1, edges.find(client_dump2->guid())->second.importance);
- EXPECT_FALSE(edges.find(client_dump2->guid())->second.overridable);
-}
-
-TEST(ProcessMemoryDumpTest, BackgroundModeTest) {
- MemoryDumpArgs background_args = {MemoryDumpLevelOfDetail::BACKGROUND};
- std::unique_ptr<ProcessMemoryDump> pmd(
- new ProcessMemoryDump(nullptr, background_args));
- ProcessMemoryDump::is_black_hole_non_fatal_for_testing_ = true;
- SetAllocatorDumpNameWhitelistForTesting(kTestDumpNameWhitelist);
- MemoryAllocatorDump* black_hole_mad = pmd->GetBlackHoleMad();
-
- // Invalid dump names.
- EXPECT_EQ(black_hole_mad,
- pmd->CreateAllocatorDump("NotWhitelisted/TestName"));
- EXPECT_EQ(black_hole_mad, pmd->CreateAllocatorDump("TestName"));
- EXPECT_EQ(black_hole_mad, pmd->CreateAllocatorDump("Whitelisted/Test"));
- EXPECT_EQ(black_hole_mad,
- pmd->CreateAllocatorDump("Not/Whitelisted/TestName"));
- EXPECT_EQ(black_hole_mad,
- pmd->CreateAllocatorDump("Whitelisted/TestName/Google"));
- EXPECT_EQ(black_hole_mad,
- pmd->CreateAllocatorDump("Whitelisted/TestName/0x1a2Google"));
- EXPECT_EQ(black_hole_mad,
- pmd->CreateAllocatorDump("Whitelisted/TestName/__12/Google"));
-
- // Suballocations.
- MemoryAllocatorDumpGuid guid(1);
- pmd->AddSuballocation(guid, "malloc/allocated_objects");
- EXPECT_EQ(0u, pmd->allocator_dumps_edges_.size());
- EXPECT_EQ(0u, pmd->allocator_dumps_.size());
-
- // Global dumps.
- EXPECT_NE(black_hole_mad, pmd->CreateSharedGlobalAllocatorDump(guid));
- EXPECT_NE(black_hole_mad, pmd->CreateWeakSharedGlobalAllocatorDump(guid));
- EXPECT_NE(black_hole_mad, pmd->GetSharedGlobalAllocatorDump(guid));
-
- // Valid dump names.
- EXPECT_NE(black_hole_mad, pmd->CreateAllocatorDump("Whitelisted/TestName"));
- EXPECT_NE(black_hole_mad,
- pmd->CreateAllocatorDump("Whitelisted/TestName_0xA1b2"));
- EXPECT_NE(black_hole_mad,
- pmd->CreateAllocatorDump("Whitelisted/0xaB/TestName"));
-
- // GetAllocatorDump is consistent.
- EXPECT_EQ(black_hole_mad, pmd->GetAllocatorDump("NotWhitelisted/TestName"));
- EXPECT_NE(black_hole_mad, pmd->GetAllocatorDump("Whitelisted/TestName"));
-
- // Test whitelisted entries.
- ASSERT_TRUE(IsMemoryAllocatorDumpNameWhitelisted("Whitelisted/TestName"));
-
- // Global dumps should be whitelisted.
- ASSERT_TRUE(IsMemoryAllocatorDumpNameWhitelisted("global/13456"));
-
- // Global dumps with non-guids should not be.
- ASSERT_FALSE(IsMemoryAllocatorDumpNameWhitelisted("global/random"));
-
- // Random names should not.
- ASSERT_FALSE(IsMemoryAllocatorDumpNameWhitelisted("NotWhitelisted/TestName"));
-
- // Check hex processing.
- ASSERT_TRUE(IsMemoryAllocatorDumpNameWhitelisted("Whitelisted/0xA1b2"));
-}
-
-TEST(ProcessMemoryDumpTest, GuidsTest) {
- MemoryDumpArgs dump_args = {MemoryDumpLevelOfDetail::DETAILED};
-
- const auto process_token_one = UnguessableToken::Create();
- const auto process_token_two = UnguessableToken::Create();
-
- ProcessMemoryDump pmd1(nullptr, dump_args);
- pmd1.set_process_token_for_testing(process_token_one);
- MemoryAllocatorDump* mad1 = pmd1.CreateAllocatorDump("foo");
-
- ProcessMemoryDump pmd2(nullptr, dump_args);
- pmd2.set_process_token_for_testing(process_token_one);
- MemoryAllocatorDump* mad2 = pmd2.CreateAllocatorDump("foo");
-
- // If we don't pass the argument we get a random PMD:
- ProcessMemoryDump pmd3(nullptr, dump_args);
- MemoryAllocatorDump* mad3 = pmd3.CreateAllocatorDump("foo");
-
- // PMD's for different processes produce different GUIDs even for the same
- // names:
- ProcessMemoryDump pmd4(nullptr, dump_args);
- pmd4.set_process_token_for_testing(process_token_two);
- MemoryAllocatorDump* mad4 = pmd4.CreateAllocatorDump("foo");
-
- ASSERT_EQ(mad1->guid(), mad2->guid());
-
- ASSERT_NE(mad2->guid(), mad3->guid());
- ASSERT_NE(mad3->guid(), mad4->guid());
- ASSERT_NE(mad4->guid(), mad2->guid());
-
- ASSERT_EQ(mad1->guid(), pmd1.GetDumpId("foo"));
-}
-
-#if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-TEST(ProcessMemoryDumpTest, CountResidentBytes) {
- const size_t page_size = ProcessMemoryDump::GetSystemPageSize();
-
- // Allocate few page of dirty memory and check if it is resident.
- const size_t size1 = 5 * page_size;
- void* memory1 = Map(size1);
- memset(memory1, 0, size1);
- size_t res1 = ProcessMemoryDump::CountResidentBytes(memory1, size1);
- ASSERT_EQ(res1, size1);
- Unmap(memory1, size1);
-
- // Allocate a large memory segment (> 8Mib).
- const size_t kVeryLargeMemorySize = 15 * 1024 * 1024;
- void* memory2 = Map(kVeryLargeMemorySize);
- memset(memory2, 0, kVeryLargeMemorySize);
- size_t res2 =
- ProcessMemoryDump::CountResidentBytes(memory2, kVeryLargeMemorySize);
- ASSERT_EQ(res2, kVeryLargeMemorySize);
- Unmap(memory2, kVeryLargeMemorySize);
-}
-
-TEST(ProcessMemoryDumpTest, CountResidentBytesInSharedMemory) {
-#if defined(OS_IOS)
- // TODO(crbug.com/748410): Reenable this test.
- if (!base::ios::IsRunningOnIOS10OrLater()) {
- return;
- }
-#endif
-
- const size_t page_size = ProcessMemoryDump::GetSystemPageSize();
-
- // Allocate few page of dirty memory and check if it is resident.
- const size_t size1 = 5 * page_size;
- SharedMemory shared_memory1;
- shared_memory1.CreateAndMapAnonymous(size1);
- memset(shared_memory1.memory(), 0, size1);
- base::Optional<size_t> res1 =
- ProcessMemoryDump::CountResidentBytesInSharedMemory(
- shared_memory1.memory(), shared_memory1.mapped_size());
- ASSERT_TRUE(res1.has_value());
- ASSERT_EQ(res1.value(), size1);
- shared_memory1.Unmap();
- shared_memory1.Close();
-
- // Allocate a large memory segment (> 8Mib).
- const size_t kVeryLargeMemorySize = 15 * 1024 * 1024;
- SharedMemory shared_memory2;
- shared_memory2.CreateAndMapAnonymous(kVeryLargeMemorySize);
- memset(shared_memory2.memory(), 0, kVeryLargeMemorySize);
- base::Optional<size_t> res2 =
- ProcessMemoryDump::CountResidentBytesInSharedMemory(
- shared_memory2.memory(), shared_memory2.mapped_size());
- ASSERT_TRUE(res2.has_value());
- ASSERT_EQ(res2.value(), kVeryLargeMemorySize);
- shared_memory2.Unmap();
- shared_memory2.Close();
-
- // Allocate a large memory segment, but touch about half of all pages.
- const size_t kTouchedMemorySize = 7 * 1024 * 1024;
- SharedMemory shared_memory3;
- shared_memory3.CreateAndMapAnonymous(kVeryLargeMemorySize);
- memset(shared_memory3.memory(), 0, kTouchedMemorySize);
- base::Optional<size_t> res3 =
- ProcessMemoryDump::CountResidentBytesInSharedMemory(
- shared_memory3.memory(), shared_memory3.mapped_size());
- ASSERT_TRUE(res3.has_value());
- ASSERT_EQ(res3.value(), kTouchedMemorySize);
- shared_memory3.Unmap();
- shared_memory3.Close();
-}
-#endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/trace_category_unittest.cc b/base/trace_event/trace_category_unittest.cc
deleted file mode 100644
index 964064e..0000000
--- a/base/trace_event/trace_category_unittest.cc
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright 2016 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 <string.h>
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "base/trace_event/category_registry.h"
-#include "base/trace_event/trace_category.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-// Static initializers are generally forbidden. However, in the past we ran in
-// the case of some test using tracing in a static initializer. This test checks
-// That the category registry doesn't rely on static initializers itself and is
-// functional even if called from another static initializer.
-bool Initializer() {
- return CategoryRegistry::kCategoryMetadata &&
- CategoryRegistry::kCategoryMetadata->is_valid();
-}
-bool g_initializer_check = Initializer();
-
-class TraceCategoryTest : public testing::Test {
- public:
- void SetUp() override { CategoryRegistry::Initialize(); }
-
- void TearDown() override { CategoryRegistry::ResetForTesting(); }
-
- static bool GetOrCreateCategoryByName(const char* name, TraceCategory** cat) {
- static LazyInstance<Lock>::Leaky g_lock = LAZY_INSTANCE_INITIALIZER;
- bool is_new_cat = false;
- *cat = CategoryRegistry::GetCategoryByName(name);
- if (!*cat) {
- AutoLock lock(g_lock.Get());
- is_new_cat = CategoryRegistry::GetOrCreateCategoryLocked(
- name, [](TraceCategory*) {}, cat);
- }
- return is_new_cat;
- };
-
- static CategoryRegistry::Range GetAllCategories() {
- return CategoryRegistry::GetAllCategories();
- }
-
- static void TestRaceThreadMain(WaitableEvent* event) {
- TraceCategory* cat = nullptr;
- event->Wait();
- GetOrCreateCategoryByName("__test_race", &cat);
- EXPECT_NE(nullptr, cat);
- }
-};
-
-TEST_F(TraceCategoryTest, Basic) {
- ASSERT_NE(nullptr, CategoryRegistry::kCategoryMetadata);
- ASSERT_TRUE(CategoryRegistry::kCategoryMetadata->is_valid());
- ASSERT_FALSE(CategoryRegistry::kCategoryMetadata->is_enabled());
-
- // Metadata category is built-in and should create a new category.
- TraceCategory* cat_meta = nullptr;
- const char* kMetadataName = CategoryRegistry::kCategoryMetadata->name();
- ASSERT_FALSE(GetOrCreateCategoryByName(kMetadataName, &cat_meta));
- ASSERT_EQ(CategoryRegistry::kCategoryMetadata, cat_meta);
-
- TraceCategory* cat_1 = nullptr;
- ASSERT_TRUE(GetOrCreateCategoryByName("__test_basic_ab", &cat_1));
- ASSERT_FALSE(cat_1->is_enabled());
- ASSERT_EQ(0u, cat_1->enabled_filters());
- cat_1->set_state_flag(TraceCategory::ENABLED_FOR_RECORDING);
- cat_1->set_state_flag(TraceCategory::ENABLED_FOR_FILTERING);
- ASSERT_EQ(TraceCategory::ENABLED_FOR_RECORDING |
- TraceCategory::ENABLED_FOR_FILTERING,
- cat_1->state());
-
- cat_1->set_enabled_filters(129);
- ASSERT_EQ(129u, cat_1->enabled_filters());
- ASSERT_EQ(cat_1, CategoryRegistry::GetCategoryByStatePtr(cat_1->state_ptr()));
-
- cat_1->clear_state_flag(TraceCategory::ENABLED_FOR_FILTERING);
- ASSERT_EQ(TraceCategory::ENABLED_FOR_RECORDING, cat_1->state());
- ASSERT_EQ(TraceCategory::ENABLED_FOR_RECORDING, *cat_1->state_ptr());
- ASSERT_TRUE(cat_1->is_enabled());
-
- TraceCategory* cat_2 = nullptr;
- ASSERT_TRUE(GetOrCreateCategoryByName("__test_basic_a", &cat_2));
- ASSERT_FALSE(cat_2->is_enabled());
- cat_2->set_state_flag(TraceCategory::ENABLED_FOR_RECORDING);
-
- TraceCategory* cat_2_copy = nullptr;
- ASSERT_FALSE(GetOrCreateCategoryByName("__test_basic_a", &cat_2_copy));
- ASSERT_EQ(cat_2, cat_2_copy);
-
- TraceCategory* cat_3 = nullptr;
- ASSERT_TRUE(
- GetOrCreateCategoryByName("__test_basic_ab,__test_basic_a", &cat_3));
- ASSERT_FALSE(cat_3->is_enabled());
- ASSERT_EQ(0u, cat_3->enabled_filters());
-
- int num_test_categories_seen = 0;
- for (const TraceCategory& cat : GetAllCategories()) {
- if (strcmp(cat.name(), kMetadataName) == 0)
- ASSERT_TRUE(CategoryRegistry::IsBuiltinCategory(&cat));
-
- if (strncmp(cat.name(), "__test_basic_", 13) == 0) {
- ASSERT_FALSE(CategoryRegistry::IsBuiltinCategory(&cat));
- num_test_categories_seen++;
- }
- }
- ASSERT_EQ(3, num_test_categories_seen);
- ASSERT_TRUE(g_initializer_check);
-}
-
-// Tries to cover the case of multiple threads creating the same category
-// simultaneously. Should never end up with distinct entries with the same name.
-TEST_F(TraceCategoryTest, ThreadRaces) {
- const int kNumThreads = 32;
- std::unique_ptr<Thread> threads[kNumThreads];
- for (int i = 0; i < kNumThreads; i++) {
- threads[i].reset(new Thread("test thread"));
- threads[i]->Start();
- }
- WaitableEvent sync_event(WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED);
- for (int i = 0; i < kNumThreads; i++) {
- threads[i]->task_runner()->PostTask(
- FROM_HERE, BindOnce(&TestRaceThreadMain, Unretained(&sync_event)));
- }
- sync_event.Signal();
- for (int i = 0; i < kNumThreads; i++)
- threads[i]->Stop();
-
- int num_times_seen = 0;
- for (const TraceCategory& cat : GetAllCategories()) {
- if (strcmp(cat.name(), "__test_race") == 0)
- num_times_seen++;
- }
- ASSERT_EQ(1, num_times_seen);
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/trace_config_unittest.cc b/base/trace_event/trace_config_unittest.cc
deleted file mode 100644
index 3cb6d61..0000000
--- a/base/trace_event/trace_config_unittest.cc
+++ /dev/null
@@ -1,673 +0,0 @@
-// Copyright 2015 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 <stddef.h>
-
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/macros.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/trace_config.h"
-#include "base/trace_event/trace_config_memory_test_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-const char kDefaultTraceConfigString[] =
- "{"
- "\"enable_argument_filter\":false,"
- "\"enable_systrace\":false,"
- "\"record_mode\":\"record-until-full\""
- "}";
-
-const char kCustomTraceConfigString[] =
- "{"
- "\"enable_argument_filter\":true,"
- "\"enable_systrace\":true,"
- "\"event_filters\":["
- "{"
- "\"excluded_categories\":[\"unfiltered_cat\"],"
- "\"filter_args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
- "\"filter_predicate\":\"event_whitelist_predicate\","
- "\"included_categories\":[\"*\"]"
- "}"
- "],"
- "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
- "\"included_categories\":["
- "\"included\","
- "\"inc_pattern*\","
- "\"disabled-by-default-cc\","
- "\"disabled-by-default-memory-infra\"],"
- "\"memory_dump_config\":{"
- "\"allowed_dump_modes\":[\"background\",\"light\",\"detailed\"],"
- "\"heap_profiler_options\":{"
- "\"breakdown_threshold_bytes\":10240"
- "},"
- "\"triggers\":["
- "{"
- "\"min_time_between_dumps_ms\":50,"
- "\"mode\":\"light\","
- "\"type\":\"periodic_interval\""
- "},"
- "{"
- "\"min_time_between_dumps_ms\":1000,"
- "\"mode\":\"detailed\","
- "\"type\":\"peak_memory_usage\""
- "}"
- "]"
- "},"
- "\"record_mode\":\"record-continuously\""
- "}";
-
-void CheckDefaultTraceConfigBehavior(const TraceConfig& tc) {
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
-
- // Default trace config enables every category filter except the
- // disabled-by-default-* ones.
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("not-excluded-category"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
-
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1,not-excluded-category"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("Category1,disabled-by-default-cc"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled(
- "disabled-by-default-cc,disabled-by-default-cc2"));
-}
-
-} // namespace
-
-TEST(TraceConfigTest, TraceConfigFromValidLegacyFormat) {
- // From trace options strings
- TraceConfig config("", "record-until-full");
- EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", "record-continuously");
- EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", "trace-to-console");
- EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", "record-as-much-as-possible");
- EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-as-much-as-possible",
- config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", "enable-systrace, record-continuously");
- EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode());
- EXPECT_TRUE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-continuously,enable-systrace",
- config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", "enable-argument-filter,record-as-much-as-possible");
- EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_TRUE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-as-much-as-possible,enable-argument-filter",
- config.ToTraceOptionsString().c_str());
-
- config = TraceConfig(
- "",
- "enable-systrace,trace-to-console,enable-argument-filter");
- EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode());
- EXPECT_TRUE(config.IsSystraceEnabled());
- EXPECT_TRUE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ(
- "trace-to-console,enable-systrace,enable-argument-filter",
- config.ToTraceOptionsString().c_str());
-
- config = TraceConfig(
- "", "record-continuously, record-until-full, trace-to-console");
- EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str());
-
- // From TraceRecordMode
- config = TraceConfig("", RECORD_UNTIL_FULL);
- EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", RECORD_CONTINUOUSLY);
- EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", ECHO_TO_CONSOLE);
- EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("trace-to-console", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("", RECORD_AS_MUCH_AS_POSSIBLE);
- EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("record-as-much-as-possible",
- config.ToTraceOptionsString().c_str());
-
- // From category filter strings
- config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*", "");
- EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*",
- config.ToCategoryFilterString().c_str());
-
- config = TraceConfig("only_inc_cat", "");
- EXPECT_STREQ("only_inc_cat", config.ToCategoryFilterString().c_str());
-
- config = TraceConfig("-only_exc_cat", "");
- EXPECT_STREQ("-only_exc_cat", config.ToCategoryFilterString().c_str());
-
- config = TraceConfig("disabled-by-default-cc,-excluded", "");
- EXPECT_STREQ("disabled-by-default-cc,-excluded",
- config.ToCategoryFilterString().c_str());
-
- config = TraceConfig("disabled-by-default-cc,included", "");
- EXPECT_STREQ("included,disabled-by-default-cc",
- config.ToCategoryFilterString().c_str());
-
- // From both trace options and category filter strings
- config = TraceConfig("", "");
- EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("", config.ToCategoryFilterString().c_str());
- EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*",
- "enable-systrace, trace-to-console");
- EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode());
- EXPECT_TRUE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*",
- config.ToCategoryFilterString().c_str());
- EXPECT_STREQ("trace-to-console,enable-systrace",
- config.ToTraceOptionsString().c_str());
-
- // From both trace options and category filter strings with spaces.
- config = TraceConfig(" included , -excluded, inc_pattern*, ,-exc_pattern* ",
- "enable-systrace, ,trace-to-console ");
- EXPECT_EQ(ECHO_TO_CONSOLE, config.GetTraceRecordMode());
- EXPECT_TRUE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*",
- config.ToCategoryFilterString().c_str());
- EXPECT_STREQ("trace-to-console,enable-systrace",
- config.ToTraceOptionsString().c_str());
-
- // From category filter string and TraceRecordMode
- config = TraceConfig("included,-excluded,inc_pattern*,-exc_pattern*",
- RECORD_CONTINUOUSLY);
- EXPECT_EQ(RECORD_CONTINUOUSLY, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("included,inc_pattern*,-excluded,-exc_pattern*",
- config.ToCategoryFilterString().c_str());
- EXPECT_STREQ("record-continuously", config.ToTraceOptionsString().c_str());
-}
-
-TEST(TraceConfigTest, TraceConfigFromInvalidLegacyStrings) {
- TraceConfig config("", "foo-bar-baz");
- EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode());
- EXPECT_FALSE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("", config.ToCategoryFilterString().c_str());
- EXPECT_STREQ("record-until-full", config.ToTraceOptionsString().c_str());
-
- config = TraceConfig("arbitrary-category", "foo-bar-baz, enable-systrace");
- EXPECT_EQ(RECORD_UNTIL_FULL, config.GetTraceRecordMode());
- EXPECT_TRUE(config.IsSystraceEnabled());
- EXPECT_FALSE(config.IsArgumentFilterEnabled());
- EXPECT_STREQ("arbitrary-category", config.ToCategoryFilterString().c_str());
- EXPECT_STREQ("record-until-full,enable-systrace",
- config.ToTraceOptionsString().c_str());
-}
-
-TEST(TraceConfigTest, ConstructDefaultTraceConfig) {
- TraceConfig tc;
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- // Constructors from category filter string and trace option string.
- TraceConfig tc_asterisk("*", "");
- EXPECT_STREQ("*", tc_asterisk.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc_asterisk);
-
- TraceConfig tc_empty_category_filter("", "");
- EXPECT_STREQ("", tc_empty_category_filter.ToCategoryFilterString().c_str());
- EXPECT_STREQ(kDefaultTraceConfigString,
- tc_empty_category_filter.ToString().c_str());
- CheckDefaultTraceConfigBehavior(tc_empty_category_filter);
-
- // Constructor from JSON formated config string.
- TraceConfig tc_empty_json_string("");
- EXPECT_STREQ("", tc_empty_json_string.ToCategoryFilterString().c_str());
- EXPECT_STREQ(kDefaultTraceConfigString,
- tc_empty_json_string.ToString().c_str());
- CheckDefaultTraceConfigBehavior(tc_empty_json_string);
-
- // Constructor from dictionary value.
- DictionaryValue dict;
- TraceConfig tc_dict(dict);
- EXPECT_STREQ("", tc_dict.ToCategoryFilterString().c_str());
- EXPECT_STREQ(kDefaultTraceConfigString, tc_dict.ToString().c_str());
- CheckDefaultTraceConfigBehavior(tc_dict);
-}
-
-TEST(TraceConfigTest, EmptyAndAsteriskCategoryFilterString) {
- TraceConfig tc_empty("", "");
- TraceConfig tc_asterisk("*", "");
-
- EXPECT_STREQ("", tc_empty.ToCategoryFilterString().c_str());
- EXPECT_STREQ("*", tc_asterisk.ToCategoryFilterString().c_str());
-
- // Both fall back to default config.
- CheckDefaultTraceConfigBehavior(tc_empty);
- CheckDefaultTraceConfigBehavior(tc_asterisk);
-
- // They differ only for internal checking.
- EXPECT_FALSE(tc_empty.category_filter().IsCategoryEnabled("Category1"));
- EXPECT_FALSE(
- tc_empty.category_filter().IsCategoryEnabled("not-excluded-category"));
- EXPECT_TRUE(tc_asterisk.category_filter().IsCategoryEnabled("Category1"));
- EXPECT_TRUE(
- tc_asterisk.category_filter().IsCategoryEnabled("not-excluded-category"));
-}
-
-TEST(TraceConfigTest, DisabledByDefaultCategoryFilterString) {
- TraceConfig tc("foo,disabled-by-default-foo", "");
- EXPECT_STREQ("foo,disabled-by-default-foo",
- tc.ToCategoryFilterString().c_str());
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("foo"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-foo"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("bar"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-bar"));
-
- EXPECT_TRUE(tc.event_filters().empty());
- // Enabling only the disabled-by-default-* category means the default ones
- // are also enabled.
- tc = TraceConfig("disabled-by-default-foo", "");
- EXPECT_STREQ("disabled-by-default-foo", tc.ToCategoryFilterString().c_str());
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-foo"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("foo"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("bar"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-bar"));
-}
-
-TEST(TraceConfigTest, TraceConfigFromDict) {
- // Passing in empty dictionary will result in default trace config.
- DictionaryValue dict;
- TraceConfig tc(dict);
- EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str());
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
-
- std::unique_ptr<Value> default_value(
- JSONReader::Read(kDefaultTraceConfigString));
- DCHECK(default_value);
- const DictionaryValue* default_dict = nullptr;
- bool is_dict = default_value->GetAsDictionary(&default_dict);
- DCHECK(is_dict);
- TraceConfig default_tc(*default_dict);
- EXPECT_STREQ(kDefaultTraceConfigString, default_tc.ToString().c_str());
- EXPECT_EQ(RECORD_UNTIL_FULL, default_tc.GetTraceRecordMode());
- EXPECT_FALSE(default_tc.IsSystraceEnabled());
- EXPECT_FALSE(default_tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", default_tc.ToCategoryFilterString().c_str());
-
- std::unique_ptr<Value> custom_value(
- JSONReader::Read(kCustomTraceConfigString));
- DCHECK(custom_value);
- const DictionaryValue* custom_dict = nullptr;
- is_dict = custom_value->GetAsDictionary(&custom_dict);
- DCHECK(is_dict);
- TraceConfig custom_tc(*custom_dict);
- EXPECT_STREQ(kCustomTraceConfigString, custom_tc.ToString().c_str());
- EXPECT_EQ(RECORD_CONTINUOUSLY, custom_tc.GetTraceRecordMode());
- EXPECT_TRUE(custom_tc.IsSystraceEnabled());
- EXPECT_TRUE(custom_tc.IsArgumentFilterEnabled());
- EXPECT_STREQ(
- "included,inc_pattern*,"
- "disabled-by-default-cc,disabled-by-default-memory-infra,"
- "-excluded,-exc_pattern*",
- custom_tc.ToCategoryFilterString().c_str());
-}
-
-TEST(TraceConfigTest, TraceConfigFromValidString) {
- // Using some non-empty config string.
- const char config_string[] =
- "{"
- "\"enable_argument_filter\":true,"
- "\"enable_systrace\":true,"
- "\"event_filters\":["
- "{"
- "\"excluded_categories\":[\"unfiltered_cat\"],"
- "\"filter_args\":{\"event_name_whitelist\":[\"a snake\",\"a dog\"]},"
- "\"filter_predicate\":\"event_whitelist_predicate\","
- "\"included_categories\":[\"*\"]"
- "}"
- "],"
- "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
- "\"included_categories\":[\"included\","
- "\"inc_pattern*\","
- "\"disabled-by-default-cc\"],"
- "\"record_mode\":\"record-continuously\""
- "}";
- TraceConfig tc(config_string);
-
- EXPECT_STREQ(config_string, tc.ToString().c_str());
- EXPECT_EQ(RECORD_CONTINUOUSLY, tc.GetTraceRecordMode());
- EXPECT_TRUE(tc.IsSystraceEnabled());
- EXPECT_TRUE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ(
- "included,inc_pattern*,disabled-by-default-cc,-excluded,"
- "-exc_pattern*",
- tc.ToCategoryFilterString().c_str());
-
- EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("included"));
- EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("inc_pattern_category"));
- EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("disabled-by-default-cc"));
- EXPECT_FALSE(tc.category_filter().IsCategoryEnabled("excluded"));
- EXPECT_FALSE(tc.category_filter().IsCategoryEnabled("exc_pattern_category"));
- EXPECT_FALSE(
- tc.category_filter().IsCategoryEnabled("disabled-by-default-others"));
- EXPECT_FALSE(
- tc.category_filter().IsCategoryEnabled("not-excluded-nor-included"));
-
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("inc_pattern_category"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("exc_pattern_category"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-others"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("not-excluded-nor-included"));
-
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,excluded"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded,exc_pattern_category"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
-
- EXPECT_EQ(tc.event_filters().size(), 1u);
- const TraceConfig::EventFilterConfig& event_filter = tc.event_filters()[0];
- EXPECT_STREQ("event_whitelist_predicate",
- event_filter.predicate_name().c_str());
- EXPECT_EQ(1u, event_filter.category_filter().included_categories().size());
- EXPECT_STREQ("*",
- event_filter.category_filter().included_categories()[0].c_str());
- EXPECT_EQ(1u, event_filter.category_filter().excluded_categories().size());
- EXPECT_STREQ("unfiltered_cat",
- event_filter.category_filter().excluded_categories()[0].c_str());
- EXPECT_TRUE(event_filter.filter_args());
-
- std::string json_out;
- base::JSONWriter::Write(*event_filter.filter_args(), &json_out);
- EXPECT_STREQ(json_out.c_str(),
- "{\"event_name_whitelist\":[\"a snake\",\"a dog\"]}");
- std::unordered_set<std::string> filter_values;
- EXPECT_TRUE(event_filter.GetArgAsSet("event_name_whitelist", &filter_values));
- EXPECT_EQ(2u, filter_values.size());
- EXPECT_EQ(1u, filter_values.count("a snake"));
- EXPECT_EQ(1u, filter_values.count("a dog"));
-
- const char config_string_2[] = "{\"included_categories\":[\"*\"]}";
- TraceConfig tc2(config_string_2);
- EXPECT_TRUE(tc2.category_filter().IsCategoryEnabled(
- "non-disabled-by-default-pattern"));
- EXPECT_FALSE(
- tc2.category_filter().IsCategoryEnabled("disabled-by-default-pattern"));
- EXPECT_TRUE(tc2.IsCategoryGroupEnabled("non-disabled-by-default-pattern"));
- EXPECT_FALSE(tc2.IsCategoryGroupEnabled("disabled-by-default-pattern"));
-
- // Clear
- tc.Clear();
- EXPECT_STREQ(tc.ToString().c_str(),
- "{"
- "\"enable_argument_filter\":false,"
- "\"enable_systrace\":false,"
- "\"record_mode\":\"record-until-full\""
- "}");
-}
-
-TEST(TraceConfigTest, TraceConfigFromInvalidString) {
- // The config string needs to be a dictionary correctly formatted as a JSON
- // string. Otherwise, it will fall back to the default initialization.
- TraceConfig tc("");
- EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str());
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- tc = TraceConfig("This is an invalid config string.");
- EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str());
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- tc = TraceConfig("[\"This\", \"is\", \"not\", \"a\", \"dictionary\"]");
- EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str());
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- tc = TraceConfig("{\"record_mode\": invalid-value-needs-double-quote}");
- EXPECT_STREQ(kDefaultTraceConfigString, tc.ToString().c_str());
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- // If the config string a dictionary formatted as a JSON string, it will
- // initialize TraceConfig with best effort.
- tc = TraceConfig("{}");
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- tc = TraceConfig("{\"arbitrary-key\":\"arbitrary-value\"}");
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
- EXPECT_STREQ("", tc.ToCategoryFilterString().c_str());
- CheckDefaultTraceConfigBehavior(tc);
-
- const char invalid_config_string[] =
- "{"
- "\"enable_systrace\":1,"
- "\"excluded_categories\":[\"excluded\"],"
- "\"included_categories\":\"not a list\","
- "\"record_mode\":\"arbitrary-mode\""
- "}";
- tc = TraceConfig(invalid_config_string);
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
- EXPECT_FALSE(tc.IsArgumentFilterEnabled());
-
- const char invalid_config_string_2[] =
- "{"
- "\"included_categories\":[\"category\",\"disabled-by-default-pattern\"],"
- "\"excluded_categories\":[\"category\",\"disabled-by-default-pattern\"]"
- "}";
- tc = TraceConfig(invalid_config_string_2);
- EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("category"));
- EXPECT_TRUE(
- tc.category_filter().IsCategoryEnabled("disabled-by-default-pattern"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("category"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-pattern"));
-}
-
-TEST(TraceConfigTest, MergingTraceConfigs) {
- // Merge
- TraceConfig tc;
- TraceConfig tc2("included,-excluded,inc_pattern*,-exc_pattern*", "");
- tc.Merge(tc2);
- EXPECT_STREQ("{"
- "\"enable_argument_filter\":false,"
- "\"enable_systrace\":false,"
- "\"excluded_categories\":[\"excluded\",\"exc_pattern*\"],"
- "\"record_mode\":\"record-until-full\""
- "}",
- tc.ToString().c_str());
-}
-
-TEST(TraceConfigTest, IsCategoryGroupEnabled) {
- // Enabling a disabled- category does not require all categories to be traced
- // to be included.
- TraceConfig tc("disabled-by-default-cc,-excluded", "");
- EXPECT_STREQ("disabled-by-default-cc,-excluded",
- tc.ToCategoryFilterString().c_str());
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("some_other_group"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded"));
-
- // Enabled a disabled- category and also including makes all categories to
- // be traced require including.
- tc = TraceConfig("disabled-by-default-cc,included", "");
- EXPECT_STREQ("included,disabled-by-default-cc",
- tc.ToCategoryFilterString().c_str());
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
- EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("other_included"));
-
- // Excluding categories won't enable disabled-by-default ones with the
- // excluded category is also present in the group.
- tc = TraceConfig("-excluded", "");
- EXPECT_STREQ("-excluded", tc.ToCategoryFilterString().c_str());
- EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded,disabled-by-default-cc"));
-}
-
-TEST(TraceConfigTest, IsCategoryNameAllowed) {
- // Test that IsCategoryNameAllowed actually catches categories that are
- // explicitly forbidden. This method is called in a DCHECK to assert that we
- // don't have these types of strings as categories.
- EXPECT_FALSE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed(" bad_category "));
- EXPECT_FALSE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed(" bad_category"));
- EXPECT_FALSE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed("bad_category "));
- EXPECT_FALSE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed(" bad_category"));
- EXPECT_FALSE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed("bad_category "));
- EXPECT_FALSE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed(" bad_category "));
- EXPECT_FALSE(TraceConfigCategoryFilter::IsCategoryNameAllowed(""));
- EXPECT_TRUE(
- TraceConfigCategoryFilter::IsCategoryNameAllowed("good_category"));
-}
-
-TEST(TraceConfigTest, SetTraceOptionValues) {
- TraceConfig tc;
- EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
- EXPECT_FALSE(tc.IsSystraceEnabled());
-
- tc.SetTraceRecordMode(RECORD_AS_MUCH_AS_POSSIBLE);
- EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, tc.GetTraceRecordMode());
-
- tc.EnableSystrace();
- EXPECT_TRUE(tc.IsSystraceEnabled());
-}
-
-TEST(TraceConfigTest, TraceConfigFromMemoryConfigString) {
- std::string tc_str1 =
- TraceConfigMemoryTestUtil::GetTraceConfig_PeriodicTriggers(200, 2000);
- TraceConfig tc1(tc_str1);
- EXPECT_EQ(tc_str1, tc1.ToString());
- TraceConfig tc2(
- TraceConfigMemoryTestUtil::GetTraceConfig_LegacyPeriodicTriggers(200,
- 2000));
- EXPECT_EQ(tc_str1, tc2.ToString());
-
- EXPECT_TRUE(tc1.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
- ASSERT_EQ(2u, tc1.memory_dump_config().triggers.size());
-
- EXPECT_EQ(200u,
- tc1.memory_dump_config().triggers[0].min_time_between_dumps_ms);
- EXPECT_EQ(MemoryDumpLevelOfDetail::LIGHT,
- tc1.memory_dump_config().triggers[0].level_of_detail);
-
- EXPECT_EQ(2000u,
- tc1.memory_dump_config().triggers[1].min_time_between_dumps_ms);
- EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
- tc1.memory_dump_config().triggers[1].level_of_detail);
- EXPECT_EQ(
- 2048u,
- tc1.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
-
- std::string tc_str3 =
- TraceConfigMemoryTestUtil::GetTraceConfig_BackgroundTrigger(
- 1 /* period_ms */);
- TraceConfig tc3(tc_str3);
- EXPECT_EQ(tc_str3, tc3.ToString());
- EXPECT_TRUE(tc3.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
- ASSERT_EQ(1u, tc3.memory_dump_config().triggers.size());
- EXPECT_EQ(1u, tc3.memory_dump_config().triggers[0].min_time_between_dumps_ms);
- EXPECT_EQ(MemoryDumpLevelOfDetail::BACKGROUND,
- tc3.memory_dump_config().triggers[0].level_of_detail);
-
- std::string tc_str4 =
- TraceConfigMemoryTestUtil::GetTraceConfig_PeakDetectionTrigger(
- 1 /*heavy_period */);
- TraceConfig tc4(tc_str4);
- EXPECT_EQ(tc_str4, tc4.ToString());
- ASSERT_EQ(1u, tc4.memory_dump_config().triggers.size());
- EXPECT_EQ(1u, tc4.memory_dump_config().triggers[0].min_time_between_dumps_ms);
- EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
- tc4.memory_dump_config().triggers[0].level_of_detail);
-}
-
-TEST(TraceConfigTest, EmptyMemoryDumpConfigTest) {
- // Empty trigger list should also be specified when converting back to string.
- TraceConfig tc(TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers());
- EXPECT_EQ(TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers(),
- tc.ToString());
- EXPECT_EQ(0u, tc.memory_dump_config().triggers.size());
- EXPECT_EQ(
- static_cast<uint32_t>(TraceConfig::MemoryDumpConfig::HeapProfiler::
- kDefaultBreakdownThresholdBytes),
- tc.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
-}
-
-TEST(TraceConfigTest, LegacyStringToMemoryDumpConfig) {
- TraceConfig tc(MemoryDumpManager::kTraceCategory, "");
- EXPECT_TRUE(tc.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
- EXPECT_NE(std::string::npos, tc.ToString().find("memory_dump_config"));
- EXPECT_EQ(0u, tc.memory_dump_config().triggers.size());
- EXPECT_EQ(
- static_cast<uint32_t>(TraceConfig::MemoryDumpConfig::HeapProfiler::
- kDefaultBreakdownThresholdBytes),
- tc.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/trace_event_android_unittest.cc b/base/trace_event/trace_event_android_unittest.cc
deleted file mode 100644
index 58bd77e..0000000
--- a/base/trace_event/trace_event_android_unittest.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2015 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 "base/trace_event/trace_event.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-TEST(TraceEventAndroidTest, WriteToATrace) {
- // Just a smoke test to ensure no crash.
- TraceLog* trace_log = TraceLog::GetInstance();
- trace_log->StartATrace();
- TRACE_EVENT0("test", "test-event");
- trace_log->StopATrace();
- trace_log->AddClockSyncMetadataEvent();
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/trace_event_argument_unittest.cc b/base/trace_event/trace_event_argument_unittest.cc
deleted file mode 100644
index 448b2d5..0000000
--- a/base/trace_event/trace_event_argument_unittest.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright (c) 2014 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 "base/trace_event/trace_event_argument.h"
-
-#include <stddef.h>
-
-#include <utility>
-
-#include "base/memory/ptr_util.h"
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-TEST(TraceEventArgumentTest, FlatDictionary) {
- std::unique_ptr<TracedValue> value(new TracedValue());
- value->SetBoolean("bool", true);
- value->SetDouble("double", 0.0);
- value->SetInteger("int", 2014);
- value->SetString("string", "string");
- std::string json = "PREFIX";
- value->AppendAsTraceFormat(&json);
- EXPECT_EQ(
- "PREFIX{\"bool\":true,\"double\":0.0,\"int\":2014,\"string\":\"string\"}",
- json);
-}
-
-TEST(TraceEventArgumentTest, NoDotPathExpansion) {
- std::unique_ptr<TracedValue> value(new TracedValue());
- value->SetBoolean("bo.ol", true);
- value->SetDouble("doub.le", 0.0);
- value->SetInteger("in.t", 2014);
- value->SetString("str.ing", "str.ing");
- std::string json;
- value->AppendAsTraceFormat(&json);
- EXPECT_EQ(
- "{\"bo.ol\":true,\"doub.le\":0.0,\"in.t\":2014,\"str.ing\":\"str.ing\"}",
- json);
-}
-
-TEST(TraceEventArgumentTest, Hierarchy) {
- std::unique_ptr<TracedValue> value(new TracedValue());
- value->BeginArray("a1");
- value->AppendInteger(1);
- value->AppendBoolean(true);
- value->BeginDictionary();
- value->SetInteger("i2", 3);
- value->EndDictionary();
- value->EndArray();
- value->SetBoolean("b0", true);
- value->SetDouble("d0", 0.0);
- value->BeginDictionary("dict1");
- value->BeginDictionary("dict2");
- value->SetBoolean("b2", false);
- value->EndDictionary();
- value->SetInteger("i1", 2014);
- value->SetString("s1", "foo");
- value->EndDictionary();
- value->SetInteger("i0", 2014);
- value->SetString("s0", "foo");
- std::string json;
- value->AppendAsTraceFormat(&json);
- EXPECT_EQ(
- "{\"a1\":[1,true,{\"i2\":3}],\"b0\":true,\"d0\":0.0,\"dict1\":{\"dict2\":"
- "{\"b2\":false},\"i1\":2014,\"s1\":\"foo\"},\"i0\":2014,\"s0\":"
- "\"foo\"}",
- json);
-}
-
-TEST(TraceEventArgumentTest, LongStrings) {
- std::string kLongString = "supercalifragilisticexpialidocious";
- std::string kLongString2 = "0123456789012345678901234567890123456789";
- char kLongString3[4096];
- for (size_t i = 0; i < sizeof(kLongString3); ++i)
- kLongString3[i] = 'a' + (i % 25);
- kLongString3[sizeof(kLongString3) - 1] = '\0';
-
- std::unique_ptr<TracedValue> value(new TracedValue());
- value->SetString("a", "short");
- value->SetString("b", kLongString);
- value->BeginArray("c");
- value->AppendString(kLongString2);
- value->AppendString("");
- value->BeginDictionary();
- value->SetString("a", kLongString3);
- value->EndDictionary();
- value->EndArray();
-
- std::string json;
- value->AppendAsTraceFormat(&json);
- EXPECT_EQ("{\"a\":\"short\",\"b\":\"" + kLongString + "\",\"c\":[\"" +
- kLongString2 + "\",\"\",{\"a\":\"" + kLongString3 + "\"}]}",
- json);
-}
-
-TEST(TraceEventArgumentTest, PassBaseValue) {
- Value int_value(42);
- Value bool_value(true);
- Value double_value(42.0f);
-
- auto dict_value = WrapUnique(new DictionaryValue);
- dict_value->SetBoolean("bool", true);
- dict_value->SetInteger("int", 42);
- dict_value->SetDouble("double", 42.0f);
- dict_value->SetString("string", std::string("a") + "b");
- dict_value->SetString("string", std::string("a") + "b");
-
- auto list_value = WrapUnique(new ListValue);
- list_value->AppendBoolean(false);
- list_value->AppendInteger(1);
- list_value->AppendString("in_list");
- list_value->Append(std::move(dict_value));
-
- std::unique_ptr<TracedValue> value(new TracedValue());
- value->BeginDictionary("outer_dict");
- value->SetValue("inner_list", std::move(list_value));
- value->EndDictionary();
-
- dict_value.reset();
- list_value.reset();
-
- std::string json;
- value->AppendAsTraceFormat(&json);
- EXPECT_EQ(
- "{\"outer_dict\":{\"inner_list\":[false,1,\"in_list\",{\"bool\":true,"
- "\"double\":42.0,\"int\":42,\"string\":\"ab\"}]}}",
- json);
-}
-
-TEST(TraceEventArgumentTest, PassTracedValue) {
- auto dict_value = std::make_unique<TracedValue>();
- dict_value->SetInteger("a", 1);
-
- auto nested_dict_value = std::make_unique<TracedValue>();
- nested_dict_value->SetInteger("b", 2);
- nested_dict_value->BeginArray("c");
- nested_dict_value->AppendString("foo");
- nested_dict_value->EndArray();
-
- dict_value->SetValue("e", *nested_dict_value);
-
- // Check the merged result.
- std::string json;
- dict_value->AppendAsTraceFormat(&json);
- EXPECT_EQ("{\"a\":1,\"e\":{\"b\":2,\"c\":[\"foo\"]}}", json);
-
- // Check that the passed nestd dict was left unouthced.
- json = "";
- nested_dict_value->AppendAsTraceFormat(&json);
- EXPECT_EQ("{\"b\":2,\"c\":[\"foo\"]}", json);
-
- // And that it is still usable.
- nested_dict_value->SetInteger("f", 3);
- nested_dict_value->BeginDictionary("g");
- nested_dict_value->EndDictionary();
- json = "";
- nested_dict_value->AppendAsTraceFormat(&json);
- EXPECT_EQ("{\"b\":2,\"c\":[\"foo\"],\"f\":3,\"g\":{}}", json);
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/trace_event_system_stats_monitor_unittest.cc b/base/trace_event/trace_event_system_stats_monitor_unittest.cc
deleted file mode 100644
index 978746d..0000000
--- a/base/trace_event/trace_event_system_stats_monitor_unittest.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 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 "base/trace_event/trace_event_system_stats_monitor.h"
-
-#include <sstream>
-#include <string>
-
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/trace_event/trace_event_impl.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-#if !defined(OS_IOS)
-// Tests for the system stats monitor.
-// Exists as a class so it can be a friend of TraceEventSystemStatsMonitor.
-class TraceSystemStatsMonitorTest : public testing::Test {
- public:
- TraceSystemStatsMonitorTest() = default;
- ~TraceSystemStatsMonitorTest() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TraceSystemStatsMonitorTest);
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-TEST_F(TraceSystemStatsMonitorTest, TraceEventSystemStatsMonitor) {
- MessageLoop message_loop;
-
- // Start with no observers of the TraceLog.
- EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
-
- // Creating a system stats monitor adds it to the TraceLog observer list.
- std::unique_ptr<TraceEventSystemStatsMonitor> system_stats_monitor(
- new TraceEventSystemStatsMonitor(message_loop.task_runner()));
- EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest());
- EXPECT_TRUE(
- TraceLog::GetInstance()->HasEnabledStateObserver(
- system_stats_monitor.get()));
-
- // By default the observer isn't dumping memory profiles.
- EXPECT_FALSE(system_stats_monitor->IsTimerRunningForTest());
-
- // Simulate enabling tracing.
- system_stats_monitor->StartProfiling();
- RunLoop().RunUntilIdle();
- EXPECT_TRUE(system_stats_monitor->IsTimerRunningForTest());
-
- // Simulate disabling tracing.
- system_stats_monitor->StopProfiling();
- RunLoop().RunUntilIdle();
- EXPECT_FALSE(system_stats_monitor->IsTimerRunningForTest());
-
- // Deleting the observer removes it from the TraceLog observer list.
- system_stats_monitor.reset();
- EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
-}
-#endif // !defined(OS_IOS)
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/trace_event/trace_event_unittest.cc b/base/trace_event/trace_event_unittest.cc
deleted file mode 100644
index a413ee5..0000000
--- a/base/trace_event/trace_event_unittest.cc
+++ /dev/null
@@ -1,3169 +0,0 @@
-// 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.
-
-#include "base/trace_event/trace_event.h"
-
-#include <math.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <cstdlib>
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/command_line.h"
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/location.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/memory/singleton.h"
-#include "base/process/process_handle.h"
-#include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
-#include "base/strings/pattern.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/time/time.h"
-#include "base/trace_event/event_name_filter.h"
-#include "base/trace_event/heap_profiler_event_filter.h"
-#include "base/trace_event/trace_buffer.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_filter.h"
-#include "base/trace_event/trace_event_filter_test_utils.h"
-#include "base/values.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-enum CompareOp {
- IS_EQUAL,
- IS_NOT_EQUAL,
-};
-
-struct JsonKeyValue {
- const char* key;
- const char* value;
- CompareOp op;
-};
-
-const int kThreadId = 42;
-const int kAsyncId = 5;
-const char kAsyncIdStr[] = "0x5";
-const int kAsyncId2 = 6;
-const char kAsyncId2Str[] = "0x6";
-const int kFlowId = 7;
-const char kFlowIdStr[] = "0x7";
-
-const char kRecordAllCategoryFilter[] = "*";
-
-class TraceEventTestFixture : public testing::Test {
- public:
- void OnTraceDataCollected(
- WaitableEvent* flush_complete_event,
- const scoped_refptr<base::RefCountedString>& events_str,
- bool has_more_events);
- DictionaryValue* FindMatchingTraceEntry(const JsonKeyValue* key_values);
- DictionaryValue* FindNamePhase(const char* name, const char* phase);
- DictionaryValue* FindNamePhaseKeyValue(const char* name,
- const char* phase,
- const char* key,
- const char* value);
- void DropTracedMetadataRecords();
- bool FindMatchingValue(const char* key,
- const char* value);
- bool FindNonMatchingValue(const char* key,
- const char* value);
- void Clear() {
- trace_parsed_.Clear();
- json_output_.json_output.clear();
- }
-
- void BeginTrace() {
- BeginSpecificTrace("*");
- }
-
- void BeginSpecificTrace(const std::string& filter) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(filter, ""),
- TraceLog::RECORDING_MODE);
- }
-
- void CancelTrace() {
- WaitableEvent flush_complete_event(
- WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- CancelTraceAsync(&flush_complete_event);
- flush_complete_event.Wait();
- }
-
- void EndTraceAndFlush() {
- num_flush_callbacks_ = 0;
- WaitableEvent flush_complete_event(
- WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- EndTraceAndFlushAsync(&flush_complete_event);
- flush_complete_event.Wait();
- }
-
- // Used when testing thread-local buffers which requires the thread initiating
- // flush to have a message loop.
- void EndTraceAndFlushInThreadWithMessageLoop() {
- WaitableEvent flush_complete_event(
- WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- Thread flush_thread("flush");
- flush_thread.Start();
- flush_thread.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&TraceEventTestFixture::EndTraceAndFlushAsync,
- base::Unretained(this), &flush_complete_event));
- flush_complete_event.Wait();
- }
-
- void CancelTraceAsync(WaitableEvent* flush_complete_event) {
- TraceLog::GetInstance()->CancelTracing(
- base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
- base::Unretained(static_cast<TraceEventTestFixture*>(this)),
- base::Unretained(flush_complete_event)));
- }
-
- void EndTraceAndFlushAsync(WaitableEvent* flush_complete_event) {
- TraceLog::GetInstance()->SetDisabled(TraceLog::RECORDING_MODE |
- TraceLog::FILTERING_MODE);
- TraceLog::GetInstance()->Flush(
- base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
- base::Unretained(static_cast<TraceEventTestFixture*>(this)),
- base::Unretained(flush_complete_event)));
- }
-
- void SetUp() override {
- const char* name = PlatformThread::GetName();
- old_thread_name_ = name ? strdup(name) : nullptr;
-
- TraceLog::ResetForTesting();
- TraceLog* tracelog = TraceLog::GetInstance();
- ASSERT_TRUE(tracelog);
- ASSERT_FALSE(tracelog->IsEnabled());
- trace_buffer_.SetOutputCallback(json_output_.GetCallback());
- num_flush_callbacks_ = 0;
- }
- void TearDown() override {
- if (TraceLog::GetInstance())
- EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
- PlatformThread::SetName(old_thread_name_ ? old_thread_name_ : "");
- free(old_thread_name_);
- old_thread_name_ = nullptr;
- // We want our singleton torn down after each test.
- TraceLog::ResetForTesting();
- }
-
- char* old_thread_name_;
- ListValue trace_parsed_;
- TraceResultBuffer trace_buffer_;
- TraceResultBuffer::SimpleOutput json_output_;
- size_t num_flush_callbacks_;
-
- private:
- // We want our singleton torn down after each test.
- ShadowingAtExitManager at_exit_manager_;
- Lock lock_;
-};
-
-void TraceEventTestFixture::OnTraceDataCollected(
- WaitableEvent* flush_complete_event,
- const scoped_refptr<base::RefCountedString>& events_str,
- bool has_more_events) {
- num_flush_callbacks_++;
- if (num_flush_callbacks_ > 1) {
- EXPECT_FALSE(events_str->data().empty());
- }
- AutoLock lock(lock_);
- json_output_.json_output.clear();
- trace_buffer_.Start();
- trace_buffer_.AddFragment(events_str->data());
- trace_buffer_.Finish();
-
- std::unique_ptr<Value> root =
- base::JSONReader::Read(json_output_.json_output, JSON_PARSE_RFC);
-
- if (!root.get()) {
- LOG(ERROR) << json_output_.json_output;
- }
-
- ListValue* root_list = nullptr;
- ASSERT_TRUE(root.get());
- ASSERT_TRUE(root->GetAsList(&root_list));
-
- // Move items into our aggregate collection
- while (root_list->GetSize()) {
- std::unique_ptr<Value> item;
- root_list->Remove(0, &item);
- trace_parsed_.Append(std::move(item));
- }
-
- if (!has_more_events)
- flush_complete_event->Signal();
-}
-
-static bool CompareJsonValues(const std::string& lhs,
- const std::string& rhs,
- CompareOp op) {
- switch (op) {
- case IS_EQUAL:
- return lhs == rhs;
- case IS_NOT_EQUAL:
- return lhs != rhs;
- default:
- CHECK(0);
- }
- return false;
-}
-
-static bool IsKeyValueInDict(const JsonKeyValue* key_value,
- DictionaryValue* dict) {
- Value* value = nullptr;
- std::string value_str;
- if (dict->Get(key_value->key, &value) &&
- value->GetAsString(&value_str) &&
- CompareJsonValues(value_str, key_value->value, key_value->op))
- return true;
-
- // Recurse to test arguments
- DictionaryValue* args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- if (args_dict)
- return IsKeyValueInDict(key_value, args_dict);
-
- return false;
-}
-
-static bool IsAllKeyValueInDict(const JsonKeyValue* key_values,
- DictionaryValue* dict) {
- // Scan all key_values, they must all be present and equal.
- while (key_values && key_values->key) {
- if (!IsKeyValueInDict(key_values, dict))
- return false;
- ++key_values;
- }
- return true;
-}
-
-DictionaryValue* TraceEventTestFixture::FindMatchingTraceEntry(
- const JsonKeyValue* key_values) {
- // Scan all items
- size_t trace_parsed_count = trace_parsed_.GetSize();
- for (size_t i = 0; i < trace_parsed_count; i++) {
- Value* value = nullptr;
- trace_parsed_.Get(i, &value);
- if (!value || value->type() != Value::Type::DICTIONARY)
- continue;
- DictionaryValue* dict = static_cast<DictionaryValue*>(value);
-
- if (IsAllKeyValueInDict(key_values, dict))
- return dict;
- }
- return nullptr;
-}
-
-void TraceEventTestFixture::DropTracedMetadataRecords() {
- std::unique_ptr<ListValue> old_trace_parsed(trace_parsed_.CreateDeepCopy());
- size_t old_trace_parsed_size = old_trace_parsed->GetSize();
- trace_parsed_.Clear();
-
- for (size_t i = 0; i < old_trace_parsed_size; i++) {
- Value* value = nullptr;
- old_trace_parsed->Get(i, &value);
- if (!value || value->type() != Value::Type::DICTIONARY) {
- trace_parsed_.Append(value->CreateDeepCopy());
- continue;
- }
- DictionaryValue* dict = static_cast<DictionaryValue*>(value);
- std::string tmp;
- if (dict->GetString("ph", &tmp) && tmp == "M")
- continue;
-
- trace_parsed_.Append(value->CreateDeepCopy());
- }
-}
-
-DictionaryValue* TraceEventTestFixture::FindNamePhase(const char* name,
- const char* phase) {
- JsonKeyValue key_values[] = {{"name", name, IS_EQUAL},
- {"ph", phase, IS_EQUAL},
- {nullptr, nullptr, IS_EQUAL}};
- return FindMatchingTraceEntry(key_values);
-}
-
-DictionaryValue* TraceEventTestFixture::FindNamePhaseKeyValue(
- const char* name,
- const char* phase,
- const char* key,
- const char* value) {
- JsonKeyValue key_values[] = {{"name", name, IS_EQUAL},
- {"ph", phase, IS_EQUAL},
- {key, value, IS_EQUAL},
- {nullptr, nullptr, IS_EQUAL}};
- return FindMatchingTraceEntry(key_values);
-}
-
-bool TraceEventTestFixture::FindMatchingValue(const char* key,
- const char* value) {
- JsonKeyValue key_values[] = {{key, value, IS_EQUAL},
- {nullptr, nullptr, IS_EQUAL}};
- return FindMatchingTraceEntry(key_values);
-}
-
-bool TraceEventTestFixture::FindNonMatchingValue(const char* key,
- const char* value) {
- JsonKeyValue key_values[] = {{key, value, IS_NOT_EQUAL},
- {nullptr, nullptr, IS_EQUAL}};
- return FindMatchingTraceEntry(key_values);
-}
-
-bool IsStringInDict(const char* string_to_match, const DictionaryValue* dict) {
- for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
- if (it.key().find(string_to_match) != std::string::npos)
- return true;
-
- std::string value_str;
- it.value().GetAsString(&value_str);
- if (value_str.find(string_to_match) != std::string::npos)
- return true;
- }
-
- // Recurse to test arguments
- const DictionaryValue* args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- if (args_dict)
- return IsStringInDict(string_to_match, args_dict);
-
- return false;
-}
-
-const DictionaryValue* FindTraceEntry(
- const ListValue& trace_parsed,
- const char* string_to_match,
- const DictionaryValue* match_after_this_item = nullptr) {
- // Scan all items
- size_t trace_parsed_count = trace_parsed.GetSize();
- for (size_t i = 0; i < trace_parsed_count; i++) {
- const Value* value = nullptr;
- trace_parsed.Get(i, &value);
- if (match_after_this_item) {
- if (value == match_after_this_item)
- match_after_this_item = nullptr;
- continue;
- }
- if (!value || value->type() != Value::Type::DICTIONARY)
- continue;
- const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
-
- if (IsStringInDict(string_to_match, dict))
- return dict;
- }
- return nullptr;
-}
-
-std::vector<const DictionaryValue*> FindTraceEntries(
- const ListValue& trace_parsed,
- const char* string_to_match) {
- std::vector<const DictionaryValue*> hits;
- size_t trace_parsed_count = trace_parsed.GetSize();
- for (size_t i = 0; i < trace_parsed_count; i++) {
- const Value* value = nullptr;
- trace_parsed.Get(i, &value);
- if (!value || value->type() != Value::Type::DICTIONARY)
- continue;
- const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
-
- if (IsStringInDict(string_to_match, dict))
- hits.push_back(dict);
- }
- return hits;
-}
-
-const char kControlCharacters[] = "\001\002\003\n\r";
-
-void TraceWithAllMacroVariants(WaitableEvent* task_complete_event) {
- {
- TRACE_EVENT0("all", "TRACE_EVENT0 call");
- TRACE_EVENT1("all", "TRACE_EVENT1 call", "name1", "value1");
- TRACE_EVENT2("all", "TRACE_EVENT2 call",
- "name1", "\"value1\"",
- "name2", "value\\2");
-
- TRACE_EVENT_INSTANT0("all", "TRACE_EVENT_INSTANT0 call",
- TRACE_EVENT_SCOPE_GLOBAL);
- TRACE_EVENT_INSTANT1("all", "TRACE_EVENT_INSTANT1 call",
- TRACE_EVENT_SCOPE_PROCESS, "name1", "value1");
- TRACE_EVENT_INSTANT2("all", "TRACE_EVENT_INSTANT2 call",
- TRACE_EVENT_SCOPE_THREAD,
- "name1", "value1",
- "name2", "value2");
-
- TRACE_EVENT_BEGIN0("all", "TRACE_EVENT_BEGIN0 call");
- TRACE_EVENT_BEGIN1("all", "TRACE_EVENT_BEGIN1 call", "name1", "value1");
- TRACE_EVENT_BEGIN2("all", "TRACE_EVENT_BEGIN2 call",
- "name1", "value1",
- "name2", "value2");
-
- TRACE_EVENT_END0("all", "TRACE_EVENT_END0 call");
- TRACE_EVENT_END1("all", "TRACE_EVENT_END1 call", "name1", "value1");
- TRACE_EVENT_END2("all", "TRACE_EVENT_END2 call",
- "name1", "value1",
- "name2", "value2");
-
- TRACE_EVENT_ASYNC_BEGIN0("all", "TRACE_EVENT_ASYNC_BEGIN0 call", kAsyncId);
- TRACE_EVENT_ASYNC_BEGIN1("all", "TRACE_EVENT_ASYNC_BEGIN1 call", kAsyncId,
- "name1", "value1");
- TRACE_EVENT_ASYNC_BEGIN2("all", "TRACE_EVENT_ASYNC_BEGIN2 call", kAsyncId,
- "name1", "value1",
- "name2", "value2");
-
- TRACE_EVENT_ASYNC_STEP_INTO0("all", "TRACE_EVENT_ASYNC_STEP_INTO0 call",
- kAsyncId, "step_begin1");
- TRACE_EVENT_ASYNC_STEP_INTO1("all", "TRACE_EVENT_ASYNC_STEP_INTO1 call",
- kAsyncId, "step_begin2", "name1", "value1");
-
- TRACE_EVENT_ASYNC_END0("all", "TRACE_EVENT_ASYNC_END0 call", kAsyncId);
- TRACE_EVENT_ASYNC_END1("all", "TRACE_EVENT_ASYNC_END1 call", kAsyncId,
- "name1", "value1");
- TRACE_EVENT_ASYNC_END2("all", "TRACE_EVENT_ASYNC_END2 call", kAsyncId,
- "name1", "value1",
- "name2", "value2");
-
- TRACE_EVENT_FLOW_BEGIN0("all", "TRACE_EVENT_FLOW_BEGIN0 call", kFlowId);
- TRACE_EVENT_FLOW_STEP0("all", "TRACE_EVENT_FLOW_STEP0 call",
- kFlowId, "step1");
- TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0("all",
- "TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0 call", kFlowId);
-
- TRACE_COUNTER1("all", "TRACE_COUNTER1 call", 31415);
- TRACE_COUNTER2("all", "TRACE_COUNTER2 call",
- "a", 30000,
- "b", 1415);
-
- TRACE_COUNTER_WITH_TIMESTAMP1("all", "TRACE_COUNTER_WITH_TIMESTAMP1 call",
- TimeTicks::FromInternalValue(42), 31415);
- TRACE_COUNTER_WITH_TIMESTAMP2("all", "TRACE_COUNTER_WITH_TIMESTAMP2 call",
- TimeTicks::FromInternalValue(42),
- "a", 30000, "b", 1415);
-
- TRACE_COUNTER_ID1("all", "TRACE_COUNTER_ID1 call", 0x319009, 31415);
- TRACE_COUNTER_ID2("all", "TRACE_COUNTER_ID2 call", 0x319009,
- "a", 30000, "b", 1415);
-
- TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0("all",
- "TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0 call",
- kAsyncId, kThreadId, TimeTicks::FromInternalValue(12345));
- TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0("all",
- "TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0 call",
- kAsyncId, kThreadId, TimeTicks::FromInternalValue(23456));
-
- TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0("all",
- "TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0 call",
- kAsyncId2, kThreadId, TimeTicks::FromInternalValue(34567));
- TRACE_EVENT_ASYNC_STEP_PAST0("all", "TRACE_EVENT_ASYNC_STEP_PAST0 call",
- kAsyncId2, "step_end1");
- TRACE_EVENT_ASYNC_STEP_PAST1("all", "TRACE_EVENT_ASYNC_STEP_PAST1 call",
- kAsyncId2, "step_end2", "name1", "value1");
-
- TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0("all",
- "TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0 call",
- kAsyncId2, kThreadId, TimeTicks::FromInternalValue(45678));
-
- TRACE_EVENT_OBJECT_CREATED_WITH_ID("all", "tracked object 1", 0x42);
- TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
- "all", "tracked object 1", 0x42, "hello");
- TRACE_EVENT_OBJECT_DELETED_WITH_ID("all", "tracked object 1", 0x42);
-
- TraceScopedTrackableObject<int> trackable("all", "tracked object 2",
- 0x2128506);
- trackable.snapshot("world");
-
- TRACE_EVENT_OBJECT_CREATED_WITH_ID(
- "all", "tracked object 3", TRACE_ID_WITH_SCOPE("scope", 0x42));
- TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
- "all", "tracked object 3", TRACE_ID_WITH_SCOPE("scope", 0x42), "hello");
- TRACE_EVENT_OBJECT_DELETED_WITH_ID(
- "all", "tracked object 3", TRACE_ID_WITH_SCOPE("scope", 0x42));
-
- TRACE_EVENT1(kControlCharacters, kControlCharacters,
- kControlCharacters, kControlCharacters);
-
- uint64_t context_id = 0x20151021;
-
- TRACE_EVENT_ENTER_CONTEXT("all", "TRACE_EVENT_ENTER_CONTEXT call",
- TRACE_ID_WITH_SCOPE("scope", context_id));
- TRACE_EVENT_LEAVE_CONTEXT("all", "TRACE_EVENT_LEAVE_CONTEXT call",
- TRACE_ID_WITH_SCOPE("scope", context_id));
- TRACE_EVENT_SCOPED_CONTEXT("disabled-by-default-cat",
- "TRACE_EVENT_SCOPED_CONTEXT disabled call",
- context_id);
- TRACE_EVENT_SCOPED_CONTEXT("all", "TRACE_EVENT_SCOPED_CONTEXT call",
- context_id);
-
- TRACE_LINK_IDS("all", "TRACE_LINK_IDS simple call", 0x1000, 0x2000);
- TRACE_LINK_IDS("all", "TRACE_LINK_IDS scoped call",
- TRACE_ID_WITH_SCOPE("scope 1", 0x1000),
- TRACE_ID_WITH_SCOPE("scope 2", 0x2000));
- TRACE_LINK_IDS("all", "TRACE_LINK_IDS to a local ID", 0x1000,
- TRACE_ID_LOCAL(0x2000));
- TRACE_LINK_IDS("all", "TRACE_LINK_IDS to a global ID", 0x1000,
- TRACE_ID_GLOBAL(0x2000));
- TRACE_LINK_IDS("all", "TRACE_LINK_IDS to a composite ID", 0x1000,
- TRACE_ID_WITH_SCOPE("scope 1", 0x2000, 0x3000));
-
- TRACE_EVENT_ASYNC_BEGIN0("all", "async default process scope", 0x1000);
- TRACE_EVENT_ASYNC_BEGIN0("all", "async local id", TRACE_ID_LOCAL(0x2000));
- TRACE_EVENT_ASYNC_BEGIN0("all", "async global id", TRACE_ID_GLOBAL(0x3000));
- TRACE_EVENT_ASYNC_BEGIN0("all", "async global id with scope string",
- TRACE_ID_WITH_SCOPE("scope string",
- TRACE_ID_GLOBAL(0x4000)));
- } // Scope close causes TRACE_EVENT0 etc to send their END events.
-
- if (task_complete_event)
- task_complete_event->Signal();
-}
-
-void ValidateAllTraceMacrosCreatedData(const ListValue& trace_parsed) {
- const DictionaryValue* item = nullptr;
-
-#define EXPECT_FIND_(string) \
- item = FindTraceEntry(trace_parsed, string); \
- EXPECT_TRUE(item);
-#define EXPECT_NOT_FIND_(string) \
- item = FindTraceEntry(trace_parsed, string); \
- EXPECT_FALSE(item);
-#define EXPECT_SUB_FIND_(string) \
- if (item) \
- EXPECT_TRUE(IsStringInDict(string, item));
-
- EXPECT_FIND_("TRACE_EVENT0 call");
- {
- std::string ph;
- std::string ph_end;
- EXPECT_TRUE((item = FindTraceEntry(trace_parsed, "TRACE_EVENT0 call")));
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("X", ph);
- item = FindTraceEntry(trace_parsed, "TRACE_EVENT0 call", item);
- EXPECT_FALSE(item);
- }
- EXPECT_FIND_("TRACE_EVENT1 call");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_FIND_("TRACE_EVENT2 call");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("\"value1\"");
- EXPECT_SUB_FIND_("name2");
- EXPECT_SUB_FIND_("value\\2");
-
- EXPECT_FIND_("TRACE_EVENT_INSTANT0 call");
- {
- std::string scope;
- EXPECT_TRUE((item && item->GetString("s", &scope)));
- EXPECT_EQ("g", scope);
- }
- EXPECT_FIND_("TRACE_EVENT_INSTANT1 call");
- {
- std::string scope;
- EXPECT_TRUE((item && item->GetString("s", &scope)));
- EXPECT_EQ("p", scope);
- }
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_FIND_("TRACE_EVENT_INSTANT2 call");
- {
- std::string scope;
- EXPECT_TRUE((item && item->GetString("s", &scope)));
- EXPECT_EQ("t", scope);
- }
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_SUB_FIND_("name2");
- EXPECT_SUB_FIND_("value2");
-
- EXPECT_FIND_("TRACE_EVENT_BEGIN0 call");
- EXPECT_FIND_("TRACE_EVENT_BEGIN1 call");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_FIND_("TRACE_EVENT_BEGIN2 call");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_SUB_FIND_("name2");
- EXPECT_SUB_FIND_("value2");
-
- EXPECT_FIND_("TRACE_EVENT_END0 call");
- EXPECT_FIND_("TRACE_EVENT_END1 call");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_FIND_("TRACE_EVENT_END2 call");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_SUB_FIND_("name2");
- EXPECT_SUB_FIND_("value2");
-
- EXPECT_FIND_("TRACE_EVENT_ASYNC_BEGIN0 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_FIND_("TRACE_EVENT_ASYNC_BEGIN1 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_FIND_("TRACE_EVENT_ASYNC_BEGIN2 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_SUB_FIND_("name2");
- EXPECT_SUB_FIND_("value2");
-
- EXPECT_FIND_("TRACE_EVENT_ASYNC_STEP_INTO0 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_SUB_FIND_("step_begin1");
- EXPECT_FIND_("TRACE_EVENT_ASYNC_STEP_INTO1 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_SUB_FIND_("step_begin2");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
-
- EXPECT_FIND_("TRACE_EVENT_ASYNC_END0 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_FIND_("TRACE_EVENT_ASYNC_END1 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_FIND_("TRACE_EVENT_ASYNC_END2 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncIdStr);
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- EXPECT_SUB_FIND_("name2");
- EXPECT_SUB_FIND_("value2");
-
- EXPECT_FIND_("TRACE_EVENT_FLOW_BEGIN0 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kFlowIdStr);
- EXPECT_FIND_("TRACE_EVENT_FLOW_STEP0 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kFlowIdStr);
- EXPECT_SUB_FIND_("step1");
- EXPECT_FIND_("TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kFlowIdStr);
-
- EXPECT_FIND_("TRACE_COUNTER1 call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("C", ph);
-
- int value;
- EXPECT_TRUE((item && item->GetInteger("args.value", &value)));
- EXPECT_EQ(31415, value);
- }
-
- EXPECT_FIND_("TRACE_COUNTER2 call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("C", ph);
-
- int value;
- EXPECT_TRUE((item && item->GetInteger("args.a", &value)));
- EXPECT_EQ(30000, value);
-
- EXPECT_TRUE((item && item->GetInteger("args.b", &value)));
- EXPECT_EQ(1415, value);
- }
-
- EXPECT_FIND_("TRACE_COUNTER_WITH_TIMESTAMP1 call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("C", ph);
-
- int value;
- EXPECT_TRUE((item && item->GetInteger("args.value", &value)));
- EXPECT_EQ(31415, value);
-
- int ts;
- EXPECT_TRUE((item && item->GetInteger("ts", &ts)));
- EXPECT_EQ(42, ts);
- }
-
- EXPECT_FIND_("TRACE_COUNTER_WITH_TIMESTAMP2 call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("C", ph);
-
- int value;
- EXPECT_TRUE((item && item->GetInteger("args.a", &value)));
- EXPECT_EQ(30000, value);
-
- EXPECT_TRUE((item && item->GetInteger("args.b", &value)));
- EXPECT_EQ(1415, value);
-
- int ts;
- EXPECT_TRUE((item && item->GetInteger("ts", &ts)));
- EXPECT_EQ(42, ts);
- }
-
- EXPECT_FIND_("TRACE_COUNTER_ID1 call");
- {
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x319009", id);
-
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("C", ph);
-
- int value;
- EXPECT_TRUE((item && item->GetInteger("args.value", &value)));
- EXPECT_EQ(31415, value);
- }
-
- EXPECT_FIND_("TRACE_COUNTER_ID2 call");
- {
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x319009", id);
-
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("C", ph);
-
- int value;
- EXPECT_TRUE((item && item->GetInteger("args.a", &value)));
- EXPECT_EQ(30000, value);
-
- EXPECT_TRUE((item && item->GetInteger("args.b", &value)));
- EXPECT_EQ(1415, value);
- }
-
- EXPECT_FIND_("TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0 call");
- {
- int val;
- EXPECT_TRUE((item && item->GetInteger("ts", &val)));
- EXPECT_EQ(12345, val);
- EXPECT_TRUE((item && item->GetInteger("tid", &val)));
- EXPECT_EQ(kThreadId, val);
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ(kAsyncIdStr, id);
- }
-
- EXPECT_FIND_("TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0 call");
- {
- int val;
- EXPECT_TRUE((item && item->GetInteger("ts", &val)));
- EXPECT_EQ(23456, val);
- EXPECT_TRUE((item && item->GetInteger("tid", &val)));
- EXPECT_EQ(kThreadId, val);
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ(kAsyncIdStr, id);
- }
-
- EXPECT_FIND_("TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0 call");
- {
- int val;
- EXPECT_TRUE((item && item->GetInteger("ts", &val)));
- EXPECT_EQ(34567, val);
- EXPECT_TRUE((item && item->GetInteger("tid", &val)));
- EXPECT_EQ(kThreadId, val);
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ(kAsyncId2Str, id);
- }
-
- EXPECT_FIND_("TRACE_EVENT_ASYNC_STEP_PAST0 call");
- {
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncId2Str);
- EXPECT_SUB_FIND_("step_end1");
- EXPECT_FIND_("TRACE_EVENT_ASYNC_STEP_PAST1 call");
- EXPECT_SUB_FIND_("id");
- EXPECT_SUB_FIND_(kAsyncId2Str);
- EXPECT_SUB_FIND_("step_end2");
- EXPECT_SUB_FIND_("name1");
- EXPECT_SUB_FIND_("value1");
- }
-
- EXPECT_FIND_("TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0 call");
- {
- int val;
- EXPECT_TRUE((item && item->GetInteger("ts", &val)));
- EXPECT_EQ(45678, val);
- EXPECT_TRUE((item && item->GetInteger("tid", &val)));
- EXPECT_EQ(kThreadId, val);
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ(kAsyncId2Str, id);
- }
-
- EXPECT_FIND_("tracked object 1");
- {
- std::string phase;
- std::string id;
- std::string snapshot;
-
- EXPECT_TRUE((item && item->GetString("ph", &phase)));
- EXPECT_EQ("N", phase);
- EXPECT_FALSE((item && item->HasKey("scope")));
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x42", id);
-
- item = FindTraceEntry(trace_parsed, "tracked object 1", item);
- EXPECT_TRUE(item);
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("O", phase);
- EXPECT_FALSE((item && item->HasKey("scope")));
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x42", id);
- EXPECT_TRUE(item && item->GetString("args.snapshot", &snapshot));
- EXPECT_EQ("hello", snapshot);
-
- item = FindTraceEntry(trace_parsed, "tracked object 1", item);
- EXPECT_TRUE(item);
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("D", phase);
- EXPECT_FALSE((item && item->HasKey("scope")));
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x42", id);
- }
-
- EXPECT_FIND_("tracked object 2");
- {
- std::string phase;
- std::string id;
- std::string snapshot;
-
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("N", phase);
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x2128506", id);
-
- item = FindTraceEntry(trace_parsed, "tracked object 2", item);
- EXPECT_TRUE(item);
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("O", phase);
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x2128506", id);
- EXPECT_TRUE(item && item->GetString("args.snapshot", &snapshot));
- EXPECT_EQ("world", snapshot);
-
- item = FindTraceEntry(trace_parsed, "tracked object 2", item);
- EXPECT_TRUE(item);
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("D", phase);
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x2128506", id);
- }
-
- EXPECT_FIND_("tracked object 3");
- {
- std::string phase;
- std::string scope;
- std::string id;
- std::string snapshot;
-
- EXPECT_TRUE((item && item->GetString("ph", &phase)));
- EXPECT_EQ("N", phase);
- EXPECT_TRUE((item && item->GetString("scope", &scope)));
- EXPECT_EQ("scope", scope);
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x42", id);
-
- item = FindTraceEntry(trace_parsed, "tracked object 3", item);
- EXPECT_TRUE(item);
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("O", phase);
- EXPECT_TRUE((item && item->GetString("scope", &scope)));
- EXPECT_EQ("scope", scope);
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x42", id);
- EXPECT_TRUE(item && item->GetString("args.snapshot", &snapshot));
- EXPECT_EQ("hello", snapshot);
-
- item = FindTraceEntry(trace_parsed, "tracked object 3", item);
- EXPECT_TRUE(item);
- EXPECT_TRUE(item && item->GetString("ph", &phase));
- EXPECT_EQ("D", phase);
- EXPECT_TRUE((item && item->GetString("scope", &scope)));
- EXPECT_EQ("scope", scope);
- EXPECT_TRUE(item && item->GetString("id", &id));
- EXPECT_EQ("0x42", id);
- }
-
- EXPECT_FIND_(kControlCharacters);
- EXPECT_SUB_FIND_(kControlCharacters);
-
- EXPECT_FIND_("TRACE_EVENT_ENTER_CONTEXT call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("(", ph);
-
- std::string scope;
- std::string id;
- EXPECT_TRUE((item && item->GetString("scope", &scope)));
- EXPECT_EQ("scope", scope);
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x20151021", id);
- }
-
- EXPECT_FIND_("TRACE_EVENT_LEAVE_CONTEXT call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ(")", ph);
-
- std::string scope;
- std::string id;
- EXPECT_TRUE((item && item->GetString("scope", &scope)));
- EXPECT_EQ("scope", scope);
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x20151021", id);
- }
-
- std::vector<const DictionaryValue*> scoped_context_calls =
- FindTraceEntries(trace_parsed, "TRACE_EVENT_SCOPED_CONTEXT call");
- EXPECT_EQ(2u, scoped_context_calls.size());
- {
- item = scoped_context_calls[0];
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("(", ph);
-
- std::string id;
- EXPECT_FALSE((item && item->HasKey("scope")));
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x20151021", id);
- }
-
- {
- item = scoped_context_calls[1];
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ(")", ph);
-
- std::string id;
- EXPECT_FALSE((item && item->HasKey("scope")));
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x20151021", id);
- }
-
- EXPECT_FIND_("TRACE_LINK_IDS simple call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("=", ph);
-
- EXPECT_FALSE((item && item->HasKey("scope")));
- std::string id1;
- EXPECT_TRUE((item && item->GetString("id", &id1)));
- EXPECT_EQ("0x1000", id1);
-
- EXPECT_FALSE((item && item->HasKey("args.linked_id.scope")));
- std::string id2;
- EXPECT_TRUE((item && item->GetString("args.linked_id.id", &id2)));
- EXPECT_EQ("0x2000", id2);
- }
-
- EXPECT_FIND_("TRACE_LINK_IDS scoped call");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("=", ph);
-
- std::string scope1;
- EXPECT_TRUE((item && item->GetString("scope", &scope1)));
- EXPECT_EQ("scope 1", scope1);
- std::string id1;
- EXPECT_TRUE((item && item->GetString("id", &id1)));
- EXPECT_EQ("0x1000", id1);
-
- std::string scope2;
- EXPECT_TRUE((item && item->GetString("args.linked_id.scope", &scope2)));
- EXPECT_EQ("scope 2", scope2);
- std::string id2;
- EXPECT_TRUE((item && item->GetString("args.linked_id.id", &id2)));
- EXPECT_EQ("0x2000", id2);
- }
-
- EXPECT_FIND_("TRACE_LINK_IDS to a local ID");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("=", ph);
-
- EXPECT_FALSE((item && item->HasKey("scope")));
- std::string id1;
- EXPECT_TRUE((item && item->GetString("id", &id1)));
- EXPECT_EQ("0x1000", id1);
-
- EXPECT_FALSE((item && item->HasKey("args.linked_id.scope")));
- std::string id2;
- EXPECT_TRUE((item && item->GetString("args.linked_id.id2.local", &id2)));
- EXPECT_EQ("0x2000", id2);
- }
-
- EXPECT_FIND_("TRACE_LINK_IDS to a global ID");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("=", ph);
-
- EXPECT_FALSE((item && item->HasKey("scope")));
- std::string id1;
- EXPECT_TRUE((item && item->GetString("id", &id1)));
- EXPECT_EQ("0x1000", id1);
-
- EXPECT_FALSE((item && item->HasKey("args.linked_id.scope")));
- std::string id2;
- EXPECT_TRUE((item && item->GetString("args.linked_id.id2.global", &id2)));
- EXPECT_EQ("0x2000", id2);
- }
-
- EXPECT_FIND_("TRACE_LINK_IDS to a composite ID");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("=", ph);
-
- EXPECT_FALSE(item->HasKey("scope"));
- std::string id1;
- EXPECT_TRUE(item->GetString("id", &id1));
- EXPECT_EQ("0x1000", id1);
-
- std::string scope;
- EXPECT_TRUE(item->GetString("args.linked_id.scope", &scope));
- EXPECT_EQ("scope 1", scope);
- std::string id2;
- EXPECT_TRUE(item->GetString("args.linked_id.id", &id2));
- EXPECT_EQ(id2, "0x2000/0x3000");
- }
-
- EXPECT_FIND_("async default process scope");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("S", ph);
-
- std::string id;
- EXPECT_TRUE((item && item->GetString("id", &id)));
- EXPECT_EQ("0x1000", id);
- }
-
- EXPECT_FIND_("async local id");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("S", ph);
-
- std::string id;
- EXPECT_TRUE((item && item->GetString("id2.local", &id)));
- EXPECT_EQ("0x2000", id);
- }
-
- EXPECT_FIND_("async global id");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("S", ph);
-
- std::string id;
- EXPECT_TRUE((item && item->GetString("id2.global", &id)));
- EXPECT_EQ("0x3000", id);
- }
-
- EXPECT_FIND_("async global id with scope string");
- {
- std::string ph;
- EXPECT_TRUE((item && item->GetString("ph", &ph)));
- EXPECT_EQ("S", ph);
-
- std::string id;
- EXPECT_TRUE((item && item->GetString("id2.global", &id)));
- EXPECT_EQ("0x4000", id);
- std::string scope;
- EXPECT_TRUE((item && item->GetString("scope", &scope)));
- EXPECT_EQ("scope string", scope);
- }
-}
-
-void TraceManyInstantEvents(int thread_id, int num_events,
- WaitableEvent* task_complete_event) {
- for (int i = 0; i < num_events; i++) {
- TRACE_EVENT_INSTANT2("all", "multi thread event",
- TRACE_EVENT_SCOPE_THREAD,
- "thread", thread_id,
- "event", i);
- }
-
- if (task_complete_event)
- task_complete_event->Signal();
-}
-
-void ValidateInstantEventPresentOnEveryThread(const ListValue& trace_parsed,
- int num_threads,
- int num_events) {
- std::map<int, std::map<int, bool> > results;
-
- size_t trace_parsed_count = trace_parsed.GetSize();
- for (size_t i = 0; i < trace_parsed_count; i++) {
- const Value* value = nullptr;
- trace_parsed.Get(i, &value);
- if (!value || value->type() != Value::Type::DICTIONARY)
- continue;
- const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
- std::string name;
- dict->GetString("name", &name);
- if (name != "multi thread event")
- continue;
-
- int thread = 0;
- int event = 0;
- EXPECT_TRUE(dict->GetInteger("args.thread", &thread));
- EXPECT_TRUE(dict->GetInteger("args.event", &event));
- results[thread][event] = true;
- }
-
- EXPECT_FALSE(results[-1][-1]);
- for (int thread = 0; thread < num_threads; thread++) {
- for (int event = 0; event < num_events; event++) {
- EXPECT_TRUE(results[thread][event]);
- }
- }
-}
-
-void CheckTraceDefaultCategoryFilters(const TraceLog& trace_log) {
- // Default enables all category filters except the disabled-by-default-* ones.
- EXPECT_TRUE(*trace_log.GetCategoryGroupEnabled("foo"));
- EXPECT_TRUE(*trace_log.GetCategoryGroupEnabled("bar"));
- EXPECT_TRUE(*trace_log.GetCategoryGroupEnabled("foo,bar"));
- EXPECT_TRUE(*trace_log.GetCategoryGroupEnabled(
- "foo,disabled-by-default-foo"));
- EXPECT_FALSE(*trace_log.GetCategoryGroupEnabled(
- "disabled-by-default-foo,disabled-by-default-bar"));
-}
-
-} // namespace
-
-// Simple Test for emitting data and validating it was received.
-TEST_F(TraceEventTestFixture, DataCaptured) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
-
- TraceWithAllMacroVariants(nullptr);
-
- EndTraceAndFlush();
-
- ValidateAllTraceMacrosCreatedData(trace_parsed_);
-}
-
-// Emit some events and validate that only empty strings are received
-// if we tell Flush() to discard events.
-TEST_F(TraceEventTestFixture, DataDiscarded) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
-
- TraceWithAllMacroVariants(nullptr);
-
- CancelTrace();
-
- EXPECT_TRUE(trace_parsed_.empty());
-}
-
-class MockEnabledStateChangedObserver :
- public TraceLog::EnabledStateObserver {
- public:
- MOCK_METHOD0(OnTraceLogEnabled, void());
- MOCK_METHOD0(OnTraceLogDisabled, void());
-};
-
-TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) {
- MockEnabledStateChangedObserver observer;
- TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
-
- EXPECT_CALL(observer, OnTraceLogEnabled())
- .Times(1);
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- testing::Mock::VerifyAndClear(&observer);
- EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
-
- // Cleanup.
- TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
- TraceLog::GetInstance()->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
-
- testing::StrictMock<MockEnabledStateChangedObserver> observer;
- TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
-
- EXPECT_CALL(observer, OnTraceLogEnabled())
- .Times(0);
- EXPECT_CALL(observer, OnTraceLogDisabled())
- .Times(0);
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- testing::Mock::VerifyAndClear(&observer);
- EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
-
- // Cleanup.
- TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
- TraceLog::GetInstance()->SetDisabled();
- TraceLog::GetInstance()->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, EnabledObserverFiresOnFirstDisable) {
- TraceConfig tc_inc_all("*", "");
- TraceLog::GetInstance()->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
- TraceLog::GetInstance()->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
-
- testing::StrictMock<MockEnabledStateChangedObserver> observer;
- TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
-
- EXPECT_CALL(observer, OnTraceLogEnabled())
- .Times(0);
- EXPECT_CALL(observer, OnTraceLogDisabled())
- .Times(1);
- TraceLog::GetInstance()->SetDisabled();
- testing::Mock::VerifyAndClear(&observer);
-
- // Cleanup.
- TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
- TraceLog::GetInstance()->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, EnabledObserverFiresOnDisable) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
-
- MockEnabledStateChangedObserver observer;
- TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
-
- EXPECT_CALL(observer, OnTraceLogDisabled())
- .Times(1);
- TraceLog::GetInstance()->SetDisabled();
- testing::Mock::VerifyAndClear(&observer);
-
- // Cleanup.
- TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
-}
-
-// Tests the IsEnabled() state of TraceLog changes before callbacks.
-class AfterStateChangeEnabledStateObserver
- : public TraceLog::EnabledStateObserver {
- public:
- AfterStateChangeEnabledStateObserver() = default;
- ~AfterStateChangeEnabledStateObserver() override = default;
-
- // TraceLog::EnabledStateObserver overrides:
- void OnTraceLogEnabled() override {
- EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
- }
-
- void OnTraceLogDisabled() override {
- EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
- }
-};
-
-TEST_F(TraceEventTestFixture, ObserversFireAfterStateChange) {
- AfterStateChangeEnabledStateObserver observer;
- TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
-
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
-
- TraceLog::GetInstance()->SetDisabled();
- EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
-
- TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
-}
-
-// Tests that a state observer can remove itself during a callback.
-class SelfRemovingEnabledStateObserver
- : public TraceLog::EnabledStateObserver {
- public:
- SelfRemovingEnabledStateObserver() = default;
- ~SelfRemovingEnabledStateObserver() override = default;
-
- // TraceLog::EnabledStateObserver overrides:
- void OnTraceLogEnabled() override {}
-
- void OnTraceLogDisabled() override {
- TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
- }
-};
-
-TEST_F(TraceEventTestFixture, SelfRemovingObserver) {
- ASSERT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
-
- SelfRemovingEnabledStateObserver observer;
- TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
- EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest());
-
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- TraceLog::GetInstance()->SetDisabled();
- // The observer removed itself on disable.
- EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
-}
-
-bool IsNewTrace() {
- bool is_new_trace;
- TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
- return is_new_trace;
-}
-
-TEST_F(TraceEventTestFixture, NewTraceRecording) {
- ASSERT_FALSE(IsNewTrace());
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- // First call to IsNewTrace() should succeed. But, the second shouldn't.
- ASSERT_TRUE(IsNewTrace());
- ASSERT_FALSE(IsNewTrace());
- EndTraceAndFlush();
-
- // IsNewTrace() should definitely be false now.
- ASSERT_FALSE(IsNewTrace());
-
- // Start another trace. IsNewTrace() should become true again, briefly, as
- // before.
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- ASSERT_TRUE(IsNewTrace());
- ASSERT_FALSE(IsNewTrace());
-
- // Cleanup.
- EndTraceAndFlush();
-}
-
-TEST_F(TraceEventTestFixture, TestTraceFlush) {
- size_t min_traces = 1;
- size_t max_traces = 1;
- do {
- max_traces *= 2;
- TraceLog::GetInstance()->SetEnabled(TraceConfig(),
- TraceLog::RECORDING_MODE);
- for (size_t i = 0; i < max_traces; i++) {
- TRACE_EVENT_INSTANT0("x", "y", TRACE_EVENT_SCOPE_THREAD);
- }
- EndTraceAndFlush();
- } while (num_flush_callbacks_ < 2);
-
- while (min_traces + 50 < max_traces) {
- size_t traces = (min_traces + max_traces) / 2;
- TraceLog::GetInstance()->SetEnabled(TraceConfig(),
- TraceLog::RECORDING_MODE);
- for (size_t i = 0; i < traces; i++) {
- TRACE_EVENT_INSTANT0("x", "y", TRACE_EVENT_SCOPE_THREAD);
- }
- EndTraceAndFlush();
- if (num_flush_callbacks_ < 2) {
- min_traces = traces - 10;
- } else {
- max_traces = traces + 10;
- }
- }
-
- for (size_t traces = min_traces; traces < max_traces; traces++) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(),
- TraceLog::RECORDING_MODE);
- for (size_t i = 0; i < traces; i++) {
- TRACE_EVENT_INSTANT0("x", "y", TRACE_EVENT_SCOPE_THREAD);
- }
- EndTraceAndFlush();
- }
-}
-
-TEST_F(TraceEventTestFixture, AddMetadataEvent) {
- int num_calls = 0;
-
- class Convertable : public ConvertableToTraceFormat {
- public:
- explicit Convertable(int* num_calls) : num_calls_(num_calls) {}
- ~Convertable() override = default;
- void AppendAsTraceFormat(std::string* out) const override {
- (*num_calls_)++;
- out->append("\"metadata_value\"");
- }
-
- private:
- int* num_calls_;
- };
-
- std::unique_ptr<ConvertableToTraceFormat> conv1(new Convertable(&num_calls));
- std::unique_ptr<Convertable> conv2(new Convertable(&num_calls));
-
- BeginTrace();
- TRACE_EVENT_API_ADD_METADATA_EVENT(
- TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_1",
- "metadata_arg_name", std::move(conv1));
- TRACE_EVENT_API_ADD_METADATA_EVENT(
- TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_2",
- "metadata_arg_name", std::move(conv2));
- // |AppendAsTraceFormat| should only be called on flush, not when the event
- // is added.
- ASSERT_EQ(0, num_calls);
- EndTraceAndFlush();
- ASSERT_EQ(2, num_calls);
- EXPECT_TRUE(FindNamePhaseKeyValue("metadata_event_1", "M",
- "metadata_arg_name", "metadata_value"));
- EXPECT_TRUE(FindNamePhaseKeyValue("metadata_event_2", "M",
- "metadata_arg_name", "metadata_value"));
-
- // The metadata event should only be adde to the current trace. In this new
- // trace, the event should not appear.
- BeginTrace();
- EndTraceAndFlush();
- ASSERT_EQ(2, num_calls);
-}
-
-// Test that categories work.
-TEST_F(TraceEventTestFixture, Categories) {
- // Test that categories that are used can be retrieved whether trace was
- // enabled or disabled when the trace event was encountered.
- TRACE_EVENT_INSTANT0("c1", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("c2", "name", TRACE_EVENT_SCOPE_THREAD);
- BeginTrace();
- TRACE_EVENT_INSTANT0("c3", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("c4", "name", TRACE_EVENT_SCOPE_THREAD);
- // Category groups containing more than one category.
- TRACE_EVENT_INSTANT0("c5,c6", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("c7,c8", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("c9"), "name",
- TRACE_EVENT_SCOPE_THREAD);
-
- EndTraceAndFlush();
- std::vector<std::string> cat_groups;
- TraceLog::GetInstance()->GetKnownCategoryGroups(&cat_groups);
- EXPECT_TRUE(ContainsValue(cat_groups, "c1"));
- EXPECT_TRUE(ContainsValue(cat_groups, "c2"));
- EXPECT_TRUE(ContainsValue(cat_groups, "c3"));
- EXPECT_TRUE(ContainsValue(cat_groups, "c4"));
- EXPECT_TRUE(ContainsValue(cat_groups, "c5,c6"));
- EXPECT_TRUE(ContainsValue(cat_groups, "c7,c8"));
- EXPECT_TRUE(ContainsValue(cat_groups, "disabled-by-default-c9"));
- // Make sure metadata isn't returned.
- EXPECT_FALSE(ContainsValue(cat_groups, "__metadata"));
-
- const std::vector<std::string> empty_categories;
- std::vector<std::string> included_categories;
- std::vector<std::string> excluded_categories;
-
- // Test that category filtering works.
-
- // Include nonexistent category -> no events
- Clear();
- included_categories.clear();
- TraceLog::GetInstance()->SetEnabled(TraceConfig("not_found823564786", ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- DropTracedMetadataRecords();
- EXPECT_TRUE(trace_parsed_.empty());
-
- // Include existent category -> only events of that category
- Clear();
- included_categories.clear();
- TraceLog::GetInstance()->SetEnabled(TraceConfig("inc", ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- DropTracedMetadataRecords();
- EXPECT_TRUE(FindMatchingValue("cat", "inc"));
- EXPECT_FALSE(FindNonMatchingValue("cat", "inc"));
-
- // Include existent wildcard -> all categories matching wildcard
- Clear();
- included_categories.clear();
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig("inc_wildcard_*,inc_wildchar_?_end", ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_INSTANT0("inc_wildcard_abc", "included",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildcard_", "included", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "included",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "not_inc",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat1", "not_inc", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat2", "not_inc", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildcard_category,other_category", "included",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0(
- "non_included_category,inc_wildcard_category", "included",
- TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_abc"));
- EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_"));
- EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_x_end"));
- EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
- EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_category,other_category"));
- EXPECT_TRUE(FindMatchingValue("cat",
- "non_included_category,inc_wildcard_category"));
-
- included_categories.clear();
-
- // Exclude nonexistent category -> all events
- Clear();
- TraceLog::GetInstance()->SetEnabled(TraceConfig("-not_found823564786", ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("category1,category2", "name", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
- EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
- EXPECT_TRUE(FindMatchingValue("cat", "category1,category2"));
-
- // Exclude existent category -> only events of other categories
- Clear();
- TraceLog::GetInstance()->SetEnabled(TraceConfig("-inc", ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc2,inc", "name", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc,inc2", "name", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- EXPECT_TRUE(FindMatchingValue("cat", "inc2"));
- EXPECT_FALSE(FindMatchingValue("cat", "inc"));
- EXPECT_TRUE(FindMatchingValue("cat", "inc2,inc"));
- EXPECT_TRUE(FindMatchingValue("cat", "inc,inc2"));
-
- // Exclude existent wildcard -> all categories not matching wildcard
- Clear();
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig("-inc_wildcard_*,-inc_wildchar_?_end", ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_INSTANT0("inc_wildcard_abc", "not_inc",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildcard_", "not_inc",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "not_inc",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "included",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat1", "included", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("cat2", "included", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_bla_end"));
- EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
- EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
- EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
-}
-
-
-// Test ASYNC_BEGIN/END events
-TEST_F(TraceEventTestFixture, AsyncBeginEndEvents) {
- BeginTrace();
-
- unsigned long long id = 0xfeedbeeffeedbeefull;
- TRACE_EVENT_ASYNC_BEGIN0("cat", "name1", id);
- TRACE_EVENT_ASYNC_STEP_INTO0("cat", "name1", id, "step1");
- TRACE_EVENT_ASYNC_END0("cat", "name1", id);
- TRACE_EVENT_BEGIN0("cat", "name2");
- TRACE_EVENT_ASYNC_BEGIN0("cat", "name3", 0);
- TRACE_EVENT_ASYNC_STEP_PAST0("cat", "name3", 0, "step2");
-
- EndTraceAndFlush();
-
- EXPECT_TRUE(FindNamePhase("name1", "S"));
- EXPECT_TRUE(FindNamePhase("name1", "T"));
- EXPECT_TRUE(FindNamePhase("name1", "F"));
-
- std::string id_str;
- StringAppendF(&id_str, "0x%llx", id);
-
- EXPECT_TRUE(FindNamePhaseKeyValue("name1", "S", "id", id_str.c_str()));
- EXPECT_TRUE(FindNamePhaseKeyValue("name1", "T", "id", id_str.c_str()));
- EXPECT_TRUE(FindNamePhaseKeyValue("name1", "F", "id", id_str.c_str()));
- EXPECT_TRUE(FindNamePhaseKeyValue("name3", "S", "id", "0x0"));
- EXPECT_TRUE(FindNamePhaseKeyValue("name3", "p", "id", "0x0"));
-
- // BEGIN events should not have id
- EXPECT_FALSE(FindNamePhaseKeyValue("name2", "B", "id", "0"));
-}
-
-// Test ASYNC_BEGIN/END events
-TEST_F(TraceEventTestFixture, AsyncBeginEndPointerMangling) {
- void* ptr = this;
-
- TraceLog::GetInstance()->SetProcessID(100);
- BeginTrace();
- TRACE_EVENT_ASYNC_BEGIN0("cat", "name1", ptr);
- TRACE_EVENT_ASYNC_BEGIN0("cat", "name2", ptr);
- EndTraceAndFlush();
-
- TraceLog::GetInstance()->SetProcessID(200);
- BeginTrace();
- TRACE_EVENT_ASYNC_END0("cat", "name1", ptr);
- EndTraceAndFlush();
-
- DictionaryValue* async_begin = FindNamePhase("name1", "S");
- DictionaryValue* async_begin2 = FindNamePhase("name2", "S");
- DictionaryValue* async_end = FindNamePhase("name1", "F");
- EXPECT_TRUE(async_begin);
- EXPECT_TRUE(async_begin2);
- EXPECT_TRUE(async_end);
-
- Value* value = nullptr;
- std::string async_begin_id_str;
- std::string async_begin2_id_str;
- std::string async_end_id_str;
- ASSERT_TRUE(async_begin->Get("id", &value));
- ASSERT_TRUE(value->GetAsString(&async_begin_id_str));
- ASSERT_TRUE(async_begin2->Get("id", &value));
- ASSERT_TRUE(value->GetAsString(&async_begin2_id_str));
- ASSERT_TRUE(async_end->Get("id", &value));
- ASSERT_TRUE(value->GetAsString(&async_end_id_str));
-
- EXPECT_STREQ(async_begin_id_str.c_str(), async_begin2_id_str.c_str());
- EXPECT_STRNE(async_begin_id_str.c_str(), async_end_id_str.c_str());
-}
-
-// Test that static strings are not copied.
-TEST_F(TraceEventTestFixture, StaticStringVsString) {
- TraceLog* tracer = TraceLog::GetInstance();
- // Make sure old events are flushed:
- EXPECT_EQ(0u, tracer->GetStatus().event_count);
- const unsigned char* category_group_enabled =
- TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("cat");
-
- {
- BeginTrace();
- // Test that string arguments are copied.
- TraceEventHandle handle1 =
- trace_event_internal::AddTraceEvent(
- TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name1",
- trace_event_internal::kGlobalScope, trace_event_internal::kNoId,
- 0, trace_event_internal::kNoId,
- "arg1", std::string("argval"), "arg2", std::string("argval"));
- // Test that static TRACE_STR_COPY string arguments are copied.
- TraceEventHandle handle2 =
- trace_event_internal::AddTraceEvent(
- TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name2",
- trace_event_internal::kGlobalScope, trace_event_internal::kNoId,
- 0, trace_event_internal::kNoId,
- "arg1", TRACE_STR_COPY("argval"),
- "arg2", TRACE_STR_COPY("argval"));
- EXPECT_GT(tracer->GetStatus().event_count, 1u);
- const TraceEvent* event1 = tracer->GetEventByHandle(handle1);
- const TraceEvent* event2 = tracer->GetEventByHandle(handle2);
- ASSERT_TRUE(event1);
- ASSERT_TRUE(event2);
- EXPECT_STREQ("name1", event1->name());
- EXPECT_STREQ("name2", event2->name());
- EXPECT_TRUE(event1->parameter_copy_storage() != nullptr);
- EXPECT_TRUE(event2->parameter_copy_storage() != nullptr);
- EXPECT_GT(event1->parameter_copy_storage()->size(), 0u);
- EXPECT_GT(event2->parameter_copy_storage()->size(), 0u);
- EndTraceAndFlush();
- }
-
- {
- BeginTrace();
- // Test that static literal string arguments are not copied.
- TraceEventHandle handle1 =
- trace_event_internal::AddTraceEvent(
- TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name1",
- trace_event_internal::kGlobalScope, trace_event_internal::kNoId,
- 0, trace_event_internal::kNoId,
- "arg1", "argval", "arg2", "argval");
- // Test that static TRACE_STR_COPY NULL string arguments are not copied.
- const char* str1 = nullptr;
- const char* str2 = nullptr;
- TraceEventHandle handle2 =
- trace_event_internal::AddTraceEvent(
- TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name2",
- trace_event_internal::kGlobalScope, trace_event_internal::kNoId,
- 0, trace_event_internal::kNoId,
- "arg1", TRACE_STR_COPY(str1),
- "arg2", TRACE_STR_COPY(str2));
- EXPECT_GT(tracer->GetStatus().event_count, 1u);
- const TraceEvent* event1 = tracer->GetEventByHandle(handle1);
- const TraceEvent* event2 = tracer->GetEventByHandle(handle2);
- ASSERT_TRUE(event1);
- ASSERT_TRUE(event2);
- EXPECT_STREQ("name1", event1->name());
- EXPECT_STREQ("name2", event2->name());
- EXPECT_TRUE(event1->parameter_copy_storage() == nullptr);
- EXPECT_TRUE(event2->parameter_copy_storage() == nullptr);
- EndTraceAndFlush();
- }
-}
-
-// Test that data sent from other threads is gathered
-TEST_F(TraceEventTestFixture, DataCapturedOnThread) {
- BeginTrace();
-
- Thread thread("1");
- WaitableEvent task_complete_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.Start();
-
- thread.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&TraceWithAllMacroVariants, &task_complete_event));
- task_complete_event.Wait();
- thread.Stop();
-
- EndTraceAndFlush();
- ValidateAllTraceMacrosCreatedData(trace_parsed_);
-}
-
-// Test that data sent from multiple threads is gathered
-TEST_F(TraceEventTestFixture, DataCapturedManyThreads) {
- BeginTrace();
-
- const int num_threads = 4;
- const int num_events = 4000;
- Thread* threads[num_threads];
- WaitableEvent* task_complete_events[num_threads];
- for (int i = 0; i < num_threads; i++) {
- threads[i] = new Thread(StringPrintf("Thread %d", i));
- task_complete_events[i] =
- new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- threads[i]->Start();
- threads[i]->task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&TraceManyInstantEvents, i, num_events,
- task_complete_events[i]));
- }
-
- for (int i = 0; i < num_threads; i++) {
- task_complete_events[i]->Wait();
- }
-
- // Let half of the threads end before flush.
- for (int i = 0; i < num_threads / 2; i++) {
- threads[i]->Stop();
- delete threads[i];
- delete task_complete_events[i];
- }
-
- EndTraceAndFlushInThreadWithMessageLoop();
- ValidateInstantEventPresentOnEveryThread(trace_parsed_,
- num_threads, num_events);
-
- // Let the other half of the threads end after flush.
- for (int i = num_threads / 2; i < num_threads; i++) {
- threads[i]->Stop();
- delete threads[i];
- delete task_complete_events[i];
- }
-}
-
-// Test that thread and process names show up in the trace
-TEST_F(TraceEventTestFixture, ThreadNames) {
- // Create threads before we enable tracing to make sure
- // that tracelog still captures them.
- const int kNumThreads = 4;
- const int kNumEvents = 10;
- Thread* threads[kNumThreads];
- PlatformThreadId thread_ids[kNumThreads];
- for (int i = 0; i < kNumThreads; i++)
- threads[i] = new Thread(StringPrintf("Thread %d", i));
-
- // Enable tracing.
- BeginTrace();
-
- // Now run some trace code on these threads.
- WaitableEvent* task_complete_events[kNumThreads];
- for (int i = 0; i < kNumThreads; i++) {
- task_complete_events[i] =
- new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- threads[i]->Start();
- thread_ids[i] = threads[i]->GetThreadId();
- threads[i]->task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&TraceManyInstantEvents, i, kNumEvents,
- task_complete_events[i]));
- }
- for (int i = 0; i < kNumThreads; i++) {
- task_complete_events[i]->Wait();
- }
-
- // Shut things down.
- for (int i = 0; i < kNumThreads; i++) {
- threads[i]->Stop();
- delete threads[i];
- delete task_complete_events[i];
- }
-
- EndTraceAndFlush();
-
- std::string tmp;
- int tmp_int;
- const DictionaryValue* item;
-
- // Make sure we get thread name metadata.
- // Note, the test suite may have created a ton of threads.
- // So, we'll have thread names for threads we didn't create.
- std::vector<const DictionaryValue*> items =
- FindTraceEntries(trace_parsed_, "thread_name");
- for (int i = 0; i < static_cast<int>(items.size()); i++) {
- item = items[i];
- ASSERT_TRUE(item);
- EXPECT_TRUE(item->GetInteger("tid", &tmp_int));
-
- // See if this thread name is one of the threads we just created
- for (int j = 0; j < kNumThreads; j++) {
- if (static_cast<int>(thread_ids[j]) != tmp_int)
- continue;
-
- std::string expected_name = StringPrintf("Thread %d", j);
- EXPECT_TRUE(item->GetString("ph", &tmp) && tmp == "M");
- EXPECT_TRUE(item->GetInteger("pid", &tmp_int) &&
- tmp_int == static_cast<int>(base::GetCurrentProcId()));
- // If the thread name changes or the tid gets reused, the name will be
- // a comma-separated list of thread names, so look for a substring.
- EXPECT_TRUE(item->GetString("args.name", &tmp) &&
- tmp.find(expected_name) != std::string::npos);
- }
- }
-}
-
-TEST_F(TraceEventTestFixture, ThreadNameChanges) {
- BeginTrace();
-
- PlatformThread::SetName("");
- TRACE_EVENT_INSTANT0("drink", "water", TRACE_EVENT_SCOPE_THREAD);
-
- PlatformThread::SetName("cafe");
- TRACE_EVENT_INSTANT0("drink", "coffee", TRACE_EVENT_SCOPE_THREAD);
-
- PlatformThread::SetName("shop");
- // No event here, so won't appear in combined name.
-
- PlatformThread::SetName("pub");
- TRACE_EVENT_INSTANT0("drink", "beer", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("drink", "wine", TRACE_EVENT_SCOPE_THREAD);
-
- PlatformThread::SetName(" bar");
- TRACE_EVENT_INSTANT0("drink", "whisky", TRACE_EVENT_SCOPE_THREAD);
-
- EndTraceAndFlush();
-
- std::vector<const DictionaryValue*> items =
- FindTraceEntries(trace_parsed_, "thread_name");
- EXPECT_EQ(1u, items.size());
- ASSERT_GT(items.size(), 0u);
- const DictionaryValue* item = items[0];
- ASSERT_TRUE(item);
- int tid;
- EXPECT_TRUE(item->GetInteger("tid", &tid));
- EXPECT_EQ(PlatformThread::CurrentId(), static_cast<PlatformThreadId>(tid));
-
- std::string expected_name = "cafe,pub, bar";
- std::string tmp;
- EXPECT_TRUE(item->GetString("args.name", &tmp));
- EXPECT_EQ(expected_name, tmp);
-}
-
-// Test that the disabled trace categories are included/excluded from the
-// trace output correctly.
-TEST_F(TraceEventTestFixture, DisabledCategories) {
- BeginTrace();
- TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("cc"), "first",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("included", "first", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
- {
- const DictionaryValue* item = nullptr;
- ListValue& trace_parsed = trace_parsed_;
- EXPECT_NOT_FIND_("disabled-by-default-cc");
- EXPECT_FIND_("included");
- }
- Clear();
-
- BeginSpecificTrace("disabled-by-default-cc");
- TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("cc"), "second",
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("other_included", "second", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
-
- {
- const DictionaryValue* item = nullptr;
- ListValue& trace_parsed = trace_parsed_;
- EXPECT_FIND_("disabled-by-default-cc");
- EXPECT_FIND_("other_included");
- }
-
- Clear();
-
- BeginSpecificTrace("other_included");
- TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("cc") ",other_included",
- "first", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_INSTANT0("other_included," TRACE_DISABLED_BY_DEFAULT("cc"),
- "second", TRACE_EVENT_SCOPE_THREAD);
- EndTraceAndFlush();
-
- {
- const DictionaryValue* item = nullptr;
- ListValue& trace_parsed = trace_parsed_;
- EXPECT_FIND_("disabled-by-default-cc,other_included");
- EXPECT_FIND_("other_included,disabled-by-default-cc");
- }
-}
-
-TEST_F(TraceEventTestFixture, NormallyNoDeepCopy) {
- // Test that the TRACE_EVENT macros do not deep-copy their string. If they
- // do so it may indicate a performance regression, but more-over it would
- // make the DEEP_COPY overloads redundant.
- std::string name_string("event name");
-
- BeginTrace();
- TRACE_EVENT_INSTANT0("category", name_string.c_str(),
- TRACE_EVENT_SCOPE_THREAD);
-
- // Modify the string in place (a wholesale reassignment may leave the old
- // string intact on the heap).
- name_string[0] = '@';
-
- EndTraceAndFlush();
-
- EXPECT_FALSE(FindTraceEntry(trace_parsed_, "event name"));
- EXPECT_TRUE(FindTraceEntry(trace_parsed_, name_string.c_str()));
-}
-
-TEST_F(TraceEventTestFixture, DeepCopy) {
- static const char kOriginalName1[] = "name1";
- static const char kOriginalName2[] = "name2";
- static const char kOriginalName3[] = "name3";
- std::string name1(kOriginalName1);
- std::string name2(kOriginalName2);
- std::string name3(kOriginalName3);
- std::string arg1("arg1");
- std::string arg2("arg2");
- std::string val1("val1");
- std::string val2("val2");
-
- BeginTrace();
- TRACE_EVENT_COPY_INSTANT0("category", name1.c_str(),
- TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_COPY_BEGIN1("category", name2.c_str(),
- arg1.c_str(), 5);
- TRACE_EVENT_COPY_END2("category", name3.c_str(),
- arg1.c_str(), val1,
- arg2.c_str(), val2);
-
- // As per NormallyNoDeepCopy, modify the strings in place.
- name1[0] = name2[0] = name3[0] = arg1[0] = arg2[0] = val1[0] = val2[0] = '@';
-
- EndTraceAndFlush();
-
- EXPECT_FALSE(FindTraceEntry(trace_parsed_, name1.c_str()));
- EXPECT_FALSE(FindTraceEntry(trace_parsed_, name2.c_str()));
- EXPECT_FALSE(FindTraceEntry(trace_parsed_, name3.c_str()));
-
- const DictionaryValue* entry1 = FindTraceEntry(trace_parsed_, kOriginalName1);
- const DictionaryValue* entry2 = FindTraceEntry(trace_parsed_, kOriginalName2);
- const DictionaryValue* entry3 = FindTraceEntry(trace_parsed_, kOriginalName3);
- ASSERT_TRUE(entry1);
- ASSERT_TRUE(entry2);
- ASSERT_TRUE(entry3);
-
- int i;
- EXPECT_FALSE(entry2->GetInteger("args.@rg1", &i));
- EXPECT_TRUE(entry2->GetInteger("args.arg1", &i));
- EXPECT_EQ(5, i);
-
- std::string s;
- EXPECT_TRUE(entry3->GetString("args.arg1", &s));
- EXPECT_EQ("val1", s);
- EXPECT_TRUE(entry3->GetString("args.arg2", &s));
- EXPECT_EQ("val2", s);
-}
-
-// Test that TraceResultBuffer outputs the correct result whether it is added
-// in chunks or added all at once.
-TEST_F(TraceEventTestFixture, TraceResultBuffer) {
- Clear();
-
- trace_buffer_.Start();
- trace_buffer_.AddFragment("bla1");
- trace_buffer_.AddFragment("bla2");
- trace_buffer_.AddFragment("bla3,bla4");
- trace_buffer_.Finish();
- EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
-
- Clear();
-
- trace_buffer_.Start();
- trace_buffer_.AddFragment("bla1,bla2,bla3,bla4");
- trace_buffer_.Finish();
- EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
-}
-
-// Test that trace_event parameters are not evaluated if the tracing
-// system is disabled.
-TEST_F(TraceEventTestFixture, TracingIsLazy) {
- BeginTrace();
-
- int a = 0;
- TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
- EXPECT_EQ(1, a);
-
- TraceLog::GetInstance()->SetDisabled();
-
- TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
- EXPECT_EQ(1, a);
-
- EndTraceAndFlush();
-}
-
-TEST_F(TraceEventTestFixture, TraceEnableDisable) {
- TraceLog* trace_log = TraceLog::GetInstance();
- TraceConfig tc_inc_all("*", "");
- trace_log->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
- EXPECT_TRUE(trace_log->IsEnabled());
- trace_log->SetDisabled();
- EXPECT_FALSE(trace_log->IsEnabled());
-
- trace_log->SetEnabled(tc_inc_all, TraceLog::RECORDING_MODE);
- EXPECT_TRUE(trace_log->IsEnabled());
- const std::vector<std::string> empty;
- trace_log->SetEnabled(TraceConfig(), TraceLog::RECORDING_MODE);
- EXPECT_TRUE(trace_log->IsEnabled());
- trace_log->SetDisabled();
- EXPECT_FALSE(trace_log->IsEnabled());
- trace_log->SetDisabled();
- EXPECT_FALSE(trace_log->IsEnabled());
-}
-
-TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
- TraceLog* trace_log = TraceLog::GetInstance();
- trace_log->SetEnabled(TraceConfig("foo,bar", ""), TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
- trace_log->SetEnabled(TraceConfig("foo2", ""), TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo2"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
- // The "" becomes the default catergory set when applied.
- trace_log->SetEnabled(TraceConfig(), TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
- EXPECT_STREQ(
- "",
- trace_log->GetCurrentTraceConfig().ToCategoryFilterString().c_str());
- trace_log->SetDisabled();
- trace_log->SetDisabled();
- trace_log->SetDisabled();
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
-
- trace_log->SetEnabled(TraceConfig("-foo,-bar", ""), TraceLog::RECORDING_MODE);
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
- trace_log->SetEnabled(TraceConfig("moo", ""), TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("moo"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_STREQ(
- "-foo,-bar",
- trace_log->GetCurrentTraceConfig().ToCategoryFilterString().c_str());
- trace_log->SetDisabled();
- trace_log->SetDisabled();
-
- // Make sure disabled categories aren't cleared if we set in the second.
- trace_log->SetEnabled(TraceConfig("disabled-by-default-cc,foo", ""),
- TraceLog::RECORDING_MODE);
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("bar"));
- trace_log->SetEnabled(TraceConfig("disabled-by-default-gpu", ""),
- TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-cc"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-gpu"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
- EXPECT_STREQ(
- "disabled-by-default-cc,disabled-by-default-gpu",
- trace_log->GetCurrentTraceConfig().ToCategoryFilterString().c_str());
- trace_log->SetDisabled();
- trace_log->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, TraceWithDefaultCategoryFilters) {
- TraceLog* trace_log = TraceLog::GetInstance();
-
- trace_log->SetEnabled(TraceConfig(), TraceLog::RECORDING_MODE);
- CheckTraceDefaultCategoryFilters(*trace_log);
- trace_log->SetDisabled();
-
- trace_log->SetEnabled(TraceConfig("", ""), TraceLog::RECORDING_MODE);
- CheckTraceDefaultCategoryFilters(*trace_log);
- trace_log->SetDisabled();
-
- trace_log->SetEnabled(TraceConfig("*", ""), TraceLog::RECORDING_MODE);
- CheckTraceDefaultCategoryFilters(*trace_log);
- trace_log->SetDisabled();
-
- trace_log->SetEnabled(TraceConfig(""), TraceLog::RECORDING_MODE);
- CheckTraceDefaultCategoryFilters(*trace_log);
- trace_log->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, TraceWithDisabledByDefaultCategoryFilters) {
- TraceLog* trace_log = TraceLog::GetInstance();
-
- trace_log->SetEnabled(TraceConfig("foo,disabled-by-default-foo", ""),
- TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-foo"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("bar"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-bar"));
- trace_log->SetDisabled();
-
- // Enabling only the disabled-by-default-* category means the default ones
- // are also enabled.
- trace_log->SetEnabled(TraceConfig("disabled-by-default-foo", ""),
- TraceLog::RECORDING_MODE);
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-foo"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
- EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
- EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-bar"));
- trace_log->SetDisabled();
-}
-
-class MyData : public ConvertableToTraceFormat {
- public:
- MyData() = default;
- ~MyData() override = default;
-
- void AppendAsTraceFormat(std::string* out) const override {
- out->append("{\"foo\":1}");
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MyData);
-};
-
-TEST_F(TraceEventTestFixture, ConvertableTypes) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
-
- std::unique_ptr<ConvertableToTraceFormat> data(new MyData());
- std::unique_ptr<ConvertableToTraceFormat> data1(new MyData());
- std::unique_ptr<ConvertableToTraceFormat> data2(new MyData());
- TRACE_EVENT1("foo", "bar", "data", std::move(data));
- TRACE_EVENT2("foo", "baz", "data1", std::move(data1), "data2",
- std::move(data2));
-
- // Check that std::unique_ptr<DerivedClassOfConvertable> are properly treated
- // as
- // convertable and not accidentally casted to bool.
- std::unique_ptr<MyData> convertData1(new MyData());
- std::unique_ptr<MyData> convertData2(new MyData());
- std::unique_ptr<MyData> convertData3(new MyData());
- std::unique_ptr<MyData> convertData4(new MyData());
- TRACE_EVENT2("foo", "string_first", "str", "string value 1", "convert",
- std::move(convertData1));
- TRACE_EVENT2("foo", "string_second", "convert", std::move(convertData2),
- "str", "string value 2");
- TRACE_EVENT2("foo", "both_conv", "convert1", std::move(convertData3),
- "convert2", std::move(convertData4));
- EndTraceAndFlush();
-
- // One arg version.
- DictionaryValue* dict = FindNamePhase("bar", "X");
- ASSERT_TRUE(dict);
-
- const DictionaryValue* args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
-
- const Value* value = nullptr;
- const DictionaryValue* convertable_dict = nullptr;
- EXPECT_TRUE(args_dict->Get("data", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
-
- int foo_val;
- EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
- EXPECT_EQ(1, foo_val);
-
- // Two arg version.
- dict = FindNamePhase("baz", "X");
- ASSERT_TRUE(dict);
-
- args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
-
- value = nullptr;
- convertable_dict = nullptr;
- EXPECT_TRUE(args_dict->Get("data1", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
-
- value = nullptr;
- convertable_dict = nullptr;
- EXPECT_TRUE(args_dict->Get("data2", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
-
- // Convertable with other types.
- dict = FindNamePhase("string_first", "X");
- ASSERT_TRUE(dict);
-
- args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
-
- std::string str_value;
- EXPECT_TRUE(args_dict->GetString("str", &str_value));
- EXPECT_STREQ("string value 1", str_value.c_str());
-
- value = nullptr;
- convertable_dict = nullptr;
- foo_val = 0;
- EXPECT_TRUE(args_dict->Get("convert", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
- EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
- EXPECT_EQ(1, foo_val);
-
- dict = FindNamePhase("string_second", "X");
- ASSERT_TRUE(dict);
-
- args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
-
- EXPECT_TRUE(args_dict->GetString("str", &str_value));
- EXPECT_STREQ("string value 2", str_value.c_str());
-
- value = nullptr;
- convertable_dict = nullptr;
- foo_val = 0;
- EXPECT_TRUE(args_dict->Get("convert", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
- EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
- EXPECT_EQ(1, foo_val);
-
- dict = FindNamePhase("both_conv", "X");
- ASSERT_TRUE(dict);
-
- args_dict = nullptr;
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
-
- value = nullptr;
- convertable_dict = nullptr;
- foo_val = 0;
- EXPECT_TRUE(args_dict->Get("convert1", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
- EXPECT_TRUE(args_dict->Get("convert2", &value));
- ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
-}
-
-TEST_F(TraceEventTestFixture, PrimitiveArgs) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
-
- TRACE_EVENT1("foo", "event1", "int_one", 1);
- TRACE_EVENT1("foo", "event2", "int_neg_ten", -10);
- TRACE_EVENT1("foo", "event3", "float_one", 1.0f);
- TRACE_EVENT1("foo", "event4", "float_half", .5f);
- TRACE_EVENT1("foo", "event5", "float_neghalf", -.5f);
- TRACE_EVENT1("foo", "event6", "float_infinity",
- std::numeric_limits<float>::infinity());
- TRACE_EVENT1("foo", "event6b", "float_neg_infinity",
- -std::numeric_limits<float>::infinity());
- TRACE_EVENT1("foo", "event7", "double_nan",
- std::numeric_limits<double>::quiet_NaN());
- void* p = nullptr;
- TRACE_EVENT1("foo", "event8", "pointer_null", p);
- p = reinterpret_cast<void*>(0xbadf00d);
- TRACE_EVENT1("foo", "event9", "pointer_badf00d", p);
- TRACE_EVENT1("foo", "event10", "bool_true", true);
- TRACE_EVENT1("foo", "event11", "bool_false", false);
- TRACE_EVENT1("foo", "event12", "time_null",
- base::Time());
- TRACE_EVENT1("foo", "event13", "time_one",
- base::Time::FromInternalValue(1));
- TRACE_EVENT1("foo", "event14", "timeticks_null",
- base::TimeTicks());
- TRACE_EVENT1("foo", "event15", "timeticks_one",
- base::TimeTicks::FromInternalValue(1));
- EndTraceAndFlush();
-
- const DictionaryValue* args_dict = nullptr;
- DictionaryValue* dict = nullptr;
- const Value* value = nullptr;
- std::string str_value;
- int int_value;
- double double_value;
- bool bool_value;
-
- dict = FindNamePhase("event1", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("int_one", &int_value));
- EXPECT_EQ(1, int_value);
-
- dict = FindNamePhase("event2", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("int_neg_ten", &int_value));
- EXPECT_EQ(-10, int_value);
-
- // 1f must be serlized to JSON as "1.0" in order to be a double, not an int.
- dict = FindNamePhase("event3", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->Get("float_one", &value));
- EXPECT_TRUE(value->is_double());
- EXPECT_TRUE(value->GetAsDouble(&double_value));
- EXPECT_EQ(1, double_value);
-
- // .5f must be serlized to JSON as "0.5".
- dict = FindNamePhase("event4", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->Get("float_half", &value));
- EXPECT_TRUE(value->is_double());
- EXPECT_TRUE(value->GetAsDouble(&double_value));
- EXPECT_EQ(0.5, double_value);
-
- // -.5f must be serlized to JSON as "-0.5".
- dict = FindNamePhase("event5", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->Get("float_neghalf", &value));
- EXPECT_TRUE(value->is_double());
- EXPECT_TRUE(value->GetAsDouble(&double_value));
- EXPECT_EQ(-0.5, double_value);
-
- // Infinity is serialized to JSON as a string.
- dict = FindNamePhase("event6", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetString("float_infinity", &str_value));
- EXPECT_STREQ("Infinity", str_value.c_str());
- dict = FindNamePhase("event6b", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetString("float_neg_infinity", &str_value));
- EXPECT_STREQ("-Infinity", str_value.c_str());
-
- // NaN is serialized to JSON as a string.
- dict = FindNamePhase("event7", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetString("double_nan", &str_value));
- EXPECT_STREQ("NaN", str_value.c_str());
-
- // NULL pointers should be serialized as "0x0".
- dict = FindNamePhase("event8", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetString("pointer_null", &str_value));
- EXPECT_STREQ("0x0", str_value.c_str());
-
- // Other pointers should be serlized as a hex string.
- dict = FindNamePhase("event9", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetString("pointer_badf00d", &str_value));
- EXPECT_STREQ("0xbadf00d", str_value.c_str());
-
- dict = FindNamePhase("event10", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetBoolean("bool_true", &bool_value));
- EXPECT_TRUE(bool_value);
-
- dict = FindNamePhase("event11", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetBoolean("bool_false", &bool_value));
- EXPECT_FALSE(bool_value);
-
- dict = FindNamePhase("event12", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("time_null", &int_value));
- EXPECT_EQ(0, int_value);
-
- dict = FindNamePhase("event13", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("time_one", &int_value));
- EXPECT_EQ(1, int_value);
-
- dict = FindNamePhase("event14", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("timeticks_null", &int_value));
- EXPECT_EQ(0, int_value);
-
- dict = FindNamePhase("event15", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("timeticks_one", &int_value));
- EXPECT_EQ(1, int_value);
-}
-
-TEST_F(TraceEventTestFixture, NameIsEscaped) {
- TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT0("category", "name\\with\\backspaces");
- EndTraceAndFlush();
-
- EXPECT_TRUE(FindMatchingValue("cat", "category"));
- EXPECT_TRUE(FindMatchingValue("name", "name\\with\\backspaces"));
-}
-
-namespace {
-
-bool IsArgNameWhitelisted(const char* arg_name) {
- return base::MatchPattern(arg_name, "granular_arg_whitelisted");
-}
-
-bool IsTraceEventArgsWhitelisted(const char* category_group_name,
- const char* event_name,
- ArgumentNameFilterPredicate* arg_filter) {
- if (base::MatchPattern(category_group_name, "toplevel") &&
- base::MatchPattern(event_name, "*")) {
- return true;
- }
-
- if (base::MatchPattern(category_group_name, "benchmark") &&
- base::MatchPattern(event_name, "granularly_whitelisted")) {
- *arg_filter = base::Bind(&IsArgNameWhitelisted);
- return true;
- }
-
- return false;
-}
-
-} // namespace
-
-TEST_F(TraceEventTestFixture, ArgsWhitelisting) {
- TraceLog::GetInstance()->SetArgumentFilterPredicate(
- base::Bind(&IsTraceEventArgsWhitelisted));
-
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, "enable-argument-filter"),
- TraceLog::RECORDING_MODE);
-
- TRACE_EVENT1("toplevel", "event1", "int_one", 1);
- TRACE_EVENT1("whitewashed", "event2", "int_two", 1);
-
- TRACE_EVENT2("benchmark", "granularly_whitelisted",
- "granular_arg_whitelisted", "whitelisted_value",
- "granular_arg_blacklisted", "blacklisted_value");
-
- EndTraceAndFlush();
-
- const DictionaryValue* args_dict = nullptr;
- DictionaryValue* dict = nullptr;
- int int_value;
-
- dict = FindNamePhase("event1", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_TRUE(args_dict->GetInteger("int_one", &int_value));
- EXPECT_EQ(1, int_value);
-
- dict = FindNamePhase("event2", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
- EXPECT_FALSE(args_dict->GetInteger("int_two", &int_value));
-
- std::string args_string;
- EXPECT_TRUE(dict->GetString("args", &args_string));
- EXPECT_EQ(args_string, "__stripped__");
-
- dict = FindNamePhase("granularly_whitelisted", "X");
- ASSERT_TRUE(dict);
- dict->GetDictionary("args", &args_dict);
- ASSERT_TRUE(args_dict);
-
- EXPECT_TRUE(args_dict->GetString("granular_arg_whitelisted", &args_string));
- EXPECT_EQ(args_string, "whitelisted_value");
-
- EXPECT_TRUE(args_dict->GetString("granular_arg_blacklisted", &args_string));
- EXPECT_EQ(args_string, "__stripped__");
-}
-
-TEST_F(TraceEventTestFixture, TraceBufferVectorReportFull) {
- TraceLog* trace_log = TraceLog::GetInstance();
- trace_log->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, ""), TraceLog::RECORDING_MODE);
- trace_log->logged_events_.reset(
- TraceBuffer::CreateTraceBufferVectorOfSize(100));
- do {
- TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
- "all", "with_timestamp", 0, 0, TimeTicks::Now());
- TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(
- "all", "with_timestamp", 0, 0, TimeTicks::Now());
- } while (!trace_log->BufferIsFull());
-
- EndTraceAndFlush();
-
- const DictionaryValue* trace_full_metadata = nullptr;
-
- trace_full_metadata = FindTraceEntry(trace_parsed_,
- "overflowed_at_ts");
- std::string phase;
- double buffer_limit_reached_timestamp = 0;
-
- EXPECT_TRUE(trace_full_metadata);
- EXPECT_TRUE(trace_full_metadata->GetString("ph", &phase));
- EXPECT_EQ("M", phase);
- EXPECT_TRUE(trace_full_metadata->GetDouble(
- "args.overflowed_at_ts", &buffer_limit_reached_timestamp));
- EXPECT_DOUBLE_EQ(
- static_cast<double>(
- trace_log->buffer_limit_reached_timestamp_.ToInternalValue()),
- buffer_limit_reached_timestamp);
-
- // Test that buffer_limit_reached_timestamp's value is between the timestamp
- // of the last trace event and current time.
- DropTracedMetadataRecords();
- const DictionaryValue* last_trace_event = nullptr;
- double last_trace_event_timestamp = 0;
- EXPECT_TRUE(trace_parsed_.GetDictionary(trace_parsed_.GetSize() - 1,
- &last_trace_event));
- EXPECT_TRUE(last_trace_event->GetDouble("ts", &last_trace_event_timestamp));
- EXPECT_LE(last_trace_event_timestamp, buffer_limit_reached_timestamp);
- EXPECT_LE(buffer_limit_reached_timestamp,
- trace_log->OffsetNow().ToInternalValue());
-}
-
-TEST_F(TraceEventTestFixture, TraceBufferRingBufferGetReturnChunk) {
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY),
- TraceLog::RECORDING_MODE);
- TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
- size_t capacity = buffer->Capacity();
- size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
- uint32_t last_seq = 0;
- size_t chunk_index;
- EXPECT_EQ(0u, buffer->Size());
-
- std::unique_ptr<TraceBufferChunk* []> chunks(
- new TraceBufferChunk*[num_chunks]);
- for (size_t i = 0; i < num_chunks; ++i) {
- chunks[i] = buffer->GetChunk(&chunk_index).release();
- EXPECT_TRUE(chunks[i]);
- EXPECT_EQ(i, chunk_index);
- EXPECT_GT(chunks[i]->seq(), last_seq);
- EXPECT_EQ((i + 1) * TraceBufferChunk::kTraceBufferChunkSize,
- buffer->Size());
- last_seq = chunks[i]->seq();
- }
-
- // Ring buffer is never full.
- EXPECT_FALSE(buffer->IsFull());
-
- // Return all chunks in original order.
- for (size_t i = 0; i < num_chunks; ++i)
- buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
-
- // Should recycle the chunks in the returned order.
- for (size_t i = 0; i < num_chunks; ++i) {
- chunks[i] = buffer->GetChunk(&chunk_index).release();
- EXPECT_TRUE(chunks[i]);
- EXPECT_EQ(i, chunk_index);
- EXPECT_GT(chunks[i]->seq(), last_seq);
- last_seq = chunks[i]->seq();
- }
-
- // Return all chunks in reverse order.
- for (size_t i = 0; i < num_chunks; ++i) {
- buffer->ReturnChunk(num_chunks - i - 1, std::unique_ptr<TraceBufferChunk>(
- chunks[num_chunks - i - 1]));
- }
-
- // Should recycle the chunks in the returned order.
- for (size_t i = 0; i < num_chunks; ++i) {
- chunks[i] = buffer->GetChunk(&chunk_index).release();
- EXPECT_TRUE(chunks[i]);
- EXPECT_EQ(num_chunks - i - 1, chunk_index);
- EXPECT_GT(chunks[i]->seq(), last_seq);
- last_seq = chunks[i]->seq();
- }
-
- for (size_t i = 0; i < num_chunks; ++i)
- buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
-
- TraceLog::GetInstance()->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, TraceBufferRingBufferHalfIteration) {
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY),
- TraceLog::RECORDING_MODE);
- TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
- size_t capacity = buffer->Capacity();
- size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
- size_t chunk_index;
- EXPECT_EQ(0u, buffer->Size());
- EXPECT_FALSE(buffer->NextChunk());
-
- size_t half_chunks = num_chunks / 2;
- std::unique_ptr<TraceBufferChunk* []> chunks(
- new TraceBufferChunk*[half_chunks]);
-
- for (size_t i = 0; i < half_chunks; ++i) {
- chunks[i] = buffer->GetChunk(&chunk_index).release();
- EXPECT_TRUE(chunks[i]);
- EXPECT_EQ(i, chunk_index);
- }
- for (size_t i = 0; i < half_chunks; ++i)
- buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
-
- for (size_t i = 0; i < half_chunks; ++i)
- EXPECT_EQ(chunks[i], buffer->NextChunk());
- EXPECT_FALSE(buffer->NextChunk());
- TraceLog::GetInstance()->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, TraceBufferRingBufferFullIteration) {
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY),
- TraceLog::RECORDING_MODE);
- TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
- size_t capacity = buffer->Capacity();
- size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
- size_t chunk_index;
- EXPECT_EQ(0u, buffer->Size());
- EXPECT_FALSE(buffer->NextChunk());
-
- std::unique_ptr<TraceBufferChunk* []> chunks(
- new TraceBufferChunk*[num_chunks]);
-
- for (size_t i = 0; i < num_chunks; ++i) {
- chunks[i] = buffer->GetChunk(&chunk_index).release();
- EXPECT_TRUE(chunks[i]);
- EXPECT_EQ(i, chunk_index);
- }
- for (size_t i = 0; i < num_chunks; ++i)
- buffer->ReturnChunk(i, std::unique_ptr<TraceBufferChunk>(chunks[i]));
-
- for (size_t i = 0; i < num_chunks; ++i)
- EXPECT_TRUE(chunks[i] == buffer->NextChunk());
- EXPECT_FALSE(buffer->NextChunk());
- TraceLog::GetInstance()->SetDisabled();
-}
-
-TEST_F(TraceEventTestFixture, TraceRecordAsMuchAsPossibleMode) {
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, RECORD_AS_MUCH_AS_POSSIBLE),
- TraceLog::RECORDING_MODE);
- TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
- EXPECT_EQ(512000000UL, buffer->Capacity());
- TraceLog::GetInstance()->SetDisabled();
-}
-
-void BlockUntilStopped(WaitableEvent* task_start_event,
- WaitableEvent* task_stop_event) {
- task_start_event->Signal();
- task_stop_event->Wait();
-}
-
-TEST_F(TraceEventTestFixture, SetCurrentThreadBlocksMessageLoopBeforeTracing) {
- BeginTrace();
-
- Thread thread("1");
- WaitableEvent task_complete_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.Start();
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TraceLog::SetCurrentThreadBlocksMessageLoop,
- Unretained(TraceLog::GetInstance())));
-
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TraceWithAllMacroVariants, &task_complete_event));
- task_complete_event.Wait();
-
- WaitableEvent task_start_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_stop_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&BlockUntilStopped, &task_start_event, &task_stop_event));
- task_start_event.Wait();
-
- EndTraceAndFlush();
- ValidateAllTraceMacrosCreatedData(trace_parsed_);
-
- task_stop_event.Signal();
- thread.Stop();
-}
-
-TEST_F(TraceEventTestFixture, ConvertTraceConfigToInternalOptions) {
- TraceLog* trace_log = TraceLog::GetInstance();
- EXPECT_EQ(TraceLog::kInternalRecordUntilFull,
- trace_log->GetInternalOptionsFromTraceConfig(
- TraceConfig(kRecordAllCategoryFilter, RECORD_UNTIL_FULL)));
-
- EXPECT_EQ(TraceLog::kInternalRecordContinuously,
- trace_log->GetInternalOptionsFromTraceConfig(
- TraceConfig(kRecordAllCategoryFilter, RECORD_CONTINUOUSLY)));
-
- EXPECT_EQ(TraceLog::kInternalEchoToConsole,
- trace_log->GetInternalOptionsFromTraceConfig(
- TraceConfig(kRecordAllCategoryFilter, ECHO_TO_CONSOLE)));
-
- EXPECT_EQ(TraceLog::kInternalEchoToConsole,
- trace_log->GetInternalOptionsFromTraceConfig(
- TraceConfig("*", "trace-to-console,enable-systrace")));
-}
-
-void SetBlockingFlagAndBlockUntilStopped(WaitableEvent* task_start_event,
- WaitableEvent* task_stop_event) {
- TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop();
- BlockUntilStopped(task_start_event, task_stop_event);
-}
-
-TEST_F(TraceEventTestFixture, SetCurrentThreadBlocksMessageLoopAfterTracing) {
- BeginTrace();
-
- Thread thread("1");
- WaitableEvent task_complete_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.Start();
-
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TraceWithAllMacroVariants, &task_complete_event));
- task_complete_event.Wait();
-
- WaitableEvent task_start_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_stop_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.task_runner()->PostTask(FROM_HERE,
- BindOnce(&SetBlockingFlagAndBlockUntilStopped,
- &task_start_event, &task_stop_event));
- task_start_event.Wait();
-
- EndTraceAndFlush();
- ValidateAllTraceMacrosCreatedData(trace_parsed_);
-
- task_stop_event.Signal();
- thread.Stop();
-}
-
-TEST_F(TraceEventTestFixture, ThreadOnceBlocking) {
- BeginTrace();
-
- Thread thread("1");
- WaitableEvent task_complete_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.Start();
-
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TraceWithAllMacroVariants, &task_complete_event));
- task_complete_event.Wait();
-
- WaitableEvent task_start_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- WaitableEvent task_stop_event(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED);
- thread.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&BlockUntilStopped, &task_start_event, &task_stop_event));
- task_start_event.Wait();
-
- // The thread will timeout in this flush.
- EndTraceAndFlushInThreadWithMessageLoop();
- Clear();
-
- // Let the thread's message loop continue to spin.
- task_stop_event.Signal();
-
- // The following sequence ensures that the FlushCurrentThread task has been
- // executed in the thread before continuing.
- thread.task_runner()->PostTask(
- FROM_HERE,
- BindOnce(&BlockUntilStopped, &task_start_event, &task_stop_event));
- task_start_event.Wait();
- task_stop_event.Signal();
- Clear();
-
- // TraceLog should discover the generation mismatch and recover the thread
- // local buffer for the thread without any error.
- BeginTrace();
- thread.task_runner()->PostTask(
- FROM_HERE, BindOnce(&TraceWithAllMacroVariants, &task_complete_event));
- task_complete_event.Wait();
- EndTraceAndFlushInThreadWithMessageLoop();
- ValidateAllTraceMacrosCreatedData(trace_parsed_);
-}
-
-std::string* g_log_buffer = nullptr;
-bool MockLogMessageHandler(int, const char*, int, size_t,
- const std::string& str) {
- if (!g_log_buffer)
- g_log_buffer = new std::string();
- g_log_buffer->append(str);
- return false;
-}
-
-TEST_F(TraceEventTestFixture, EchoToConsole) {
- logging::LogMessageHandlerFunction old_log_message_handler =
- logging::GetLogMessageHandler();
- logging::SetLogMessageHandler(MockLogMessageHandler);
-
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, ECHO_TO_CONSOLE),
- TraceLog::RECORDING_MODE);
- TRACE_EVENT_BEGIN0("a", "begin_end");
- {
- TRACE_EVENT0("b", "duration");
- TRACE_EVENT0("b1", "duration1");
- }
- TRACE_EVENT_INSTANT0("c", "instant", TRACE_EVENT_SCOPE_GLOBAL);
- TRACE_EVENT_END0("a", "begin_end");
-
- EXPECT_NE(std::string::npos, g_log_buffer->find("begin_end[a]\x1b"));
- EXPECT_NE(std::string::npos, g_log_buffer->find("| duration[b]\x1b"));
- EXPECT_NE(std::string::npos, g_log_buffer->find("| | duration1[b1]\x1b"));
- EXPECT_NE(std::string::npos, g_log_buffer->find("| | duration1[b1] ("));
- EXPECT_NE(std::string::npos, g_log_buffer->find("| duration[b] ("));
- EXPECT_NE(std::string::npos, g_log_buffer->find("| instant[c]\x1b"));
- EXPECT_NE(std::string::npos, g_log_buffer->find("begin_end[a] ("));
-
- EndTraceAndFlush();
- delete g_log_buffer;
- logging::SetLogMessageHandler(old_log_message_handler);
- g_log_buffer = nullptr;
-}
-
-bool LogMessageHandlerWithTraceEvent(int, const char*, int, size_t,
- const std::string&) {
- TRACE_EVENT0("log", "trace_event");
- return false;
-}
-
-TEST_F(TraceEventTestFixture, EchoToConsoleTraceEventRecursion) {
- logging::LogMessageHandlerFunction old_log_message_handler =
- logging::GetLogMessageHandler();
- logging::SetLogMessageHandler(LogMessageHandlerWithTraceEvent);
-
- TraceLog::GetInstance()->SetEnabled(
- TraceConfig(kRecordAllCategoryFilter, ECHO_TO_CONSOLE),
- TraceLog::RECORDING_MODE);
- {
- // This should not cause deadlock or infinite recursion.
- TRACE_EVENT0("b", "duration");
- }
-
- EndTraceAndFlush();
- logging::SetLogMessageHandler(old_log_message_handler);
-}
-
-TEST_F(TraceEventTestFixture, TimeOffset) {
- BeginTrace();
- // Let TraceLog timer start from 0.
- TimeDelta time_offset = TimeTicks::Now() - TimeTicks();
- TraceLog::GetInstance()->SetTimeOffset(time_offset);
-
- {
- TRACE_EVENT0("all", "duration1");
- TRACE_EVENT0("all", "duration2");
- }
- TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
- "all", "with_timestamp", 0, 0, TimeTicks::Now());
- TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(
- "all", "with_timestamp", 0, 0, TimeTicks::Now());
-
- EndTraceAndFlush();
- DropTracedMetadataRecords();
-
- double end_time = static_cast<double>(
- (TimeTicks::Now() - time_offset).ToInternalValue());
- double last_timestamp = 0;
- for (size_t i = 0; i < trace_parsed_.GetSize(); ++i) {
- const DictionaryValue* item;
- EXPECT_TRUE(trace_parsed_.GetDictionary(i, &item));
- double timestamp;
- EXPECT_TRUE(item->GetDouble("ts", ×tamp));
- EXPECT_GE(timestamp, last_timestamp);
- EXPECT_LE(timestamp, end_time);
- last_timestamp = timestamp;
- }
-}
-
-TEST_F(TraceEventTestFixture, TraceFilteringMode) {
- const char config_json[] =
- "{"
- " \"event_filters\": ["
- " {"
- " \"filter_predicate\": \"testing_predicate\", "
- " \"included_categories\": [\"*\"]"
- " }"
- " ]"
- "}";
-
- // Run RECORDING_MODE within FILTERING_MODE:
- TestEventFilter::HitsCounter filter_hits_counter;
- TestEventFilter::set_filter_return_value(true);
- TraceLog::GetInstance()->SetFilterFactoryForTesting(TestEventFilter::Factory);
-
- // Only filtering mode is enabled with test filters.
- TraceLog::GetInstance()->SetEnabled(TraceConfig(config_json),
- TraceLog::FILTERING_MODE);
- EXPECT_EQ(TraceLog::FILTERING_MODE, TraceLog::GetInstance()->enabled_modes());
- {
- void* ptr = this;
- TRACE_EVENT0("c0", "name0");
- TRACE_EVENT_ASYNC_BEGIN0("c1", "name1", ptr);
- TRACE_EVENT_INSTANT0("c0", "name0", TRACE_EVENT_SCOPE_THREAD);
- TRACE_EVENT_ASYNC_END0("c1", "name1", ptr);
- }
-
- // Recording mode is enabled when filtering mode is turned on.
- TraceLog::GetInstance()->SetEnabled(TraceConfig("", ""),
- TraceLog::RECORDING_MODE);
- EXPECT_EQ(TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE,
- TraceLog::GetInstance()->enabled_modes());
- {
- TRACE_EVENT0("c2", "name2");
- }
- // Only recording mode is disabled and filtering mode will continue to run.
- TraceLog::GetInstance()->SetDisabled(TraceLog::RECORDING_MODE);
- EXPECT_EQ(TraceLog::FILTERING_MODE, TraceLog::GetInstance()->enabled_modes());
-
- {
- TRACE_EVENT0("c0", "name0");
- }
- // Filtering mode is disabled and no tracing mode should be enabled.
- TraceLog::GetInstance()->SetDisabled(TraceLog::FILTERING_MODE);
- EXPECT_EQ(0, TraceLog::GetInstance()->enabled_modes());
-
- EndTraceAndFlush();
- EXPECT_FALSE(FindMatchingValue("cat", "c0"));
- EXPECT_FALSE(FindMatchingValue("cat", "c1"));
- EXPECT_FALSE(FindMatchingValue("name", "name0"));
- EXPECT_FALSE(FindMatchingValue("name", "name1"));
- EXPECT_TRUE(FindMatchingValue("cat", "c2"));
- EXPECT_TRUE(FindMatchingValue("name", "name2"));
- EXPECT_EQ(6u, filter_hits_counter.filter_trace_event_hit_count);
- EXPECT_EQ(3u, filter_hits_counter.end_event_hit_count);
- Clear();
- filter_hits_counter.Reset();
-
- // Run FILTERING_MODE within RECORDING_MODE:
- // Only recording mode is enabled and all events must be recorded.
- TraceLog::GetInstance()->SetEnabled(TraceConfig("", ""),
- TraceLog::RECORDING_MODE);
- EXPECT_EQ(TraceLog::RECORDING_MODE, TraceLog::GetInstance()->enabled_modes());
- {
- TRACE_EVENT0("c0", "name0");
- }
-
- // Filtering mode is also enabled and all events must be filtered-out.
- TestEventFilter::set_filter_return_value(false);
- TraceLog::GetInstance()->SetEnabled(TraceConfig(config_json),
- TraceLog::FILTERING_MODE);
- EXPECT_EQ(TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE,
- TraceLog::GetInstance()->enabled_modes());
- {
- TRACE_EVENT0("c1", "name1");
- }
- // Only filtering mode is disabled and recording mode should continue to run
- // with all events being recorded.
- TraceLog::GetInstance()->SetDisabled(TraceLog::FILTERING_MODE);
- EXPECT_EQ(TraceLog::RECORDING_MODE, TraceLog::GetInstance()->enabled_modes());
-
- {
- TRACE_EVENT0("c2", "name2");
- }
- // Recording mode is disabled and no tracing mode should be enabled.
- TraceLog::GetInstance()->SetDisabled(TraceLog::RECORDING_MODE);
- EXPECT_EQ(0, TraceLog::GetInstance()->enabled_modes());
-
- EndTraceAndFlush();
- EXPECT_TRUE(FindMatchingValue("cat", "c0"));
- EXPECT_TRUE(FindMatchingValue("cat", "c2"));
- EXPECT_TRUE(FindMatchingValue("name", "name0"));
- EXPECT_TRUE(FindMatchingValue("name", "name2"));
- EXPECT_FALSE(FindMatchingValue("cat", "c1"));
- EXPECT_FALSE(FindMatchingValue("name", "name1"));
- EXPECT_EQ(1u, filter_hits_counter.filter_trace_event_hit_count);
- EXPECT_EQ(1u, filter_hits_counter.end_event_hit_count);
- Clear();
-}
-
-TEST_F(TraceEventTestFixture, EventFiltering) {
- const char config_json[] =
- "{"
- " \"included_categories\": ["
- " \"filtered_cat\","
- " \"unfiltered_cat\","
- " \"" TRACE_DISABLED_BY_DEFAULT("filtered_cat") "\","
- " \"" TRACE_DISABLED_BY_DEFAULT("unfiltered_cat") "\"],"
- " \"event_filters\": ["
- " {"
- " \"filter_predicate\": \"testing_predicate\", "
- " \"included_categories\": ["
- " \"filtered_cat\","
- " \"" TRACE_DISABLED_BY_DEFAULT("filtered_cat") "\"]"
- " }"
- " "
- " ]"
- "}";
-
- TestEventFilter::HitsCounter filter_hits_counter;
- TestEventFilter::set_filter_return_value(true);
- TraceLog::GetInstance()->SetFilterFactoryForTesting(TestEventFilter::Factory);
-
- TraceConfig trace_config(config_json);
- TraceLog::GetInstance()->SetEnabled(
- trace_config, TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE);
- ASSERT_TRUE(TraceLog::GetInstance()->IsEnabled());
-
- TRACE_EVENT0("filtered_cat", "a snake");
- TRACE_EVENT0("filtered_cat", "a mushroom");
- TRACE_EVENT0("unfiltered_cat", "a horse");
-
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("filtered_cat"), "a dog");
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("unfiltered_cat"), "a pony");
-
- // This is scoped so we can test the end event being filtered.
- { TRACE_EVENT0("filtered_cat", "another cat whoa"); }
-
- EndTraceAndFlush();
-
- EXPECT_EQ(4u, filter_hits_counter.filter_trace_event_hit_count);
- EXPECT_EQ(1u, filter_hits_counter.end_event_hit_count);
-}
-
-TEST_F(TraceEventTestFixture, EventWhitelistFiltering) {
- std::string config_json = StringPrintf(
- "{"
- " \"included_categories\": ["
- " \"filtered_cat\","
- " \"unfiltered_cat\","
- " \"" TRACE_DISABLED_BY_DEFAULT("filtered_cat") "\"],"
- " \"event_filters\": ["
- " {"
- " \"filter_predicate\": \"%s\", "
- " \"included_categories\": ["
- " \"filtered_cat\","
- " \"" TRACE_DISABLED_BY_DEFAULT("*") "\"], "
- " \"filter_args\": {"
- " \"event_name_whitelist\": [\"a snake\", \"a dog\"]"
- " }"
- " }"
- " "
- " ]"
- "}",
- EventNameFilter::kName);
-
- TraceConfig trace_config(config_json);
- TraceLog::GetInstance()->SetEnabled(
- trace_config, TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE);
- EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
-
- TRACE_EVENT0("filtered_cat", "a snake");
- TRACE_EVENT0("filtered_cat", "a mushroom");
- TRACE_EVENT0("unfiltered_cat", "a cat");
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("filtered_cat"), "a dog");
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("filtered_cat"), "a pony");
-
- EndTraceAndFlush();
-
- EXPECT_TRUE(FindMatchingValue("name", "a snake"));
- EXPECT_FALSE(FindMatchingValue("name", "a mushroom"));
- EXPECT_TRUE(FindMatchingValue("name", "a cat"));
- EXPECT_TRUE(FindMatchingValue("name", "a dog"));
- EXPECT_FALSE(FindMatchingValue("name", "a pony"));
-}
-
-TEST_F(TraceEventTestFixture, HeapProfilerFiltering) {
- std::string config_json = StringPrintf(
- "{"
- " \"included_categories\": ["
- " \"filtered_cat\","
- " \"unfiltered_cat\","
- " \"" TRACE_DISABLED_BY_DEFAULT("filtered_cat") "\","
- " \"" TRACE_DISABLED_BY_DEFAULT("unfiltered_cat") "\"],"
- " \"excluded_categories\": [\"excluded_cat\"],"
- " \"event_filters\": ["
- " {"
- " \"filter_predicate\": \"%s\", "
- " \"included_categories\": ["
- " \"*\","
- " \"" TRACE_DISABLED_BY_DEFAULT("filtered_cat") "\"]"
- " }"
- " ]"
- "}",
- HeapProfilerEventFilter::kName);
-
- TraceConfig trace_config(config_json);
- TraceLog::GetInstance()->SetEnabled(
- trace_config, TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE);
- EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
-
- TRACE_EVENT0("filtered_cat", "a snake");
- TRACE_EVENT0("excluded_cat", "a mushroom");
- TRACE_EVENT0("unfiltered_cat", "a cat");
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("filtered_cat"), "a dog");
- TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("unfiltered_cat"), "a pony");
-
- EndTraceAndFlush();
-
- // The predicate should not change behavior of the trace events.
- EXPECT_TRUE(FindMatchingValue("name", "a snake"));
- EXPECT_FALSE(FindMatchingValue("name", "a mushroom"));
- EXPECT_TRUE(FindMatchingValue("name", "a cat"));
- EXPECT_TRUE(FindMatchingValue("name", "a dog"));
- EXPECT_TRUE(FindMatchingValue("name", "a pony"));
-}
-
-TEST_F(TraceEventTestFixture, ClockSyncEventsAreAlwaysAddedToTrace) {
- BeginSpecificTrace("-*");
- TRACE_EVENT_CLOCK_SYNC_RECEIVER(1);
- EndTraceAndFlush();
- EXPECT_TRUE(FindNamePhase("clock_sync", "c"));
-}
-
-} // namespace trace_event
-} // namespace base
diff --git a/base/tuple_unittest.cc b/base/tuple_unittest.cc
deleted file mode 100644
index 4b38797..0000000
--- a/base/tuple_unittest.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (c) 2006-2008 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 "base/tuple.h"
-
-#include "base/compiler_specific.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-void DoAdd(int a, int b, int c, int* res) {
- *res = a + b + c;
-}
-
-struct Addy {
- Addy() = default;
- void DoAdd(int a, int b, int c, int d, int* res) {
- *res = a + b + c + d;
- }
-};
-
-struct Addz {
- Addz() = default;
- void DoAdd(int a, int b, int c, int d, int e, int* res) {
- *res = a + b + c + d + e;
- }
-};
-
-} // namespace
-
-TEST(TupleTest, Basic) {
- std::tuple<> t0 = std::make_tuple();
- ALLOW_UNUSED_LOCAL(t0);
- std::tuple<int> t1(1);
- std::tuple<int, const char*> t2 =
- std::make_tuple(1, static_cast<const char*>("wee"));
- ALLOW_UNUSED_LOCAL(t2);
- std::tuple<int, int, int> t3(1, 2, 3);
- ALLOW_UNUSED_LOCAL(t3);
- std::tuple<int, int, int, int*> t4(1, 2, 3, &std::get<0>(t1));
- std::tuple<int, int, int, int, int*> t5(1, 2, 3, 4, &std::get<0>(t4));
- std::tuple<int, int, int, int, int, int*> t6(1, 2, 3, 4, 5, &std::get<0>(t4));
-
- EXPECT_EQ(1, std::get<0>(t1));
- DispatchToFunction(&DoAdd, t4);
- EXPECT_EQ(6, std::get<0>(t1));
-
- int res = 0;
- DispatchToFunction(&DoAdd, std::make_tuple(9, 8, 7, &res));
- EXPECT_EQ(24, res);
-
- Addy addy;
- EXPECT_EQ(1, std::get<0>(t4));
- DispatchToMethod(&addy, &Addy::DoAdd, t5);
- EXPECT_EQ(10, std::get<0>(t4));
-
- Addz addz;
- EXPECT_EQ(10, std::get<0>(t4));
- DispatchToMethod(&addz, &Addz::DoAdd, t6);
- EXPECT_EQ(15, std::get<0>(t4));
-}
-
-namespace {
-
-struct CopyLogger {
- CopyLogger() { ++TimesConstructed; }
- CopyLogger(const CopyLogger& tocopy) { ++TimesConstructed; ++TimesCopied; }
- ~CopyLogger() = default;
-
- static int TimesCopied;
- static int TimesConstructed;
-};
-
-void SomeLoggerMethRef(const CopyLogger& logy, const CopyLogger* ptr, bool* b) {
- *b = &logy == ptr;
-}
-
-void SomeLoggerMethCopy(CopyLogger logy, const CopyLogger* ptr, bool* b) {
- *b = &logy == ptr;
-}
-
-int CopyLogger::TimesCopied = 0;
-int CopyLogger::TimesConstructed = 0;
-
-} // namespace
-
-TEST(TupleTest, Copying) {
- CopyLogger logger;
- EXPECT_EQ(0, CopyLogger::TimesCopied);
- EXPECT_EQ(1, CopyLogger::TimesConstructed);
-
- bool res = false;
-
- // Creating the tuple should copy the class to store internally in the tuple.
- std::tuple<CopyLogger, CopyLogger*, bool*> tuple(logger, &logger, &res);
- std::get<CopyLogger*>(tuple) = &std::get<CopyLogger>(tuple);
- EXPECT_EQ(2, CopyLogger::TimesConstructed);
- EXPECT_EQ(1, CopyLogger::TimesCopied);
-
- // Our internal Logger and the one passed to the function should be the same.
- res = false;
- DispatchToFunction(&SomeLoggerMethRef, tuple);
- EXPECT_TRUE(res);
- EXPECT_EQ(2, CopyLogger::TimesConstructed);
- EXPECT_EQ(1, CopyLogger::TimesCopied);
-
- // Now they should be different, since the function call will make a copy.
- res = false;
- DispatchToFunction(&SomeLoggerMethCopy, tuple);
- EXPECT_FALSE(res);
- EXPECT_EQ(3, CopyLogger::TimesConstructed);
- EXPECT_EQ(2, CopyLogger::TimesCopied);
-}
-
-} // namespace base
diff --git a/base/unguessable_token_unittest.cc b/base/unguessable_token_unittest.cc
deleted file mode 100644
index b70cc72..0000000
--- a/base/unguessable_token_unittest.cc
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright (c) 2016 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 "base/unguessable_token.h"
-
-#include <memory>
-#include <sstream>
-#include <type_traits>
-
-#include "base/value_conversions.h"
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-void TestSmallerThanOperator(const UnguessableToken& a,
- const UnguessableToken& b) {
- EXPECT_TRUE(a < b);
- EXPECT_FALSE(b < a);
-}
-
-TEST(UnguessableTokenTest, VerifyEqualityOperators) {
- // Deserialize is used for testing purposes.
- // Use UnguessableToken::Create() in production code instead.
- UnguessableToken token = UnguessableToken::Deserialize(1, 2);
- UnguessableToken same_token = UnguessableToken::Deserialize(1, 2);
- UnguessableToken diff_token = UnguessableToken::Deserialize(1, 3);
-
- EXPECT_TRUE(token == token);
- EXPECT_FALSE(token != token);
-
- EXPECT_TRUE(token == same_token);
- EXPECT_FALSE(token != same_token);
-
- EXPECT_FALSE(token == diff_token);
- EXPECT_FALSE(diff_token == token);
- EXPECT_TRUE(token != diff_token);
- EXPECT_TRUE(diff_token != token);
-}
-
-TEST(UnguessableTokenTest, VerifyConstructors) {
- UnguessableToken token = UnguessableToken::Create();
- EXPECT_FALSE(token.is_empty());
- EXPECT_TRUE(token);
-
- UnguessableToken copied_token(token);
- EXPECT_TRUE(copied_token);
- EXPECT_EQ(token, copied_token);
-
- UnguessableToken uninitialized;
- EXPECT_TRUE(uninitialized.is_empty());
- EXPECT_FALSE(uninitialized);
-
- EXPECT_TRUE(UnguessableToken().is_empty());
- EXPECT_FALSE(UnguessableToken());
-}
-
-TEST(UnguessableTokenTest, VerifySerialization) {
- UnguessableToken token = UnguessableToken::Create();
-
- uint64_t high = token.GetHighForSerialization();
- uint64_t low = token.GetLowForSerialization();
-
- EXPECT_TRUE(high);
- EXPECT_TRUE(low);
-
- UnguessableToken Deserialized = UnguessableToken::Deserialize(high, low);
- EXPECT_EQ(token, Deserialized);
-}
-
-TEST(UnguessableTokenTest, VerifyValueSerialization) {
- UnguessableToken token = UnguessableToken::Create();
- std::unique_ptr<Value> value = CreateUnguessableTokenValue(token);
-
- UnguessableToken deserialized;
- EXPECT_TRUE(GetValueAsUnguessableToken(*value, &deserialized));
- EXPECT_EQ(token, deserialized);
-}
-
-// Common case (~88% of the time) - no leading zeroes in high_ nor low_.
-TEST(UnguessableTokenTest, VerifyToString1) {
- UnguessableToken token =
- UnguessableToken::Deserialize(0x1234567890ABCDEF, 0xFEDCBA0987654321);
- std::string expected = "1234567890ABCDEFFEDCBA0987654321";
-
- EXPECT_EQ(expected, token.ToString());
-
- std::string expected_stream = "(1234567890ABCDEFFEDCBA0987654321)";
- std::stringstream stream;
- stream << token;
- EXPECT_EQ(expected_stream, stream.str());
-}
-
-// Less common case - leading zeroes in high_ or low_ (testing with both).
-TEST(UnguessableTokenTest, VerifyToString2) {
- UnguessableToken token = UnguessableToken::Deserialize(0x123, 0xABC);
- std::string expected = "00000000000001230000000000000ABC";
-
- EXPECT_EQ(expected, token.ToString());
-
- std::string expected_stream = "(00000000000001230000000000000ABC)";
- std::stringstream stream;
- stream << token;
- EXPECT_EQ(expected_stream, stream.str());
-}
-
-TEST(UnguessableTokenTest, VerifyToStringUniqueness) {
- const UnguessableToken token1 =
- UnguessableToken::Deserialize(0x0000000012345678, 0x0000000123456789);
- const UnguessableToken token2 =
- UnguessableToken::Deserialize(0x0000000123456781, 0x0000000023456789);
- EXPECT_NE(token1.ToString(), token2.ToString());
-}
-
-TEST(UnguessableTokenTest, VerifySmallerThanOperator) {
- // Deserialize is used for testing purposes.
- // Use UnguessableToken::Create() in production code instead.
- {
- SCOPED_TRACE("a.low < b.low and a.high == b.high.");
- TestSmallerThanOperator(UnguessableToken::Deserialize(0, 1),
- UnguessableToken::Deserialize(0, 5));
- }
- {
- SCOPED_TRACE("a.low == b.low and a.high < b.high.");
- TestSmallerThanOperator(UnguessableToken::Deserialize(1, 0),
- UnguessableToken::Deserialize(5, 0));
- }
- {
- SCOPED_TRACE("a.low < b.low and a.high < b.high.");
- TestSmallerThanOperator(UnguessableToken::Deserialize(1, 1),
- UnguessableToken::Deserialize(5, 5));
- }
- {
- SCOPED_TRACE("a.low > b.low and a.high < b.high.");
- TestSmallerThanOperator(UnguessableToken::Deserialize(1, 10),
- UnguessableToken::Deserialize(10, 1));
- }
-}
-
-TEST(UnguessableTokenTest, VerifyHash) {
- UnguessableToken token = UnguessableToken::Create();
-
- EXPECT_EQ(base::HashInts64(token.GetHighForSerialization(),
- token.GetLowForSerialization()),
- UnguessableTokenHash()(token));
-}
-
-TEST(UnguessableTokenTest, VerifyBasicUniqueness) {
- EXPECT_NE(UnguessableToken::Create(), UnguessableToken::Create());
-
- UnguessableToken token = UnguessableToken::Create();
- EXPECT_NE(token.GetHighForSerialization(), token.GetLowForSerialization());
-}
-}
diff --git a/base/value_iterators_unittest.cc b/base/value_iterators_unittest.cc
deleted file mode 100644
index ed86182..0000000
--- a/base/value_iterators_unittest.cc
+++ /dev/null
@@ -1,335 +0,0 @@
-// Copyright 2017 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 "base/value_iterators.h"
-
-#include <type_traits>
-
-#include "base/memory/ptr_util.h"
-#include "base/values.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace detail {
-
-namespace {
-
-// Implementation of std::equal variant that is missing in C++11.
-template <class BinaryPredicate, class InputIterator1, class InputIterator2>
-bool are_equal(InputIterator1 first1,
- InputIterator1 last1,
- InputIterator2 first2,
- InputIterator2 last2,
- BinaryPredicate pred) {
- for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
- if (!pred(*first1, *first2))
- return false;
- }
- return first1 == last1 && first2 == last2;
-}
-
-} // namespace
-
-TEST(ValueIteratorsTest, SameDictStorage) {
- static_assert(std::is_same<Value::DictStorage, DictStorage>::value,
- "DictStorage differs between Value and Value Iterators.");
-}
-
-TEST(ValueIteratorsTest, IsAssignable) {
- static_assert(
- !std::is_assignable<dict_iterator::reference::first_type, std::string>(),
- "Can assign strings to dict_iterator");
-
- static_assert(
- std::is_assignable<dict_iterator::reference::second_type, Value>(),
- "Can't assign Values to dict_iterator");
-
- static_assert(!std::is_assignable<const_dict_iterator::reference::first_type,
- std::string>(),
- "Can assign strings to const_dict_iterator");
-
- static_assert(
- !std::is_assignable<const_dict_iterator::reference::second_type, Value>(),
- "Can assign Values to const_dict_iterator");
-}
-
-TEST(ValueIteratorsTest, DictIteratorOperatorStar) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
-
- using iterator = dict_iterator;
- iterator iter(storage.begin());
- EXPECT_EQ("0", (*iter).first);
- EXPECT_EQ(Value(0), (*iter).second);
-
- (*iter).second = Value(1);
- EXPECT_EQ(Value(1), *storage["0"]);
-}
-
-TEST(ValueIteratorsTest, DictIteratorOperatorArrow) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
-
- using iterator = dict_iterator;
- iterator iter(storage.begin());
- EXPECT_EQ("0", iter->first);
- EXPECT_EQ(Value(0), iter->second);
-
- iter->second = Value(1);
- EXPECT_EQ(Value(1), *storage["0"]);
-}
-
-TEST(ValueIteratorsTest, DictIteratorPreIncrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = dict_iterator;
- iterator iter(storage.begin());
- EXPECT_EQ("0", iter->first);
- EXPECT_EQ(Value(0), iter->second);
-
- iterator& iter_ref = ++iter;
- EXPECT_EQ(&iter, &iter_ref);
-
- EXPECT_EQ("1", iter_ref->first);
- EXPECT_EQ(Value(1), iter_ref->second);
-}
-
-TEST(ValueIteratorsTest, DictIteratorPostIncrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = dict_iterator;
- iterator iter(storage.begin());
- iterator iter_old = iter++;
-
- EXPECT_EQ("0", iter_old->first);
- EXPECT_EQ(Value(0), iter_old->second);
-
- EXPECT_EQ("1", iter->first);
- EXPECT_EQ(Value(1), iter->second);
-}
-
-TEST(ValueIteratorsTest, DictIteratorPreDecrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = dict_iterator;
- iterator iter(++storage.begin());
- EXPECT_EQ("1", iter->first);
- EXPECT_EQ(Value(1), iter->second);
-
- iterator& iter_ref = --iter;
- EXPECT_EQ(&iter, &iter_ref);
-
- EXPECT_EQ("0", iter_ref->first);
- EXPECT_EQ(Value(0), iter_ref->second);
-}
-
-TEST(ValueIteratorsTest, DictIteratorPostDecrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = dict_iterator;
- iterator iter(++storage.begin());
- iterator iter_old = iter--;
-
- EXPECT_EQ("1", iter_old->first);
- EXPECT_EQ(Value(1), iter_old->second);
-
- EXPECT_EQ("0", iter->first);
- EXPECT_EQ(Value(0), iter->second);
-}
-
-TEST(ValueIteratorsTest, DictIteratorOperatorEQ) {
- DictStorage storage;
- using iterator = dict_iterator;
- EXPECT_EQ(iterator(storage.begin()), iterator(storage.begin()));
- EXPECT_EQ(iterator(storage.end()), iterator(storage.end()));
-}
-
-TEST(ValueIteratorsTest, DictIteratorOperatorNE) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
-
- using iterator = dict_iterator;
- EXPECT_NE(iterator(storage.begin()), iterator(storage.end()));
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorOperatorStar) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
-
- using iterator = const_dict_iterator;
- iterator iter(storage.begin());
- EXPECT_EQ("0", (*iter).first);
- EXPECT_EQ(Value(0), (*iter).second);
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorOperatorArrow) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
-
- using iterator = const_dict_iterator;
- iterator iter(storage.begin());
- EXPECT_EQ("0", iter->first);
- EXPECT_EQ(Value(0), iter->second);
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorPreIncrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = const_dict_iterator;
- iterator iter(storage.begin());
- EXPECT_EQ("0", iter->first);
- EXPECT_EQ(Value(0), iter->second);
-
- iterator& iter_ref = ++iter;
- EXPECT_EQ(&iter, &iter_ref);
-
- EXPECT_EQ("1", iter_ref->first);
- EXPECT_EQ(Value(1), iter_ref->second);
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorPostIncrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = const_dict_iterator;
- iterator iter(storage.begin());
- iterator iter_old = iter++;
-
- EXPECT_EQ("0", iter_old->first);
- EXPECT_EQ(Value(0), iter_old->second);
-
- EXPECT_EQ("1", iter->first);
- EXPECT_EQ(Value(1), iter->second);
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorPreDecrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = const_dict_iterator;
- iterator iter(++storage.begin());
- EXPECT_EQ("1", iter->first);
- EXPECT_EQ(Value(1), iter->second);
-
- iterator& iter_ref = --iter;
- EXPECT_EQ(&iter, &iter_ref);
-
- EXPECT_EQ("0", iter_ref->first);
- EXPECT_EQ(Value(0), iter_ref->second);
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorPostDecrement) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
- storage.emplace("1", std::make_unique<Value>(1));
-
- using iterator = const_dict_iterator;
- iterator iter(++storage.begin());
- iterator iter_old = iter--;
-
- EXPECT_EQ("1", iter_old->first);
- EXPECT_EQ(Value(1), iter_old->second);
-
- EXPECT_EQ("0", iter->first);
- EXPECT_EQ(Value(0), iter->second);
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorOperatorEQ) {
- DictStorage storage;
- using iterator = const_dict_iterator;
- EXPECT_EQ(iterator(storage.begin()), iterator(storage.begin()));
- EXPECT_EQ(iterator(storage.end()), iterator(storage.end()));
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorOperatorNE) {
- DictStorage storage;
- storage.emplace("0", std::make_unique<Value>(0));
-
- using iterator = const_dict_iterator;
- EXPECT_NE(iterator(storage.begin()), iterator(storage.end()));
-}
-
-TEST(ValueIteratorsTest, DictIteratorProxy) {
- DictStorage storage;
- storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
- storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
- storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
- storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
- storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
- storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
- storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
- storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
-
- using iterator = const_dict_iterator;
- using iterator_proxy = dict_iterator_proxy;
- iterator_proxy proxy(&storage);
-
- auto equal_to = [](const DictStorage::value_type& lhs,
- const iterator::reference& rhs) {
- return std::tie(lhs.first, *lhs.second) == std::tie(rhs.first, rhs.second);
- };
-
- EXPECT_TRUE(are_equal(storage.begin(), storage.end(), proxy.begin(),
- proxy.end(), equal_to));
-
- EXPECT_TRUE(are_equal(storage.rbegin(), storage.rend(), proxy.rbegin(),
- proxy.rend(), equal_to));
-
- EXPECT_TRUE(are_equal(storage.cbegin(), storage.cend(), proxy.cbegin(),
- proxy.cend(), equal_to));
-
- EXPECT_TRUE(are_equal(storage.crbegin(), storage.crend(), proxy.crbegin(),
- proxy.crend(), equal_to));
-}
-
-TEST(ValueIteratorsTest, ConstDictIteratorProxy) {
- DictStorage storage;
- storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
- storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
- storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
- storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
- storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
- storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
- storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
- storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
-
- using iterator = const_dict_iterator;
- using iterator_proxy = const_dict_iterator_proxy;
- iterator_proxy proxy(&storage);
-
- auto equal_to = [](const DictStorage::value_type& lhs,
- const iterator::reference& rhs) {
- return std::tie(lhs.first, *lhs.second) == std::tie(rhs.first, rhs.second);
- };
-
- EXPECT_TRUE(are_equal(storage.begin(), storage.end(), proxy.begin(),
- proxy.end(), equal_to));
-
- EXPECT_TRUE(are_equal(storage.rbegin(), storage.rend(), proxy.rbegin(),
- proxy.rend(), equal_to));
-
- EXPECT_TRUE(are_equal(storage.cbegin(), storage.cend(), proxy.cbegin(),
- proxy.cend(), equal_to));
-
- EXPECT_TRUE(are_equal(storage.crbegin(), storage.crend(), proxy.crbegin(),
- proxy.crend(), equal_to));
-}
-
-} // namespace detail
-
-} // namespace base
diff --git a/base/values_unittest.cc b/base/values_unittest.cc
deleted file mode 100644
index b8efac7..0000000
--- a/base/values_unittest.cc
+++ /dev/null
@@ -1,1922 +0,0 @@
-// 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.
-
-#include "base/values.h"
-
-#include <stddef.h>
-
-#include <functional>
-#include <limits>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "base/containers/adapters.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(ValuesTest, TestNothrow) {
- static_assert(std::is_nothrow_move_constructible<Value>::value,
- "IsNothrowMoveConstructible");
- static_assert(std::is_nothrow_default_constructible<Value>::value,
- "IsNothrowDefaultConstructible");
- static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
- "IsNothrowMoveConstructibleFromString");
- static_assert(
- std::is_nothrow_constructible<Value, Value::BlobStorage&&>::value,
- "IsNothrowMoveConstructibleFromBlob");
- static_assert(
- std::is_nothrow_constructible<Value, Value::ListStorage&&>::value,
- "IsNothrowMoveConstructibleFromList");
- static_assert(std::is_nothrow_move_assignable<Value>::value,
- "IsNothrowMoveAssignable");
- static_assert(
- std::is_nothrow_constructible<ListValue, Value::ListStorage&&>::value,
- "ListIsNothrowMoveConstructibleFromList");
-}
-
-// Group of tests for the value constructors.
-TEST(ValuesTest, ConstructBool) {
- Value true_value(true);
- EXPECT_EQ(Value::Type::BOOLEAN, true_value.type());
- EXPECT_TRUE(true_value.GetBool());
-
- Value false_value(false);
- EXPECT_EQ(Value::Type::BOOLEAN, false_value.type());
- EXPECT_FALSE(false_value.GetBool());
-}
-
-TEST(ValuesTest, ConstructInt) {
- Value value(-37);
- EXPECT_EQ(Value::Type::INTEGER, value.type());
- EXPECT_EQ(-37, value.GetInt());
-}
-
-TEST(ValuesTest, ConstructDouble) {
- Value value(-4.655);
- EXPECT_EQ(Value::Type::DOUBLE, value.type());
- EXPECT_EQ(-4.655, value.GetDouble());
-}
-
-TEST(ValuesTest, ConstructStringFromConstCharPtr) {
- const char* str = "foobar";
- Value value(str);
- EXPECT_EQ(Value::Type::STRING, value.type());
- EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(ValuesTest, ConstructStringFromStringPiece) {
- std::string str = "foobar";
- Value value{StringPiece(str)};
- EXPECT_EQ(Value::Type::STRING, value.type());
- EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(ValuesTest, ConstructStringFromStdStringRRef) {
- std::string str = "foobar";
- Value value(std::move(str));
- EXPECT_EQ(Value::Type::STRING, value.type());
- EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(ValuesTest, ConstructStringFromConstChar16Ptr) {
- string16 str = ASCIIToUTF16("foobar");
- Value value(str.c_str());
- EXPECT_EQ(Value::Type::STRING, value.type());
- EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(ValuesTest, ConstructStringFromStringPiece16) {
- string16 str = ASCIIToUTF16("foobar");
- Value value{StringPiece16(str)};
- EXPECT_EQ(Value::Type::STRING, value.type());
- EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(ValuesTest, ConstructBinary) {
- Value value(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
- EXPECT_EQ(Value::Type::BINARY, value.type());
- EXPECT_EQ(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}),
- value.GetBlob());
-}
-
-TEST(ValuesTest, ConstructDict) {
- DictionaryValue value;
- EXPECT_EQ(Value::Type::DICTIONARY, value.type());
-}
-
-TEST(ValuesTest, ConstructDictFromStorage) {
- Value::DictStorage storage;
- storage.emplace("foo", std::make_unique<Value>("bar"));
- {
- DictionaryValue value(storage);
- EXPECT_EQ(Value::Type::DICTIONARY, value.type());
- EXPECT_EQ(Value::Type::STRING, value.FindKey("foo")->type());
- EXPECT_EQ("bar", value.FindKey("foo")->GetString());
- }
-
- *storage["foo"] = base::Value("baz");
- {
- DictionaryValue value(std::move(storage));
- EXPECT_EQ(Value::Type::DICTIONARY, value.type());
- EXPECT_EQ(Value::Type::STRING, value.FindKey("foo")->type());
- EXPECT_EQ("baz", value.FindKey("foo")->GetString());
- }
-}
-
-TEST(ValuesTest, ConstructList) {
- ListValue value;
- EXPECT_EQ(Value::Type::LIST, value.type());
-}
-
-TEST(ValuesTest, ConstructListFromStorage) {
- Value::ListStorage storage;
- storage.emplace_back("foo");
- {
- ListValue value(storage);
- EXPECT_EQ(Value::Type::LIST, value.type());
- EXPECT_EQ(1u, value.GetList().size());
- EXPECT_EQ(Value::Type::STRING, value.GetList()[0].type());
- EXPECT_EQ("foo", value.GetList()[0].GetString());
- }
-
- storage.back() = base::Value("bar");
- {
- ListValue value(std::move(storage));
- EXPECT_EQ(Value::Type::LIST, value.type());
- EXPECT_EQ(1u, value.GetList().size());
- EXPECT_EQ(Value::Type::STRING, value.GetList()[0].type());
- EXPECT_EQ("bar", value.GetList()[0].GetString());
- }
-}
-
-// Group of tests for the copy constructors and copy-assigmnent. For equality
-// checks comparisons of the interesting fields are done instead of relying on
-// Equals being correct.
-TEST(ValuesTest, CopyBool) {
- Value true_value(true);
- Value copied_true_value(true_value.Clone());
- EXPECT_EQ(true_value.type(), copied_true_value.type());
- EXPECT_EQ(true_value.GetBool(), copied_true_value.GetBool());
-
- Value false_value(false);
- Value copied_false_value(false_value.Clone());
- EXPECT_EQ(false_value.type(), copied_false_value.type());
- EXPECT_EQ(false_value.GetBool(), copied_false_value.GetBool());
-
- Value blank;
-
- blank = true_value.Clone();
- EXPECT_EQ(true_value.type(), blank.type());
- EXPECT_EQ(true_value.GetBool(), blank.GetBool());
-
- blank = false_value.Clone();
- EXPECT_EQ(false_value.type(), blank.type());
- EXPECT_EQ(false_value.GetBool(), blank.GetBool());
-}
-
-TEST(ValuesTest, CopyInt) {
- Value value(74);
- Value copied_value(value.Clone());
- EXPECT_EQ(value.type(), copied_value.type());
- EXPECT_EQ(value.GetInt(), copied_value.GetInt());
-
- Value blank;
-
- blank = value.Clone();
- EXPECT_EQ(value.type(), blank.type());
- EXPECT_EQ(value.GetInt(), blank.GetInt());
-}
-
-TEST(ValuesTest, CopyDouble) {
- Value value(74.896);
- Value copied_value(value.Clone());
- EXPECT_EQ(value.type(), copied_value.type());
- EXPECT_EQ(value.GetDouble(), copied_value.GetDouble());
-
- Value blank;
-
- blank = value.Clone();
- EXPECT_EQ(value.type(), blank.type());
- EXPECT_EQ(value.GetDouble(), blank.GetDouble());
-}
-
-TEST(ValuesTest, CopyString) {
- Value value("foobar");
- Value copied_value(value.Clone());
- EXPECT_EQ(value.type(), copied_value.type());
- EXPECT_EQ(value.GetString(), copied_value.GetString());
-
- Value blank;
-
- blank = value.Clone();
- EXPECT_EQ(value.type(), blank.type());
- EXPECT_EQ(value.GetString(), blank.GetString());
-}
-
-TEST(ValuesTest, CopyBinary) {
- Value value(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
- Value copied_value(value.Clone());
- EXPECT_EQ(value.type(), copied_value.type());
- EXPECT_EQ(value.GetBlob(), copied_value.GetBlob());
-
- Value blank;
-
- blank = value.Clone();
- EXPECT_EQ(value.type(), blank.type());
- EXPECT_EQ(value.GetBlob(), blank.GetBlob());
-}
-
-TEST(ValuesTest, CopyDictionary) {
- Value::DictStorage storage;
- storage.emplace("Int", std::make_unique<Value>(123));
- Value value(std::move(storage));
-
- Value copied_value(value.Clone());
- EXPECT_EQ(value, copied_value);
-
- Value blank;
- blank = value.Clone();
- EXPECT_EQ(value, blank);
-}
-
-TEST(ValuesTest, CopyList) {
- Value::ListStorage storage;
- storage.emplace_back(123);
- Value value(std::move(storage));
-
- Value copied_value(value.Clone());
- EXPECT_EQ(value, copied_value);
-
- Value blank;
- blank = value.Clone();
- EXPECT_EQ(value, blank);
-}
-
-// Group of tests for the move constructors and move-assigmnent.
-TEST(ValuesTest, MoveBool) {
- Value true_value(true);
- Value moved_true_value(std::move(true_value));
- EXPECT_EQ(Value::Type::BOOLEAN, moved_true_value.type());
- EXPECT_TRUE(moved_true_value.GetBool());
-
- Value false_value(false);
- Value moved_false_value(std::move(false_value));
- EXPECT_EQ(Value::Type::BOOLEAN, moved_false_value.type());
- EXPECT_FALSE(moved_false_value.GetBool());
-
- Value blank;
-
- blank = Value(true);
- EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
- EXPECT_TRUE(blank.GetBool());
-
- blank = Value(false);
- EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
- EXPECT_FALSE(blank.GetBool());
-}
-
-TEST(ValuesTest, MoveInt) {
- Value value(74);
- Value moved_value(std::move(value));
- EXPECT_EQ(Value::Type::INTEGER, moved_value.type());
- EXPECT_EQ(74, moved_value.GetInt());
-
- Value blank;
-
- blank = Value(47);
- EXPECT_EQ(Value::Type::INTEGER, blank.type());
- EXPECT_EQ(47, blank.GetInt());
-}
-
-TEST(ValuesTest, MoveDouble) {
- Value value(74.896);
- Value moved_value(std::move(value));
- EXPECT_EQ(Value::Type::DOUBLE, moved_value.type());
- EXPECT_EQ(74.896, moved_value.GetDouble());
-
- Value blank;
-
- blank = Value(654.38);
- EXPECT_EQ(Value::Type::DOUBLE, blank.type());
- EXPECT_EQ(654.38, blank.GetDouble());
-}
-
-TEST(ValuesTest, MoveString) {
- Value value("foobar");
- Value moved_value(std::move(value));
- EXPECT_EQ(Value::Type::STRING, moved_value.type());
- EXPECT_EQ("foobar", moved_value.GetString());
-
- Value blank;
-
- blank = Value("foobar");
- EXPECT_EQ(Value::Type::STRING, blank.type());
- EXPECT_EQ("foobar", blank.GetString());
-}
-
-TEST(ValuesTest, MoveBinary) {
- const Value::BlobStorage buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
- Value value(buffer);
- Value moved_value(std::move(value));
- EXPECT_EQ(Value::Type::BINARY, moved_value.type());
- EXPECT_EQ(buffer, moved_value.GetBlob());
-
- Value blank;
-
- blank = Value(buffer);
- EXPECT_EQ(Value::Type::BINARY, blank.type());
- EXPECT_EQ(buffer, blank.GetBlob());
-}
-
-TEST(ValuesTest, MoveConstructDictionary) {
- Value::DictStorage storage;
- storage.emplace("Int", std::make_unique<Value>(123));
-
- Value value(std::move(storage));
- Value moved_value(std::move(value));
- EXPECT_EQ(Value::Type::DICTIONARY, moved_value.type());
- EXPECT_EQ(123, moved_value.FindKey("Int")->GetInt());
-}
-
-TEST(ValuesTest, MoveAssignDictionary) {
- Value::DictStorage storage;
- storage.emplace("Int", std::make_unique<Value>(123));
-
- Value blank;
- blank = Value(std::move(storage));
- EXPECT_EQ(Value::Type::DICTIONARY, blank.type());
- EXPECT_EQ(123, blank.FindKey("Int")->GetInt());
-}
-
-TEST(ValuesTest, MoveList) {
- Value::ListStorage storage;
- storage.emplace_back(123);
- Value value(storage);
- Value moved_value(std::move(value));
- EXPECT_EQ(Value::Type::LIST, moved_value.type());
- EXPECT_EQ(123, moved_value.GetList().back().GetInt());
-
- Value blank;
- blank = Value(std::move(storage));
- EXPECT_EQ(Value::Type::LIST, blank.type());
- EXPECT_EQ(123, blank.GetList().back().GetInt());
-}
-
-TEST(ValuesTest, FindKey) {
- Value::DictStorage storage;
- storage.emplace("foo", std::make_unique<Value>("bar"));
- Value dict(std::move(storage));
- EXPECT_NE(nullptr, dict.FindKey("foo"));
- EXPECT_EQ(nullptr, dict.FindKey("baz"));
-
- // Single not found key.
- bool found = dict.FindKey("notfound");
- EXPECT_FALSE(found);
-}
-
-TEST(ValuesTest, FindKeyChangeValue) {
- Value::DictStorage storage;
- storage.emplace("foo", std::make_unique<Value>("bar"));
- Value dict(std::move(storage));
- Value* found = dict.FindKey("foo");
- EXPECT_NE(nullptr, found);
- EXPECT_EQ("bar", found->GetString());
-
- *found = Value(123);
- EXPECT_EQ(123, dict.FindKey("foo")->GetInt());
-}
-
-TEST(ValuesTest, FindKeyConst) {
- Value::DictStorage storage;
- storage.emplace("foo", std::make_unique<Value>("bar"));
- const Value dict(std::move(storage));
- EXPECT_NE(nullptr, dict.FindKey("foo"));
- EXPECT_EQ(nullptr, dict.FindKey("baz"));
-}
-
-TEST(ValuesTest, FindKeyOfType) {
- Value::DictStorage storage;
- storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
- storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
- storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
- storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
- storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
- storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
- storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
- storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
-
- Value dict(std::move(storage));
- EXPECT_NE(nullptr, dict.FindKeyOfType("null", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::NONE));
- EXPECT_NE(nullptr, dict.FindKeyOfType("bool", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BOOLEAN));
- EXPECT_NE(nullptr, dict.FindKeyOfType("int", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::INTEGER));
- EXPECT_NE(nullptr, dict.FindKeyOfType("double", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DOUBLE));
- EXPECT_NE(nullptr, dict.FindKeyOfType("string", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::STRING));
- EXPECT_NE(nullptr, dict.FindKeyOfType("blob", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BINARY));
- EXPECT_NE(nullptr, dict.FindKeyOfType("list", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::LIST));
- EXPECT_NE(nullptr, dict.FindKeyOfType("dict", Value::Type::DICTIONARY));
-}
-
-TEST(ValuesTest, FindKeyOfTypeConst) {
- Value::DictStorage storage;
- storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
- storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
- storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
- storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
- storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
- storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
- storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
- storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
-
- const Value dict(std::move(storage));
- EXPECT_NE(nullptr, dict.FindKeyOfType("null", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::NONE));
- EXPECT_NE(nullptr, dict.FindKeyOfType("bool", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BOOLEAN));
- EXPECT_NE(nullptr, dict.FindKeyOfType("int", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::INTEGER));
- EXPECT_NE(nullptr, dict.FindKeyOfType("double", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DOUBLE));
- EXPECT_NE(nullptr, dict.FindKeyOfType("string", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::STRING));
- EXPECT_NE(nullptr, dict.FindKeyOfType("blob", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BINARY));
- EXPECT_NE(nullptr, dict.FindKeyOfType("list", Value::Type::LIST));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DICTIONARY));
-
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::NONE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BOOLEAN));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::INTEGER));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::DOUBLE));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::STRING));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BINARY));
- EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::LIST));
- EXPECT_NE(nullptr, dict.FindKeyOfType("dict", Value::Type::DICTIONARY));
-}
-
-TEST(ValuesTest, SetKey) {
- Value::DictStorage storage;
- storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
- storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
- storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
- storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
- storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
- storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
- storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
- storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
-
- Value dict(Value::Type::DICTIONARY);
- dict.SetKey(StringPiece("null"), Value(Value::Type::NONE));
- dict.SetKey(StringPiece("bool"), Value(Value::Type::BOOLEAN));
- dict.SetKey(std::string("int"), Value(Value::Type::INTEGER));
- dict.SetKey(std::string("double"), Value(Value::Type::DOUBLE));
- dict.SetKey(std::string("string"), Value(Value::Type::STRING));
- dict.SetKey("blob", Value(Value::Type::BINARY));
- dict.SetKey("list", Value(Value::Type::LIST));
- dict.SetKey("dict", Value(Value::Type::DICTIONARY));
-
- EXPECT_EQ(Value(std::move(storage)), dict);
-}
-
-TEST(ValuesTest, FindPath) {
- // Construct a dictionary path {root}.foo.bar = 123
- Value foo(Value::Type::DICTIONARY);
- foo.SetKey("bar", Value(123));
-
- Value root(Value::Type::DICTIONARY);
- root.SetKey("foo", std::move(foo));
-
- // No key (stupid but well-defined and takes work to prevent).
- Value* found = root.FindPath(std::vector<StringPiece>{});
- EXPECT_EQ(&root, found);
-
- // Double key, second not found.
- found = root.FindPath(std::vector<StringPiece>{"foo", "notfound"});
- EXPECT_FALSE(found);
-
- // Double key, found.
- found = root.FindPath(std::vector<StringPiece>{"foo", "bar"});
- EXPECT_TRUE(found);
- EXPECT_TRUE(found->is_int());
- EXPECT_EQ(123, found->GetInt());
-}
-
-TEST(ValuesTest, SetPath) {
- Value root(Value::Type::DICTIONARY);
-
- Value* inserted = root.SetPath({"one", "two"}, Value(123));
- Value* found = root.FindPathOfType({"one", "two"}, Value::Type::INTEGER);
- ASSERT_TRUE(found);
- EXPECT_EQ(inserted, found);
- EXPECT_EQ(123, found->GetInt());
-
- inserted = root.SetPath(std::vector<StringPiece>{"foo", "bar"}, Value(123));
- found = root.FindPathOfType({"foo", "bar"}, Value::Type::INTEGER);
- ASSERT_TRUE(found);
- EXPECT_EQ(inserted, found);
- EXPECT_EQ(123, found->GetInt());
-
- // Overwrite with a different value.
- root.SetPath({"foo", "bar"}, Value("hello"));
- found = root.FindPathOfType(std::vector<StringPiece>{"foo", "bar"},
- Value::Type::STRING);
- ASSERT_TRUE(found);
- EXPECT_EQ("hello", found->GetString());
-
- // Can't change existing non-dictionary keys to dictionaries.
- found =
- root.SetPath(std::vector<StringPiece>{"foo", "bar", "baz"}, Value(123));
- EXPECT_FALSE(found);
-}
-
-TEST(ValuesTest, RemoveKey) {
- Value root(Value::Type::DICTIONARY);
- root.SetKey("one", Value(123));
-
- // Removal of missing key should fail.
- EXPECT_FALSE(root.RemoveKey("two"));
-
- // Removal of existing key should succeed.
- EXPECT_TRUE(root.RemoveKey("one"));
-
- // Second removal of previously existing key should fail.
- EXPECT_FALSE(root.RemoveKey("one"));
-}
-
-TEST(ValuesTest, RemovePath) {
- Value root(Value::Type::DICTIONARY);
- root.SetPath({"one", "two", "three"}, Value(123));
-
- // Removal of missing key should fail.
- EXPECT_FALSE(root.RemovePath({"one", "two", "four"}));
-
- // Removal of existing key should succeed.
- EXPECT_TRUE(root.RemovePath({"one", "two", "three"}));
-
- // Second removal of previously existing key should fail.
- EXPECT_FALSE(root.RemovePath({"one", "two", "three"}));
-
- // Intermediate empty dictionaries should be cleared.
- EXPECT_FALSE(root.FindKey("one"));
-
- root.SetPath({"one", "two", "three"}, Value(123));
- root.SetPath({"one", "two", "four"}, Value(124));
-
- EXPECT_TRUE(root.RemovePath(std::vector<StringPiece>{"one", "two", "three"}));
- // Intermediate non-empty dictionaries should be kept.
- EXPECT_TRUE(root.FindKey("one"));
- EXPECT_TRUE(root.FindPath({"one", "two"}));
- EXPECT_TRUE(root.FindPath({"one", "two", "four"}));
-}
-
-TEST(ValuesTest, Basic) {
- // Test basic dictionary getting/setting
- DictionaryValue settings;
- std::string homepage = "http://google.com";
- ASSERT_FALSE(settings.GetString("global.homepage", &homepage));
- ASSERT_EQ(std::string("http://google.com"), homepage);
-
- ASSERT_FALSE(settings.Get("global", nullptr));
- settings.SetBoolean("global", true);
- ASSERT_TRUE(settings.Get("global", nullptr));
- settings.SetString("global.homepage", "http://scurvy.com");
- ASSERT_TRUE(settings.Get("global", nullptr));
- homepage = "http://google.com";
- ASSERT_TRUE(settings.GetString("global.homepage", &homepage));
- ASSERT_EQ(std::string("http://scurvy.com"), homepage);
-
- // Test storing a dictionary in a list.
- ListValue* toolbar_bookmarks;
- ASSERT_FALSE(
- settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
-
- std::unique_ptr<ListValue> new_toolbar_bookmarks(new ListValue);
- settings.Set("global.toolbar.bookmarks", std::move(new_toolbar_bookmarks));
- ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
-
- std::unique_ptr<DictionaryValue> new_bookmark(new DictionaryValue);
- new_bookmark->SetString("name", "Froogle");
- new_bookmark->SetString("url", "http://froogle.com");
- toolbar_bookmarks->Append(std::move(new_bookmark));
-
- ListValue* bookmark_list;
- ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &bookmark_list));
- DictionaryValue* bookmark;
- ASSERT_EQ(1U, bookmark_list->GetSize());
- ASSERT_TRUE(bookmark_list->GetDictionary(0, &bookmark));
- std::string bookmark_name = "Unnamed";
- ASSERT_TRUE(bookmark->GetString("name", &bookmark_name));
- ASSERT_EQ(std::string("Froogle"), bookmark_name);
- std::string bookmark_url;
- ASSERT_TRUE(bookmark->GetString("url", &bookmark_url));
- ASSERT_EQ(std::string("http://froogle.com"), bookmark_url);
-}
-
-TEST(ValuesTest, List) {
- std::unique_ptr<ListValue> mixed_list(new ListValue());
- mixed_list->Set(0, std::make_unique<Value>(true));
- mixed_list->Set(1, std::make_unique<Value>(42));
- mixed_list->Set(2, std::make_unique<Value>(88.8));
- mixed_list->Set(3, std::make_unique<Value>("foo"));
- ASSERT_EQ(4u, mixed_list->GetSize());
-
- Value* value = nullptr;
- bool bool_value = false;
- int int_value = 0;
- double double_value = 0.0;
- std::string string_value;
-
- ASSERT_FALSE(mixed_list->Get(4, &value));
-
- ASSERT_FALSE(mixed_list->GetInteger(0, &int_value));
- ASSERT_EQ(0, int_value);
- ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value));
- ASSERT_FALSE(bool_value);
- ASSERT_FALSE(mixed_list->GetString(2, &string_value));
- ASSERT_EQ("", string_value);
- ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
- ASSERT_EQ(0, int_value);
- ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value));
- ASSERT_FALSE(bool_value);
-
- ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value));
- ASSERT_TRUE(bool_value);
- ASSERT_TRUE(mixed_list->GetInteger(1, &int_value));
- ASSERT_EQ(42, int_value);
- // implicit conversion from Integer to Double should be possible.
- ASSERT_TRUE(mixed_list->GetDouble(1, &double_value));
- ASSERT_EQ(42, double_value);
- ASSERT_TRUE(mixed_list->GetDouble(2, &double_value));
- ASSERT_EQ(88.8, double_value);
- ASSERT_TRUE(mixed_list->GetString(3, &string_value));
- ASSERT_EQ("foo", string_value);
-
- // Try searching in the mixed list.
- base::Value sought_value(42);
- base::Value not_found_value(false);
-
- ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value));
- ASSERT_TRUE((*mixed_list->Find(sought_value)).GetAsInteger(&int_value));
- ASSERT_EQ(42, int_value);
- ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
-}
-
-TEST(ValuesTest, BinaryValue) {
- // Default constructor creates a BinaryValue with a buffer of size 0.
- auto binary = std::make_unique<Value>(Value::Type::BINARY);
- ASSERT_TRUE(binary.get());
- ASSERT_TRUE(binary->GetBlob().empty());
-
- // Test the common case of a non-empty buffer
- Value::BlobStorage buffer(15);
- char* original_buffer = buffer.data();
- binary.reset(new Value(std::move(buffer)));
- ASSERT_TRUE(binary.get());
- ASSERT_TRUE(binary->GetBlob().data());
- ASSERT_EQ(original_buffer, binary->GetBlob().data());
- ASSERT_EQ(15U, binary->GetBlob().size());
-
- char stack_buffer[42];
- memset(stack_buffer, '!', 42);
- binary = Value::CreateWithCopiedBuffer(stack_buffer, 42);
- ASSERT_TRUE(binary.get());
- ASSERT_TRUE(binary->GetBlob().data());
- ASSERT_NE(stack_buffer, binary->GetBlob().data());
- ASSERT_EQ(42U, binary->GetBlob().size());
- ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBlob().data(),
- binary->GetBlob().size()));
-}
-
-TEST(ValuesTest, StringValue) {
- // Test overloaded StringValue constructor.
- std::unique_ptr<Value> narrow_value(new Value("narrow"));
- ASSERT_TRUE(narrow_value.get());
- ASSERT_TRUE(narrow_value->is_string());
- std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16")));
- ASSERT_TRUE(utf16_value.get());
- ASSERT_TRUE(utf16_value->is_string());
-
- // Test overloaded GetAsString.
- std::string narrow = "http://google.com";
- string16 utf16 = ASCIIToUTF16("http://google.com");
- const Value* string_value = nullptr;
- ASSERT_TRUE(narrow_value->GetAsString(&narrow));
- ASSERT_TRUE(narrow_value->GetAsString(&utf16));
- ASSERT_TRUE(narrow_value->GetAsString(&string_value));
- ASSERT_EQ(std::string("narrow"), narrow);
- ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
- ASSERT_EQ(string_value->GetString(), narrow);
-
- ASSERT_TRUE(utf16_value->GetAsString(&narrow));
- ASSERT_TRUE(utf16_value->GetAsString(&utf16));
- ASSERT_TRUE(utf16_value->GetAsString(&string_value));
- ASSERT_EQ(std::string("utf16"), narrow);
- ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
- ASSERT_EQ(string_value->GetString(), narrow);
-
- // Don't choke on NULL values.
- ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(nullptr)));
- ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(nullptr)));
- ASSERT_TRUE(narrow_value->GetAsString(static_cast<const Value**>(nullptr)));
-}
-
-TEST(ValuesTest, ListDeletion) {
- ListValue list;
- list.Append(std::make_unique<Value>());
- EXPECT_FALSE(list.empty());
- list.Clear();
- EXPECT_TRUE(list.empty());
-}
-
-TEST(ValuesTest, ListRemoval) {
- std::unique_ptr<Value> removed_item;
-
- {
- ListValue list;
- list.Append(std::make_unique<Value>());
- EXPECT_EQ(1U, list.GetSize());
- EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(),
- &removed_item));
- EXPECT_FALSE(list.Remove(1, &removed_item));
- EXPECT_TRUE(list.Remove(0, &removed_item));
- ASSERT_TRUE(removed_item);
- EXPECT_EQ(0U, list.GetSize());
- }
- removed_item.reset();
-
- {
- ListValue list;
- list.Append(std::make_unique<Value>());
- EXPECT_TRUE(list.Remove(0, nullptr));
- EXPECT_EQ(0U, list.GetSize());
- }
-
- {
- ListValue list;
- auto value = std::make_unique<Value>();
- Value original_value = value->Clone();
- list.Append(std::move(value));
- size_t index = 0;
- list.Remove(original_value, &index);
- EXPECT_EQ(0U, index);
- EXPECT_EQ(0U, list.GetSize());
- }
-}
-
-TEST(ValuesTest, DictionaryDeletion) {
- std::string key = "test";
- DictionaryValue dict;
- dict.Set(key, std::make_unique<Value>());
- EXPECT_FALSE(dict.empty());
- EXPECT_FALSE(dict.DictEmpty());
- EXPECT_EQ(1U, dict.DictSize());
- dict.Clear();
- EXPECT_TRUE(dict.empty());
- EXPECT_TRUE(dict.DictEmpty());
- EXPECT_EQ(0U, dict.DictSize());
-}
-
-TEST(ValuesTest, DictionarySetReturnsPointer) {
- {
- DictionaryValue dict;
- Value* blank_ptr = dict.Set("foo.bar", std::make_unique<base::Value>());
- EXPECT_EQ(Value::Type::NONE, blank_ptr->type());
- }
-
- {
- DictionaryValue dict;
- Value* blank_ptr = dict.SetWithoutPathExpansion(
- "foo.bar", std::make_unique<base::Value>());
- EXPECT_EQ(Value::Type::NONE, blank_ptr->type());
- }
-
- {
- DictionaryValue dict;
- Value* int_ptr = dict.SetInteger("foo.bar", 42);
- EXPECT_EQ(Value::Type::INTEGER, int_ptr->type());
- EXPECT_EQ(42, int_ptr->GetInt());
- }
-
- {
- DictionaryValue dict;
- Value* double_ptr = dict.SetDouble("foo.bar", 3.142);
- EXPECT_EQ(Value::Type::DOUBLE, double_ptr->type());
- EXPECT_EQ(3.142, double_ptr->GetDouble());
- }
-
- {
- DictionaryValue dict;
- Value* string_ptr = dict.SetString("foo.bar", "foo");
- EXPECT_EQ(Value::Type::STRING, string_ptr->type());
- EXPECT_EQ("foo", string_ptr->GetString());
- }
-
- {
- DictionaryValue dict;
- Value* string16_ptr = dict.SetString("foo.bar", ASCIIToUTF16("baz"));
- EXPECT_EQ(Value::Type::STRING, string16_ptr->type());
- EXPECT_EQ("baz", string16_ptr->GetString());
- }
-
- {
- DictionaryValue dict;
- DictionaryValue* dict_ptr = dict.SetDictionary(
- "foo.bar", std::make_unique<base::DictionaryValue>());
- EXPECT_EQ(Value::Type::DICTIONARY, dict_ptr->type());
- }
-
- {
- DictionaryValue dict;
- ListValue* list_ptr =
- dict.SetList("foo.bar", std::make_unique<base::ListValue>());
- EXPECT_EQ(Value::Type::LIST, list_ptr->type());
- }
-}
-
-TEST(ValuesTest, DictionaryRemoval) {
- std::string key = "test";
- std::unique_ptr<Value> removed_item;
-
- {
- DictionaryValue dict;
- EXPECT_EQ(0U, dict.DictSize());
- EXPECT_TRUE(dict.DictEmpty());
- dict.Set(key, std::make_unique<Value>());
- EXPECT_TRUE(dict.HasKey(key));
- EXPECT_FALSE(dict.Remove("absent key", &removed_item));
- EXPECT_EQ(1U, dict.DictSize());
- EXPECT_FALSE(dict.DictEmpty());
-
- EXPECT_TRUE(dict.Remove(key, &removed_item));
- EXPECT_FALSE(dict.HasKey(key));
- ASSERT_TRUE(removed_item);
- EXPECT_EQ(0U, dict.DictSize());
- EXPECT_TRUE(dict.DictEmpty());
- }
-
- {
- DictionaryValue dict;
- dict.Set(key, std::make_unique<Value>());
- EXPECT_TRUE(dict.HasKey(key));
- EXPECT_TRUE(dict.Remove(key, nullptr));
- EXPECT_FALSE(dict.HasKey(key));
- }
-}
-
-TEST(ValuesTest, DictionaryWithoutPathExpansion) {
- DictionaryValue dict;
- dict.Set("this.is.expanded", std::make_unique<Value>());
- dict.SetWithoutPathExpansion("this.isnt.expanded", std::make_unique<Value>());
-
- EXPECT_FALSE(dict.HasKey("this.is.expanded"));
- EXPECT_TRUE(dict.HasKey("this"));
- Value* value1;
- EXPECT_TRUE(dict.Get("this", &value1));
- DictionaryValue* value2;
- ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
- EXPECT_EQ(value1, value2);
- EXPECT_EQ(1U, value2->size());
-
- EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
- Value* value3;
- EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
- Value* value4;
- ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
- EXPECT_EQ(Value::Type::NONE, value4->type());
-}
-
-// Tests the deprecated version of SetWithoutPathExpansion.
-// TODO(estade): remove.
-TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) {
- DictionaryValue dict;
- dict.Set("this.is.expanded", std::make_unique<Value>());
- dict.SetWithoutPathExpansion("this.isnt.expanded", std::make_unique<Value>());
-
- EXPECT_FALSE(dict.HasKey("this.is.expanded"));
- EXPECT_TRUE(dict.HasKey("this"));
- Value* value1;
- EXPECT_TRUE(dict.Get("this", &value1));
- DictionaryValue* value2;
- ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
- EXPECT_EQ(value1, value2);
- EXPECT_EQ(1U, value2->size());
-
- EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
- Value* value3;
- EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
- Value* value4;
- ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
- EXPECT_EQ(Value::Type::NONE, value4->type());
-}
-
-TEST(ValuesTest, DictionaryRemovePath) {
- DictionaryValue dict;
- dict.SetInteger("a.long.way.down", 1);
- dict.SetBoolean("a.long.key.path", true);
-
- std::unique_ptr<Value> removed_item;
- EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item));
- ASSERT_TRUE(removed_item);
- EXPECT_TRUE(removed_item->is_int());
- EXPECT_FALSE(dict.HasKey("a.long.way.down"));
- EXPECT_FALSE(dict.HasKey("a.long.way"));
- EXPECT_TRUE(dict.Get("a.long.key.path", nullptr));
-
- removed_item.reset();
- EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item));
- EXPECT_FALSE(removed_item);
- EXPECT_TRUE(dict.Get("a.long.key.path", nullptr));
-
- removed_item.reset();
- EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item));
- ASSERT_TRUE(removed_item);
- EXPECT_TRUE(removed_item->is_bool());
- EXPECT_TRUE(dict.empty());
-}
-
-TEST(ValuesTest, DeepCopy) {
- DictionaryValue original_dict;
- Value* null_weak = original_dict.Set("null", std::make_unique<Value>());
- Value* bool_weak = original_dict.Set("bool", std::make_unique<Value>(true));
- Value* int_weak = original_dict.Set("int", std::make_unique<Value>(42));
- Value* double_weak =
- original_dict.Set("double", std::make_unique<Value>(3.14));
- Value* string_weak =
- original_dict.Set("string", std::make_unique<Value>("hello"));
- Value* string16_weak = original_dict.Set(
- "string16", std::make_unique<Value>(ASCIIToUTF16("hello16")));
-
- Value* binary_weak = original_dict.Set(
- "binary", std::make_unique<Value>(Value::BlobStorage(42, '!')));
-
- Value::ListStorage storage;
- storage.emplace_back(0);
- storage.emplace_back(1);
- Value* list_weak =
- original_dict.Set("list", std::make_unique<Value>(std::move(storage)));
- Value* list_element_0_weak = &list_weak->GetList()[0];
- Value* list_element_1_weak = &list_weak->GetList()[1];
-
- DictionaryValue* dict_weak = original_dict.SetDictionary(
- "dictionary", std::make_unique<DictionaryValue>());
- dict_weak->SetString("key", "value");
-
- auto copy_dict = original_dict.CreateDeepCopy();
- ASSERT_TRUE(copy_dict.get());
- ASSERT_NE(copy_dict.get(), &original_dict);
-
- Value* copy_null = nullptr;
- ASSERT_TRUE(copy_dict->Get("null", ©_null));
- ASSERT_TRUE(copy_null);
- ASSERT_NE(copy_null, null_weak);
- ASSERT_TRUE(copy_null->is_none());
-
- Value* copy_bool = nullptr;
- ASSERT_TRUE(copy_dict->Get("bool", ©_bool));
- ASSERT_TRUE(copy_bool);
- ASSERT_NE(copy_bool, bool_weak);
- ASSERT_TRUE(copy_bool->is_bool());
- bool copy_bool_value = false;
- ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value));
- ASSERT_TRUE(copy_bool_value);
-
- Value* copy_int = nullptr;
- ASSERT_TRUE(copy_dict->Get("int", ©_int));
- ASSERT_TRUE(copy_int);
- ASSERT_NE(copy_int, int_weak);
- ASSERT_TRUE(copy_int->is_int());
- int copy_int_value = 0;
- ASSERT_TRUE(copy_int->GetAsInteger(©_int_value));
- ASSERT_EQ(42, copy_int_value);
-
- Value* copy_double = nullptr;
- ASSERT_TRUE(copy_dict->Get("double", ©_double));
- ASSERT_TRUE(copy_double);
- ASSERT_NE(copy_double, double_weak);
- ASSERT_TRUE(copy_double->is_double());
- double copy_double_value = 0;
- ASSERT_TRUE(copy_double->GetAsDouble(©_double_value));
- ASSERT_EQ(3.14, copy_double_value);
-
- Value* copy_string = nullptr;
- ASSERT_TRUE(copy_dict->Get("string", ©_string));
- ASSERT_TRUE(copy_string);
- ASSERT_NE(copy_string, string_weak);
- ASSERT_TRUE(copy_string->is_string());
- std::string copy_string_value;
- string16 copy_string16_value;
- ASSERT_TRUE(copy_string->GetAsString(©_string_value));
- ASSERT_TRUE(copy_string->GetAsString(©_string16_value));
- ASSERT_EQ(std::string("hello"), copy_string_value);
- ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
-
- Value* copy_string16 = nullptr;
- ASSERT_TRUE(copy_dict->Get("string16", ©_string16));
- ASSERT_TRUE(copy_string16);
- ASSERT_NE(copy_string16, string16_weak);
- ASSERT_TRUE(copy_string16->is_string());
- ASSERT_TRUE(copy_string16->GetAsString(©_string_value));
- ASSERT_TRUE(copy_string16->GetAsString(©_string16_value));
- ASSERT_EQ(std::string("hello16"), copy_string_value);
- ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
-
- Value* copy_binary = nullptr;
- ASSERT_TRUE(copy_dict->Get("binary", ©_binary));
- ASSERT_TRUE(copy_binary);
- ASSERT_NE(copy_binary, binary_weak);
- ASSERT_TRUE(copy_binary->is_blob());
- ASSERT_NE(binary_weak->GetBlob().data(), copy_binary->GetBlob().data());
- ASSERT_EQ(binary_weak->GetBlob(), copy_binary->GetBlob());
-
- Value* copy_value = nullptr;
- ASSERT_TRUE(copy_dict->Get("list", ©_value));
- ASSERT_TRUE(copy_value);
- ASSERT_NE(copy_value, list_weak);
- ASSERT_TRUE(copy_value->is_list());
- ListValue* copy_list = nullptr;
- ASSERT_TRUE(copy_value->GetAsList(©_list));
- ASSERT_TRUE(copy_list);
- ASSERT_EQ(2U, copy_list->GetSize());
-
- Value* copy_list_element_0;
- ASSERT_TRUE(copy_list->Get(0, ©_list_element_0));
- ASSERT_TRUE(copy_list_element_0);
- ASSERT_NE(copy_list_element_0, list_element_0_weak);
- int copy_list_element_0_value;
- ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value));
- ASSERT_EQ(0, copy_list_element_0_value);
-
- Value* copy_list_element_1;
- ASSERT_TRUE(copy_list->Get(1, ©_list_element_1));
- ASSERT_TRUE(copy_list_element_1);
- ASSERT_NE(copy_list_element_1, list_element_1_weak);
- int copy_list_element_1_value;
- ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value));
- ASSERT_EQ(1, copy_list_element_1_value);
-
- copy_value = nullptr;
- ASSERT_TRUE(copy_dict->Get("dictionary", ©_value));
- ASSERT_TRUE(copy_value);
- ASSERT_NE(copy_value, dict_weak);
- ASSERT_TRUE(copy_value->is_dict());
- DictionaryValue* copy_nested_dictionary = nullptr;
- ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary));
- ASSERT_TRUE(copy_nested_dictionary);
- EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
-}
-
-TEST(ValuesTest, Equals) {
- auto null1 = std::make_unique<Value>();
- auto null2 = std::make_unique<Value>();
- EXPECT_NE(null1.get(), null2.get());
- EXPECT_EQ(*null1, *null2);
-
- Value boolean(false);
- EXPECT_NE(*null1, boolean);
-
- DictionaryValue dv;
- dv.SetBoolean("a", false);
- dv.SetInteger("b", 2);
- dv.SetDouble("c", 2.5);
- dv.SetString("d1", "string");
- dv.SetString("d2", ASCIIToUTF16("http://google.com"));
- dv.Set("e", std::make_unique<Value>());
-
- auto copy = dv.CreateDeepCopy();
- EXPECT_EQ(dv, *copy);
-
- std::unique_ptr<ListValue> list(new ListValue);
- list->Append(std::make_unique<Value>());
- list->Append(WrapUnique(new DictionaryValue));
- auto list_copy = std::make_unique<Value>(list->Clone());
-
- ListValue* list_weak = dv.SetList("f", std::move(list));
- EXPECT_NE(dv, *copy);
- copy->Set("f", std::move(list_copy));
- EXPECT_EQ(dv, *copy);
-
- list_weak->Append(std::make_unique<Value>(true));
- EXPECT_NE(dv, *copy);
-
- // Check if Equals detects differences in only the keys.
- copy = dv.CreateDeepCopy();
- EXPECT_EQ(dv, *copy);
- copy->Remove("a", nullptr);
- copy->SetBoolean("aa", false);
- EXPECT_NE(dv, *copy);
-}
-
-TEST(ValuesTest, Comparisons) {
- // Test None Values.
- Value null1;
- Value null2;
- EXPECT_EQ(null1, null2);
- EXPECT_FALSE(null1 != null2);
- EXPECT_FALSE(null1 < null2);
- EXPECT_FALSE(null1 > null2);
- EXPECT_LE(null1, null2);
- EXPECT_GE(null1, null2);
-
- // Test Bool Values.
- Value bool1(false);
- Value bool2(true);
- EXPECT_FALSE(bool1 == bool2);
- EXPECT_NE(bool1, bool2);
- EXPECT_LT(bool1, bool2);
- EXPECT_FALSE(bool1 > bool2);
- EXPECT_LE(bool1, bool2);
- EXPECT_FALSE(bool1 >= bool2);
-
- // Test Int Values.
- Value int1(1);
- Value int2(2);
- EXPECT_FALSE(int1 == int2);
- EXPECT_NE(int1, int2);
- EXPECT_LT(int1, int2);
- EXPECT_FALSE(int1 > int2);
- EXPECT_LE(int1, int2);
- EXPECT_FALSE(int1 >= int2);
-
- // Test Double Values.
- Value double1(1.0);
- Value double2(2.0);
- EXPECT_FALSE(double1 == double2);
- EXPECT_NE(double1, double2);
- EXPECT_LT(double1, double2);
- EXPECT_FALSE(double1 > double2);
- EXPECT_LE(double1, double2);
- EXPECT_FALSE(double1 >= double2);
-
- // Test String Values.
- Value string1("1");
- Value string2("2");
- EXPECT_FALSE(string1 == string2);
- EXPECT_NE(string1, string2);
- EXPECT_LT(string1, string2);
- EXPECT_FALSE(string1 > string2);
- EXPECT_LE(string1, string2);
- EXPECT_FALSE(string1 >= string2);
-
- // Test Binary Values.
- Value binary1(Value::BlobStorage{0x01});
- Value binary2(Value::BlobStorage{0x02});
- EXPECT_FALSE(binary1 == binary2);
- EXPECT_NE(binary1, binary2);
- EXPECT_LT(binary1, binary2);
- EXPECT_FALSE(binary1 > binary2);
- EXPECT_LE(binary1, binary2);
- EXPECT_FALSE(binary1 >= binary2);
-
- // Test Empty List Values.
- ListValue null_list1;
- ListValue null_list2;
- EXPECT_EQ(null_list1, null_list2);
- EXPECT_FALSE(null_list1 != null_list2);
- EXPECT_FALSE(null_list1 < null_list2);
- EXPECT_FALSE(null_list1 > null_list2);
- EXPECT_LE(null_list1, null_list2);
- EXPECT_GE(null_list1, null_list2);
-
- // Test Non Empty List Values.
- ListValue int_list1;
- ListValue int_list2;
- int_list1.AppendInteger(1);
- int_list2.AppendInteger(2);
- EXPECT_FALSE(int_list1 == int_list2);
- EXPECT_NE(int_list1, int_list2);
- EXPECT_LT(int_list1, int_list2);
- EXPECT_FALSE(int_list1 > int_list2);
- EXPECT_LE(int_list1, int_list2);
- EXPECT_FALSE(int_list1 >= int_list2);
-
- // Test Empty Dict Values.
- DictionaryValue null_dict1;
- DictionaryValue null_dict2;
- EXPECT_EQ(null_dict1, null_dict2);
- EXPECT_FALSE(null_dict1 != null_dict2);
- EXPECT_FALSE(null_dict1 < null_dict2);
- EXPECT_FALSE(null_dict1 > null_dict2);
- EXPECT_LE(null_dict1, null_dict2);
- EXPECT_GE(null_dict1, null_dict2);
-
- // Test Non Empty Dict Values.
- DictionaryValue int_dict1;
- DictionaryValue int_dict2;
- int_dict1.SetInteger("key", 1);
- int_dict2.SetInteger("key", 2);
- EXPECT_FALSE(int_dict1 == int_dict2);
- EXPECT_NE(int_dict1, int_dict2);
- EXPECT_LT(int_dict1, int_dict2);
- EXPECT_FALSE(int_dict1 > int_dict2);
- EXPECT_LE(int_dict1, int_dict2);
- EXPECT_FALSE(int_dict1 >= int_dict2);
-
- // Test Values of different types.
- std::vector<Value> values;
- values.emplace_back(std::move(null1));
- values.emplace_back(std::move(bool1));
- values.emplace_back(std::move(int1));
- values.emplace_back(std::move(double1));
- values.emplace_back(std::move(string1));
- values.emplace_back(std::move(binary1));
- values.emplace_back(std::move(int_dict1));
- values.emplace_back(std::move(int_list1));
- for (size_t i = 0; i < values.size(); ++i) {
- for (size_t j = i + 1; j < values.size(); ++j) {
- EXPECT_FALSE(values[i] == values[j]);
- EXPECT_NE(values[i], values[j]);
- EXPECT_LT(values[i], values[j]);
- EXPECT_FALSE(values[i] > values[j]);
- EXPECT_LE(values[i], values[j]);
- EXPECT_FALSE(values[i] >= values[j]);
- }
- }
-}
-
-TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
- DictionaryValue original_dict;
- Value* null_weak = original_dict.SetKey("null", Value());
- Value* bool_weak = original_dict.SetKey("bool", Value(true));
- Value* int_weak = original_dict.SetKey("int", Value(42));
- Value* double_weak = original_dict.SetKey("double", Value(3.14));
- Value* string_weak = original_dict.SetKey("string", Value("hello"));
- Value* string16_weak =
- original_dict.SetKey("string16", Value(ASCIIToUTF16("hello16")));
- Value* binary_weak =
- original_dict.SetKey("binary", Value(Value::BlobStorage(42, '!')));
-
- Value::ListStorage storage;
- storage.emplace_back(0);
- storage.emplace_back(1);
- Value* list_weak = original_dict.SetKey("list", Value(std::move(storage)));
-
- auto copy_dict = std::make_unique<Value>(original_dict.Clone());
- auto copy_null = std::make_unique<Value>(null_weak->Clone());
- auto copy_bool = std::make_unique<Value>(bool_weak->Clone());
- auto copy_int = std::make_unique<Value>(int_weak->Clone());
- auto copy_double = std::make_unique<Value>(double_weak->Clone());
- auto copy_string = std::make_unique<Value>(string_weak->Clone());
- auto copy_string16 = std::make_unique<Value>(string16_weak->Clone());
- auto copy_binary = std::make_unique<Value>(binary_weak->Clone());
- auto copy_list = std::make_unique<Value>(list_weak->Clone());
-
- EXPECT_EQ(original_dict, *copy_dict);
- EXPECT_EQ(*null_weak, *copy_null);
- EXPECT_EQ(*bool_weak, *copy_bool);
- EXPECT_EQ(*int_weak, *copy_int);
- EXPECT_EQ(*double_weak, *copy_double);
- EXPECT_EQ(*string_weak, *copy_string);
- EXPECT_EQ(*string16_weak, *copy_string16);
- EXPECT_EQ(*binary_weak, *copy_binary);
- EXPECT_EQ(*list_weak, *copy_list);
-}
-
-TEST(ValuesTest, RemoveEmptyChildren) {
- auto root = std::make_unique<DictionaryValue>();
- // Remove empty lists and dictionaries.
- root->Set("empty_dict", std::make_unique<DictionaryValue>());
- root->Set("empty_list", std::make_unique<ListValue>());
- root->SetWithoutPathExpansion("a.b.c.d.e",
- std::make_unique<DictionaryValue>());
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_TRUE(root->empty());
-
- // Make sure we don't prune too much.
- root->SetBoolean("bool", true);
- root->Set("empty_dict", std::make_unique<DictionaryValue>());
- root->SetString("empty_string", std::string());
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(2U, root->size());
-
- // Should do nothing.
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(2U, root->size());
-
- // Nested test cases. These should all reduce back to the bool and string
- // set above.
- {
- root->Set("a.b.c.d.e", std::make_unique<DictionaryValue>());
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(2U, root->size());
- }
- {
- auto inner = std::make_unique<DictionaryValue>();
- inner->Set("empty_dict", std::make_unique<DictionaryValue>());
- inner->Set("empty_list", std::make_unique<ListValue>());
- root->Set("dict_with_empty_children", std::move(inner));
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(2U, root->size());
- }
- {
- auto inner = std::make_unique<ListValue>();
- inner->Append(std::make_unique<DictionaryValue>());
- inner->Append(std::make_unique<ListValue>());
- root->Set("list_with_empty_children", std::move(inner));
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(2U, root->size());
- }
-
- // Nested with siblings.
- {
- auto inner = std::make_unique<ListValue>();
- inner->Append(std::make_unique<DictionaryValue>());
- inner->Append(std::make_unique<ListValue>());
- root->Set("list_with_empty_children", std::move(inner));
- auto inner2 = std::make_unique<DictionaryValue>();
- inner2->Set("empty_dict", std::make_unique<DictionaryValue>());
- inner2->Set("empty_list", std::make_unique<ListValue>());
- root->Set("dict_with_empty_children", std::move(inner2));
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(2U, root->size());
- }
-
- // Make sure nested values don't get pruned.
- {
- auto inner = std::make_unique<ListValue>();
- auto inner2 = std::make_unique<ListValue>();
- inner2->Append(std::make_unique<Value>("hello"));
- inner->Append(std::make_unique<DictionaryValue>());
- inner->Append(std::move(inner2));
- root->Set("list_with_empty_children", std::move(inner));
- root = root->DeepCopyWithoutEmptyChildren();
- EXPECT_EQ(3U, root->size());
-
- ListValue* inner_value, *inner_value2;
- EXPECT_TRUE(root->GetList("list_with_empty_children", &inner_value));
- EXPECT_EQ(1U, inner_value->GetSize()); // Dictionary was pruned.
- EXPECT_TRUE(inner_value->GetList(0, &inner_value2));
- EXPECT_EQ(1U, inner_value2->GetSize());
- }
-}
-
-TEST(ValuesTest, MergeDictionary) {
- std::unique_ptr<DictionaryValue> base(new DictionaryValue);
- base->SetString("base_key", "base_key_value_base");
- base->SetString("collide_key", "collide_key_value_base");
- std::unique_ptr<DictionaryValue> base_sub_dict(new DictionaryValue);
- base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base");
- base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base");
- base->Set("sub_dict_key", std::move(base_sub_dict));
-
- std::unique_ptr<DictionaryValue> merge(new DictionaryValue);
- merge->SetString("merge_key", "merge_key_value_merge");
- merge->SetString("collide_key", "collide_key_value_merge");
- std::unique_ptr<DictionaryValue> merge_sub_dict(new DictionaryValue);
- merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge");
- merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge");
- merge->Set("sub_dict_key", std::move(merge_sub_dict));
-
- base->MergeDictionary(merge.get());
-
- EXPECT_EQ(4U, base->size());
- std::string base_key_value;
- EXPECT_TRUE(base->GetString("base_key", &base_key_value));
- EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved.
- std::string collide_key_value;
- EXPECT_TRUE(base->GetString("collide_key", &collide_key_value));
- EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced.
- std::string merge_key_value;
- EXPECT_TRUE(base->GetString("merge_key", &merge_key_value));
- EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in.
-
- DictionaryValue* res_sub_dict;
- EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict));
- EXPECT_EQ(3U, res_sub_dict->size());
- std::string sub_base_key_value;
- EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
- EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
- std::string sub_collide_key_value;
- EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key",
- &sub_collide_key_value));
- EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
- std::string sub_merge_key_value;
- EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
- EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
-}
-
-TEST(ValuesTest, MergeDictionaryDeepCopy) {
- std::unique_ptr<DictionaryValue> child(new DictionaryValue);
- DictionaryValue* original_child = child.get();
- child->SetString("test", "value");
- EXPECT_EQ(1U, child->size());
-
- std::string value;
- EXPECT_TRUE(child->GetString("test", &value));
- EXPECT_EQ("value", value);
-
- std::unique_ptr<DictionaryValue> base(new DictionaryValue);
- base->Set("dict", std::move(child));
- EXPECT_EQ(1U, base->size());
-
- DictionaryValue* ptr;
- EXPECT_TRUE(base->GetDictionary("dict", &ptr));
- EXPECT_EQ(original_child, ptr);
-
- std::unique_ptr<DictionaryValue> merged(new DictionaryValue);
- merged->MergeDictionary(base.get());
- EXPECT_EQ(1U, merged->size());
- EXPECT_TRUE(merged->GetDictionary("dict", &ptr));
- EXPECT_NE(original_child, ptr);
- EXPECT_TRUE(ptr->GetString("test", &value));
- EXPECT_EQ("value", value);
-
- original_child->SetString("test", "overwrite");
- base.reset();
- EXPECT_TRUE(ptr->GetString("test", &value));
- EXPECT_EQ("value", value);
-}
-
-TEST(ValuesTest, DictionaryIterator) {
- DictionaryValue dict;
- for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
- ADD_FAILURE();
- }
-
- Value value1("value1");
- dict.SetKey("key1", value1.Clone());
- bool seen1 = false;
- for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
- EXPECT_FALSE(seen1);
- EXPECT_EQ("key1", it.key());
- EXPECT_EQ(value1, it.value());
- seen1 = true;
- }
- EXPECT_TRUE(seen1);
-
- Value value2("value2");
- dict.SetKey("key2", value2.Clone());
- bool seen2 = seen1 = false;
- for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
- if (it.key() == "key1") {
- EXPECT_FALSE(seen1);
- EXPECT_EQ(value1, it.value());
- seen1 = true;
- } else if (it.key() == "key2") {
- EXPECT_FALSE(seen2);
- EXPECT_EQ(value2, it.value());
- seen2 = true;
- } else {
- ADD_FAILURE();
- }
- }
- EXPECT_TRUE(seen1);
- EXPECT_TRUE(seen2);
-}
-
-TEST(ValuesTest, StdDictionaryIterator) {
- DictionaryValue dict;
- for (auto it = dict.begin(); it != dict.end(); ++it) {
- ADD_FAILURE();
- }
-
- Value value1("value1");
- dict.SetKey("key1", value1.Clone());
- bool seen1 = false;
- for (const auto& it : dict) {
- EXPECT_FALSE(seen1);
- EXPECT_EQ("key1", it.first);
- EXPECT_EQ(value1, *it.second);
- seen1 = true;
- }
- EXPECT_TRUE(seen1);
-
- Value value2("value2");
- dict.SetKey("key2", value2.Clone());
- bool seen2 = seen1 = false;
- for (const auto& it : dict) {
- if (it.first == "key1") {
- EXPECT_FALSE(seen1);
- EXPECT_EQ(value1, *it.second);
- seen1 = true;
- } else if (it.first == "key2") {
- EXPECT_FALSE(seen2);
- EXPECT_EQ(value2, *it.second);
- seen2 = true;
- } else {
- ADD_FAILURE();
- }
- }
- EXPECT_TRUE(seen1);
- EXPECT_TRUE(seen2);
-}
-
-// DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
-// and still return true/false based on success.
-TEST(ValuesTest, GetWithNullOutValue) {
- DictionaryValue main_dict;
- ListValue main_list;
-
- Value bool_value(false);
- Value int_value(1234);
- Value double_value(12.34567);
- Value string_value("foo");
- Value binary_value(Value::Type::BINARY);
- DictionaryValue dict_value;
- ListValue list_value;
-
- main_dict.SetKey("bool", bool_value.Clone());
- main_dict.SetKey("int", int_value.Clone());
- main_dict.SetKey("double", double_value.Clone());
- main_dict.SetKey("string", string_value.Clone());
- main_dict.SetKey("binary", binary_value.Clone());
- main_dict.SetKey("dict", dict_value.Clone());
- main_dict.SetKey("list", list_value.Clone());
-
- main_list.Append(std::make_unique<Value>(bool_value.Clone()));
- main_list.Append(std::make_unique<Value>(int_value.Clone()));
- main_list.Append(std::make_unique<Value>(double_value.Clone()));
- main_list.Append(std::make_unique<Value>(string_value.Clone()));
- main_list.Append(std::make_unique<Value>(binary_value.Clone()));
- main_list.Append(std::make_unique<Value>(dict_value.Clone()));
- main_list.Append(std::make_unique<Value>(list_value.Clone()));
-
- EXPECT_TRUE(main_dict.Get("bool", nullptr));
- EXPECT_TRUE(main_dict.Get("int", nullptr));
- EXPECT_TRUE(main_dict.Get("double", nullptr));
- EXPECT_TRUE(main_dict.Get("string", nullptr));
- EXPECT_TRUE(main_dict.Get("binary", nullptr));
- EXPECT_TRUE(main_dict.Get("dict", nullptr));
- EXPECT_TRUE(main_dict.Get("list", nullptr));
- EXPECT_FALSE(main_dict.Get("DNE", nullptr));
-
- EXPECT_TRUE(main_dict.GetBoolean("bool", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("int", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("double", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("string", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("binary", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("dict", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("list", nullptr));
- EXPECT_FALSE(main_dict.GetBoolean("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetInteger("bool", nullptr));
- EXPECT_TRUE(main_dict.GetInteger("int", nullptr));
- EXPECT_FALSE(main_dict.GetInteger("double", nullptr));
- EXPECT_FALSE(main_dict.GetInteger("string", nullptr));
- EXPECT_FALSE(main_dict.GetInteger("binary", nullptr));
- EXPECT_FALSE(main_dict.GetInteger("dict", nullptr));
- EXPECT_FALSE(main_dict.GetInteger("list", nullptr));
- EXPECT_FALSE(main_dict.GetInteger("DNE", nullptr));
-
- // Both int and double values can be obtained from GetDouble.
- EXPECT_FALSE(main_dict.GetDouble("bool", nullptr));
- EXPECT_TRUE(main_dict.GetDouble("int", nullptr));
- EXPECT_TRUE(main_dict.GetDouble("double", nullptr));
- EXPECT_FALSE(main_dict.GetDouble("string", nullptr));
- EXPECT_FALSE(main_dict.GetDouble("binary", nullptr));
- EXPECT_FALSE(main_dict.GetDouble("dict", nullptr));
- EXPECT_FALSE(main_dict.GetDouble("list", nullptr));
- EXPECT_FALSE(main_dict.GetDouble("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(
- main_dict.GetString("double", static_cast<std::string*>(nullptr)));
- EXPECT_TRUE(
- main_dict.GetString("string", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(
- main_dict.GetString("binary", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(nullptr)));
-
- EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(nullptr)));
- EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(nullptr)));
-
- EXPECT_FALSE(main_dict.GetBinary("bool", nullptr));
- EXPECT_FALSE(main_dict.GetBinary("int", nullptr));
- EXPECT_FALSE(main_dict.GetBinary("double", nullptr));
- EXPECT_FALSE(main_dict.GetBinary("string", nullptr));
- EXPECT_TRUE(main_dict.GetBinary("binary", nullptr));
- EXPECT_FALSE(main_dict.GetBinary("dict", nullptr));
- EXPECT_FALSE(main_dict.GetBinary("list", nullptr));
- EXPECT_FALSE(main_dict.GetBinary("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetDictionary("bool", nullptr));
- EXPECT_FALSE(main_dict.GetDictionary("int", nullptr));
- EXPECT_FALSE(main_dict.GetDictionary("double", nullptr));
- EXPECT_FALSE(main_dict.GetDictionary("string", nullptr));
- EXPECT_FALSE(main_dict.GetDictionary("binary", nullptr));
- EXPECT_TRUE(main_dict.GetDictionary("dict", nullptr));
- EXPECT_FALSE(main_dict.GetDictionary("list", nullptr));
- EXPECT_FALSE(main_dict.GetDictionary("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetList("bool", nullptr));
- EXPECT_FALSE(main_dict.GetList("int", nullptr));
- EXPECT_FALSE(main_dict.GetList("double", nullptr));
- EXPECT_FALSE(main_dict.GetList("string", nullptr));
- EXPECT_FALSE(main_dict.GetList("binary", nullptr));
- EXPECT_FALSE(main_dict.GetList("dict", nullptr));
- EXPECT_TRUE(main_dict.GetList("list", nullptr));
- EXPECT_FALSE(main_dict.GetList("DNE", nullptr));
-
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", nullptr));
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", nullptr));
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", nullptr));
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", nullptr));
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", nullptr));
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", nullptr));
- EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", nullptr));
- EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", nullptr));
-
- EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", nullptr));
- EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", nullptr));
- EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", nullptr));
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", nullptr));
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", nullptr));
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", nullptr));
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", nullptr));
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", nullptr));
- EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", nullptr));
- EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", nullptr));
- EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", nullptr));
- EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", nullptr));
- EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", nullptr));
- EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", nullptr));
- EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", nullptr));
- EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "bool", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "int", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "double", static_cast<std::string*>(nullptr)));
- EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
- "string", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "binary", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "dict", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "list", static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "DNE", static_cast<std::string*>(nullptr)));
-
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "bool", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "int", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "double", static_cast<string16*>(nullptr)));
- EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
- "string", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "binary", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "dict", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "list", static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "DNE", static_cast<string16*>(nullptr)));
-
- // There is no GetBinaryWithoutPathExpansion for some reason, but if there
- // were it should be tested here...
-
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", nullptr));
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", nullptr));
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", nullptr));
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", nullptr));
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", nullptr));
- EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", nullptr));
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", nullptr));
- EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", nullptr));
-
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", nullptr));
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", nullptr));
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", nullptr));
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", nullptr));
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", nullptr));
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", nullptr));
- EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", nullptr));
- EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", nullptr));
-
- EXPECT_TRUE(main_list.Get(0, nullptr));
- EXPECT_TRUE(main_list.Get(1, nullptr));
- EXPECT_TRUE(main_list.Get(2, nullptr));
- EXPECT_TRUE(main_list.Get(3, nullptr));
- EXPECT_TRUE(main_list.Get(4, nullptr));
- EXPECT_TRUE(main_list.Get(5, nullptr));
- EXPECT_TRUE(main_list.Get(6, nullptr));
- EXPECT_FALSE(main_list.Get(7, nullptr));
-
- EXPECT_TRUE(main_list.GetBoolean(0, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(1, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(2, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(3, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(4, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(5, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(6, nullptr));
- EXPECT_FALSE(main_list.GetBoolean(7, nullptr));
-
- EXPECT_FALSE(main_list.GetInteger(0, nullptr));
- EXPECT_TRUE(main_list.GetInteger(1, nullptr));
- EXPECT_FALSE(main_list.GetInteger(2, nullptr));
- EXPECT_FALSE(main_list.GetInteger(3, nullptr));
- EXPECT_FALSE(main_list.GetInteger(4, nullptr));
- EXPECT_FALSE(main_list.GetInteger(5, nullptr));
- EXPECT_FALSE(main_list.GetInteger(6, nullptr));
- EXPECT_FALSE(main_list.GetInteger(7, nullptr));
-
- EXPECT_FALSE(main_list.GetDouble(0, nullptr));
- EXPECT_TRUE(main_list.GetDouble(1, nullptr));
- EXPECT_TRUE(main_list.GetDouble(2, nullptr));
- EXPECT_FALSE(main_list.GetDouble(3, nullptr));
- EXPECT_FALSE(main_list.GetDouble(4, nullptr));
- EXPECT_FALSE(main_list.GetDouble(5, nullptr));
- EXPECT_FALSE(main_list.GetDouble(6, nullptr));
- EXPECT_FALSE(main_list.GetDouble(7, nullptr));
-
- EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(nullptr)));
- EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(nullptr)));
-
- EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(nullptr)));
- EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(nullptr)));
- EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(nullptr)));
-
- EXPECT_FALSE(main_list.GetDictionary(0, nullptr));
- EXPECT_FALSE(main_list.GetDictionary(1, nullptr));
- EXPECT_FALSE(main_list.GetDictionary(2, nullptr));
- EXPECT_FALSE(main_list.GetDictionary(3, nullptr));
- EXPECT_FALSE(main_list.GetDictionary(4, nullptr));
- EXPECT_TRUE(main_list.GetDictionary(5, nullptr));
- EXPECT_FALSE(main_list.GetDictionary(6, nullptr));
- EXPECT_FALSE(main_list.GetDictionary(7, nullptr));
-
- EXPECT_FALSE(main_list.GetList(0, nullptr));
- EXPECT_FALSE(main_list.GetList(1, nullptr));
- EXPECT_FALSE(main_list.GetList(2, nullptr));
- EXPECT_FALSE(main_list.GetList(3, nullptr));
- EXPECT_FALSE(main_list.GetList(4, nullptr));
- EXPECT_FALSE(main_list.GetList(5, nullptr));
- EXPECT_TRUE(main_list.GetList(6, nullptr));
- EXPECT_FALSE(main_list.GetList(7, nullptr));
-}
-
-TEST(ValuesTest, SelfSwap) {
- base::Value test(1);
- std::swap(test, test);
- EXPECT_EQ(1, test.GetInt());
-}
-
-TEST(ValuesTest, FromToUniquePtrValue) {
- std::unique_ptr<DictionaryValue> dict = std::make_unique<DictionaryValue>();
- dict->SetString("name", "Froogle");
- dict->SetString("url", "http://froogle.com");
- Value dict_copy = dict->Clone();
-
- Value dict_converted = Value::FromUniquePtrValue(std::move(dict));
- EXPECT_EQ(dict_copy, dict_converted);
-
- std::unique_ptr<Value> val =
- Value::ToUniquePtrValue(std::move(dict_converted));
- EXPECT_EQ(dict_copy, *val);
-}
-
-} // namespace base
diff --git a/base/version_unittest.cc b/base/version_unittest.cc
deleted file mode 100644
index 285ca9c..0000000
--- a/base/version_unittest.cc
+++ /dev/null
@@ -1,200 +0,0 @@
-// 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.
-
-#include "base/version.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <utility>
-
-#include "base/macros.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-TEST(VersionTest, DefaultConstructor) {
- base::Version v;
- EXPECT_FALSE(v.IsValid());
-}
-
-TEST(VersionTest, ValueSemantics) {
- base::Version v1("1.2.3.4");
- EXPECT_TRUE(v1.IsValid());
- base::Version v3;
- EXPECT_FALSE(v3.IsValid());
- {
- base::Version v2(v1);
- v3 = v2;
- EXPECT_TRUE(v2.IsValid());
- EXPECT_EQ(v1, v2);
- }
- EXPECT_EQ(v3, v1);
-}
-
-TEST(VersionTest, MoveSemantics) {
- const std::vector<uint32_t> components = {1, 2, 3, 4};
- base::Version v1(std::move(components));
- EXPECT_TRUE(v1.IsValid());
- base::Version v2("1.2.3.4");
- EXPECT_EQ(v1, v2);
-}
-
-TEST(VersionTest, GetVersionFromString) {
- static const struct version_string {
- const char* input;
- size_t parts;
- uint32_t firstpart;
- bool success;
- } cases[] = {
- {"", 0, 0, false},
- {" ", 0, 0, false},
- {"\t", 0, 0, false},
- {"\n", 0, 0, false},
- {" ", 0, 0, false},
- {".", 0, 0, false},
- {" . ", 0, 0, false},
- {"0", 1, 0, true},
- {"0.", 0, 0, false},
- {"0.0", 2, 0, true},
- {"4294967295.0", 2, 4294967295, true},
- {"4294967296.0", 0, 0, false},
- {"-1.0", 0, 0, false},
- {"1.-1.0", 0, 0, false},
- {"1,--1.0", 0, 0, false},
- {"+1.0", 0, 0, false},
- {"1.+1.0", 0, 0, false},
- {"1+1.0", 0, 0, false},
- {"++1.0", 0, 0, false},
- {"1.0a", 0, 0, false},
- {"1.2.3.4.5.6.7.8.9.0", 10, 1, true},
- {"02.1", 0, 0, false},
- {"0.01", 2, 0, true},
- {"f.1", 0, 0, false},
- {"15.007.20011", 3, 15, true},
- {"15.5.28.130162", 4, 15, true},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- base::Version version(cases[i].input);
- EXPECT_EQ(cases[i].success, version.IsValid());
- if (cases[i].success) {
- EXPECT_EQ(cases[i].parts, version.components().size());
- EXPECT_EQ(cases[i].firstpart, version.components()[0]);
- }
- }
-}
-
-TEST(VersionTest, Compare) {
- static const struct version_compare {
- const char* lhs;
- const char* rhs;
- int expected;
- } cases[] = {
- {"1.0", "1.0", 0},
- {"1.0", "0.0", 1},
- {"1.0", "2.0", -1},
- {"1.0", "1.1", -1},
- {"1.1", "1.0", 1},
- {"1.0", "1.0.1", -1},
- {"1.1", "1.0.1", 1},
- {"1.1", "1.0.1", 1},
- {"1.0.0", "1.0", 0},
- {"1.0.3", "1.0.20", -1},
- {"11.0.10", "15.007.20011", -1},
- {"11.0.10", "15.5.28.130162", -1},
- {"15.5.28.130162", "15.5.28.130162", 0},
- };
- for (size_t i = 0; i < arraysize(cases); ++i) {
- base::Version lhs(cases[i].lhs);
- base::Version rhs(cases[i].rhs);
- EXPECT_EQ(lhs.CompareTo(rhs), cases[i].expected) <<
- cases[i].lhs << " ? " << cases[i].rhs;
- // CompareToWildcardString() should have same behavior as CompareTo() when
- // no wildcards are present.
- EXPECT_EQ(lhs.CompareToWildcardString(cases[i].rhs), cases[i].expected)
- << cases[i].lhs << " ? " << cases[i].rhs;
- EXPECT_EQ(rhs.CompareToWildcardString(cases[i].lhs), -cases[i].expected)
- << cases[i].lhs << " ? " << cases[i].rhs;
-
- // Test comparison operators
- switch (cases[i].expected) {
- case -1:
- EXPECT_LT(lhs, rhs);
- EXPECT_LE(lhs, rhs);
- EXPECT_NE(lhs, rhs);
- EXPECT_FALSE(lhs == rhs);
- EXPECT_FALSE(lhs >= rhs);
- EXPECT_FALSE(lhs > rhs);
- break;
- case 0:
- EXPECT_FALSE(lhs < rhs);
- EXPECT_LE(lhs, rhs);
- EXPECT_FALSE(lhs != rhs);
- EXPECT_EQ(lhs, rhs);
- EXPECT_GE(lhs, rhs);
- EXPECT_FALSE(lhs > rhs);
- break;
- case 1:
- EXPECT_FALSE(lhs < rhs);
- EXPECT_FALSE(lhs <= rhs);
- EXPECT_NE(lhs, rhs);
- EXPECT_FALSE(lhs == rhs);
- EXPECT_GE(lhs, rhs);
- EXPECT_GT(lhs, rhs);
- break;
- }
- }
-}
-
-TEST(VersionTest, CompareToWildcardString) {
- static const struct version_compare {
- const char* lhs;
- const char* rhs;
- int expected;
- } cases[] = {
- {"1.0", "1.*", 0},
- {"1.0", "0.*", 1},
- {"1.0", "2.*", -1},
- {"1.2.3", "1.2.3.*", 0},
- {"10.0", "1.0.*", 1},
- {"1.0", "3.0.*", -1},
- {"1.4", "1.3.0.*", 1},
- {"1.3.9", "1.3.*", 0},
- {"1.4.1", "1.3.*", 1},
- {"1.3", "1.4.5.*", -1},
- {"1.5", "1.4.5.*", 1},
- {"1.3.9", "1.3.*", 0},
- {"1.2.0.0.0.0", "1.2.*", 0},
- };
- for (size_t i = 0; i < arraysize(cases); ++i) {
- const base::Version version(cases[i].lhs);
- const int result = version.CompareToWildcardString(cases[i].rhs);
- EXPECT_EQ(result, cases[i].expected) << cases[i].lhs << "?" << cases[i].rhs;
- }
-}
-
-TEST(VersionTest, IsValidWildcardString) {
- static const struct version_compare {
- const char* version;
- bool expected;
- } cases[] = {
- {"1.0", true},
- {"", false},
- {"1.2.3.4.5.6", true},
- {"1.2.3.*", true},
- {"1.2.3.5*", false},
- {"1.2.3.56*", false},
- {"1.*.3", false},
- {"20.*", true},
- {"+2.*", false},
- {"*", false},
- {"*.2", false},
- };
- for (size_t i = 0; i < arraysize(cases); ++i) {
- EXPECT_EQ(base::Version::IsValidWildcardString(cases[i].version),
- cases[i].expected) << cases[i].version << "?" << cases[i].expected;
- }
-}
-
-} // namespace
diff --git a/base/vlog_unittest.cc b/base/vlog_unittest.cc
deleted file mode 100644
index 3c3f49c..0000000
--- a/base/vlog_unittest.cc
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (c) 2010 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 "base/vlog.h"
-
-#include "base/logging.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace logging {
-
-namespace {
-
-TEST(VlogTest, NoVmodule) {
- int min_log_level = 0;
- EXPECT_EQ(0,
- VlogInfo(std::string(), std::string(), &min_log_level)
- .GetVlogLevel("test1"));
- EXPECT_EQ(0,
- VlogInfo("0", std::string(), &min_log_level).GetVlogLevel("test2"));
- EXPECT_EQ(
- 0, VlogInfo("blah", std::string(), &min_log_level).GetVlogLevel("test3"));
- EXPECT_EQ(
- 0,
- VlogInfo("0blah1", std::string(), &min_log_level).GetVlogLevel("test4"));
- EXPECT_EQ(1,
- VlogInfo("1", std::string(), &min_log_level).GetVlogLevel("test5"));
- EXPECT_EQ(5,
- VlogInfo("5", std::string(), &min_log_level).GetVlogLevel("test6"));
-}
-
-TEST(VlogTest, MatchVlogPattern) {
- // Degenerate cases.
- EXPECT_TRUE(MatchVlogPattern("", ""));
- EXPECT_TRUE(MatchVlogPattern("", "****"));
- EXPECT_FALSE(MatchVlogPattern("", "x"));
- EXPECT_FALSE(MatchVlogPattern("x", ""));
-
- // Basic.
- EXPECT_TRUE(MatchVlogPattern("blah", "blah"));
-
- // ? should match exactly one character.
- EXPECT_TRUE(MatchVlogPattern("blah", "bl?h"));
- EXPECT_FALSE(MatchVlogPattern("blh", "bl?h"));
- EXPECT_FALSE(MatchVlogPattern("blaah", "bl?h"));
- EXPECT_TRUE(MatchVlogPattern("blah", "?lah"));
- EXPECT_FALSE(MatchVlogPattern("lah", "?lah"));
- EXPECT_FALSE(MatchVlogPattern("bblah", "?lah"));
-
- // * can match any number (even 0) of characters.
- EXPECT_TRUE(MatchVlogPattern("blah", "bl*h"));
- EXPECT_TRUE(MatchVlogPattern("blabcdefh", "bl*h"));
- EXPECT_TRUE(MatchVlogPattern("blh", "bl*h"));
- EXPECT_TRUE(MatchVlogPattern("blah", "*blah"));
- EXPECT_TRUE(MatchVlogPattern("ohblah", "*blah"));
- EXPECT_TRUE(MatchVlogPattern("blah", "blah*"));
- EXPECT_TRUE(MatchVlogPattern("blahhhh", "blah*"));
- EXPECT_TRUE(MatchVlogPattern("blahhhh", "blah*"));
- EXPECT_TRUE(MatchVlogPattern("blah", "*blah*"));
- EXPECT_TRUE(MatchVlogPattern("blahhhh", "*blah*"));
- EXPECT_TRUE(MatchVlogPattern("bbbblahhhh", "*blah*"));
-
- // Multiple *s should work fine.
- EXPECT_TRUE(MatchVlogPattern("ballaah", "b*la*h"));
- EXPECT_TRUE(MatchVlogPattern("blah", "b*la*h"));
- EXPECT_TRUE(MatchVlogPattern("bbbblah", "b*la*h"));
- EXPECT_TRUE(MatchVlogPattern("blaaah", "b*la*h"));
-
- // There should be no escaping going on.
- EXPECT_TRUE(MatchVlogPattern("bl\\ah", "bl\\?h"));
- EXPECT_FALSE(MatchVlogPattern("bl?h", "bl\\?h"));
- EXPECT_TRUE(MatchVlogPattern("bl\\aaaah", "bl\\*h"));
- EXPECT_FALSE(MatchVlogPattern("bl*h", "bl\\*h"));
-
- // Any slash matches any slash.
- EXPECT_TRUE(MatchVlogPattern("/b\\lah", "/b\\lah"));
- EXPECT_TRUE(MatchVlogPattern("\\b/lah", "/b\\lah"));
-}
-
-TEST(VlogTest, VmoduleBasic) {
- const char kVSwitch[] = "-1";
- const char kVModuleSwitch[] =
- "foo=,bar=0,baz=blah,,qux=0blah1,quux=1,corge.ext=5";
- int min_log_level = 0;
- VlogInfo vlog_info(kVSwitch, kVModuleSwitch, &min_log_level);
- EXPECT_EQ(-1, vlog_info.GetVlogLevel("/path/to/grault.cc"));
- EXPECT_EQ(0, vlog_info.GetVlogLevel("/path/to/foo.cc"));
- EXPECT_EQ(0, vlog_info.GetVlogLevel("D:\\Path\\To\\bar-inl.mm"));
- EXPECT_EQ(-1, vlog_info.GetVlogLevel("D:\\path\\to what/bar_unittest.m"));
- EXPECT_EQ(0, vlog_info.GetVlogLevel("baz.h"));
- EXPECT_EQ(0, vlog_info.GetVlogLevel("/another/path/to/qux.h"));
- EXPECT_EQ(1, vlog_info.GetVlogLevel("/path/to/quux"));
- EXPECT_EQ(5, vlog_info.GetVlogLevel("c:\\path/to/corge.ext.h"));
-}
-
-TEST(VlogTest, VmoduleDirs) {
- const char kVModuleSwitch[] =
- "foo/bar.cc=1,baz\\*\\qux.cc=2,*quux/*=3,*/*-inl.h=4";
- int min_log_level = 0;
- VlogInfo vlog_info(std::string(), kVModuleSwitch, &min_log_level);
- EXPECT_EQ(0, vlog_info.GetVlogLevel("/foo/bar.cc"));
- EXPECT_EQ(0, vlog_info.GetVlogLevel("bar.cc"));
- EXPECT_EQ(1, vlog_info.GetVlogLevel("foo/bar.cc"));
-
- EXPECT_EQ(0, vlog_info.GetVlogLevel("baz/grault/qux.h"));
- EXPECT_EQ(0, vlog_info.GetVlogLevel("/baz/grault/qux.cc"));
- EXPECT_EQ(2, vlog_info.GetVlogLevel("baz/grault/qux.cc"));
- EXPECT_EQ(2, vlog_info.GetVlogLevel("baz/grault/blah/qux.cc"));
- EXPECT_EQ(2, vlog_info.GetVlogLevel("baz\\grault\\qux.cc"));
- EXPECT_EQ(2, vlog_info.GetVlogLevel("baz\\grault//blah\\qux.cc"));
-
- EXPECT_EQ(0, vlog_info.GetVlogLevel("/foo/bar/baz/quux.cc"));
- EXPECT_EQ(3, vlog_info.GetVlogLevel("/foo/bar/baz/quux/grault.cc"));
- EXPECT_EQ(3, vlog_info.GetVlogLevel("/foo\\bar/baz\\quux/grault.cc"));
-
- EXPECT_EQ(0, vlog_info.GetVlogLevel("foo/bar/test-inl.cc"));
- EXPECT_EQ(4, vlog_info.GetVlogLevel("foo/bar/test-inl.h"));
- EXPECT_EQ(4, vlog_info.GetVlogLevel("foo/bar/baz/blah-inl.h"));
-}
-
-} // namespace
-
-} // namespace logging
diff --git a/base/win/BUILD.gn b/base/win/BUILD.gn
deleted file mode 100644
index 19c2982..0000000
--- a/base/win/BUILD.gn
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) 2016 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.
-
-import("//build/buildflag_header.gni")
-
-declare_args() {
- # Indicates if the handle verifier should operate in a single module mode. By
- # default a single instance gets shared by all the modules.
- single_module_mode_handle_verifier = false
-}
-
-# Ensure that the handle verifier is always used in a single module mode for the
-# component builds.
-if (is_component_build) {
- single_module_mode_handle_verifier = true
-}
-
-buildflag_header("base_win_buildflags") {
- header = "base_win_buildflags.h"
- header_dir = "base/win"
- flags = [
- "SINGLE_MODULE_MODE_HANDLE_VERIFIER=$single_module_mode_handle_verifier",
- ]
-}
-
-static_library("pe_image") {
- sources = [
- "pe_image.cc",
- "pe_image.h",
- ]
-}
diff --git a/base/win/async_operation_unittest.cc b/base/win/async_operation_unittest.cc
deleted file mode 100644
index b29e181..0000000
--- a/base/win/async_operation_unittest.cc
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright 2018 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 "base/win/async_operation.h"
-
-#include <utility>
-
-#include "base/test/gtest_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace WRL = Microsoft::WRL;
-
-using ABI::Windows::Foundation::IAsyncOperation;
-using ABI::Windows::Foundation::IAsyncOperationCompletedHandler;
-
-// In order to exercise the interface logic of AsyncOperation we define an empty
-// dummy interface, its implementation, and the necessary boilerplate to hook it
-// up with IAsyncOperation and IAsyncOperationCompletedHandler.
-namespace {
-
-// Chosen by fair `uuidgen` invocation. Also applies to the UUIDs below.
-MIDL_INTERFACE("756358C7-8083-4D78-9D27-9278B76096d4")
-IFooBar : public IInspectable{};
-
-class FooBar
- : public WRL::RuntimeClass<
- WRL::RuntimeClassFlags<WRL::WinRt | WRL::InhibitRoOriginateError>,
- IFooBar> {};
-
-} // namespace
-
-namespace ABI {
-namespace Windows {
-namespace Foundation {
-
-// Provide the required template specializations to register
-// IAsyncOperation<Foobar*> as an AggregateType. This is similar to how it is
-// done for UWP classes.
-template <>
-struct DECLSPEC_UUID("124858e4-f97e-409c-86ae-418c4781144c")
- IAsyncOperation<FooBar*>
- : IAsyncOperation_impl<Internal::AggregateType<FooBar*, IFooBar*>> {
- static const wchar_t* z_get_rc_name_impl() {
- return L"Windows.Foundation.IAsyncOperation<FooBar>";
- }
-};
-
-template <>
-struct DECLSPEC_UUID("9e49373c-200c-4715-abd7-4214ba669c81")
- IAsyncOperationCompletedHandler<FooBar*>
- : IAsyncOperationCompletedHandler_impl<
- Internal::AggregateType<FooBar*, IFooBar*>> {
- static const wchar_t* z_get_rc_name_impl() {
- return L"Windows.Foundation.AsyncOperationCompletedHandler<FooBar>";
- }
-};
-
-} // namespace Foundation
-} // namespace Windows
-} // namespace ABI
-
-namespace base {
-namespace win {
-
-namespace {
-
-// Utility method to add a completion callback to |async_op|. |*called_cb| will
-// be set to true once the callback is invoked.
-template <typename T>
-void PutCallback(AsyncOperation<T>* async_op, bool* called_cb) {
- async_op->put_Completed(
- WRL::Callback<IAsyncOperationCompletedHandler<T>>(
- [=](IAsyncOperation<T>* iasync_op, AsyncStatus status) {
- EXPECT_EQ(async_op, iasync_op);
- *called_cb = true;
- return S_OK;
- })
- .Get());
-}
-
-} // namespace
-
-TEST(AsyncOperationTest, TestInt) {
- bool called_cb = false;
-
- auto int_op = WRL::Make<AsyncOperation<int>>();
- PutCallback(int_op.Get(), &called_cb);
-
- int results;
- EXPECT_TRUE(FAILED(int_op->GetResults(&results)));
- EXPECT_FALSE(called_cb);
- int_op->callback().Run(123);
-
- EXPECT_TRUE(called_cb);
- EXPECT_TRUE(SUCCEEDED(int_op->GetResults(&results)));
- EXPECT_EQ(123, results);
-
- // GetResults should be idempotent.
- EXPECT_TRUE(SUCCEEDED(int_op->GetResults(&results)));
- EXPECT_EQ(123, results);
-}
-
-TEST(AsyncOperationTest, TestBool) {
- bool called_cb = false;
-
- auto bool_op = WRL::Make<AsyncOperation<bool>>();
- PutCallback(bool_op.Get(), &called_cb);
-
- // AsyncOperation<bool> is an aggregate of bool and boolean, and requires a
- // pointer to the latter to get the results.
- boolean results;
- EXPECT_TRUE(FAILED(bool_op->GetResults(&results)));
- EXPECT_FALSE(called_cb);
- bool_op->callback().Run(true);
-
- EXPECT_TRUE(called_cb);
- EXPECT_TRUE(SUCCEEDED(bool_op->GetResults(&results)));
- EXPECT_TRUE(results);
-}
-
-TEST(AsyncOperationTest, TestInterface) {
- bool called_cb = false;
-
- auto foobar_op = WRL::Make<AsyncOperation<FooBar*>>();
- PutCallback(foobar_op.Get(), &called_cb);
-
- // AsyncOperation<FooBar*> is an aggregate of FooBar* and IFooBar*.
- WRL::ComPtr<IFooBar> results;
- EXPECT_TRUE(FAILED(foobar_op->GetResults(&results)));
- EXPECT_FALSE(called_cb);
-
- auto foobar = WRL::Make<FooBar>();
- IFooBar* foobar_ptr = foobar.Get();
- foobar_op->callback().Run(std::move(foobar));
-
- EXPECT_TRUE(called_cb);
- EXPECT_TRUE(SUCCEEDED(foobar_op->GetResults(&results)));
- EXPECT_EQ(foobar_ptr, results.Get());
-}
-
-TEST(AsyncOperationTest, TestIdempotence) {
- bool called_cb = false;
-
- auto int_op = WRL::Make<AsyncOperation<int>>();
- PutCallback(int_op.Get(), &called_cb);
-
- int results;
- EXPECT_TRUE(FAILED(int_op->GetResults(&results)));
- EXPECT_FALSE(called_cb);
- // Calling GetResults twice shouldn't change the result.
- EXPECT_TRUE(FAILED(int_op->GetResults(&results)));
- EXPECT_FALSE(called_cb);
-
- int_op->callback().Run(42);
-
- EXPECT_TRUE(called_cb);
- EXPECT_TRUE(SUCCEEDED(int_op->GetResults(&results)));
- EXPECT_EQ(42, results);
- // Calling GetResults twice shouldn't change the result.
- EXPECT_TRUE(SUCCEEDED(int_op->GetResults(&results)));
- EXPECT_EQ(42, results);
-}
-
-TEST(AsyncOperationTest, DoubleCallbackFails) {
- auto int_op = WRL::Make<AsyncOperation<int>>();
- auto cb = int_op->callback();
-
- // Obtaining another callback should result in a DCHECK failure.
- EXPECT_DCHECK_DEATH(int_op->callback());
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/com_init_check_hook_unittest.cc b/base/win/com_init_check_hook_unittest.cc
deleted file mode 100644
index 32aede4..0000000
--- a/base/win/com_init_check_hook_unittest.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2017 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 "base/win/com_init_check_hook.h"
-
-#include <objbase.h>
-#include <shlobj.h>
-#include <wrl/client.h>
-
-#include "base/test/gtest_util.h"
-#include "base/win/com_init_util.h"
-#include "base/win/patch_util.h"
-#include "base/win/scoped_com_initializer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-using Microsoft::WRL::ComPtr;
-
-TEST(ComInitCheckHook, AssertNotInitialized) {
- ComInitCheckHook com_check_hook;
- AssertComApartmentType(ComApartmentType::NONE);
- ComPtr<IUnknown> shell_link;
-#if defined(COM_INIT_CHECK_HOOK_ENABLED)
- EXPECT_DCHECK_DEATH(::CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_ALL,
- IID_PPV_ARGS(&shell_link)));
-#else
- EXPECT_EQ(CO_E_NOTINITIALIZED,
- ::CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_ALL,
- IID_PPV_ARGS(&shell_link)));
-#endif
-}
-
-TEST(ComInitCheckHook, HookRemoval) {
- AssertComApartmentType(ComApartmentType::NONE);
- { ComInitCheckHook com_check_hook; }
- ComPtr<IUnknown> shell_link;
- EXPECT_EQ(CO_E_NOTINITIALIZED,
- ::CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_ALL,
- IID_PPV_ARGS(&shell_link)));
-}
-
-TEST(ComInitCheckHook, NoAssertComInitialized) {
- ComInitCheckHook com_check_hook;
- ScopedCOMInitializer com_initializer;
- ComPtr<IUnknown> shell_link;
- EXPECT_TRUE(SUCCEEDED(::CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_ALL,
- IID_PPV_ARGS(&shell_link))));
-}
-
-TEST(ComInitCheckHook, MultipleHooks) {
- ComInitCheckHook com_check_hook_1;
- ComInitCheckHook com_check_hook_2;
- AssertComApartmentType(ComApartmentType::NONE);
- ComPtr<IUnknown> shell_link;
-#if defined(COM_INIT_CHECK_HOOK_ENABLED)
- EXPECT_DCHECK_DEATH(::CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_ALL,
- IID_PPV_ARGS(&shell_link)));
-#else
- EXPECT_EQ(CO_E_NOTINITIALIZED,
- ::CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_ALL,
- IID_PPV_ARGS(&shell_link)));
-#endif
-}
-
-TEST(ComInitCheckHook, UnexpectedHook) {
-#if defined(COM_INIT_CHECK_HOOK_ENABLED)
- HMODULE ole32_library = ::LoadLibrary(L"ole32.dll");
- ASSERT_TRUE(ole32_library);
-
- uint32_t co_create_instance_padded_address =
- reinterpret_cast<uint32_t>(
- GetProcAddress(ole32_library, "CoCreateInstance")) - 5;
- const unsigned char* co_create_instance_bytes =
- reinterpret_cast<const unsigned char*>(co_create_instance_padded_address);
- const unsigned char original_byte = co_create_instance_bytes[0];
- const unsigned char unexpected_byte = 0xdb;
- ASSERT_EQ(static_cast<DWORD>(NO_ERROR),
- internal::ModifyCode(
- reinterpret_cast<void*>(co_create_instance_padded_address),
- reinterpret_cast<const void*>(&unexpected_byte),
- sizeof(unexpected_byte)));
-
- EXPECT_DCHECK_DEATH({ ComInitCheckHook com_check_hook; });
-
- // If this call fails, really bad things are going to happen to other tests
- // so CHECK here.
- CHECK_EQ(static_cast<DWORD>(NO_ERROR),
- internal::ModifyCode(
- reinterpret_cast<void*>(co_create_instance_padded_address),
- reinterpret_cast<const void*>(&original_byte),
- sizeof(original_byte)));
-
- ::FreeLibrary(ole32_library);
- ole32_library = nullptr;
-#endif
-}
-
-TEST(ComInitCheckHook, ExternallyHooked) {
-#if defined(COM_INIT_CHECK_HOOK_ENABLED)
- HMODULE ole32_library = ::LoadLibrary(L"ole32.dll");
- ASSERT_TRUE(ole32_library);
-
- uint32_t co_create_instance_address = reinterpret_cast<uint32_t>(
- GetProcAddress(ole32_library, "CoCreateInstance"));
- const unsigned char* co_create_instance_bytes =
- reinterpret_cast<const unsigned char*>(co_create_instance_address);
- const unsigned char original_byte = co_create_instance_bytes[0];
- const unsigned char jmp_byte = 0xe9;
- ASSERT_EQ(static_cast<DWORD>(NO_ERROR),
- internal::ModifyCode(
- reinterpret_cast<void*>(co_create_instance_address),
- reinterpret_cast<const void*>(&jmp_byte), sizeof(jmp_byte)));
-
- // Externally patched instances should crash so we catch these cases on bots.
- EXPECT_DCHECK_DEATH({ ComInitCheckHook com_check_hook; });
-
- // If this call fails, really bad things are going to happen to other tests
- // so CHECK here.
- CHECK_EQ(
- static_cast<DWORD>(NO_ERROR),
- internal::ModifyCode(reinterpret_cast<void*>(co_create_instance_address),
- reinterpret_cast<const void*>(&original_byte),
- sizeof(original_byte)));
-
- ::FreeLibrary(ole32_library);
- ole32_library = nullptr;
-#endif
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/com_init_util_unittest.cc b/base/win/com_init_util_unittest.cc
deleted file mode 100644
index fb897dd..0000000
--- a/base/win/com_init_util_unittest.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2017 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 "base/win/com_init_util.h"
-
-#include "base/test/gtest_util.h"
-#include "base/win/scoped_com_initializer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-TEST(ComInitUtil, AssertNotInitialized) {
- EXPECT_DCHECK_DEATH(AssertComInitialized());
-}
-
-TEST(ComInitUtil, AssertUninitialized) {
- // When COM is uninitialized, the TLS data will remain, but the apartment
- // status will be updated. This covers that case.
- {
- ScopedCOMInitializer com_initializer;
- ASSERT_TRUE(com_initializer.Succeeded());
- }
- EXPECT_DCHECK_DEATH(AssertComInitialized());
-}
-
-TEST(ComInitUtil, AssertSTAInitialized) {
- ScopedCOMInitializer com_initializer;
- ASSERT_TRUE(com_initializer.Succeeded());
-
- AssertComInitialized();
-}
-
-TEST(ComInitUtil, AssertMTAInitialized) {
- ScopedCOMInitializer com_initializer(ScopedCOMInitializer::kMTA);
- ASSERT_TRUE(com_initializer.Succeeded());
-
- AssertComInitialized();
-}
-
-TEST(ComInitUtil, AssertNoneApartmentType) {
- AssertComApartmentType(ComApartmentType::NONE);
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::STA));
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::MTA));
-}
-
-TEST(ComInitUtil, AssertNoneApartmentTypeUninitialized) {
- // When COM is uninitialized, the TLS data will remain, but the apartment
- // status will be updated. This covers that case.
- {
- ScopedCOMInitializer com_initializer;
- ASSERT_TRUE(com_initializer.Succeeded());
- }
- AssertComApartmentType(ComApartmentType::NONE);
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::STA));
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::MTA));
-}
-
-TEST(ComInitUtil, AssertSTAApartmentType) {
- ScopedCOMInitializer com_initializer;
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::NONE));
- AssertComApartmentType(ComApartmentType::STA);
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::MTA));
-}
-
-TEST(ComInitUtil, AssertMTAApartmentType) {
- ScopedCOMInitializer com_initializer(ScopedCOMInitializer::kMTA);
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::NONE));
- EXPECT_DCHECK_DEATH(AssertComApartmentType(ComApartmentType::STA));
- AssertComApartmentType(ComApartmentType::MTA);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/core_winrt_util_unittest.cc b/base/win/core_winrt_util_unittest.cc
deleted file mode 100644
index 11d08b8..0000000
--- a/base/win/core_winrt_util_unittest.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2017 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 "base/win/core_winrt_util.h"
-
-#include "base/win/com_init_util.h"
-#include "base/win/scoped_com_initializer.h"
-#include "base/win/windows_version.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-TEST(CoreWinrtUtilTest, PreloadFunctions) {
- if (GetVersion() < VERSION_WIN8)
- EXPECT_FALSE(ResolveCoreWinRTDelayload());
- else
- EXPECT_TRUE(ResolveCoreWinRTDelayload());
-}
-
-TEST(CoreWinrtUtilTest, RoInitializeAndUninitialize) {
- if (GetVersion() < VERSION_WIN8)
- return;
-
- ASSERT_TRUE(ResolveCoreWinRTDelayload());
- ASSERT_HRESULT_SUCCEEDED(base::win::RoInitialize(RO_INIT_MULTITHREADED));
- AssertComApartmentType(ComApartmentType::MTA);
- base::win::RoUninitialize();
- AssertComApartmentType(ComApartmentType::NONE);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/enum_variant_unittest.cc b/base/win/enum_variant_unittest.cc
deleted file mode 100644
index 288c97e..0000000
--- a/base/win/enum_variant_unittest.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (c) 2011 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 "base/win/enum_variant.h"
-
-#include "base/win/scoped_com_initializer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-TEST(EnumVariantTest, EmptyEnumVariant) {
- ScopedCOMInitializer com_initializer;
-
- EnumVariant* ev = new EnumVariant(0);
- ev->AddRef();
-
- IUnknown* iunknown;
- EXPECT_TRUE(SUCCEEDED(
- ev->QueryInterface(IID_IUnknown, reinterpret_cast<void**>(&iunknown))));
- iunknown->Release();
-
- IEnumVARIANT* ienumvariant;
- EXPECT_TRUE(SUCCEEDED(
- ev->QueryInterface(IID_IEnumVARIANT,
- reinterpret_cast<void**>(&ienumvariant))));
- EXPECT_EQ(ev, ienumvariant);
- ienumvariant->Release();
-
- VARIANT out_element;
- ULONG out_received = 0;
- EXPECT_EQ(S_FALSE, ev->Next(1, &out_element, &out_received));
- EXPECT_EQ(0u, out_received);
-
- EXPECT_EQ(S_FALSE, ev->Skip(1));
-
- EXPECT_EQ(S_OK, ev->Reset());
-
- IEnumVARIANT* ev2 = NULL;
- EXPECT_EQ(S_OK, ev->Clone(&ev2));
-
- EXPECT_NE(static_cast<IEnumVARIANT*>(NULL), ev2);
- EXPECT_NE(ev, ev2);
- EXPECT_EQ(S_FALSE, ev2->Skip(1));
- EXPECT_EQ(S_OK, ev2->Reset());
-
- ULONG ev2_finalrefcount = ev2->Release();
- EXPECT_EQ(0u, ev2_finalrefcount);
-
- ULONG ev_finalrefcount = ev->Release();
- EXPECT_EQ(0u, ev_finalrefcount);
-}
-
-TEST(EnumVariantTest, SimpleEnumVariant) {
- ScopedCOMInitializer com_initializer;
-
- EnumVariant* ev = new EnumVariant(3);
- ev->AddRef();
- ev->ItemAt(0)->vt = VT_I4;
- ev->ItemAt(0)->lVal = 10;
- ev->ItemAt(1)->vt = VT_I4;
- ev->ItemAt(1)->lVal = 20;
- ev->ItemAt(2)->vt = VT_I4;
- ev->ItemAt(2)->lVal = 30;
-
- // Get elements one at a time.
- VARIANT out_element;
- ULONG out_received = 0;
- EXPECT_EQ(S_OK, ev->Next(1, &out_element, &out_received));
- EXPECT_EQ(1u, out_received);
- EXPECT_EQ(VT_I4, out_element.vt);
- EXPECT_EQ(10, out_element.lVal);
- EXPECT_EQ(S_OK, ev->Skip(1));
- EXPECT_EQ(S_OK, ev->Next(1, &out_element, &out_received));
- EXPECT_EQ(1u, out_received);
- EXPECT_EQ(VT_I4, out_element.vt);
- EXPECT_EQ(30, out_element.lVal);
- EXPECT_EQ(S_FALSE, ev->Next(1, &out_element, &out_received));
-
- // Reset and get all elements at once.
- VARIANT out_elements[3];
- EXPECT_EQ(S_OK, ev->Reset());
- EXPECT_EQ(S_OK, ev->Next(3, out_elements, &out_received));
- EXPECT_EQ(3u, out_received);
- EXPECT_EQ(VT_I4, out_elements[0].vt);
- EXPECT_EQ(10, out_elements[0].lVal);
- EXPECT_EQ(VT_I4, out_elements[1].vt);
- EXPECT_EQ(20, out_elements[1].lVal);
- EXPECT_EQ(VT_I4, out_elements[2].vt);
- EXPECT_EQ(30, out_elements[2].lVal);
- EXPECT_EQ(S_FALSE, ev->Next(1, &out_element, &out_received));
-
- // Clone it.
- IEnumVARIANT* ev2 = NULL;
- EXPECT_EQ(S_OK, ev->Clone(&ev2));
- EXPECT_TRUE(ev2 != NULL);
- EXPECT_EQ(S_FALSE, ev->Next(1, &out_element, &out_received));
- EXPECT_EQ(S_OK, ev2->Reset());
- EXPECT_EQ(S_OK, ev2->Next(3, out_elements, &out_received));
- EXPECT_EQ(3u, out_received);
- EXPECT_EQ(VT_I4, out_elements[0].vt);
- EXPECT_EQ(10, out_elements[0].lVal);
- EXPECT_EQ(VT_I4, out_elements[1].vt);
- EXPECT_EQ(20, out_elements[1].lVal);
- EXPECT_EQ(VT_I4, out_elements[2].vt);
- EXPECT_EQ(30, out_elements[2].lVal);
- EXPECT_EQ(S_FALSE, ev2->Next(1, &out_element, &out_received));
-
- ULONG ev2_finalrefcount = ev2->Release();
- EXPECT_EQ(0u, ev2_finalrefcount);
-
- ULONG ev_finalrefcount = ev->Release();
- EXPECT_EQ(0u, ev_finalrefcount);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/event_trace_consumer_unittest.cc b/base/win/event_trace_consumer_unittest.cc
deleted file mode 100644
index 9c4c242..0000000
--- a/base/win/event_trace_consumer_unittest.cc
+++ /dev/null
@@ -1,367 +0,0 @@
-// 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.
-//
-// Unit tests for event trace consumer base class.
-#include "base/win/event_trace_consumer.h"
-
-#include <list>
-
-#include <objbase.h>
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#include "base/strings/stringprintf.h"
-#include "base/win/event_trace_controller.h"
-#include "base/win/event_trace_provider.h"
-#include "base/win/scoped_handle.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#include <initguid.h> // NOLINT - has to be last
-
-namespace base {
-namespace win {
-
-namespace {
-
-typedef std::list<EVENT_TRACE> EventQueue;
-
-class TestConsumer: public EtwTraceConsumerBase<TestConsumer> {
- public:
- TestConsumer() {
- sank_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
- ClearQueue();
- }
-
- ~TestConsumer() {
- ClearQueue();
- sank_event_.Close();
- }
-
- void ClearQueue() {
- for (EventQueue::const_iterator it(events_.begin()), end(events_.end());
- it != end; ++it) {
- delete[] reinterpret_cast<char*>(it->MofData);
- }
-
- events_.clear();
- }
-
- static void EnqueueEvent(EVENT_TRACE* event) {
- events_.push_back(*event);
- EVENT_TRACE& back = events_.back();
-
- if (event->MofData != NULL && event->MofLength != 0) {
- back.MofData = new char[event->MofLength];
- memcpy(back.MofData, event->MofData, event->MofLength);
- }
- }
-
- static void ProcessEvent(EVENT_TRACE* event) {
- EnqueueEvent(event);
- ::SetEvent(sank_event_.Get());
- }
-
- static ScopedHandle sank_event_;
- static EventQueue events_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TestConsumer);
-};
-
-ScopedHandle TestConsumer::sank_event_;
-EventQueue TestConsumer::events_;
-
-class EtwTraceConsumerBaseTest: public testing::Test {
- public:
- EtwTraceConsumerBaseTest()
- : session_name_(StringPrintf(L"TestSession-%d", GetCurrentProcId())) {
- }
-
- void SetUp() override {
- // Cleanup any potentially dangling sessions.
- EtwTraceProperties ignore;
- EtwTraceController::Stop(session_name_.c_str(), &ignore);
-
- // Allocate a new GUID for each provider test.
- ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
- }
-
- void TearDown() override {
- // Cleanup any potentially dangling sessions.
- EtwTraceProperties ignore;
- EtwTraceController::Stop(session_name_.c_str(), &ignore);
- }
-
- protected:
- GUID test_provider_;
- std::wstring session_name_;
-};
-
-} // namespace
-
-TEST_F(EtwTraceConsumerBaseTest, Initialize) {
- TestConsumer consumer_;
-}
-
-TEST_F(EtwTraceConsumerBaseTest, OpenRealtimeSucceedsWhenNoSession) {
- TestConsumer consumer_;
- ASSERT_HRESULT_SUCCEEDED(
- consumer_.OpenRealtimeSession(session_name_.c_str()));
-}
-
-TEST_F(EtwTraceConsumerBaseTest, ConsumerImmediateFailureWhenNoSession) {
- TestConsumer consumer_;
- ASSERT_HRESULT_SUCCEEDED(
- consumer_.OpenRealtimeSession(session_name_.c_str()));
- ASSERT_HRESULT_FAILED(consumer_.Consume());
-}
-
-namespace {
-
-class EtwTraceConsumerRealtimeTest: public EtwTraceConsumerBaseTest {
- public:
- void SetUp() override {
- EtwTraceConsumerBaseTest::SetUp();
- ASSERT_HRESULT_SUCCEEDED(
- consumer_.OpenRealtimeSession(session_name_.c_str()));
- }
-
- void TearDown() override {
- consumer_.Close();
- EtwTraceConsumerBaseTest::TearDown();
- }
-
- DWORD ConsumerThread() {
- ::SetEvent(consumer_ready_.Get());
- return consumer_.Consume();
- }
-
- static DWORD WINAPI ConsumerThreadMainProc(void* arg) {
- return reinterpret_cast<EtwTraceConsumerRealtimeTest*>(arg)->
- ConsumerThread();
- }
-
- HRESULT StartConsumerThread() {
- consumer_ready_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
- EXPECT_TRUE(consumer_ready_.IsValid());
- consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc, this,
- 0, NULL));
- if (consumer_thread_.Get() == NULL)
- return HRESULT_FROM_WIN32(::GetLastError());
-
- HANDLE events[] = { consumer_ready_.Get(), consumer_thread_.Get() };
- DWORD result = ::WaitForMultipleObjects(arraysize(events), events,
- FALSE, INFINITE);
- switch (result) {
- case WAIT_OBJECT_0:
- // The event was set, the consumer_ is ready.
- return S_OK;
- case WAIT_OBJECT_0 + 1: {
- // The thread finished. This may race with the event, so check
- // explicitly for the event here, before concluding there's trouble.
- if (::WaitForSingleObject(consumer_ready_.Get(), 0) == WAIT_OBJECT_0)
- return S_OK;
- DWORD exit_code = 0;
- if (::GetExitCodeThread(consumer_thread_.Get(), &exit_code))
- return exit_code;
- return HRESULT_FROM_WIN32(::GetLastError());
- }
- default:
- return E_UNEXPECTED;
- }
- }
-
- // Waits for consumer_ thread to exit, and returns its exit code.
- HRESULT JoinConsumerThread() {
- if (::WaitForSingleObject(consumer_thread_.Get(), INFINITE) !=
- WAIT_OBJECT_0) {
- return HRESULT_FROM_WIN32(::GetLastError());
- }
-
- DWORD exit_code = 0;
- if (::GetExitCodeThread(consumer_thread_.Get(), &exit_code))
- return exit_code;
-
- return HRESULT_FROM_WIN32(::GetLastError());
- }
-
- TestConsumer consumer_;
- ScopedHandle consumer_ready_;
- ScopedHandle consumer_thread_;
-};
-
-} // namespace
-
-TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) {
- EtwTraceController controller;
- if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
- E_ACCESSDENIED) {
- VLOG(1) << "You must be an administrator to run this test on Vista";
- return;
- }
-
- // Start the consumer_.
- ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
-
- // Wait around for the consumer_ thread a bit.
- ASSERT_EQ(static_cast<DWORD>(WAIT_TIMEOUT),
- ::WaitForSingleObject(consumer_thread_.Get(), 50));
- ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
-
- // The consumer_ returns success on session stop.
- ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
-}
-
-namespace {
-
-// {57E47923-A549-476f-86CA-503D57F59E62}
-DEFINE_GUID(
- kTestEventType,
- 0x57e47923, 0xa549, 0x476f, 0x86, 0xca, 0x50, 0x3d, 0x57, 0xf5, 0x9e, 0x62);
-
-} // namespace
-
-TEST_F(EtwTraceConsumerRealtimeTest, ConsumeEvent) {
- EtwTraceController controller;
- if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
- E_ACCESSDENIED) {
- VLOG(1) << "You must be an administrator to run this test on Vista";
- return;
- }
-
- ASSERT_HRESULT_SUCCEEDED(controller.EnableProvider(
- test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
-
- EtwTraceProvider provider(test_provider_);
- ASSERT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Register());
-
- // Start the consumer_.
- ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
- ASSERT_EQ(0u, TestConsumer::events_.size());
-
- EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
- EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Log(&event.header));
- EXPECT_EQ(WAIT_OBJECT_0,
- ::WaitForSingleObject(TestConsumer::sank_event_.Get(), INFINITE));
- ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
- ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
- ASSERT_NE(0u, TestConsumer::events_.size());
-}
-
-namespace {
-
-// We run events through a file session to assert that
-// the content comes through.
-class EtwTraceConsumerDataTest: public EtwTraceConsumerBaseTest {
- public:
- EtwTraceConsumerDataTest() {
- }
-
- void SetUp() override {
- EtwTraceConsumerBaseTest::SetUp();
-
- EtwTraceProperties prop;
- EtwTraceController::Stop(session_name_.c_str(), &prop);
-
- // Create a temp dir for this test.
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- // Construct a temp file name in our dir.
- temp_file_ = temp_dir_.GetPath().Append(L"test.etl");
- }
-
- void TearDown() override {
- EXPECT_TRUE(base::DeleteFile(temp_file_, false));
-
- EtwTraceConsumerBaseTest::TearDown();
- }
-
- HRESULT LogEventToTempSession(PEVENT_TRACE_HEADER header) {
- EtwTraceController controller;
-
- // Set up a file session.
- HRESULT hr = controller.StartFileSession(session_name_.c_str(),
- temp_file_.value().c_str());
- if (FAILED(hr))
- return hr;
-
- // Enable our provider.
- EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(
- test_provider_, TRACE_LEVEL_VERBOSE, 0xFFFFFFFF));
-
- EtwTraceProvider provider(test_provider_);
- // Then register our provider, means we get a session handle immediately.
- EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Register());
- // Trace the event, it goes to the temp file.
- EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Log(header));
- EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
- EXPECT_HRESULT_SUCCEEDED(provider.Unregister());
- EXPECT_HRESULT_SUCCEEDED(controller.Flush(NULL));
- EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
-
- return S_OK;
- }
-
- HRESULT ConsumeEventFromTempSession() {
- // Now consume the event(s).
- TestConsumer consumer_;
- HRESULT hr = consumer_.OpenFileSession(temp_file_.value().c_str());
- if (SUCCEEDED(hr))
- hr = consumer_.Consume();
- consumer_.Close();
- // And nab the result.
- events_.swap(TestConsumer::events_);
- return hr;
- }
-
- HRESULT RoundTripEvent(PEVENT_TRACE_HEADER header, PEVENT_TRACE* trace) {
- base::DeleteFile(temp_file_, false);
-
- HRESULT hr = LogEventToTempSession(header);
- if (SUCCEEDED(hr))
- hr = ConsumeEventFromTempSession();
-
- if (FAILED(hr))
- return hr;
-
- // We should now have the event in the queue.
- if (events_.empty())
- return E_FAIL;
-
- *trace = &events_.back();
- return S_OK;
- }
-
- EventQueue events_;
- ScopedTempDir temp_dir_;
- FilePath temp_file_;
-};
-
-} // namespace
-
-
-TEST_F(EtwTraceConsumerDataTest, RoundTrip) {
- EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
-
- static const char kData[] = "This is but test data";
- event.fields[0].DataPtr = reinterpret_cast<ULONG64>(kData);
- event.fields[0].Length = sizeof(kData);
-
- PEVENT_TRACE trace = NULL;
- HRESULT hr = RoundTripEvent(&event.header, &trace);
- if (hr == E_ACCESSDENIED) {
- VLOG(1) << "You must be an administrator to run this test on Vista";
- return;
- }
- ASSERT_HRESULT_SUCCEEDED(hr) << "RoundTripEvent failed";
- ASSERT_TRUE(trace != NULL);
- ASSERT_EQ(sizeof(kData), trace->MofLength);
- ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData));
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/event_trace_controller_unittest.cc b/base/win/event_trace_controller_unittest.cc
deleted file mode 100644
index f19ee31..0000000
--- a/base/win/event_trace_controller_unittest.cc
+++ /dev/null
@@ -1,244 +0,0 @@
-// 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.
-//
-// Unit tests for event trace controller.
-
-#include <objbase.h>
-#include <initguid.h>
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#include "base/strings/stringprintf.h"
-#include "base/sys_info.h"
-#include "base/win/event_trace_controller.h"
-#include "base/win/event_trace_provider.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/windows_version.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-DEFINE_GUID(kGuidNull,
- 0x0000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0);
-
-const ULONG kTestProviderFlags = 0xCAFEBABE;
-
-class TestingProvider: public EtwTraceProvider {
- public:
- explicit TestingProvider(const GUID& provider_name)
- : EtwTraceProvider(provider_name) {
- callback_event_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
- }
-
- void WaitForCallback() {
- ::WaitForSingleObject(callback_event_.Get(), INFINITE);
- ::ResetEvent(callback_event_.Get());
- }
-
- private:
- void OnEventsEnabled() override { ::SetEvent(callback_event_.Get()); }
- void PostEventsDisabled() override { ::SetEvent(callback_event_.Get()); }
-
- ScopedHandle callback_event_;
-
- DISALLOW_COPY_AND_ASSIGN(TestingProvider);
-};
-
-} // namespace
-
-TEST(EtwTracePropertiesTest, Initialization) {
- EtwTraceProperties prop;
-
- EVENT_TRACE_PROPERTIES* p = prop.get();
- EXPECT_NE(0u, p->Wnode.BufferSize);
- EXPECT_EQ(0u, p->Wnode.ProviderId);
- EXPECT_EQ(0u, p->Wnode.HistoricalContext);
-
- EXPECT_TRUE(kGuidNull == p->Wnode.Guid);
- EXPECT_EQ(0u, p->Wnode.ClientContext);
- EXPECT_EQ(static_cast<ULONG>(WNODE_FLAG_TRACED_GUID), p->Wnode.Flags);
-
- EXPECT_EQ(0u, p->BufferSize);
- EXPECT_EQ(0u, p->MinimumBuffers);
- EXPECT_EQ(0u, p->MaximumBuffers);
- EXPECT_EQ(0u, p->MaximumFileSize);
- EXPECT_EQ(0u, p->LogFileMode);
- EXPECT_EQ(0u, p->FlushTimer);
- EXPECT_EQ(0u, p->EnableFlags);
- EXPECT_EQ(0, p->AgeLimit);
-
- EXPECT_EQ(0u, p->NumberOfBuffers);
- EXPECT_EQ(0u, p->FreeBuffers);
- EXPECT_EQ(0u, p->EventsLost);
- EXPECT_EQ(0u, p->BuffersWritten);
- EXPECT_EQ(0u, p->LogBuffersLost);
- EXPECT_EQ(0u, p->RealTimeBuffersLost);
- EXPECT_EQ(0u, p->LoggerThreadId);
- EXPECT_NE(0u, p->LogFileNameOffset);
- EXPECT_NE(0u, p->LoggerNameOffset);
-}
-
-TEST(EtwTracePropertiesTest, Strings) {
- EtwTraceProperties prop;
-
- ASSERT_STREQ(L"", prop.GetLoggerFileName());
- ASSERT_STREQ(L"", prop.GetLoggerName());
-
- std::wstring name(1023, L'A');
- ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerFileName(name.c_str()));
- ASSERT_HRESULT_SUCCEEDED(prop.SetLoggerName(name.c_str()));
- ASSERT_STREQ(name.c_str(), prop.GetLoggerFileName());
- ASSERT_STREQ(name.c_str(), prop.GetLoggerName());
-
- std::wstring name2(1024, L'A');
- ASSERT_HRESULT_FAILED(prop.SetLoggerFileName(name2.c_str()));
- ASSERT_HRESULT_FAILED(prop.SetLoggerName(name2.c_str()));
-}
-
-namespace {
-
-class EtwTraceControllerTest : public testing::Test {
- public:
- EtwTraceControllerTest()
- : session_name_(StringPrintf(L"TestSession-%d", GetCurrentProcId())) {
- }
-
- void SetUp() override {
- EtwTraceProperties ignore;
- EtwTraceController::Stop(session_name_.c_str(), &ignore);
-
- // Allocate a new provider name GUID for each test.
- ASSERT_HRESULT_SUCCEEDED(::CoCreateGuid(&test_provider_));
- }
-
- void TearDown() override {
- EtwTraceProperties prop;
- EtwTraceController::Stop(session_name_.c_str(), &prop);
- }
-
- protected:
- GUID test_provider_;
- std::wstring session_name_;
-};
-
-} // namespace
-
-TEST_F(EtwTraceControllerTest, Initialize) {
- EtwTraceController controller;
-
- EXPECT_EQ(0u, controller.session());
- EXPECT_STREQ(L"", controller.session_name());
-}
-
-
-TEST_F(EtwTraceControllerTest, StartRealTimeSession) {
- EtwTraceController controller;
-
- HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
- 100 * 1024);
- if (hr == E_ACCESSDENIED) {
- VLOG(1) << "You must be an administrator to run this test on Vista";
- return;
- }
-
- EXPECT_NE(0u, controller.session());
- EXPECT_STREQ(session_name_.c_str(), controller.session_name());
-
- EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
- EXPECT_EQ(0u, controller.session());
- EXPECT_STREQ(L"", controller.session_name());
-}
-
-TEST_F(EtwTraceControllerTest, StartFileSession) {
- ScopedTempDir temp_dir;
- ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- FilePath temp;
- ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.GetPath(), &temp));
-
- EtwTraceController controller;
- HRESULT hr = controller.StartFileSession(session_name_.c_str(),
- temp.value().c_str());
- if (hr == E_ACCESSDENIED) {
- VLOG(1) << "You must be an administrator to run this test on Vista";
- base::DeleteFile(temp, false);
- return;
- }
-
- EXPECT_NE(0u, controller.session());
- EXPECT_STREQ(session_name_.c_str(), controller.session_name());
-
- EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
- EXPECT_EQ(0u, controller.session());
- EXPECT_STREQ(L"", controller.session_name());
- base::DeleteFile(temp, false);
-}
-
-// This test is flaky for unclear reasons. See bugs 525297 and 534184
-TEST_F(EtwTraceControllerTest, DISABLED_EnableDisable) {
- TestingProvider provider(test_provider_);
-
- EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Register());
- EXPECT_EQ(0u, provider.session_handle());
-
- EtwTraceController controller;
- HRESULT hr = controller.StartRealtimeSession(session_name_.c_str(),
- 100 * 1024);
- if (hr == E_ACCESSDENIED) {
- VLOG(1) << "You must be an administrator to run this test on Vista";
- return;
- }
-
- EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
- TRACE_LEVEL_VERBOSE, kTestProviderFlags));
-
- provider.WaitForCallback();
-
- EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
- EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
-
- EXPECT_HRESULT_SUCCEEDED(controller.DisableProvider(test_provider_));
-
- provider.WaitForCallback();
-
- EXPECT_EQ(0, provider.enable_level());
- EXPECT_EQ(0u, provider.enable_flags());
-
- EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Unregister());
-
- // Enable the provider again, before registering.
- EXPECT_HRESULT_SUCCEEDED(controller.EnableProvider(test_provider_,
- TRACE_LEVEL_VERBOSE, kTestProviderFlags));
-
- // Register the provider again, the settings above
- // should take immediate effect.
- EXPECT_EQ(static_cast<DWORD>(ERROR_SUCCESS), provider.Register());
-
- EXPECT_EQ(TRACE_LEVEL_VERBOSE, provider.enable_level());
- EXPECT_EQ(kTestProviderFlags, provider.enable_flags());
-
- // Consume the callback event of the previous controller.EnableProvider().
- provider.WaitForCallback();
-
- EXPECT_HRESULT_SUCCEEDED(controller.Stop(NULL));
-
- // Windows 7 does not call the callback when Stop() is called so we
- // can't wait, and enable_level and enable_flags are not zeroed.
- if (base::win::GetVersion() >= VERSION_WIN8) {
- provider.WaitForCallback();
-
- // Session should have wound down.
- EXPECT_EQ(0, provider.enable_level());
- EXPECT_EQ(0u, provider.enable_flags());
- }
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/event_trace_provider_unittest.cc b/base/win/event_trace_provider_unittest.cc
deleted file mode 100644
index 7d57773..0000000
--- a/base/win/event_trace_provider_unittest.cc
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright (c) 2010 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.
-//
-// Unit tests for event trace provider.
-#include "base/win/event_trace_provider.h"
-#include <new>
-#include "testing/gtest/include/gtest/gtest.h"
-#include <initguid.h> // NOLINT - has to be last
-
-namespace {
-
-using base::win::EtwTraceProvider;
-using base::win::EtwMofEvent;
-
-// {7F0FD37F-FA3C-4cd6-9242-DF60967A2CB2}
-DEFINE_GUID(kTestProvider,
- 0x7f0fd37f, 0xfa3c, 0x4cd6, 0x92, 0x42, 0xdf, 0x60, 0x96, 0x7a, 0x2c, 0xb2);
-
-// {7F0FD37F-FA3C-4cd6-9242-DF60967A2CB2}
-DEFINE_GUID(kTestEventClass,
- 0x7f0fd37f, 0xfa3c, 0x4cd6, 0x92, 0x42, 0xdf, 0x60, 0x96, 0x7a, 0x2c, 0xb2);
-
-} // namespace
-
-TEST(EtwTraceProviderTest, ToleratesPreCreateInvocations) {
- // Because the trace provider is used in logging, it's important that
- // it be possible to use static provider instances without regard to
- // whether they've been constructed or destructed.
- // The interface of the class is designed to tolerate this usage.
- char buf[sizeof(EtwTraceProvider)] = {0};
- EtwTraceProvider& provider = reinterpret_cast<EtwTraceProvider&>(buf);
-
- EXPECT_EQ(0u, provider.registration_handle());
- EXPECT_EQ(0u, provider.session_handle());
- EXPECT_EQ(0u, provider.enable_flags());
- EXPECT_EQ(0u, provider.enable_level());
-
- EXPECT_FALSE(provider.ShouldLog(TRACE_LEVEL_FATAL, 0xfffffff));
-
- // We expect these not to crash.
- provider.Log(kTestEventClass, 0, TRACE_LEVEL_FATAL, "foo");
- provider.Log(kTestEventClass, 0, TRACE_LEVEL_FATAL, L"foo");
-
- EtwMofEvent<1> dummy(kTestEventClass, 0, TRACE_LEVEL_FATAL);
- DWORD data = 0;
- dummy.SetField(0, sizeof(data), &data);
- provider.Log(dummy.get());
-
- // Placement-new the provider into our buffer.
- new (buf) EtwTraceProvider(kTestProvider);
-
- // Registration is now safe.
- EXPECT_EQ(static_cast<ULONG>(ERROR_SUCCESS), provider.Register());
-
- // Destruct the instance, this should unregister it.
- provider.EtwTraceProvider::~EtwTraceProvider();
-
- // And post-destruction, all of the above should still be safe.
- EXPECT_EQ(0u, provider.registration_handle());
- EXPECT_EQ(0u, provider.session_handle());
- EXPECT_EQ(0u, provider.enable_flags());
- EXPECT_EQ(0u, provider.enable_level());
-
- EXPECT_FALSE(provider.ShouldLog(TRACE_LEVEL_FATAL, 0xfffffff));
-
- // We expect these not to crash.
- provider.Log(kTestEventClass, 0, TRACE_LEVEL_FATAL, "foo");
- provider.Log(kTestEventClass, 0, TRACE_LEVEL_FATAL, L"foo");
- provider.Log(dummy.get());
-}
-
-TEST(EtwTraceProviderTest, Initialize) {
- EtwTraceProvider provider(kTestProvider);
-
- EXPECT_EQ(0u, provider.registration_handle());
- EXPECT_EQ(0u, provider.session_handle());
- EXPECT_EQ(0u, provider.enable_flags());
- EXPECT_EQ(0u, provider.enable_level());
-}
-
-TEST(EtwTraceProviderTest, Register) {
- EtwTraceProvider provider(kTestProvider);
-
- ASSERT_EQ(static_cast<ULONG>(ERROR_SUCCESS), provider.Register());
- EXPECT_NE(0u, provider.registration_handle());
- ASSERT_EQ(static_cast<ULONG>(ERROR_SUCCESS), provider.Unregister());
- EXPECT_EQ(0u, provider.registration_handle());
-}
-
-TEST(EtwTraceProviderTest, RegisterWithNoNameFails) {
- EtwTraceProvider provider;
-
- EXPECT_TRUE(provider.Register() != ERROR_SUCCESS);
-}
-
-TEST(EtwTraceProviderTest, Enable) {
- EtwTraceProvider provider(kTestProvider);
-
- ASSERT_EQ(static_cast<ULONG>(ERROR_SUCCESS), provider.Register());
- EXPECT_NE(0u, provider.registration_handle());
-
- // No session so far.
- EXPECT_EQ(0u, provider.session_handle());
- EXPECT_EQ(0u, provider.enable_flags());
- EXPECT_EQ(0u, provider.enable_level());
-
- ASSERT_EQ(static_cast<ULONG>(ERROR_SUCCESS), provider.Unregister());
- EXPECT_EQ(0u, provider.registration_handle());
-}
diff --git a/base/win/i18n_unittest.cc b/base/win/i18n_unittest.cc
deleted file mode 100644
index 9af6dbf..0000000
--- a/base/win/i18n_unittest.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2010 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 file contains unit tests for Windows internationalization funcs.
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-#include <stddef.h>
-
-#include "base/win/i18n.h"
-#include "base/win/windows_version.h"
-
-namespace base {
-namespace win {
-namespace i18n {
-
-// Tests that at least one user preferred UI language can be obtained.
-TEST(I18NTest, GetUserPreferredUILanguageList) {
- std::vector<std::wstring> languages;
- EXPECT_TRUE(GetUserPreferredUILanguageList(&languages));
- EXPECT_NE(static_cast<std::vector<std::wstring>::size_type>(0),
- languages.size());
- for (std::vector<std::wstring>::const_iterator scan = languages.begin(),
- end = languages.end(); scan != end; ++scan) {
- EXPECT_FALSE((*scan).empty());
- }
-}
-
-// Tests that at least one thread preferred UI language can be obtained.
-TEST(I18NTest, GetThreadPreferredUILanguageList) {
- std::vector<std::wstring> languages;
- EXPECT_TRUE(GetThreadPreferredUILanguageList(&languages));
- EXPECT_NE(static_cast<std::vector<std::wstring>::size_type>(0),
- languages.size());
- for (std::vector<std::wstring>::const_iterator scan = languages.begin(),
- end = languages.end(); scan != end; ++scan) {
- EXPECT_FALSE((*scan).empty());
- }
-}
-
-} // namespace i18n
-} // namespace win
-} // namespace base
diff --git a/base/win/iunknown_impl_unittest.cc b/base/win/iunknown_impl_unittest.cc
deleted file mode 100644
index c6c3539..0000000
--- a/base/win/iunknown_impl_unittest.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (c) 2011 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 "base/win/iunknown_impl.h"
-
-#include "base/win/scoped_com_initializer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-class TestIUnknownImplSubclass : public IUnknownImpl {
- public:
- TestIUnknownImplSubclass() {
- ++instance_count;
- }
- ~TestIUnknownImplSubclass() override { --instance_count; }
- static int instance_count;
-};
-
-// static
-int TestIUnknownImplSubclass::instance_count = 0;
-
-TEST(IUnknownImplTest, IUnknownImpl) {
- ScopedCOMInitializer com_initializer;
-
- EXPECT_EQ(0, TestIUnknownImplSubclass::instance_count);
- IUnknown* u = new TestIUnknownImplSubclass();
-
- EXPECT_EQ(1, TestIUnknownImplSubclass::instance_count);
-
- EXPECT_EQ(1u, u->AddRef());
- EXPECT_EQ(1u, u->AddRef());
-
- IUnknown* other = NULL;
- EXPECT_EQ(E_NOINTERFACE, u->QueryInterface(
- IID_IDispatch, reinterpret_cast<void**>(&other)));
- EXPECT_EQ(S_OK, u->QueryInterface(
- IID_IUnknown, reinterpret_cast<void**>(&other)));
- other->Release();
-
- EXPECT_EQ(1u, u->Release());
- EXPECT_EQ(0u, u->Release());
- EXPECT_EQ(0, TestIUnknownImplSubclass::instance_count);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/message_window_unittest.cc b/base/win/message_window_unittest.cc
deleted file mode 100644
index 00248bf..0000000
--- a/base/win/message_window_unittest.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 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 "base/bind.h"
-#include "base/guid.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/win/message_window.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-namespace {
-
-bool HandleMessage(
- UINT message, WPARAM wparam, LPARAM lparam, LRESULT* result) {
- // Return |wparam| as the result of WM_USER message.
- if (message == WM_USER) {
- *result = wparam;
- return true;
- }
-
- return false;
-}
-
-} // namespace
-
-// Checks that a window can be created.
-TEST(MessageWindowTest, Create) {
- win::MessageWindow window;
- EXPECT_TRUE(window.Create(base::Bind(&HandleMessage)));
-}
-
-// Checks that a named window can be created.
-TEST(MessageWindowTest, CreateNamed) {
- win::MessageWindow window;
- EXPECT_TRUE(window.CreateNamed(base::Bind(&HandleMessage),
- UTF8ToUTF16("test_message_window")));
-}
-
-// Verifies that the created window can receive messages.
-TEST(MessageWindowTest, SendMessage) {
- win::MessageWindow window;
- EXPECT_TRUE(window.Create(base::Bind(&HandleMessage)));
-
- EXPECT_EQ(SendMessage(window.hwnd(), WM_USER, 100, 0), 100);
-}
-
-// Verifies that a named window can be found by name.
-TEST(MessageWindowTest, FindWindow) {
- string16 name = UTF8ToUTF16(base::GenerateGUID());
- win::MessageWindow window;
- EXPECT_TRUE(window.CreateNamed(base::Bind(&HandleMessage), name));
-
- HWND hwnd = win::MessageWindow::FindWindow(name);
- EXPECT_TRUE(hwnd != NULL);
- EXPECT_EQ(SendMessage(hwnd, WM_USER, 200, 0), 200);
-}
-
-} // namespace base
diff --git a/base/win/object_watcher_unittest.cc b/base/win/object_watcher_unittest.cc
deleted file mode 100644
index 5aa3891..0000000
--- a/base/win/object_watcher_unittest.cc
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright (c) 2011 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 "base/win/object_watcher.h"
-
-#include <process.h>
-
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-class QuitDelegate : public ObjectWatcher::Delegate {
- public:
- void OnObjectSignaled(HANDLE object) override {
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
-};
-
-class DecrementCountDelegate : public ObjectWatcher::Delegate {
- public:
- explicit DecrementCountDelegate(int* counter) : counter_(counter) {
- }
- void OnObjectSignaled(HANDLE object) override { --(*counter_); }
-
- private:
- int* counter_;
-};
-
-void RunTest_BasicSignal(MessageLoop::Type message_loop_type) {
- MessageLoop message_loop(message_loop_type);
-
- ObjectWatcher watcher;
- EXPECT_FALSE(watcher.IsWatching());
-
- // A manual-reset event that is not yet signaled.
- HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);
-
- QuitDelegate delegate;
- bool ok = watcher.StartWatchingOnce(event, &delegate);
- EXPECT_TRUE(ok);
- EXPECT_TRUE(watcher.IsWatching());
- EXPECT_EQ(event, watcher.GetWatchedObject());
-
- SetEvent(event);
-
- RunLoop().Run();
-
- EXPECT_FALSE(watcher.IsWatching());
- CloseHandle(event);
-}
-
-void RunTest_BasicCancel(MessageLoop::Type message_loop_type) {
- MessageLoop message_loop(message_loop_type);
-
- ObjectWatcher watcher;
-
- // A manual-reset event that is not yet signaled.
- HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);
-
- QuitDelegate delegate;
- bool ok = watcher.StartWatchingOnce(event, &delegate);
- EXPECT_TRUE(ok);
-
- watcher.StopWatching();
-
- CloseHandle(event);
-}
-
-void RunTest_CancelAfterSet(MessageLoop::Type message_loop_type) {
- MessageLoop message_loop(message_loop_type);
-
- ObjectWatcher watcher;
-
- int counter = 1;
- DecrementCountDelegate delegate(&counter);
-
- // A manual-reset event that is not yet signaled.
- HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL);
-
- bool ok = watcher.StartWatchingOnce(event, &delegate);
- EXPECT_TRUE(ok);
-
- SetEvent(event);
-
- // Let the background thread do its business
- Sleep(30);
-
- watcher.StopWatching();
-
- RunLoop().RunUntilIdle();
-
- // Our delegate should not have fired.
- EXPECT_EQ(1, counter);
-
- CloseHandle(event);
-}
-
-void RunTest_SignalBeforeWatch(MessageLoop::Type message_loop_type) {
- MessageLoop message_loop(message_loop_type);
-
- ObjectWatcher watcher;
-
- // A manual-reset event that is signaled before we begin watching.
- HANDLE event = CreateEvent(NULL, TRUE, TRUE, NULL);
-
- QuitDelegate delegate;
- bool ok = watcher.StartWatchingOnce(event, &delegate);
- EXPECT_TRUE(ok);
-
- RunLoop().Run();
-
- EXPECT_FALSE(watcher.IsWatching());
- CloseHandle(event);
-}
-
-void RunTest_OutlivesMessageLoop(MessageLoop::Type message_loop_type) {
- // Simulate a MessageLoop that dies before an ObjectWatcher. This ordinarily
- // doesn't happen when people use the Thread class, but it can happen when
- // people use the Singleton pattern or atexit.
- HANDLE event = CreateEvent(NULL, TRUE, FALSE, NULL); // not signaled
- {
- ObjectWatcher watcher;
- {
- MessageLoop message_loop(message_loop_type);
-
- QuitDelegate delegate;
- watcher.StartWatchingOnce(event, &delegate);
- }
- }
- CloseHandle(event);
-}
-
-class QuitAfterMultipleDelegate : public ObjectWatcher::Delegate {
- public:
- QuitAfterMultipleDelegate(HANDLE event, int iterations)
- : event_(event), iterations_(iterations) {}
- void OnObjectSignaled(HANDLE object) override {
- if (--iterations_) {
- SetEvent(event_);
- } else {
- RunLoop::QuitCurrentWhenIdleDeprecated();
- }
- }
-
- private:
- HANDLE event_;
- int iterations_;
-};
-
-void RunTest_ExecuteMultipleTimes(MessageLoop::Type message_loop_type) {
- MessageLoop message_loop(message_loop_type);
-
- ObjectWatcher watcher;
- EXPECT_FALSE(watcher.IsWatching());
-
- // An auto-reset event that is not yet signaled.
- HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
-
- QuitAfterMultipleDelegate delegate(event, 2);
- bool ok = watcher.StartWatchingMultipleTimes(event, &delegate);
- EXPECT_TRUE(ok);
- EXPECT_TRUE(watcher.IsWatching());
- EXPECT_EQ(event, watcher.GetWatchedObject());
-
- SetEvent(event);
-
- RunLoop().Run();
-
- EXPECT_TRUE(watcher.IsWatching());
- EXPECT_TRUE(watcher.StopWatching());
- CloseHandle(event);
-}
-
-} // namespace
-
-//-----------------------------------------------------------------------------
-
-TEST(ObjectWatcherTest, BasicSignal) {
- RunTest_BasicSignal(MessageLoop::TYPE_DEFAULT);
- RunTest_BasicSignal(MessageLoop::TYPE_IO);
- RunTest_BasicSignal(MessageLoop::TYPE_UI);
-}
-
-TEST(ObjectWatcherTest, BasicCancel) {
- RunTest_BasicCancel(MessageLoop::TYPE_DEFAULT);
- RunTest_BasicCancel(MessageLoop::TYPE_IO);
- RunTest_BasicCancel(MessageLoop::TYPE_UI);
-}
-
-TEST(ObjectWatcherTest, CancelAfterSet) {
- RunTest_CancelAfterSet(MessageLoop::TYPE_DEFAULT);
- RunTest_CancelAfterSet(MessageLoop::TYPE_IO);
- RunTest_CancelAfterSet(MessageLoop::TYPE_UI);
-}
-
-TEST(ObjectWatcherTest, SignalBeforeWatch) {
- RunTest_SignalBeforeWatch(MessageLoop::TYPE_DEFAULT);
- RunTest_SignalBeforeWatch(MessageLoop::TYPE_IO);
- RunTest_SignalBeforeWatch(MessageLoop::TYPE_UI);
-}
-
-TEST(ObjectWatcherTest, OutlivesMessageLoop) {
- RunTest_OutlivesMessageLoop(MessageLoop::TYPE_DEFAULT);
- RunTest_OutlivesMessageLoop(MessageLoop::TYPE_IO);
- RunTest_OutlivesMessageLoop(MessageLoop::TYPE_UI);
-}
-
-TEST(ObjectWatcherTest, ExecuteMultipleTimes) {
- RunTest_ExecuteMultipleTimes(MessageLoop::TYPE_DEFAULT);
- RunTest_ExecuteMultipleTimes(MessageLoop::TYPE_IO);
- RunTest_ExecuteMultipleTimes(MessageLoop::TYPE_UI);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/pe_image_unittest.cc b/base/win/pe_image_unittest.cc
deleted file mode 100644
index 2216449..0000000
--- a/base/win/pe_image_unittest.cc
+++ /dev/null
@@ -1,225 +0,0 @@
-// 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 file contains unit tests for PEImage.
-#include <algorithm>
-#include <vector>
-
-#include "base/files/file_path.h"
-#include "base/path_service.h"
-#include "base/scoped_native_library.h"
-#include "base/win/pe_image.h"
-#include "build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-// Just counts the number of invocations.
-bool ImportsCallback(const PEImage& image,
- LPCSTR module,
- DWORD ordinal,
- LPCSTR name,
- DWORD hint,
- PIMAGE_THUNK_DATA iat,
- PVOID cookie) {
- int* count = reinterpret_cast<int*>(cookie);
- (*count)++;
- return true;
-}
-
-// Just counts the number of invocations.
-bool SectionsCallback(const PEImage& image,
- PIMAGE_SECTION_HEADER header,
- PVOID section_start,
- DWORD section_size,
- PVOID cookie) {
- int* count = reinterpret_cast<int*>(cookie);
- (*count)++;
- return true;
-}
-
-// Just counts the number of invocations.
-bool RelocsCallback(const PEImage& image,
- WORD type,
- PVOID address,
- PVOID cookie) {
- int* count = reinterpret_cast<int*>(cookie);
- (*count)++;
- return true;
-}
-
-// Just counts the number of invocations.
-bool ImportChunksCallback(const PEImage& image,
- LPCSTR module,
- PIMAGE_THUNK_DATA name_table,
- PIMAGE_THUNK_DATA iat,
- PVOID cookie) {
- int* count = reinterpret_cast<int*>(cookie);
- (*count)++;
- return true;
-}
-
-// Just counts the number of invocations.
-bool DelayImportChunksCallback(const PEImage& image,
- PImgDelayDescr delay_descriptor,
- LPCSTR module,
- PIMAGE_THUNK_DATA name_table,
- PIMAGE_THUNK_DATA iat,
- PVOID cookie) {
- int* count = reinterpret_cast<int*>(cookie);
- (*count)++;
- return true;
-}
-
-// Just counts the number of invocations.
-bool ExportsCallback(const PEImage& image,
- DWORD ordinal,
- DWORD hint,
- LPCSTR name,
- PVOID function,
- LPCSTR forward,
- PVOID cookie) {
- int* count = reinterpret_cast<int*>(cookie);
- (*count)++;
- return true;
-}
-
-} // namespace
-
-// Tests that we are able to enumerate stuff from a PE file, and that
-// the actual number of items found matches an expected value.
-TEST(PEImageTest, EnumeratesPE) {
- base::FilePath pe_image_test_path;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &pe_image_test_path));
- pe_image_test_path = pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image"));
-
-#if defined(ARCH_CPU_64_BITS)
- pe_image_test_path =
- pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image_test_64.dll"));
- const int sections = 6;
- const int imports_dlls = 2;
- const int delay_dlls = 2;
- const int exports = 3;
- const int imports = 70;
- const int delay_imports = 2;
- const int relocs = 976;
-#else
- pe_image_test_path =
- pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image_test_32.dll"));
- const int sections = 5;
- const int imports_dlls = 2;
- const int delay_dlls = 2;
- const int exports = 3;
- const int imports = 66;
- const int delay_imports = 2;
- const int relocs = 2114;
-#endif
-
- ScopedNativeLibrary module(pe_image_test_path);
- ASSERT_TRUE(module.is_valid());
-
- PEImage pe(module.get());
- int count = 0;
- EXPECT_TRUE(pe.VerifyMagic());
-
- pe.EnumSections(SectionsCallback, &count);
- EXPECT_EQ(sections, count);
-
- count = 0;
- pe.EnumImportChunks(ImportChunksCallback, &count);
- EXPECT_EQ(imports_dlls, count);
-
- count = 0;
- pe.EnumDelayImportChunks(DelayImportChunksCallback, &count);
- EXPECT_EQ(delay_dlls, count);
-
- count = 0;
- pe.EnumExports(ExportsCallback, &count);
- EXPECT_EQ(exports, count);
-
- count = 0;
- pe.EnumAllImports(ImportsCallback, &count);
- EXPECT_EQ(imports, count);
-
- count = 0;
- pe.EnumAllDelayImports(ImportsCallback, &count);
- EXPECT_EQ(delay_imports, count);
-
- count = 0;
- pe.EnumRelocs(RelocsCallback, &count);
- EXPECT_EQ(relocs, count);
-}
-
-// Tests that we can locate an specific exported symbol, by name and by ordinal.
-TEST(PEImageTest, RetrievesExports) {
- ScopedNativeLibrary module(FilePath(L"advapi32.dll"));
- ASSERT_TRUE(module.is_valid());
-
- PEImage pe(module.get());
- WORD ordinal;
-
- EXPECT_TRUE(pe.GetProcOrdinal("RegEnumKeyExW", &ordinal));
-
- FARPROC address1 = pe.GetProcAddress("RegEnumKeyExW");
- FARPROC address2 = pe.GetProcAddress(reinterpret_cast<char*>(ordinal));
- EXPECT_TRUE(address1 != NULL);
- EXPECT_TRUE(address2 != NULL);
- EXPECT_TRUE(address1 == address2);
-}
-
-// Tests that we can locate a forwarded export.
-TEST(PEImageTest, ForwardedExport) {
- base::FilePath pe_image_test_path;
- ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &pe_image_test_path));
- pe_image_test_path = pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image"));
-
-#if defined(ARCH_CPU_64_BITS)
- pe_image_test_path =
- pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image_test_64.dll"));
-#else
- pe_image_test_path =
- pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image_test_32.dll"));
-#endif
-
- ScopedNativeLibrary module(pe_image_test_path);
-
- ASSERT_TRUE(module.is_valid());
-
- PEImage pe(module.get());
-
- FARPROC addr = pe.GetProcAddress("FwdExport");
- EXPECT_EQ(FARPROC(-1), addr);
-
- PDWORD export_entry = pe.GetExportEntry("FwdExport");
- EXPECT_NE(nullptr, export_entry);
- PVOID fwd_addr = pe.RVAToAddr(*export_entry);
- const char expected_fwd[] = "KERNEL32.CreateFileA";
- EXPECT_STREQ(expected_fwd, reinterpret_cast<char*>(fwd_addr));
-}
-
-// Test that we can get debug id out of a module.
-TEST(PEImageTest, GetDebugId) {
- ScopedNativeLibrary module(FilePath(L"advapi32.dll"));
- ASSERT_TRUE(module.is_valid());
-
- PEImage pe(module.get());
- GUID guid = {0};
- DWORD age = 0;
- LPCSTR pdb_file = nullptr;
- EXPECT_TRUE(pe.GetDebugId(&guid, &age, &pdb_file));
- EXPECT_STREQ("advapi32.pdb", pdb_file);
-
- // Should be valid to call without parameters.
- EXPECT_TRUE(pe.GetDebugId(nullptr, nullptr, nullptr));
-
- GUID empty_guid = {0};
- EXPECT_TRUE(!IsEqualGUID(empty_guid, guid));
- EXPECT_NE(0U, age);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/registry_unittest.cc b/base/win/registry_unittest.cc
deleted file mode 100644
index 5a18ffa..0000000
--- a/base/win/registry_unittest.cc
+++ /dev/null
@@ -1,423 +0,0 @@
-// Copyright (c) 2011 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 "base/win/registry.h"
-
-#include <stdint.h>
-
-#include <cstring>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/stl_util.h"
-#include "base/win/windows_version.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-class RegistryTest : public testing::Test {
- protected:
-#if defined(_WIN64)
- static const REGSAM kNativeViewMask = KEY_WOW64_64KEY;
- static const REGSAM kRedirectedViewMask = KEY_WOW64_32KEY;
-#else
- static const REGSAM kNativeViewMask = KEY_WOW64_32KEY;
- static const REGSAM kRedirectedViewMask = KEY_WOW64_64KEY;
-#endif // _WIN64
-
- RegistryTest() {}
- void SetUp() override {
- // Create a temporary key.
- RegKey key(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS);
- key.DeleteKey(kRootKey);
- ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ));
- ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, kRootKey, KEY_READ));
- foo_software_key_ = L"Software\\";
- foo_software_key_ += kRootKey;
- foo_software_key_ += L"\\Foo";
- }
-
- void TearDown() override {
- // Clean up the temporary key.
- RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE);
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
- ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ));
- }
-
- static bool IsRedirectorPresent() {
-#if defined(_WIN64)
- return true;
-#else
- return OSInfo::GetInstance()->wow64_status() == OSInfo::WOW64_ENABLED;
-#endif
- }
-
- const wchar_t* const kRootKey = L"Base_Registry_Unittest";
- std::wstring foo_software_key_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(RegistryTest);
-};
-
-// static
-const REGSAM RegistryTest::kNativeViewMask;
-const REGSAM RegistryTest::kRedirectedViewMask;
-
-TEST_F(RegistryTest, ValueTest) {
- RegKey key;
-
- std::wstring foo_key(kRootKey);
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ));
-
- {
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ | KEY_SET_VALUE));
- ASSERT_TRUE(key.Valid());
-
- const wchar_t kStringValueName[] = L"StringValue";
- const wchar_t kDWORDValueName[] = L"DWORDValue";
- const wchar_t kInt64ValueName[] = L"Int64Value";
- const wchar_t kStringData[] = L"string data";
- const DWORD kDWORDData = 0xdeadbabe;
- const int64_t kInt64Data = 0xdeadbabedeadbabeLL;
-
- // Test value creation
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kStringValueName, kStringData));
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kDWORDValueName, kDWORDData));
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kInt64ValueName, &kInt64Data,
- sizeof(kInt64Data), REG_QWORD));
- EXPECT_EQ(3U, key.GetValueCount());
- EXPECT_TRUE(key.HasValue(kStringValueName));
- EXPECT_TRUE(key.HasValue(kDWORDValueName));
- EXPECT_TRUE(key.HasValue(kInt64ValueName));
-
- // Test Read
- std::wstring string_value;
- DWORD dword_value = 0;
- int64_t int64_value = 0;
- ASSERT_EQ(ERROR_SUCCESS, key.ReadValue(kStringValueName, &string_value));
- ASSERT_EQ(ERROR_SUCCESS, key.ReadValueDW(kDWORDValueName, &dword_value));
- ASSERT_EQ(ERROR_SUCCESS, key.ReadInt64(kInt64ValueName, &int64_value));
- EXPECT_STREQ(kStringData, string_value.c_str());
- EXPECT_EQ(kDWORDData, dword_value);
- EXPECT_EQ(kInt64Data, int64_value);
-
- // Make sure out args are not touched if ReadValue fails
- const wchar_t* kNonExistent = L"NonExistent";
- ASSERT_NE(ERROR_SUCCESS, key.ReadValue(kNonExistent, &string_value));
- ASSERT_NE(ERROR_SUCCESS, key.ReadValueDW(kNonExistent, &dword_value));
- ASSERT_NE(ERROR_SUCCESS, key.ReadInt64(kNonExistent, &int64_value));
- EXPECT_STREQ(kStringData, string_value.c_str());
- EXPECT_EQ(kDWORDData, dword_value);
- EXPECT_EQ(kInt64Data, int64_value);
-
- // Test delete
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteValue(kStringValueName));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteValue(kDWORDValueName));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteValue(kInt64ValueName));
- EXPECT_EQ(0U, key.GetValueCount());
- EXPECT_FALSE(key.HasValue(kStringValueName));
- EXPECT_FALSE(key.HasValue(kDWORDValueName));
- EXPECT_FALSE(key.HasValue(kInt64ValueName));
- }
-}
-
-TEST_F(RegistryTest, BigValueIteratorTest) {
- RegKey key;
- std::wstring foo_key(kRootKey);
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ));
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ | KEY_SET_VALUE));
- ASSERT_TRUE(key.Valid());
-
- // Create a test value that is larger than MAX_PATH.
- std::wstring data(MAX_PATH * 2, L'a');
-
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(data.c_str(), data.c_str()));
-
- RegistryValueIterator iterator(HKEY_CURRENT_USER, foo_key.c_str());
- ASSERT_TRUE(iterator.Valid());
- EXPECT_STREQ(data.c_str(), iterator.Name());
- EXPECT_STREQ(data.c_str(), iterator.Value());
- // ValueSize() is in bytes, including NUL.
- EXPECT_EQ((MAX_PATH * 2 + 1) * sizeof(wchar_t), iterator.ValueSize());
- ++iterator;
- EXPECT_FALSE(iterator.Valid());
-}
-
-TEST_F(RegistryTest, TruncatedCharTest) {
- RegKey key;
- std::wstring foo_key(kRootKey);
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ));
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ | KEY_SET_VALUE));
- ASSERT_TRUE(key.Valid());
-
- const wchar_t kName[] = L"name";
- // kData size is not a multiple of sizeof(wchar_t).
- const uint8_t kData[] = {1, 2, 3, 4, 5};
- EXPECT_EQ(5u, arraysize(kData));
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kName, kData,
- arraysize(kData), REG_BINARY));
-
- RegistryValueIterator iterator(HKEY_CURRENT_USER, foo_key.c_str());
- ASSERT_TRUE(iterator.Valid());
- EXPECT_STREQ(kName, iterator.Name());
- // ValueSize() is in bytes.
- ASSERT_EQ(arraysize(kData), iterator.ValueSize());
- // Value() is NUL terminated.
- int end = (iterator.ValueSize() + sizeof(wchar_t) - 1) / sizeof(wchar_t);
- EXPECT_NE(L'\0', iterator.Value()[end-1]);
- EXPECT_EQ(L'\0', iterator.Value()[end]);
- EXPECT_EQ(0, std::memcmp(kData, iterator.Value(), arraysize(kData)));
- ++iterator;
- EXPECT_FALSE(iterator.Valid());
-}
-
-TEST_F(RegistryTest, RecursiveDelete) {
- RegKey key;
- // Create kRootKey->Foo
- // \->Bar (TestValue)
- // \->Foo (TestValue)
- // \->Bar
- // \->Foo
- // \->Moo
- // \->Foo
- // and delete kRootKey->Foo
- std::wstring foo_key(kRootKey);
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS,
- key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(L"TestValue", L"TestData"));
- ASSERT_EQ(ERROR_SUCCESS,
- key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Moo", KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS,
- key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE));
- foo_key += L"\\Bar";
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(L"TestValue", L"TestData"));
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
-
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Bar"));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo"));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar\\Foo"));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar"));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Foo"));
-
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L""));
- ASSERT_NE(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
-
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"Foo"));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Foo"));
- ASSERT_NE(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
-}
-
-// This test requires running as an Administrator as it tests redirected
-// registry writes to HKLM\Software
-// http://msdn.microsoft.com/en-us/library/windows/desktop/aa384253.aspx
-// TODO(wfh): flaky test on Vista. See http://crbug.com/377917
-TEST_F(RegistryTest, DISABLED_Wow64RedirectedFromNative) {
- if (!IsRedirectorPresent())
- return;
-
- RegKey key;
-
- // Test redirected key access from non-redirected.
- ASSERT_EQ(ERROR_SUCCESS,
- key.Create(HKEY_LOCAL_MACHINE,
- foo_software_key_.c_str(),
- KEY_WRITE | kRedirectedViewMask));
- ASSERT_NE(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ));
- ASSERT_NE(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- foo_software_key_.c_str(),
- KEY_READ | kNativeViewMask));
-
- // Open the non-redirected view of the parent and try to delete the test key.
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE, L"Software", KEY_SET_VALUE));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey));
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- L"Software",
- KEY_SET_VALUE | kNativeViewMask));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey));
-
- // Open the redirected view and delete the key created above.
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- L"Software",
- KEY_SET_VALUE | kRedirectedViewMask));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
-}
-
-// Test for the issue found in http://crbug.com/384587 where OpenKey would call
-// Close() and reset wow64_access_ flag to 0 and cause a NOTREACHED to hit on a
-// subsequent OpenKey call.
-TEST_F(RegistryTest, SameWowFlags) {
- RegKey key;
-
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- L"Software",
- KEY_READ | KEY_WOW64_64KEY));
- ASSERT_EQ(ERROR_SUCCESS,
- key.OpenKey(L"Microsoft",
- KEY_READ | KEY_WOW64_64KEY));
- ASSERT_EQ(ERROR_SUCCESS,
- key.OpenKey(L"Windows",
- KEY_READ | KEY_WOW64_64KEY));
-}
-
-// TODO(wfh): flaky test on Vista. See http://crbug.com/377917
-TEST_F(RegistryTest, DISABLED_Wow64NativeFromRedirected) {
- if (!IsRedirectorPresent())
- return;
- RegKey key;
-
- // Test non-redirected key access from redirected.
- ASSERT_EQ(ERROR_SUCCESS,
- key.Create(HKEY_LOCAL_MACHINE,
- foo_software_key_.c_str(),
- KEY_WRITE | kNativeViewMask));
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ));
- ASSERT_NE(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- foo_software_key_.c_str(),
- KEY_READ | kRedirectedViewMask));
-
- // Open the redirected view of the parent and try to delete the test key
- // from the non-redirected view.
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- L"Software",
- KEY_SET_VALUE | kRedirectedViewMask));
- ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey));
-
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_LOCAL_MACHINE,
- L"Software",
- KEY_SET_VALUE | kNativeViewMask));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
-}
-
-TEST_F(RegistryTest, OpenSubKey) {
- RegKey key;
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER,
- kRootKey,
- KEY_READ | KEY_CREATE_SUB_KEY));
-
- ASSERT_NE(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ));
- ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"foo", KEY_READ));
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ));
- ASSERT_EQ(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ));
-
- std::wstring foo_key(kRootKey);
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS,
- key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
-
- ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE));
- ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"foo"));
-}
-
-class TestChangeDelegate {
- public:
- TestChangeDelegate() : called_(false) {}
- ~TestChangeDelegate() {}
-
- void OnKeyChanged() {
- RunLoop::QuitCurrentWhenIdleDeprecated();
- called_ = true;
- }
-
- bool WasCalled() {
- bool was_called = called_;
- called_ = false;
- return was_called;
- }
-
- private:
- bool called_;
-};
-
-TEST_F(RegistryTest, ChangeCallback) {
- RegKey key;
- TestChangeDelegate delegate;
- MessageLoop message_loop;
-
- std::wstring foo_key(kRootKey);
- foo_key += L"\\Foo";
- ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ));
-
- ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
- Unretained(&delegate))));
- EXPECT_FALSE(delegate.WasCalled());
-
- // Make some change.
- RegKey key2;
- ASSERT_EQ(ERROR_SUCCESS, key2.Open(HKEY_CURRENT_USER, foo_key.c_str(),
- KEY_READ | KEY_SET_VALUE));
- ASSERT_TRUE(key2.Valid());
- EXPECT_EQ(ERROR_SUCCESS, key2.WriteValue(L"name", L"data"));
-
- // Allow delivery of the notification.
- EXPECT_FALSE(delegate.WasCalled());
- base::RunLoop().Run();
-
- ASSERT_TRUE(delegate.WasCalled());
- EXPECT_FALSE(delegate.WasCalled());
-
- ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
- Unretained(&delegate))));
-
- // Change something else.
- EXPECT_EQ(ERROR_SUCCESS, key2.WriteValue(L"name2", L"data2"));
- base::RunLoop().Run();
- ASSERT_TRUE(delegate.WasCalled());
-
- ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
- Unretained(&delegate))));
- base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(delegate.WasCalled());
-}
-
-} // namespace
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_bstr_unittest.cc b/base/win/scoped_bstr_unittest.cc
deleted file mode 100644
index d305e5a..0000000
--- a/base/win/scoped_bstr_unittest.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2010 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 <stddef.h>
-
-#include "base/macros.h"
-#include "base/win/scoped_bstr.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-static const wchar_t kTestString1[] = L"123";
-static const wchar_t kTestString2[] = L"456789";
-size_t test1_len = arraysize(kTestString1) - 1;
-size_t test2_len = arraysize(kTestString2) - 1;
-
-void DumbBstrTests() {
- ScopedBstr b;
- EXPECT_TRUE(b == NULL);
- EXPECT_EQ(0u, b.Length());
- EXPECT_EQ(0u, b.ByteLength());
- b.Reset(NULL);
- EXPECT_TRUE(b == NULL);
- EXPECT_TRUE(b.Release() == NULL);
- ScopedBstr b2;
- b.Swap(b2);
- EXPECT_TRUE(b2 == NULL);
-}
-
-void GiveMeABstr(BSTR* ret) {
- *ret = SysAllocString(kTestString1);
-}
-
-void BasicBstrTests() {
- ScopedBstr b1(kTestString1);
- EXPECT_EQ(test1_len, b1.Length());
- EXPECT_EQ(test1_len * sizeof(kTestString1[0]), b1.ByteLength());
-
- ScopedBstr b2;
- b1.Swap(b2);
- EXPECT_EQ(test1_len, b2.Length());
- EXPECT_EQ(0u, b1.Length());
- EXPECT_EQ(0, lstrcmp(b2, kTestString1));
- BSTR tmp = b2.Release();
- EXPECT_TRUE(tmp != NULL);
- EXPECT_EQ(0, lstrcmp(tmp, kTestString1));
- EXPECT_TRUE(b2 == NULL);
- SysFreeString(tmp);
-
- GiveMeABstr(b2.Receive());
- EXPECT_TRUE(b2 != NULL);
- b2.Reset();
- EXPECT_TRUE(b2.AllocateBytes(100) != NULL);
- EXPECT_EQ(100u, b2.ByteLength());
- EXPECT_EQ(100 / sizeof(kTestString1[0]), b2.Length());
- lstrcpy(static_cast<BSTR>(b2), kTestString1);
- EXPECT_EQ(test1_len, static_cast<size_t>(lstrlen(b2)));
- EXPECT_EQ(100 / sizeof(kTestString1[0]), b2.Length());
- b2.SetByteLen(lstrlen(b2) * sizeof(kTestString2[0]));
- EXPECT_EQ(b2.Length(), static_cast<size_t>(lstrlen(b2)));
-
- EXPECT_TRUE(b1.Allocate(kTestString2) != NULL);
- EXPECT_EQ(test2_len, b1.Length());
- b1.SetByteLen((test2_len - 1) * sizeof(kTestString2[0]));
- EXPECT_EQ(test2_len - 1, b1.Length());
-}
-
-} // namespace
-
-TEST(ScopedBstrTest, ScopedBstr) {
- DumbBstrTests();
- BasicBstrTests();
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_handle_unittest.cc b/base/win/scoped_handle_unittest.cc
deleted file mode 100644
index ca6fb45..0000000
--- a/base/win/scoped_handle_unittest.cc
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) 2011 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 <windows.h>
-#include <winternl.h>
-
-#include "base/base_switches.h"
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/scoped_native_library.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "base/win/scoped_handle.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace base {
-namespace win {
-
-namespace testing {
-extern "C" bool __declspec(dllexport) RunTest();
-} // namespace testing
-
-TEST(ScopedHandleTest, ScopedHandle) {
- // Any illegal error code will do. We just need to test that it is preserved
- // by ScopedHandle to avoid bug 528394.
- const DWORD magic_error = 0x12345678;
-
- HANDLE handle = ::CreateMutex(nullptr, false, nullptr);
- // Call SetLastError after creating the handle.
- ::SetLastError(magic_error);
- base::win::ScopedHandle handle_holder(handle);
- EXPECT_EQ(magic_error, ::GetLastError());
-
- // Create a new handle and then set LastError again.
- handle = ::CreateMutex(nullptr, false, nullptr);
- ::SetLastError(magic_error);
- handle_holder.Set(handle);
- EXPECT_EQ(magic_error, ::GetLastError());
-
- // Create a new handle and then set LastError again.
- handle = ::CreateMutex(nullptr, false, nullptr);
- base::win::ScopedHandle handle_source(handle);
- ::SetLastError(magic_error);
- handle_holder = std::move(handle_source);
- EXPECT_EQ(magic_error, ::GetLastError());
-}
-
-TEST(ScopedHandleTest, ActiveVerifierTrackedHasBeenClosed) {
- HANDLE handle = ::CreateMutex(nullptr, false, nullptr);
- ASSERT_NE(HANDLE(nullptr), handle);
- typedef NTSTATUS(WINAPI * NtCloseFunc)(HANDLE);
- NtCloseFunc ntclose = reinterpret_cast<NtCloseFunc>(
- GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtClose"));
- ASSERT_NE(nullptr, ntclose);
-
- ASSERT_DEATH({
- base::win::ScopedHandle handle_holder(handle);
- ntclose(handle);
- // Destructing a ScopedHandle with an illegally closed handle should fail.
- }, "");
-}
-
-TEST(ScopedHandleTest, ActiveVerifierDoubleTracking) {
- HANDLE handle = ::CreateMutex(nullptr, false, nullptr);
- ASSERT_NE(HANDLE(nullptr), handle);
-
- base::win::ScopedHandle handle_holder(handle);
-
- ASSERT_DEATH({
- base::win::ScopedHandle handle_holder2(handle);
- }, "");
-}
-
-TEST(ScopedHandleTest, ActiveVerifierWrongOwner) {
- HANDLE handle = ::CreateMutex(nullptr, false, nullptr);
- ASSERT_NE(HANDLE(nullptr), handle);
-
- base::win::ScopedHandle handle_holder(handle);
- ASSERT_DEATH({
- base::win::ScopedHandle handle_holder2;
- handle_holder2.handle_ = handle;
- }, "");
- ASSERT_TRUE(handle_holder.IsValid());
- handle_holder.Close();
-}
-
-TEST(ScopedHandleTest, ActiveVerifierUntrackedHandle) {
- HANDLE handle = ::CreateMutex(nullptr, false, nullptr);
- ASSERT_NE(HANDLE(nullptr), handle);
-
- ASSERT_DEATH({
- base::win::ScopedHandle handle_holder;
- handle_holder.handle_ = handle;
- }, "");
-
- ASSERT_TRUE(::CloseHandle(handle));
-}
-
-// Under ASan, the multi-process test crashes during process shutdown for
-// unknown reasons. Disable it for now. http://crbug.com/685262
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_MultiProcess DISABLED_MultiProcess
-#else
-#define MAYBE_MultiProcess MultiProcess
-#endif
-
-TEST(ScopedHandleTest, MAYBE_MultiProcess) {
- // Initializing ICU in the child process causes a scoped handle to be created
- // before the test gets a chance to test the race condition, so disable ICU
- // for the child process here.
- CommandLine command_line(base::GetMultiProcessTestChildBaseCommandLine());
- command_line.AppendSwitch(switches::kTestDoNotInitializeIcu);
-
- base::Process test_child_process = base::SpawnMultiProcessTestChild(
- "ActiveVerifierChildProcess", command_line, LaunchOptions());
-
- int rv = -1;
- ASSERT_TRUE(test_child_process.WaitForExitWithTimeout(
- TestTimeouts::action_timeout(), &rv));
- EXPECT_EQ(0, rv);
-}
-
-MULTIPROCESS_TEST_MAIN(ActiveVerifierChildProcess) {
- ScopedNativeLibrary module(FilePath(L"scoped_handle_test_dll.dll"));
-
- if (!module.is_valid())
- return 1;
- auto run_test_function = reinterpret_cast<decltype(&testing::RunTest)>(
- module.GetFunctionPointer("RunTest"));
- if (!run_test_function)
- return 1;
- if (!run_test_function())
- return 1;
-
- return 0;
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_hstring_unittest.cc b/base/win/scoped_hstring_unittest.cc
deleted file mode 100644
index fdcf8ff..0000000
--- a/base/win/scoped_hstring_unittest.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2017 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 "base/win/scoped_hstring.h"
-
-#include <winstring.h>
-
-#include "base/strings/utf_string_conversions.h"
-#include "base/win/core_winrt_util.h"
-#include "base/win/windows_version.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-constexpr wchar_t kTestString1[] = L"123";
-constexpr wchar_t kTestString2[] = L"456789";
-
-} // namespace
-
-TEST(ScopedHStringTest, Init) {
- // ScopedHString requires WinRT core functions, which are not available in
- // older versions.
- if (GetVersion() < VERSION_WIN8) {
- EXPECT_FALSE(ScopedHString::ResolveCoreWinRTStringDelayload());
- return;
- }
-
- EXPECT_TRUE(ScopedHString::ResolveCoreWinRTStringDelayload());
-
- ScopedHString hstring = ScopedHString::Create(kTestString1);
- std::string buffer = hstring.GetAsUTF8();
- EXPECT_EQ(kTestString1, base::UTF8ToWide(buffer));
- base::StringPiece16 contents = hstring.Get();
- EXPECT_EQ(kTestString1, contents);
-
- hstring.reset();
- EXPECT_TRUE(hstring == NULL);
- EXPECT_EQ(NULL, hstring.get());
-
- ScopedHString hstring2 = ScopedHString::Create(kTestString2);
- hstring.swap(hstring2);
- EXPECT_TRUE(hstring2 == NULL);
-
- buffer = hstring.GetAsUTF8();
- EXPECT_EQ(kTestString2, base::UTF8ToWide(buffer));
- contents = hstring.Get();
- EXPECT_EQ(kTestString2, contents);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_process_information_unittest.cc b/base/win/scoped_process_information_unittest.cc
deleted file mode 100644
index 799b273..0000000
--- a/base/win/scoped_process_information_unittest.cc
+++ /dev/null
@@ -1,166 +0,0 @@
-// 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.
-
-#include <windows.h>
-
-#include <string>
-
-#include "base/command_line.h"
-#include "base/process/kill.h"
-#include "base/process/process.h"
-#include "base/test/multiprocess_test.h"
-#include "base/win/scoped_process_information.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace {
-
-const DWORD kProcessId = 4321;
-const DWORD kThreadId = 1234;
-const HANDLE kProcessHandle = reinterpret_cast<HANDLE>(7651);
-const HANDLE kThreadHandle = reinterpret_cast<HANDLE>(1567);
-
-void MockCreateProcess(base::win::ScopedProcessInformation* process_info) {
- PROCESS_INFORMATION process_information = {};
- process_information.dwProcessId = kProcessId;
- process_information.dwThreadId = kThreadId;
- process_information.hProcess = kProcessHandle;
- process_information.hThread = kThreadHandle;
- process_info->Set(process_information);
-}
-
-} // namespace
-
-class ScopedProcessInformationTest : public base::MultiProcessTest {
- protected:
- void DoCreateProcess(const std::string& main_id,
- PROCESS_INFORMATION* process_handle);
-};
-
-MULTIPROCESS_TEST_MAIN(ReturnSeven) {
- return 7;
-}
-
-MULTIPROCESS_TEST_MAIN(ReturnNine) {
- return 9;
-}
-
-void ScopedProcessInformationTest::DoCreateProcess(
- const std::string& main_id, PROCESS_INFORMATION* process_handle) {
- std::wstring cmd_line = MakeCmdLine(main_id).GetCommandLineString();
- STARTUPINFO startup_info = {};
- startup_info.cb = sizeof(startup_info);
-
- EXPECT_TRUE(::CreateProcess(NULL, &cmd_line[0],
- NULL, NULL, false, 0, NULL, NULL,
- &startup_info, process_handle));
-}
-
-TEST_F(ScopedProcessInformationTest, InitiallyInvalid) {
- base::win::ScopedProcessInformation process_info;
- ASSERT_FALSE(process_info.IsValid());
-}
-
-TEST_F(ScopedProcessInformationTest, Receive) {
- base::win::ScopedProcessInformation process_info;
- MockCreateProcess(&process_info);
-
- EXPECT_TRUE(process_info.IsValid());
- EXPECT_EQ(kProcessId, process_info.process_id());
- EXPECT_EQ(kThreadId, process_info.thread_id());
- EXPECT_EQ(kProcessHandle, process_info.process_handle());
- EXPECT_EQ(kThreadHandle, process_info.thread_handle());
- process_info.Take();
-}
-
-TEST_F(ScopedProcessInformationTest, TakeProcess) {
- base::win::ScopedProcessInformation process_info;
- MockCreateProcess(&process_info);
-
- HANDLE process = process_info.TakeProcessHandle();
- EXPECT_EQ(kProcessHandle, process);
- EXPECT_EQ(NULL, process_info.process_handle());
- EXPECT_EQ(0u, process_info.process_id());
- EXPECT_TRUE(process_info.IsValid());
- process_info.Take();
-}
-
-TEST_F(ScopedProcessInformationTest, TakeThread) {
- base::win::ScopedProcessInformation process_info;
- MockCreateProcess(&process_info);
-
- HANDLE thread = process_info.TakeThreadHandle();
- EXPECT_EQ(kThreadHandle, thread);
- EXPECT_EQ(NULL, process_info.thread_handle());
- EXPECT_EQ(0u, process_info.thread_id());
- EXPECT_TRUE(process_info.IsValid());
- process_info.Take();
-}
-
-TEST_F(ScopedProcessInformationTest, TakeBoth) {
- base::win::ScopedProcessInformation process_info;
- MockCreateProcess(&process_info);
-
- process_info.TakeProcessHandle();
- process_info.TakeThreadHandle();
- EXPECT_FALSE(process_info.IsValid());
- process_info.Take();
-}
-
-TEST_F(ScopedProcessInformationTest, TakeWholeStruct) {
- base::win::ScopedProcessInformation process_info;
- MockCreateProcess(&process_info);
-
- PROCESS_INFORMATION to_discard = process_info.Take();
- EXPECT_EQ(kProcessId, to_discard.dwProcessId);
- EXPECT_EQ(kThreadId, to_discard.dwThreadId);
- EXPECT_EQ(kProcessHandle, to_discard.hProcess);
- EXPECT_EQ(kThreadHandle, to_discard.hThread);
- EXPECT_FALSE(process_info.IsValid());
-}
-
-TEST_F(ScopedProcessInformationTest, Duplicate) {
- PROCESS_INFORMATION temp_process_information;
- DoCreateProcess("ReturnSeven", &temp_process_information);
- base::win::ScopedProcessInformation process_info;
- process_info.Set(temp_process_information);
-
- base::win::ScopedProcessInformation duplicate;
- duplicate.DuplicateFrom(process_info);
-
- ASSERT_TRUE(process_info.IsValid());
- ASSERT_NE(0u, process_info.process_id());
- ASSERT_EQ(duplicate.process_id(), process_info.process_id());
- ASSERT_NE(0u, process_info.thread_id());
- ASSERT_EQ(duplicate.thread_id(), process_info.thread_id());
-
- // Validate that we have separate handles that are good.
- int exit_code = 0;
- base::Process process(process_info.TakeProcessHandle());
- ASSERT_TRUE(process.WaitForExit(&exit_code));
- ASSERT_EQ(7, exit_code);
-
- exit_code = 0;
- base::Process dup_process(duplicate.TakeProcessHandle());
- ASSERT_TRUE(dup_process.WaitForExit(&exit_code));
- ASSERT_EQ(7, exit_code);
-
- ASSERT_TRUE(::CloseHandle(process_info.TakeThreadHandle()));
- ASSERT_TRUE(::CloseHandle(duplicate.TakeThreadHandle()));
-}
-
-TEST_F(ScopedProcessInformationTest, Set) {
- base::win::ScopedProcessInformation base_process_info;
- MockCreateProcess(&base_process_info);
-
- PROCESS_INFORMATION base_struct = base_process_info.Take();
-
- base::win::ScopedProcessInformation process_info;
- process_info.Set(base_struct);
-
- EXPECT_EQ(kProcessId, process_info.process_id());
- EXPECT_EQ(kThreadId, process_info.thread_id());
- EXPECT_EQ(kProcessHandle, process_info.process_handle());
- EXPECT_EQ(kThreadHandle, process_info.thread_handle());
- base_struct = process_info.Take();
-}
diff --git a/base/win/scoped_variant_unittest.cc b/base/win/scoped_variant_unittest.cc
deleted file mode 100644
index 7d61e28..0000000
--- a/base/win/scoped_variant_unittest.cc
+++ /dev/null
@@ -1,263 +0,0 @@
-// Copyright (c) 2011 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 <stdint.h>
-
-#include "base/win/scoped_variant.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-static const wchar_t kTestString1[] = L"Used to create BSTRs";
-static const wchar_t kTestString2[] = L"Also used to create BSTRs";
-
-void GiveMeAVariant(VARIANT* ret) {
- EXPECT_TRUE(ret != NULL);
- ret->vt = VT_BSTR;
- V_BSTR(ret) = ::SysAllocString(kTestString1);
-}
-
-// A dummy IDispatch implementation (if you can call it that).
-// The class does nothing intelligent really. Only increments a counter
-// when AddRef is called and decrements it when Release is called.
-class FakeComObject : public IDispatch {
- public:
- FakeComObject() : ref_(0) {
- }
-
- STDMETHOD_(DWORD, AddRef)() override {
- ref_++;
- return ref_;
- }
-
- STDMETHOD_(DWORD, Release)() override {
- ref_--;
- return ref_;
- }
-
- STDMETHOD(QueryInterface)(REFIID, void**) override { return E_NOTIMPL; }
-
- STDMETHOD(GetTypeInfoCount)(UINT*) override { return E_NOTIMPL; }
-
- STDMETHOD(GetTypeInfo)(UINT, LCID, ITypeInfo**) override { return E_NOTIMPL; }
-
- STDMETHOD(GetIDsOfNames)(REFIID, LPOLESTR*, UINT, LCID, DISPID*) override {
- return E_NOTIMPL;
- }
-
- STDMETHOD(Invoke)(DISPID,
- REFIID,
- LCID,
- WORD,
- DISPPARAMS*,
- VARIANT*,
- EXCEPINFO*,
- UINT*) override {
- return E_NOTIMPL;
- }
-
- // A way to check the internal reference count of the class.
- int ref_count() const {
- return ref_;
- }
-
- protected:
- int ref_;
-};
-
-} // namespace
-
-TEST(ScopedVariantTest, ScopedVariant) {
- ScopedVariant var;
- EXPECT_TRUE(var.type() == VT_EMPTY);
- // V_BSTR(var.ptr()) = NULL; <- NOTE: Assignment like that is not supported.
-
- ScopedVariant var_bstr(L"VT_BSTR");
- EXPECT_EQ(VT_BSTR, V_VT(var_bstr.ptr()));
- EXPECT_TRUE(V_BSTR(var_bstr.ptr()) != NULL); // can't use EXPECT_NE for BSTR
- var_bstr.Reset();
- EXPECT_NE(VT_BSTR, V_VT(var_bstr.ptr()));
- var_bstr.Set(kTestString2);
- EXPECT_EQ(VT_BSTR, V_VT(var_bstr.ptr()));
-
- VARIANT tmp = var_bstr.Release();
- EXPECT_EQ(VT_EMPTY, V_VT(var_bstr.ptr()));
- EXPECT_EQ(VT_BSTR, V_VT(&tmp));
- EXPECT_EQ(0, lstrcmp(V_BSTR(&tmp), kTestString2));
-
- var.Reset(tmp);
- EXPECT_EQ(VT_BSTR, V_VT(var.ptr()));
- EXPECT_EQ(0, lstrcmpW(V_BSTR(var.ptr()), kTestString2));
-
- var_bstr.Swap(var);
- EXPECT_EQ(VT_EMPTY, V_VT(var.ptr()));
- EXPECT_EQ(VT_BSTR, V_VT(var_bstr.ptr()));
- EXPECT_EQ(0, lstrcmpW(V_BSTR(var_bstr.ptr()), kTestString2));
- var_bstr.Reset();
-
- // Test the Compare and Copy routines.
- GiveMeAVariant(var_bstr.Receive());
- ScopedVariant var_bstr2(V_BSTR(var_bstr.ptr()));
- EXPECT_EQ(0, var_bstr.Compare(var_bstr2));
- var_bstr2.Reset();
- EXPECT_NE(0, var_bstr.Compare(var_bstr2));
- var_bstr2.Reset(var_bstr.Copy());
- EXPECT_EQ(0, var_bstr.Compare(var_bstr2));
- var_bstr2.Reset();
- var_bstr2.Set(V_BSTR(var_bstr.ptr()));
- EXPECT_EQ(0, var_bstr.Compare(var_bstr2));
- var_bstr2.Reset();
- var_bstr.Reset();
-
- // Test for the SetDate setter.
- SYSTEMTIME sys_time;
- ::GetSystemTime(&sys_time);
- DATE date;
- ::SystemTimeToVariantTime(&sys_time, &date);
- var.Reset();
- var.SetDate(date);
- EXPECT_EQ(VT_DATE, var.type());
- EXPECT_EQ(date, V_DATE(var.ptr()));
-
- // Simple setter tests. These do not require resetting the variant
- // after each test since the variant type is not "leakable" (i.e. doesn't
- // need to be freed explicitly).
-
- // We need static cast here since char defaults to int (!?).
- var.Set(static_cast<int8_t>('v'));
- EXPECT_EQ(VT_I1, var.type());
- EXPECT_EQ('v', V_I1(var.ptr()));
-
- var.Set(static_cast<short>(123));
- EXPECT_EQ(VT_I2, var.type());
- EXPECT_EQ(123, V_I2(var.ptr()));
-
- var.Set(static_cast<int32_t>(123));
- EXPECT_EQ(VT_I4, var.type());
- EXPECT_EQ(123, V_I4(var.ptr()));
-
- var.Set(static_cast<int64_t>(123));
- EXPECT_EQ(VT_I8, var.type());
- EXPECT_EQ(123, V_I8(var.ptr()));
-
- var.Set(static_cast<uint8_t>(123));
- EXPECT_EQ(VT_UI1, var.type());
- EXPECT_EQ(123u, V_UI1(var.ptr()));
-
- var.Set(static_cast<unsigned short>(123));
- EXPECT_EQ(VT_UI2, var.type());
- EXPECT_EQ(123u, V_UI2(var.ptr()));
-
- var.Set(static_cast<uint32_t>(123));
- EXPECT_EQ(VT_UI4, var.type());
- EXPECT_EQ(123u, V_UI4(var.ptr()));
-
- var.Set(static_cast<uint64_t>(123));
- EXPECT_EQ(VT_UI8, var.type());
- EXPECT_EQ(123u, V_UI8(var.ptr()));
-
- var.Set(123.123f);
- EXPECT_EQ(VT_R4, var.type());
- EXPECT_EQ(123.123f, V_R4(var.ptr()));
-
- var.Set(static_cast<double>(123.123));
- EXPECT_EQ(VT_R8, var.type());
- EXPECT_EQ(123.123, V_R8(var.ptr()));
-
- var.Set(true);
- EXPECT_EQ(VT_BOOL, var.type());
- EXPECT_EQ(VARIANT_TRUE, V_BOOL(var.ptr()));
- var.Set(false);
- EXPECT_EQ(VT_BOOL, var.type());
- EXPECT_EQ(VARIANT_FALSE, V_BOOL(var.ptr()));
-
- // Com interface tests
-
- var.Set(static_cast<IDispatch*>(NULL));
- EXPECT_EQ(VT_DISPATCH, var.type());
- EXPECT_EQ(NULL, V_DISPATCH(var.ptr()));
- var.Reset();
-
- var.Set(static_cast<IUnknown*>(NULL));
- EXPECT_EQ(VT_UNKNOWN, var.type());
- EXPECT_EQ(NULL, V_UNKNOWN(var.ptr()));
- var.Reset();
-
- FakeComObject faker;
- EXPECT_EQ(0, faker.ref_count());
- var.Set(static_cast<IDispatch*>(&faker));
- EXPECT_EQ(VT_DISPATCH, var.type());
- EXPECT_EQ(&faker, V_DISPATCH(var.ptr()));
- EXPECT_EQ(1, faker.ref_count());
- var.Reset();
- EXPECT_EQ(0, faker.ref_count());
-
- var.Set(static_cast<IUnknown*>(&faker));
- EXPECT_EQ(VT_UNKNOWN, var.type());
- EXPECT_EQ(&faker, V_UNKNOWN(var.ptr()));
- EXPECT_EQ(1, faker.ref_count());
- var.Reset();
- EXPECT_EQ(0, faker.ref_count());
-
- {
- ScopedVariant disp_var(&faker);
- EXPECT_EQ(VT_DISPATCH, disp_var.type());
- EXPECT_EQ(&faker, V_DISPATCH(disp_var.ptr()));
- EXPECT_EQ(1, faker.ref_count());
- }
- EXPECT_EQ(0, faker.ref_count());
-
- {
- ScopedVariant ref1(&faker);
- EXPECT_EQ(1, faker.ref_count());
- ScopedVariant ref2(static_cast<const VARIANT&>(ref1));
- EXPECT_EQ(2, faker.ref_count());
- ScopedVariant ref3;
- ref3 = static_cast<const VARIANT&>(ref2);
- EXPECT_EQ(3, faker.ref_count());
- }
- EXPECT_EQ(0, faker.ref_count());
-
- {
- ScopedVariant unk_var(static_cast<IUnknown*>(&faker));
- EXPECT_EQ(VT_UNKNOWN, unk_var.type());
- EXPECT_EQ(&faker, V_UNKNOWN(unk_var.ptr()));
- EXPECT_EQ(1, faker.ref_count());
- }
- EXPECT_EQ(0, faker.ref_count());
-
- VARIANT raw;
- raw.vt = VT_UNKNOWN;
- raw.punkVal = &faker;
- EXPECT_EQ(0, faker.ref_count());
- var.Set(raw);
- EXPECT_EQ(1, faker.ref_count());
- var.Reset();
- EXPECT_EQ(0, faker.ref_count());
-
- {
- ScopedVariant number(123);
- EXPECT_EQ(VT_I4, number.type());
- EXPECT_EQ(123, V_I4(number.ptr()));
- }
-
- // SAFEARRAY tests
- var.Set(static_cast<SAFEARRAY*>(NULL));
- EXPECT_EQ(VT_EMPTY, var.type());
-
- SAFEARRAY* sa = ::SafeArrayCreateVector(VT_UI1, 0, 100);
- ASSERT_TRUE(sa != NULL);
-
- var.Set(sa);
- EXPECT_TRUE(ScopedVariant::IsLeakableVarType(var.type()));
- EXPECT_EQ(VT_ARRAY | VT_UI1, var.type());
- EXPECT_EQ(sa, V_ARRAY(var.ptr()));
- // The array is destroyed in the destructor of var.
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/scoped_winrt_initializer_unittest.cc b/base/win/scoped_winrt_initializer_unittest.cc
deleted file mode 100644
index 9df1187..0000000
--- a/base/win/scoped_winrt_initializer_unittest.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2017 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 "base/win/scoped_winrt_initializer.h"
-
-#include "base/test/gtest_util.h"
-#include "base/win/com_init_util.h"
-#include "base/win/scoped_com_initializer.h"
-#include "base/win/windows_version.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-TEST(ScopedWinrtInitializer, BasicFunctionality) {
- if (GetVersion() < VERSION_WIN8)
- return;
-
- AssertComApartmentType(ComApartmentType::NONE);
- {
- ScopedWinrtInitializer scoped_winrt_initializer;
- AssertComApartmentType(ComApartmentType::MTA);
- }
- AssertComApartmentType(ComApartmentType::NONE);
-}
-
-TEST(ScopedWinrtInitializer, ApartmentChangeCheck) {
- if (GetVersion() < VERSION_WIN8)
- return;
-
- ScopedCOMInitializer com_initializer;
- // ScopedCOMInitializer initialized an STA and the following should be a
- // failed request for an MTA.
- EXPECT_DCHECK_DEATH({ ScopedWinrtInitializer scoped_winrt_initializer; });
-}
-
-TEST(ScopedWinrtInitializer, VersionCheck) {
- if (GetVersion() >= VERSION_WIN8)
- return;
-
- // ScopedWinrtInitializer is unsupported on versions prior to Windows 8.
- EXPECT_DCHECK_DEATH({ ScopedWinrtInitializer scoped_winrt_initializer; });
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/shortcut_unittest.cc b/base/win/shortcut_unittest.cc
deleted file mode 100644
index 3c1c26f..0000000
--- a/base/win/shortcut_unittest.cc
+++ /dev/null
@@ -1,330 +0,0 @@
-// 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.
-
-#include "base/win/shortcut.h"
-
-#include <stdint.h>
-
-#include <string>
-
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/macros.h"
-#include "base/test/test_file_util.h"
-#include "base/test/test_shortcut_win.h"
-#include "base/win/scoped_com_initializer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-static const char kFileContents[] = "This is a target.";
-static const char kFileContents2[] = "This is another target.";
-
-class ShortcutTest : public testing::Test {
- protected:
- void SetUp() override {
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- ASSERT_TRUE(temp_dir_2_.CreateUniqueTempDir());
-
- link_file_ = temp_dir_.GetPath().Append(L"My Link.lnk");
-
- // Shortcut 1's properties
- {
- const FilePath target_file(temp_dir_.GetPath().Append(L"Target 1.txt"));
- WriteFile(target_file, kFileContents, arraysize(kFileContents));
-
- link_properties_.set_target(target_file);
- link_properties_.set_working_dir(temp_dir_.GetPath());
- link_properties_.set_arguments(L"--magic --awesome");
- link_properties_.set_description(L"Chrome is awesome.");
- link_properties_.set_icon(link_properties_.target, 4);
- link_properties_.set_app_id(L"Chrome");
- link_properties_.set_dual_mode(false);
-
- // The CLSID below was randomly selected.
- static constexpr CLSID toast_activator_clsid = {
- 0x08d401c2,
- 0x3f79,
- 0x41d8,
- {0x89, 0xd0, 0x99, 0x25, 0xee, 0x16, 0x28, 0x63}};
- link_properties_.set_toast_activator_clsid(toast_activator_clsid);
- }
-
- // Shortcut 2's properties (all different from properties of shortcut 1).
- {
- const FilePath target_file_2(temp_dir_.GetPath().Append(L"Target 2.txt"));
- WriteFile(target_file_2, kFileContents2, arraysize(kFileContents2));
-
- FilePath icon_path_2;
- CreateTemporaryFileInDir(temp_dir_.GetPath(), &icon_path_2);
-
- link_properties_2_.set_target(target_file_2);
- link_properties_2_.set_working_dir(temp_dir_2_.GetPath());
- link_properties_2_.set_arguments(L"--super --crazy");
- link_properties_2_.set_description(L"The best in the west.");
- link_properties_2_.set_icon(icon_path_2, 0);
- link_properties_2_.set_app_id(L"Chrome.UserLevelCrazySuffix");
- link_properties_2_.set_dual_mode(true);
- link_properties_2_.set_toast_activator_clsid(CLSID_NULL);
- }
- }
-
- ScopedCOMInitializer com_initializer_;
- ScopedTempDir temp_dir_;
- ScopedTempDir temp_dir_2_;
-
- // The link file to be created/updated in the shortcut tests below.
- FilePath link_file_;
-
- // Properties for the created shortcut.
- ShortcutProperties link_properties_;
-
- // Properties for the updated shortcut.
- ShortcutProperties link_properties_2_;
-};
-
-} // namespace
-
-TEST_F(ShortcutTest, CreateAndResolveShortcutProperties) {
- // Test all properties.
- FilePath file_1(temp_dir_.GetPath().Append(L"Link1.lnk"));
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- file_1, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties properties_read_1;
- ASSERT_TRUE(ResolveShortcutProperties(
- file_1, ShortcutProperties::PROPERTIES_ALL, &properties_read_1));
- EXPECT_EQ(static_cast<unsigned>(ShortcutProperties::PROPERTIES_ALL),
- properties_read_1.options);
- ValidatePathsAreEqual(link_properties_.target, properties_read_1.target);
- ValidatePathsAreEqual(link_properties_.working_dir,
- properties_read_1.working_dir);
- EXPECT_EQ(link_properties_.arguments, properties_read_1.arguments);
- EXPECT_EQ(link_properties_.description, properties_read_1.description);
- ValidatePathsAreEqual(link_properties_.icon, properties_read_1.icon);
- EXPECT_EQ(link_properties_.icon_index, properties_read_1.icon_index);
- EXPECT_EQ(link_properties_.app_id, properties_read_1.app_id);
- EXPECT_EQ(link_properties_.dual_mode, properties_read_1.dual_mode);
- EXPECT_EQ(link_properties_.toast_activator_clsid,
- properties_read_1.toast_activator_clsid);
-
- // Test simple shortcut with no special properties set.
- FilePath file_2(temp_dir_.GetPath().Append(L"Link2.lnk"));
- ShortcutProperties only_target_properties;
- only_target_properties.set_target(link_properties_.target);
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- file_2, only_target_properties, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties properties_read_2;
- ASSERT_TRUE(ResolveShortcutProperties(
- file_2, ShortcutProperties::PROPERTIES_ALL, &properties_read_2));
- EXPECT_EQ(static_cast<unsigned>(ShortcutProperties::PROPERTIES_ALL),
- properties_read_2.options);
- ValidatePathsAreEqual(only_target_properties.target,
- properties_read_2.target);
- ValidatePathsAreEqual(FilePath(), properties_read_2.working_dir);
- EXPECT_EQ(L"", properties_read_2.arguments);
- EXPECT_EQ(L"", properties_read_2.description);
- ValidatePathsAreEqual(FilePath(), properties_read_2.icon);
- EXPECT_EQ(0, properties_read_2.icon_index);
- EXPECT_EQ(L"", properties_read_2.app_id);
- EXPECT_FALSE(properties_read_2.dual_mode);
- EXPECT_EQ(CLSID_NULL, properties_read_2.toast_activator_clsid);
-}
-
-TEST_F(ShortcutTest, CreateAndResolveShortcut) {
- ShortcutProperties only_target_properties;
- only_target_properties.set_target(link_properties_.target);
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, only_target_properties, SHORTCUT_CREATE_ALWAYS));
-
- FilePath resolved_name;
- EXPECT_TRUE(ResolveShortcut(link_file_, &resolved_name, NULL));
-
- char read_contents[arraysize(kFileContents)];
- base::ReadFile(resolved_name, read_contents, arraysize(read_contents));
- EXPECT_STREQ(kFileContents, read_contents);
-}
-
-TEST_F(ShortcutTest, ResolveShortcutWithArgs) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- FilePath resolved_name;
- string16 args;
- EXPECT_TRUE(ResolveShortcut(link_file_, &resolved_name, &args));
-
- char read_contents[arraysize(kFileContents)];
- base::ReadFile(resolved_name, read_contents, arraysize(read_contents));
- EXPECT_STREQ(kFileContents, read_contents);
- EXPECT_EQ(link_properties_.arguments, args);
-}
-
-TEST_F(ShortcutTest, CreateShortcutWithOnlySomeProperties) {
- ShortcutProperties target_and_args_properties;
- target_and_args_properties.set_target(link_properties_.target);
- target_and_args_properties.set_arguments(link_properties_.arguments);
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, target_and_args_properties,
- SHORTCUT_CREATE_ALWAYS));
-
- ValidateShortcut(link_file_, target_and_args_properties);
-}
-
-TEST_F(ShortcutTest, CreateShortcutVerifyProperties) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ValidateShortcut(link_file_, link_properties_);
-}
-
-TEST_F(ShortcutTest, UpdateShortcutVerifyProperties) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_2_, SHORTCUT_UPDATE_EXISTING));
-
- ValidateShortcut(link_file_, link_properties_2_);
-}
-
-TEST_F(ShortcutTest, UpdateShortcutUpdateOnlyTargetAndResolve) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties update_only_target_properties;
- update_only_target_properties.set_target(link_properties_2_.target);
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, update_only_target_properties,
- SHORTCUT_UPDATE_EXISTING));
-
- ShortcutProperties expected_properties = link_properties_;
- expected_properties.set_target(link_properties_2_.target);
- ValidateShortcut(link_file_, expected_properties);
-
- FilePath resolved_name;
- EXPECT_TRUE(ResolveShortcut(link_file_, &resolved_name, NULL));
-
- char read_contents[arraysize(kFileContents2)];
- base::ReadFile(resolved_name, read_contents, arraysize(read_contents));
- EXPECT_STREQ(kFileContents2, read_contents);
-}
-
-TEST_F(ShortcutTest, UpdateShortcutMakeDualMode) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties make_dual_mode_properties;
- make_dual_mode_properties.set_dual_mode(true);
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, make_dual_mode_properties,
- SHORTCUT_UPDATE_EXISTING));
-
- ShortcutProperties expected_properties = link_properties_;
- expected_properties.set_dual_mode(true);
- ValidateShortcut(link_file_, expected_properties);
-}
-
-TEST_F(ShortcutTest, UpdateShortcutRemoveDualMode) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_2_, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties remove_dual_mode_properties;
- remove_dual_mode_properties.set_dual_mode(false);
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, remove_dual_mode_properties,
- SHORTCUT_UPDATE_EXISTING));
-
- ShortcutProperties expected_properties = link_properties_2_;
- expected_properties.set_dual_mode(false);
- ValidateShortcut(link_file_, expected_properties);
-}
-
-TEST_F(ShortcutTest, UpdateShortcutClearArguments) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties clear_arguments_properties;
- clear_arguments_properties.set_arguments(string16());
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, clear_arguments_properties,
- SHORTCUT_UPDATE_EXISTING));
-
- ShortcutProperties expected_properties = link_properties_;
- expected_properties.set_arguments(string16());
- ValidateShortcut(link_file_, expected_properties);
-}
-
-TEST_F(ShortcutTest, FailUpdateShortcutThatDoesNotExist) {
- ASSERT_FALSE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_UPDATE_EXISTING));
- ASSERT_FALSE(PathExists(link_file_));
-}
-
-TEST_F(ShortcutTest, ReplaceShortcutAllProperties) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_2_, SHORTCUT_REPLACE_EXISTING));
-
- ValidateShortcut(link_file_, link_properties_2_);
-}
-
-TEST_F(ShortcutTest, ReplaceShortcutSomeProperties) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- ShortcutProperties new_properties;
- new_properties.set_target(link_properties_2_.target);
- new_properties.set_arguments(link_properties_2_.arguments);
- new_properties.set_description(link_properties_2_.description);
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, new_properties, SHORTCUT_REPLACE_EXISTING));
-
- // Expect only properties in |new_properties| to be set, all other properties
- // should have been overwritten.
- ShortcutProperties expected_properties(new_properties);
- expected_properties.set_working_dir(FilePath());
- expected_properties.set_icon(FilePath(), 0);
- expected_properties.set_app_id(string16());
- expected_properties.set_dual_mode(false);
- ValidateShortcut(link_file_, expected_properties);
-}
-
-TEST_F(ShortcutTest, FailReplaceShortcutThatDoesNotExist) {
- ASSERT_FALSE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_REPLACE_EXISTING));
- ASSERT_FALSE(PathExists(link_file_));
-}
-
-// Test that the old arguments remain on the replaced shortcut when not
-// otherwise specified.
-TEST_F(ShortcutTest, ReplaceShortcutKeepOldArguments) {
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_, SHORTCUT_CREATE_ALWAYS));
-
- // Do not explicitly set the arguments.
- link_properties_2_.options &=
- ~ShortcutProperties::PROPERTIES_ARGUMENTS;
- ASSERT_TRUE(CreateOrUpdateShortcutLink(
- link_file_, link_properties_2_, SHORTCUT_REPLACE_EXISTING));
-
- ShortcutProperties expected_properties(link_properties_2_);
- expected_properties.set_arguments(link_properties_.arguments);
- ValidateShortcut(link_file_, expected_properties);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/startup_information_unittest.cc b/base/win/startup_information_unittest.cc
deleted file mode 100644
index f5d1f37..0000000
--- a/base/win/startup_information_unittest.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// 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.
-
-#include <windows.h>
-#include <stddef.h>
-
-#include <string>
-
-#include "base/command_line.h"
-#include "base/test/multiprocess_test.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/scoped_process_information.h"
-#include "base/win/startup_information.h"
-#include "testing/multiprocess_func_list.h"
-
-const wchar_t kSectionName[] = L"EventTestSection";
-const size_t kSectionSize = 4096;
-
-MULTIPROCESS_TEST_MAIN(FireInheritedEvents) {
- HANDLE section = ::OpenFileMappingW(PAGE_READWRITE, false, kSectionName);
- HANDLE* events = reinterpret_cast<HANDLE*>(::MapViewOfFile(section,
- PAGE_READWRITE, 0, 0, kSectionSize));
- // This event should not be valid because it wasn't explicitly inherited.
- if (::SetEvent(events[1]))
- return -1;
- // This event should be valid because it was explicitly inherited.
- if (!::SetEvent(events[0]))
- return -1;
-
- return 0;
-}
-
-class StartupInformationTest : public base::MultiProcessTest {};
-
-// Verify that only the explicitly specified event is inherited.
-TEST_F(StartupInformationTest, InheritStdOut) {
- base::win::StartupInformation startup_info;
-
- HANDLE section = ::CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
- PAGE_READWRITE, 0, kSectionSize,
- kSectionName);
- ASSERT_TRUE(section);
-
- HANDLE* events = reinterpret_cast<HANDLE*>(::MapViewOfFile(section,
- FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, kSectionSize));
-
- // Make two inheritable events.
- SECURITY_ATTRIBUTES security_attributes = { sizeof(security_attributes),
- NULL, true };
- events[0] = ::CreateEvent(&security_attributes, false, false, NULL);
- ASSERT_TRUE(events[0]);
- events[1] = ::CreateEvent(&security_attributes, false, false, NULL);
- ASSERT_TRUE(events[1]);
-
- ASSERT_TRUE(startup_info.InitializeProcThreadAttributeList(1));
- ASSERT_TRUE(startup_info.UpdateProcThreadAttribute(
- PROC_THREAD_ATTRIBUTE_HANDLE_LIST, &events[0],
- sizeof(events[0])));
-
- std::wstring cmd_line =
- MakeCmdLine("FireInheritedEvents").GetCommandLineString();
-
- PROCESS_INFORMATION temp_process_info = {};
- ASSERT_TRUE(::CreateProcess(NULL, &cmd_line[0],
- NULL, NULL, true, EXTENDED_STARTUPINFO_PRESENT,
- NULL, NULL, startup_info.startup_info(),
- &temp_process_info)) << ::GetLastError();
- base::win::ScopedProcessInformation process_info(temp_process_info);
-
- // Only the first event should be signalled
- EXPECT_EQ(WAIT_OBJECT_0, ::WaitForMultipleObjects(2, events, false,
- 4000));
-}
-
diff --git a/base/win/typed_event_handler_unittest.cc b/base/win/typed_event_handler_unittest.cc
deleted file mode 100644
index 76dba80..0000000
--- a/base/win/typed_event_handler_unittest.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2018 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 "base/win/typed_event_handler.h"
-
-#include <windows.foundation.h>
-
-#include "base/test/bind_test_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-TEST(TypedEventHandlerTest, InvokeSuccess) {
- bool called_callback = false;
- TypedEventHandler<IInspectable*, IInspectable*> handler(
- base::BindLambdaForTesting([&](IInspectable* sender, IInspectable* args) {
- EXPECT_EQ(reinterpret_cast<IInspectable*>(0x01), sender);
- EXPECT_EQ(reinterpret_cast<IInspectable*>(0x02), args);
- called_callback = true;
- return S_OK;
- }));
-
- EXPECT_FALSE(called_callback);
- HRESULT hr = handler.Invoke(reinterpret_cast<IInspectable*>(0x01),
- reinterpret_cast<IInspectable*>(0x02));
- EXPECT_TRUE(called_callback);
- EXPECT_EQ(S_OK, hr);
-}
-
-TEST(TypedEventHandlerTest, InvokeFail) {
- bool called_callback = false;
- TypedEventHandler<IInspectable*, IInspectable*> handler(
- base::BindLambdaForTesting([&](IInspectable* sender, IInspectable* args) {
- EXPECT_EQ(nullptr, sender);
- EXPECT_EQ(nullptr, args);
- called_callback = true;
- return E_FAIL;
- }));
-
- EXPECT_FALSE(called_callback);
- HRESULT hr = handler.Invoke(nullptr, nullptr);
- EXPECT_TRUE(called_callback);
- EXPECT_EQ(E_FAIL, hr);
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/wait_chain_unittest.cc b/base/win/wait_chain_unittest.cc
deleted file mode 100644
index 74a0ce5..0000000
--- a/base/win/wait_chain_unittest.cc
+++ /dev/null
@@ -1,317 +0,0 @@
-// Copyright 2016 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 "base/win/wait_chain.h"
-
-#include <memory>
-#include <string>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
-#include "base/test/multiprocess_test.h"
-#include "base/threading/simple_thread.h"
-#include "base/win/win_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-// Appends |handle| as a command line switch.
-void AppendSwitchHandle(CommandLine* command_line,
- StringPiece switch_name,
- HANDLE handle) {
- command_line->AppendSwitchASCII(switch_name.as_string(),
- UintToString(HandleToUint32(handle)));
-}
-
-// Retrieves the |handle| associated to |switch_name| from the command line.
-ScopedHandle GetSwitchValueHandle(CommandLine* command_line,
- StringPiece switch_name) {
- std::string switch_string =
- command_line->GetSwitchValueASCII(switch_name.as_string());
- unsigned int switch_uint = 0;
- if (switch_string.empty() || !StringToUint(switch_string, &switch_uint)) {
- DLOG(ERROR) << "Missing or invalid " << switch_name << " argument.";
- return ScopedHandle();
- }
- return ScopedHandle(reinterpret_cast<HANDLE>(switch_uint));
-}
-
-// Helper function to create a mutex.
-ScopedHandle CreateMutex(bool inheritable) {
- SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES),
- nullptr, inheritable};
- return ScopedHandle(::CreateMutex(&security_attributes, FALSE, NULL));
-}
-
-// Helper function to create an event.
-ScopedHandle CreateEvent(bool inheritable) {
- SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES),
- nullptr, inheritable};
- return ScopedHandle(
- ::CreateEvent(&security_attributes, FALSE, FALSE, nullptr));
-}
-
-// Helper thread class that runs the callback then stops.
-class SingleTaskThread : public SimpleThread {
- public:
- explicit SingleTaskThread(const Closure& task)
- : SimpleThread("WaitChainTest SingleTaskThread"), task_(task) {}
-
- void Run() override { task_.Run(); }
-
- private:
- Closure task_;
-
- DISALLOW_COPY_AND_ASSIGN(SingleTaskThread);
-};
-
-// Helper thread to cause a deadlock by acquiring 2 mutexes in a given order.
-class DeadlockThread : public SimpleThread {
- public:
- DeadlockThread(HANDLE mutex_1, HANDLE mutex_2)
- : SimpleThread("WaitChainTest DeadlockThread"),
- wait_event_(CreateEvent(false)),
- mutex_acquired_event_(CreateEvent(false)),
- mutex_1_(mutex_1),
- mutex_2_(mutex_2) {}
-
- void Run() override {
- // Acquire the mutex then signal the main thread.
- EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(mutex_1_, INFINITE));
- EXPECT_TRUE(::SetEvent(mutex_acquired_event_.Get()));
-
- // Wait until both threads are holding their mutex before trying to acquire
- // the other one.
- EXPECT_EQ(WAIT_OBJECT_0,
- ::WaitForSingleObject(wait_event_.Get(), INFINITE));
-
- // To unblock the deadlock, one of the threads will get terminated (via
- // TerminateThread()) without releasing the mutex. This causes the other
- // thread to wake up with WAIT_ABANDONED.
- EXPECT_EQ(WAIT_ABANDONED, ::WaitForSingleObject(mutex_2_, INFINITE));
- }
-
- // Blocks until a mutex is acquired.
- void WaitForMutexAcquired() {
- EXPECT_EQ(WAIT_OBJECT_0,
- ::WaitForSingleObject(mutex_acquired_event_.Get(), INFINITE));
- }
-
- // Signal the thread to acquire the second mutex.
- void SignalToAcquireMutex() { EXPECT_TRUE(::SetEvent(wait_event_.Get())); }
-
- // Terminates the thread.
- bool Terminate() {
- ScopedHandle thread_handle(::OpenThread(THREAD_TERMINATE, FALSE, tid()));
- return ::TerminateThread(thread_handle.Get(), 0);
- }
-
- private:
- ScopedHandle wait_event_;
- ScopedHandle mutex_acquired_event_;
-
- // The 2 mutex to acquire.
- HANDLE mutex_1_;
- HANDLE mutex_2_;
-
- DISALLOW_COPY_AND_ASSIGN(DeadlockThread);
-};
-
-// Creates a thread that joins |thread_to_join| and then terminates when it
-// finishes execution.
-std::unique_ptr<SingleTaskThread> CreateJoiningThread(
- SimpleThread* thread_to_join) {
- std::unique_ptr<SingleTaskThread> thread(new SingleTaskThread(
- Bind(&SimpleThread::Join, Unretained(thread_to_join))));
- thread->Start();
-
- return thread;
-}
-
-// Creates a thread that calls WaitForSingleObject() on the handle and then
-// terminates when it unblocks.
-std::unique_ptr<SingleTaskThread> CreateWaitingThread(HANDLE handle) {
- std::unique_ptr<SingleTaskThread> thread(new SingleTaskThread(
- Bind(IgnoreResult(&::WaitForSingleObject), handle, INFINITE)));
- thread->Start();
-
- return thread;
-}
-
-// Creates a thread that blocks on |mutex_2| after acquiring |mutex_1|.
-std::unique_ptr<DeadlockThread> CreateDeadlockThread(HANDLE mutex_1,
- HANDLE mutex_2) {
- std::unique_ptr<DeadlockThread> thread(new DeadlockThread(mutex_1, mutex_2));
- thread->Start();
-
- // Wait until the first mutex is acquired before returning.
- thread->WaitForMutexAcquired();
-
- return thread;
-}
-
-// Child process to test the cross-process capability of the WCT api.
-// This process will simulate a hang while holding a mutex that the parent
-// process is waiting on.
-MULTIPROCESS_TEST_MAIN(WaitChainTestProc) {
- CommandLine* command_line = CommandLine::ForCurrentProcess();
-
- ScopedHandle mutex = GetSwitchValueHandle(command_line, "mutex");
- CHECK(mutex.IsValid());
-
- ScopedHandle sync_event(GetSwitchValueHandle(command_line, "sync_event"));
- CHECK(sync_event.IsValid());
-
- // Acquire mutex.
- CHECK(::WaitForSingleObject(mutex.Get(), INFINITE) == WAIT_OBJECT_0);
-
- // Signal back to the parent process that the mutex is hold.
- CHECK(::SetEvent(sync_event.Get()));
-
- // Wait on a signal from the parent process before terminating.
- CHECK(::WaitForSingleObject(sync_event.Get(), INFINITE) == WAIT_OBJECT_0);
-
- return 0;
-}
-
-// Start a child process and passes the |mutex| and the |sync_event| to the
-// command line.
-Process StartChildProcess(HANDLE mutex, HANDLE sync_event) {
- CommandLine command_line = GetMultiProcessTestChildBaseCommandLine();
-
- AppendSwitchHandle(&command_line, "mutex", mutex);
- AppendSwitchHandle(&command_line, "sync_event", sync_event);
-
- LaunchOptions options;
- options.handles_to_inherit.push_back(mutex);
- options.handles_to_inherit.push_back(sync_event);
- return SpawnMultiProcessTestChild("WaitChainTestProc", command_line, options);
-}
-
-// Returns true if the |wait_chain| is an alternating sequence of thread objects
-// and synchronization objects.
-bool WaitChainStructureIsCorrect(const WaitChainNodeVector& wait_chain) {
- // Checks thread objects.
- for (size_t i = 0; i < wait_chain.size(); i += 2) {
- if (wait_chain[i].ObjectType != WctThreadType)
- return false;
- }
-
- // Check synchronization objects.
- for (size_t i = 1; i < wait_chain.size(); i += 2) {
- if (wait_chain[i].ObjectType == WctThreadType)
- return false;
- }
- return true;
-}
-
-// Returns true if the |wait_chain| goes through more than 1 process.
-bool WaitChainIsCrossProcess(const WaitChainNodeVector& wait_chain) {
- if (wait_chain.size() == 0)
- return false;
-
- // Just check that the process id changes somewhere in the chain.
- // Note: ThreadObjects are every 2 nodes.
- DWORD first_process = wait_chain[0].ThreadObject.ProcessId;
- for (size_t i = 2; i < wait_chain.size(); i += 2) {
- if (first_process != wait_chain[i].ThreadObject.ProcessId)
- return true;
- }
- return false;
-}
-
-} // namespace
-
-// Creates 2 threads that acquire their designated mutex and then try to
-// acquire each others' mutex to cause a deadlock.
-TEST(WaitChainTest, Deadlock) {
- // 2 mutexes are needed to get a deadlock.
- ScopedHandle mutex_1 = CreateMutex(false);
- ASSERT_TRUE(mutex_1.IsValid());
- ScopedHandle mutex_2 = CreateMutex(false);
- ASSERT_TRUE(mutex_2.IsValid());
-
- std::unique_ptr<DeadlockThread> deadlock_thread_1 =
- CreateDeadlockThread(mutex_1.Get(), mutex_2.Get());
- std::unique_ptr<DeadlockThread> deadlock_thread_2 =
- CreateDeadlockThread(mutex_2.Get(), mutex_1.Get());
-
- // Signal the threads to try to acquire the other mutex.
- deadlock_thread_1->SignalToAcquireMutex();
- deadlock_thread_2->SignalToAcquireMutex();
- // Sleep to make sure the 2 threads got a chance to execute.
- Sleep(10);
-
- // Create a few waiting threads to get a longer wait chain.
- std::unique_ptr<SingleTaskThread> waiting_thread_1 =
- CreateJoiningThread(deadlock_thread_1.get());
- std::unique_ptr<SingleTaskThread> waiting_thread_2 =
- CreateJoiningThread(waiting_thread_1.get());
-
- WaitChainNodeVector wait_chain;
- bool is_deadlock;
- ASSERT_TRUE(GetThreadWaitChain(waiting_thread_2->tid(), &wait_chain,
- &is_deadlock, nullptr, nullptr));
-
- EXPECT_EQ(9U, wait_chain.size());
- EXPECT_TRUE(is_deadlock);
- EXPECT_TRUE(WaitChainStructureIsCorrect(wait_chain));
- EXPECT_FALSE(WaitChainIsCrossProcess(wait_chain));
-
- ASSERT_TRUE(deadlock_thread_1->Terminate());
-
- // The SimpleThread API expect Join() to be called before destruction.
- deadlock_thread_2->Join();
- waiting_thread_2->Join();
-}
-
-// Creates a child process that acquires a mutex and then blocks. A chain of
-// threads then blocks on that mutex.
-TEST(WaitChainTest, CrossProcess) {
- ScopedHandle mutex = CreateMutex(true);
- ASSERT_TRUE(mutex.IsValid());
- ScopedHandle sync_event = CreateEvent(true);
- ASSERT_TRUE(sync_event.IsValid());
-
- Process child_process = StartChildProcess(mutex.Get(), sync_event.Get());
- ASSERT_TRUE(child_process.IsValid());
-
- // Wait for the child process to signal when it's holding the mutex.
- EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(sync_event.Get(), INFINITE));
-
- // Create a few waiting threads to get a longer wait chain.
- std::unique_ptr<SingleTaskThread> waiting_thread_1 =
- CreateWaitingThread(mutex.Get());
- std::unique_ptr<SingleTaskThread> waiting_thread_2 =
- CreateJoiningThread(waiting_thread_1.get());
- std::unique_ptr<SingleTaskThread> waiting_thread_3 =
- CreateJoiningThread(waiting_thread_2.get());
-
- WaitChainNodeVector wait_chain;
- bool is_deadlock;
- ASSERT_TRUE(GetThreadWaitChain(waiting_thread_3->tid(), &wait_chain,
- &is_deadlock, nullptr, nullptr));
-
- EXPECT_EQ(7U, wait_chain.size());
- EXPECT_FALSE(is_deadlock);
- EXPECT_TRUE(WaitChainStructureIsCorrect(wait_chain));
- EXPECT_TRUE(WaitChainIsCrossProcess(wait_chain));
-
- // Unblock child process and wait for it to terminate.
- ASSERT_TRUE(::SetEvent(sync_event.Get()));
- ASSERT_TRUE(child_process.WaitForExit(nullptr));
-
- // The SimpleThread API expect Join() to be called before destruction.
- waiting_thread_3->Join();
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/win_includes_unittest.cc b/base/win/win_includes_unittest.cc
deleted file mode 100644
index 20c6cbc..0000000
--- a/base/win/win_includes_unittest.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2014 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 file ensures that these header files don't include Windows.h and can
-// compile without including Windows.h. This helps to improve compile times.
-
-#include "base/atomicops.h"
-#include "base/files/file_util.h"
-#include "base/files/platform_file.h"
-#include "base/process/process_handle.h"
-#include "base/synchronization/condition_variable.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local_storage.h"
-#include "base/win/registry.h"
-#include "base/win/scoped_handle.h"
-#include "base/win/win_util.h"
-
-#ifdef _WINDOWS_
-#error Windows.h was included inappropriately.
-#endif
-
-// Make sure windows.h can be included after windows_types.h
-#include "base/win/windows_types.h"
-
-#include <windows.h>
-
-// Check that type sizes match.
-static_assert(sizeof(CHROME_CONDITION_VARIABLE) == sizeof(CONDITION_VARIABLE),
- "Definition mismatch.");
-static_assert(sizeof(CHROME_SRWLOCK) == sizeof(SRWLOCK),
- "Definition mismatch.");
diff --git a/base/win/win_util_unittest.cc b/base/win/win_util_unittest.cc
deleted file mode 100644
index 6d5cf61..0000000
--- a/base/win/win_util_unittest.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2010 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 "base/win/win_util.h"
-
-#include "base/files/file_path.h"
-#include "base/macros.h"
-#include "base/scoped_native_library.h"
-#include "base/stl_util.h"
-#include "base/win/win_client_metrics.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-namespace {
-
-// Saves the current thread's locale ID when initialized, and restores it when
-// the instance is going out of scope.
-class ThreadLocaleSaver {
- public:
- ThreadLocaleSaver() : original_locale_id_(GetThreadLocale()) {}
- ~ThreadLocaleSaver() { SetThreadLocale(original_locale_id_); }
-
- private:
- LCID original_locale_id_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadLocaleSaver);
-};
-
-} // namespace
-
-// The test is somewhat silly, because some bots some have UAC enabled and some
-// have it disabled. At least we check that it does not crash.
-TEST(BaseWinUtilTest, TestIsUACEnabled) {
- UserAccountControlIsEnabled();
-}
-
-TEST(BaseWinUtilTest, TestGetUserSidString) {
- std::wstring user_sid;
- EXPECT_TRUE(GetUserSidString(&user_sid));
- EXPECT_TRUE(!user_sid.empty());
-}
-
-TEST(BaseWinUtilTest, TestGetNonClientMetrics) {
- NONCLIENTMETRICS_XP metrics = {0};
- GetNonClientMetrics(&metrics);
- EXPECT_GT(metrics.cbSize, 0u);
- EXPECT_GT(metrics.iScrollWidth, 0);
- EXPECT_GT(metrics.iScrollHeight, 0);
-}
-
-TEST(BaseWinUtilTest, TestGetLoadedModulesSnapshot) {
- std::vector<HMODULE> snapshot;
-
- ASSERT_TRUE(GetLoadedModulesSnapshot(::GetCurrentProcess(), &snapshot));
- size_t original_snapshot_size = snapshot.size();
- ASSERT_GT(original_snapshot_size, 0u);
- snapshot.clear();
-
- // Load in a new module. Pick msvidc32.dll as it is present from WinXP to
- // Win10 and yet rarely used.
- const wchar_t dll_name[] = L"msvidc32.dll";
- ASSERT_EQ(NULL, ::GetModuleHandle(dll_name));
-
- base::ScopedNativeLibrary new_dll((base::FilePath(dll_name)));
- ASSERT_NE(static_cast<HMODULE>(NULL), new_dll.get());
- ASSERT_TRUE(GetLoadedModulesSnapshot(::GetCurrentProcess(), &snapshot));
- ASSERT_GT(snapshot.size(), original_snapshot_size);
- ASSERT_TRUE(base::ContainsValue(snapshot, new_dll.get()));
-}
-
-TEST(BaseWinUtilTest, TestUint32ToInvalidHandle) {
- // Ensure that INVALID_HANDLE_VALUE is preserved when going to a 32-bit value
- // and back on 64-bit platforms.
- uint32_t invalid_handle = base::win::HandleToUint32(INVALID_HANDLE_VALUE);
- EXPECT_EQ(INVALID_HANDLE_VALUE, base::win::Uint32ToHandle(invalid_handle));
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/windows_version_unittest.cc b/base/win/windows_version_unittest.cc
deleted file mode 100644
index f0d6d96..0000000
--- a/base/win/windows_version_unittest.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2016 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 "base/win/windows_version.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-namespace {
-
-TEST(WindowsVersion, GetVersionExAndKernelVersionMatch) {
- // If this fails, we're running in compatibility mode, or need to update the
- // application manifest.
- EXPECT_EQ(OSInfo::GetInstance()->version(),
- OSInfo::GetInstance()->Kernel32Version());
-}
-
-} // namespace
-} // namespace win
-} // namespace base
diff --git a/base/win/winrt_storage_util_unittest.cc b/base/win/winrt_storage_util_unittest.cc
deleted file mode 100644
index 530ab23..0000000
--- a/base/win/winrt_storage_util_unittest.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2017 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 "base/win/winrt_storage_util.h"
-
-#include <string.h>
-#include <wrl/client.h>
-
-#include "base/strings/string_util.h"
-#include "base/win/core_winrt_util.h"
-#include "base/win/scoped_com_initializer.h"
-#include "base/win/scoped_hstring.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace win {
-
-TEST(WinrtStorageUtilTest, CreateBufferFromData) {
- ScopedCOMInitializer com_initializer(ScopedCOMInitializer::kMTA);
-
- if (!ResolveCoreWinRTDelayload() ||
- !ScopedHString::ResolveCoreWinRTStringDelayload()) {
- return;
- }
-
- const std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
- Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer;
- ASSERT_HRESULT_SUCCEEDED(
- CreateIBufferFromData(data.data(), data.size(), &buffer));
-
- uint8_t* p_buffer_data;
- uint32_t length;
- ASSERT_HRESULT_SUCCEEDED(
- GetPointerToBufferData(buffer.Get(), &p_buffer_data, &length));
-
- ASSERT_EQ(data.size(), length);
- EXPECT_EQ(0, memcmp(p_buffer_data, data.data(), data.size()));
-}
-
-} // namespace win
-} // namespace base
diff --git a/base/win/wrapped_window_proc_unittest.cc b/base/win/wrapped_window_proc_unittest.cc
deleted file mode 100644
index 25ba2d4..0000000
--- a/base/win/wrapped_window_proc_unittest.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2011 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 "base/win/wrapped_window_proc.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace {
-
-DWORD kExceptionCode = 12345;
-WPARAM kCrashMsg = 98765;
-
-// A trivial WindowProc that generates an exception.
-LRESULT CALLBACK TestWindowProc(HWND hwnd, UINT message,
- WPARAM wparam, LPARAM lparam) {
- if (message == kCrashMsg)
- RaiseException(kExceptionCode, 0, 0, NULL);
- return DefWindowProc(hwnd, message, wparam, lparam);
-}
-
-// This class implements an exception filter that can be queried about a past
-// exception.
-class TestWrappedExceptionFiter {
- public:
- TestWrappedExceptionFiter() : called_(false) {
- EXPECT_FALSE(s_filter_);
- s_filter_ = this;
- }
-
- ~TestWrappedExceptionFiter() {
- EXPECT_EQ(s_filter_, this);
- s_filter_ = NULL;
- }
-
- bool called() {
- return called_;
- }
-
- // The actual exception filter just records the exception.
- static int Filter(EXCEPTION_POINTERS* info) {
- EXPECT_FALSE(s_filter_->called_);
- if (info->ExceptionRecord->ExceptionCode == kExceptionCode)
- s_filter_->called_ = true;
- return EXCEPTION_EXECUTE_HANDLER;
- }
-
- private:
- bool called_;
- static TestWrappedExceptionFiter* s_filter_;
-};
-TestWrappedExceptionFiter* TestWrappedExceptionFiter::s_filter_ = NULL;
-
-} // namespace.
-
-TEST(WrappedWindowProc, CatchesExceptions) {
- HINSTANCE hinst = GetModuleHandle(NULL);
- std::wstring class_name(L"TestClass");
-
- WNDCLASS wc = {0};
- wc.lpfnWndProc = base::win::WrappedWindowProc<TestWindowProc>;
- wc.hInstance = hinst;
- wc.lpszClassName = class_name.c_str();
- RegisterClass(&wc);
-
- HWND window = CreateWindow(class_name.c_str(), 0, 0, 0, 0, 0, 0, HWND_MESSAGE,
- 0, hinst, 0);
- ASSERT_TRUE(window);
-
- // Before generating the exception we make sure that the filter will see it.
- TestWrappedExceptionFiter wrapper;
- base::win::WinProcExceptionFilter old_filter =
- base::win::SetWinProcExceptionFilter(TestWrappedExceptionFiter::Filter);
-
- SendMessage(window, kCrashMsg, 0, 0);
- EXPECT_TRUE(wrapper.called());
-
- base::win::SetWinProcExceptionFilter(old_filter);
-}
