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); -}