text:
#----------------------------------------------------------------
# Generated CMake target import file for configuration "Release".
#----------------------------------------------------------------

# Commands may need to know the format version.
set(CMAKE_IMPORT_FILE_VERSION 1)

# Import target "absl::log_severity" for configuration "Release"
set_property(TARGET absl::log_severity APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::log_severity PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_log_severity.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_log_severity.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::log_severity )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::log_severity "${_IMPORT_PREFIX}/lib64/libabsl_log_severity.so.2111.0.0" )

# Import target "absl::raw_logging_internal" for configuration "Release"
set_property(TARGET absl::raw_logging_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::raw_logging_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_raw_logging_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_raw_logging_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::raw_logging_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::raw_logging_internal "${_IMPORT_PREFIX}/lib64/libabsl_raw_logging_internal.so.2111.0.0" )

# Import target "absl::spinlock_wait" for configuration "Release"
set_property(TARGET absl::spinlock_wait APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::spinlock_wait PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_spinlock_wait.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_spinlock_wait.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::spinlock_wait )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::spinlock_wait "${_IMPORT_PREFIX}/lib64/libabsl_spinlock_wait.so.2111.0.0" )

# Import target "absl::malloc_internal" for configuration "Release"
set_property(TARGET absl::malloc_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::malloc_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_malloc_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_malloc_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::malloc_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::malloc_internal "${_IMPORT_PREFIX}/lib64/libabsl_malloc_internal.so.2111.0.0" )

# Import target "absl::base" for configuration "Release"
set_property(TARGET absl::base APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::base PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_base.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_base.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::base )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::base "${_IMPORT_PREFIX}/lib64/libabsl_base.so.2111.0.0" )

# Import target "absl::throw_delegate" for configuration "Release"
set_property(TARGET absl::throw_delegate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::throw_delegate PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_throw_delegate.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_throw_delegate.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::throw_delegate )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::throw_delegate "${_IMPORT_PREFIX}/lib64/libabsl_throw_delegate.so.2111.0.0" )

# Import target "absl::scoped_set_env" for configuration "Release"
set_property(TARGET absl::scoped_set_env APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::scoped_set_env PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_scoped_set_env.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_scoped_set_env.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::scoped_set_env )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::scoped_set_env "${_IMPORT_PREFIX}/lib64/libabsl_scoped_set_env.so.2111.0.0" )

# Import target "absl::strerror" for configuration "Release"
set_property(TARGET absl::strerror APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::strerror PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_strerror.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_strerror.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::strerror )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::strerror "${_IMPORT_PREFIX}/lib64/libabsl_strerror.so.2111.0.0" )

# Import target "absl::hashtablez_sampler" for configuration "Release"
set_property(TARGET absl::hashtablez_sampler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::hashtablez_sampler PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_hashtablez_sampler.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_hashtablez_sampler.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::hashtablez_sampler )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::hashtablez_sampler "${_IMPORT_PREFIX}/lib64/libabsl_hashtablez_sampler.so.2111.0.0" )

# Import target "absl::raw_hash_set" for configuration "Release"
set_property(TARGET absl::raw_hash_set APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::raw_hash_set PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_raw_hash_set.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_raw_hash_set.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::raw_hash_set )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::raw_hash_set "${_IMPORT_PREFIX}/lib64/libabsl_raw_hash_set.so.2111.0.0" )

# Import target "absl::stacktrace" for configuration "Release"
set_property(TARGET absl::stacktrace APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::stacktrace PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_stacktrace.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_stacktrace.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::stacktrace )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::stacktrace "${_IMPORT_PREFIX}/lib64/libabsl_stacktrace.so.2111.0.0" )

# Import target "absl::symbolize" for configuration "Release"
set_property(TARGET absl::symbolize APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::symbolize PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_symbolize.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_symbolize.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::symbolize )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::symbolize "${_IMPORT_PREFIX}/lib64/libabsl_symbolize.so.2111.0.0" )

# Import target "absl::examine_stack" for configuration "Release"
set_property(TARGET absl::examine_stack APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::examine_stack PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_examine_stack.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_examine_stack.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::examine_stack )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::examine_stack "${_IMPORT_PREFIX}/lib64/libabsl_examine_stack.so.2111.0.0" )

# Import target "absl::failure_signal_handler" for configuration "Release"
set_property(TARGET absl::failure_signal_handler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::failure_signal_handler PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_failure_signal_handler.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_failure_signal_handler.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::failure_signal_handler )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::failure_signal_handler "${_IMPORT_PREFIX}/lib64/libabsl_failure_signal_handler.so.2111.0.0" )

# Import target "absl::debugging_internal" for configuration "Release"
set_property(TARGET absl::debugging_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::debugging_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_debugging_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_debugging_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::debugging_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::debugging_internal "${_IMPORT_PREFIX}/lib64/libabsl_debugging_internal.so.2111.0.0" )

# Import target "absl::demangle_internal" for configuration "Release"
set_property(TARGET absl::demangle_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::demangle_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_demangle_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_demangle_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::demangle_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::demangle_internal "${_IMPORT_PREFIX}/lib64/libabsl_demangle_internal.so.2111.0.0" )

# Import target "absl::leak_check" for configuration "Release"
set_property(TARGET absl::leak_check APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::leak_check PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_leak_check.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_leak_check.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::leak_check )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::leak_check "${_IMPORT_PREFIX}/lib64/libabsl_leak_check.so.2111.0.0" )

# Import target "absl::leak_check_disable" for configuration "Release"
set_property(TARGET absl::leak_check_disable APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::leak_check_disable PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_leak_check_disable.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_leak_check_disable.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::leak_check_disable )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::leak_check_disable "${_IMPORT_PREFIX}/lib64/libabsl_leak_check_disable.so.2111.0.0" )

# Import target "absl::flags_program_name" for configuration "Release"
set_property(TARGET absl::flags_program_name APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_program_name PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_program_name.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_program_name.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_program_name )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_program_name "${_IMPORT_PREFIX}/lib64/libabsl_flags_program_name.so.2111.0.0" )

# Import target "absl::flags_config" for configuration "Release"
set_property(TARGET absl::flags_config APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_config PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_config.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_config.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_config )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_config "${_IMPORT_PREFIX}/lib64/libabsl_flags_config.so.2111.0.0" )

# Import target "absl::flags_marshalling" for configuration "Release"
set_property(TARGET absl::flags_marshalling APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_marshalling PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_marshalling.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_marshalling.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_marshalling )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_marshalling "${_IMPORT_PREFIX}/lib64/libabsl_flags_marshalling.so.2111.0.0" )

# Import target "absl::flags_commandlineflag_internal" for configuration "Release"
set_property(TARGET absl::flags_commandlineflag_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_commandlineflag_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_commandlineflag_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_commandlineflag_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_commandlineflag_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_commandlineflag_internal "${_IMPORT_PREFIX}/lib64/libabsl_flags_commandlineflag_internal.so.2111.0.0" )

# Import target "absl::flags_commandlineflag" for configuration "Release"
set_property(TARGET absl::flags_commandlineflag APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_commandlineflag PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_commandlineflag.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_commandlineflag.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_commandlineflag )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_commandlineflag "${_IMPORT_PREFIX}/lib64/libabsl_flags_commandlineflag.so.2111.0.0" )

# Import target "absl::flags_private_handle_accessor" for configuration "Release"
set_property(TARGET absl::flags_private_handle_accessor APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_private_handle_accessor PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_private_handle_accessor.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_private_handle_accessor.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_private_handle_accessor )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_private_handle_accessor "${_IMPORT_PREFIX}/lib64/libabsl_flags_private_handle_accessor.so.2111.0.0" )

# Import target "absl::flags_reflection" for configuration "Release"
set_property(TARGET absl::flags_reflection APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_reflection PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_reflection.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_reflection.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_reflection )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_reflection "${_IMPORT_PREFIX}/lib64/libabsl_flags_reflection.so.2111.0.0" )

# Import target "absl::flags_internal" for configuration "Release"
set_property(TARGET absl::flags_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_internal "${_IMPORT_PREFIX}/lib64/libabsl_flags_internal.so.2111.0.0" )

# Import target "absl::flags" for configuration "Release"
set_property(TARGET absl::flags APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags "${_IMPORT_PREFIX}/lib64/libabsl_flags.so.2111.0.0" )

# Import target "absl::flags_usage_internal" for configuration "Release"
set_property(TARGET absl::flags_usage_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_usage_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_usage_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_usage_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_usage_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_usage_internal "${_IMPORT_PREFIX}/lib64/libabsl_flags_usage_internal.so.2111.0.0" )

# Import target "absl::flags_usage" for configuration "Release"
set_property(TARGET absl::flags_usage APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_usage PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_usage.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_usage.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_usage )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_usage "${_IMPORT_PREFIX}/lib64/libabsl_flags_usage.so.2111.0.0" )

# Import target "absl::flags_parse" for configuration "Release"
set_property(TARGET absl::flags_parse APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::flags_parse PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_flags_parse.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_flags_parse.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::flags_parse )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::flags_parse "${_IMPORT_PREFIX}/lib64/libabsl_flags_parse.so.2111.0.0" )

# Import target "absl::hash" for configuration "Release"
set_property(TARGET absl::hash APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::hash PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_hash.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_hash.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::hash )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::hash "${_IMPORT_PREFIX}/lib64/libabsl_hash.so.2111.0.0" )

# Import target "absl::city" for configuration "Release"
set_property(TARGET absl::city APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::city PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_city.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_city.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::city )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::city "${_IMPORT_PREFIX}/lib64/libabsl_city.so.2111.0.0" )

# Import target "absl::low_level_hash" for configuration "Release"
set_property(TARGET absl::low_level_hash APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::low_level_hash PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_low_level_hash.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_low_level_hash.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::low_level_hash )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::low_level_hash "${_IMPORT_PREFIX}/lib64/libabsl_low_level_hash.so.2111.0.0" )

# Import target "absl::int128" for configuration "Release"
set_property(TARGET absl::int128 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::int128 PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_int128.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_int128.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::int128 )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::int128 "${_IMPORT_PREFIX}/lib64/libabsl_int128.so.2111.0.0" )

# Import target "absl::exponential_biased" for configuration "Release"
set_property(TARGET absl::exponential_biased APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::exponential_biased PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_exponential_biased.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_exponential_biased.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::exponential_biased )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::exponential_biased "${_IMPORT_PREFIX}/lib64/libabsl_exponential_biased.so.2111.0.0" )

# Import target "absl::periodic_sampler" for configuration "Release"
set_property(TARGET absl::periodic_sampler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::periodic_sampler PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_periodic_sampler.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_periodic_sampler.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::periodic_sampler )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::periodic_sampler "${_IMPORT_PREFIX}/lib64/libabsl_periodic_sampler.so.2111.0.0" )

# Import target "absl::random_distributions" for configuration "Release"
set_property(TARGET absl::random_distributions APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_distributions PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_distributions.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_distributions.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_distributions )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_distributions "${_IMPORT_PREFIX}/lib64/libabsl_random_distributions.so.2111.0.0" )

# Import target "absl::random_seed_gen_exception" for configuration "Release"
set_property(TARGET absl::random_seed_gen_exception APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_seed_gen_exception PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_seed_gen_exception.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_seed_gen_exception.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_seed_gen_exception )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_seed_gen_exception "${_IMPORT_PREFIX}/lib64/libabsl_random_seed_gen_exception.so.2111.0.0" )

# Import target "absl::random_seed_sequences" for configuration "Release"
set_property(TARGET absl::random_seed_sequences APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_seed_sequences PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_seed_sequences.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_seed_sequences.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_seed_sequences )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_seed_sequences "${_IMPORT_PREFIX}/lib64/libabsl_random_seed_sequences.so.2111.0.0" )

# Import target "absl::random_internal_seed_material" for configuration "Release"
set_property(TARGET absl::random_internal_seed_material APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_seed_material PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_seed_material.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_seed_material.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_seed_material )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_seed_material "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_seed_material.so.2111.0.0" )

# Import target "absl::random_internal_pool_urbg" for configuration "Release"
set_property(TARGET absl::random_internal_pool_urbg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_pool_urbg PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_pool_urbg.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_pool_urbg.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_pool_urbg )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_pool_urbg "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_pool_urbg.so.2111.0.0" )

# Import target "absl::random_internal_platform" for configuration "Release"
set_property(TARGET absl::random_internal_platform APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_platform PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_platform.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_platform.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_platform )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_platform "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_platform.so.2111.0.0" )

# Import target "absl::random_internal_randen" for configuration "Release"
set_property(TARGET absl::random_internal_randen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_randen PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_randen.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_randen )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_randen "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen.so.2111.0.0" )

# Import target "absl::random_internal_randen_slow" for configuration "Release"
set_property(TARGET absl::random_internal_randen_slow APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_randen_slow PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen_slow.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_randen_slow.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_randen_slow )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_randen_slow "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen_slow.so.2111.0.0" )

# Import target "absl::random_internal_randen_hwaes" for configuration "Release"
set_property(TARGET absl::random_internal_randen_hwaes APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_randen_hwaes PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen_hwaes.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_randen_hwaes.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_randen_hwaes )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_randen_hwaes "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen_hwaes.so.2111.0.0" )

# Import target "absl::random_internal_randen_hwaes_impl" for configuration "Release"
set_property(TARGET absl::random_internal_randen_hwaes_impl APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_randen_hwaes_impl PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen_hwaes_impl.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_randen_hwaes_impl.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_randen_hwaes_impl )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_randen_hwaes_impl "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_randen_hwaes_impl.so.2111.0.0" )

# Import target "absl::random_internal_distribution_test_util" for configuration "Release"
set_property(TARGET absl::random_internal_distribution_test_util APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::random_internal_distribution_test_util PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_distribution_test_util.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_random_internal_distribution_test_util.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::random_internal_distribution_test_util )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::random_internal_distribution_test_util "${_IMPORT_PREFIX}/lib64/libabsl_random_internal_distribution_test_util.so.2111.0.0" )

# Import target "absl::status" for configuration "Release"
set_property(TARGET absl::status APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::status PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_status.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_status.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::status )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::status "${_IMPORT_PREFIX}/lib64/libabsl_status.so.2111.0.0" )

# Import target "absl::statusor" for configuration "Release"
set_property(TARGET absl::statusor APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::statusor PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_statusor.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_statusor.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::statusor )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::statusor "${_IMPORT_PREFIX}/lib64/libabsl_statusor.so.2111.0.0" )

# Import target "absl::strings" for configuration "Release"
set_property(TARGET absl::strings APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::strings PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_strings.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_strings.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::strings )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::strings "${_IMPORT_PREFIX}/lib64/libabsl_strings.so.2111.0.0" )

# Import target "absl::strings_internal" for configuration "Release"
set_property(TARGET absl::strings_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::strings_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_strings_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_strings_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::strings_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::strings_internal "${_IMPORT_PREFIX}/lib64/libabsl_strings_internal.so.2111.0.0" )

# Import target "absl::str_format_internal" for configuration "Release"
set_property(TARGET absl::str_format_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::str_format_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_str_format_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_str_format_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::str_format_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::str_format_internal "${_IMPORT_PREFIX}/lib64/libabsl_str_format_internal.so.2111.0.0" )

# Import target "absl::cord_internal" for configuration "Release"
set_property(TARGET absl::cord_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::cord_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_cord_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_cord_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::cord_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::cord_internal "${_IMPORT_PREFIX}/lib64/libabsl_cord_internal.so.2111.0.0" )

# Import target "absl::cordz_functions" for configuration "Release"
set_property(TARGET absl::cordz_functions APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::cordz_functions PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_cordz_functions.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_cordz_functions.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::cordz_functions )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::cordz_functions "${_IMPORT_PREFIX}/lib64/libabsl_cordz_functions.so.2111.0.0" )

# Import target "absl::cordz_handle" for configuration "Release"
set_property(TARGET absl::cordz_handle APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::cordz_handle PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_cordz_handle.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_cordz_handle.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::cordz_handle )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::cordz_handle "${_IMPORT_PREFIX}/lib64/libabsl_cordz_handle.so.2111.0.0" )

# Import target "absl::cordz_info" for configuration "Release"
set_property(TARGET absl::cordz_info APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::cordz_info PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_cordz_info.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_cordz_info.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::cordz_info )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::cordz_info "${_IMPORT_PREFIX}/lib64/libabsl_cordz_info.so.2111.0.0" )

# Import target "absl::cordz_sample_token" for configuration "Release"
set_property(TARGET absl::cordz_sample_token APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::cordz_sample_token PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_cordz_sample_token.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_cordz_sample_token.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::cordz_sample_token )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::cordz_sample_token "${_IMPORT_PREFIX}/lib64/libabsl_cordz_sample_token.so.2111.0.0" )

# Import target "absl::cord" for configuration "Release"
set_property(TARGET absl::cord APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::cord PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_cord.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_cord.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::cord )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::cord "${_IMPORT_PREFIX}/lib64/libabsl_cord.so.2111.0.0" )

# Import target "absl::graphcycles_internal" for configuration "Release"
set_property(TARGET absl::graphcycles_internal APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::graphcycles_internal PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_graphcycles_internal.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_graphcycles_internal.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::graphcycles_internal )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::graphcycles_internal "${_IMPORT_PREFIX}/lib64/libabsl_graphcycles_internal.so.2111.0.0" )

# Import target "absl::synchronization" for configuration "Release"
set_property(TARGET absl::synchronization APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::synchronization PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_synchronization.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_synchronization.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::synchronization )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::synchronization "${_IMPORT_PREFIX}/lib64/libabsl_synchronization.so.2111.0.0" )

# Import target "absl::time" for configuration "Release"
set_property(TARGET absl::time APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::time PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_time.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_time.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::time )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::time "${_IMPORT_PREFIX}/lib64/libabsl_time.so.2111.0.0" )

# Import target "absl::civil_time" for configuration "Release"
set_property(TARGET absl::civil_time APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::civil_time PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_civil_time.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_civil_time.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::civil_time )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::civil_time "${_IMPORT_PREFIX}/lib64/libabsl_civil_time.so.2111.0.0" )

# Import target "absl::time_zone" for configuration "Release"
set_property(TARGET absl::time_zone APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::time_zone PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_time_zone.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_time_zone.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::time_zone )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::time_zone "${_IMPORT_PREFIX}/lib64/libabsl_time_zone.so.2111.0.0" )

# Import target "absl::bad_any_cast_impl" for configuration "Release"
set_property(TARGET absl::bad_any_cast_impl APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::bad_any_cast_impl PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_bad_any_cast_impl.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_bad_any_cast_impl.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::bad_any_cast_impl )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::bad_any_cast_impl "${_IMPORT_PREFIX}/lib64/libabsl_bad_any_cast_impl.so.2111.0.0" )

# Import target "absl::bad_optional_access" for configuration "Release"
set_property(TARGET absl::bad_optional_access APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::bad_optional_access PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_bad_optional_access.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_bad_optional_access.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::bad_optional_access )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::bad_optional_access "${_IMPORT_PREFIX}/lib64/libabsl_bad_optional_access.so.2111.0.0" )

# Import target "absl::bad_variant_access" for configuration "Release"
set_property(TARGET absl::bad_variant_access APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(absl::bad_variant_access PROPERTIES
  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libabsl_bad_variant_access.so.2111.0.0"
  IMPORTED_SONAME_RELEASE "libabsl_bad_variant_access.so.2111.0.0"
  )

list(APPEND _IMPORT_CHECK_TARGETS absl::bad_variant_access )
list(APPEND _IMPORT_CHECK_FILES_FOR_absl::bad_variant_access "${_IMPORT_PREFIX}/lib64/libabsl_bad_variant_access.so.2111.0.0" )

# Commands beyond this point should not need to know the version.
set(CMAKE_IMPORT_FILE_VERSION)


text:
@InProceedings{osting13,
  pdf = {http://jmlr.org/proceedings/papers/v28/osting13.pdf},
  title = {Enhanced statistical rankings  via  targeted data collection},
  author = {Osting, Braxton and Brune, Christoph and Osher, Stanley},
  number = {1},
  section = {cycle-1},
  pages = {489-497},
  abstract = {Given a graph where vertices represent alternatives and pairwise comparison data, $y_{ij}$, is given on the edges, the statistical ranking problem is to find a potential function, defined on the vertices, such that the gradient of the potential function agrees with pairwise comparisons. We study the dependence of the statistical ranking problem on the available pairwise data, i.e., pairs (i,j) for which the pairwise comparison data $y_{ij}$ is known, and propose a framework to identify data which, when augmented with the current dataset, maximally increases the Fisher information of the ranking. Under certain assumptions, the data collection problem decouples, reducing to a problem of finding an edge set on the graph (with a fixed number of edges) such that the  second eigenvalue of the graph Laplacian is maximal. This reduction of the data collection problem to a spectral graph-theoretic question is one of the primary contributions of this work. As an application, we study the Yahoo! Movie user rating dataset and demonstrate that the addition of a small number of well-chosen pairwise comparisons can significantly increase the Fisher informativeness of the ranking. },
}

license: MIT

repository: mreid/papersite

license_type: permissive

repo_name: mreid/papersite

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
LICENSE = "MIT"

# Base this image on rpi-basic-image
require recipes-core/images/core-image-base.bb

IMAGE_LINGUAS = "en-us"

COMPATIBLE_MACHINE = "^rpi$"

IMAGE_INSTALL_append += " \
  wpa-supplicant \
  hostapd \
  dnsmasq \
  iptables \
  ntp \
  nano \
  crda \
  iw \
"

IMAGE_INSTALL = "packagegroup-core-boot \
    packagegroup-core-x11 \
    packagegroup-xfce-base \
    kernel-modules \
    linux-firmware-rpidistro-bcm43455 \
    linux-firmware-bcm43455 \
"
#OpenCV
IMAGE_INSTALL_append += " \
  opencv \
  ffmpeg \
"
#----------------------------------------------------------------------------------------------------------------
#ssh
IMAGE_INSTALL_append += " \
  openssh \
"
#-----------------------------------------------------------------------------------------------------------------
#toolbox
IMAGE_INSTALL_append += " \
  python-modules \
  python3-modules \
  git \
  wget \
  apt \
"

inherit distro_features_check
REQUIRED_DISTRO_FEATURES = "x11"

extension: bb


text:
// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/ledger/bin/cloud_sync/impl/page_upload.h"

#include <lib/fidl/cpp/optional.h>
#include <lib/fit/function.h>
#include <lib/gtest/test_loop_fixture.h>

#include <memory>
#include <utility>
#include <vector>

#include <gmock/gmock.h>

#include "src/ledger/bin/cloud_sync/impl/constants.h"
#include "src/ledger/bin/cloud_sync/impl/testing/test_page_cloud.h"
#include "src/ledger/bin/cloud_sync/impl/testing/test_page_storage.h"
#include "src/ledger/bin/cloud_sync/public/sync_state_watcher.h"
#include "src/ledger/bin/encryption/fake/fake_encryption_service.h"
#include "src/ledger/bin/storage/public/page_storage.h"
#include "src/ledger/bin/storage/testing/commit_empty_impl.h"
#include "src/ledger/bin/storage/testing/page_storage_empty_impl.h"
#include "src/lib/backoff/backoff.h"
#include "src/lib/backoff/testing/test_backoff.h"
#include "src/lib/callback/capture.h"
#include "src/lib/fsl/socket/strings.h"
#include "src/lib/fxl/macros.h"

namespace cloud_sync {
namespace {

using ::testing::Each;
using ::testing::Truly;

constexpr zx::duration kBackoffInterval = zx::msec(10);
constexpr zx::duration kHalfBackoffInterval = zx::msec(5);

// Creates a dummy continuation token.
cloud_provider::PositionToken MakeToken(convert::ExtendedStringView token_id) {
  cloud_provider::PositionToken token;
  token.opaque_id = convert::ToArray(token_id);
  return token;
}

class PageUploadTest : public gtest::TestLoopFixture, public PageUpload::Delegate {
 public:
  PageUploadTest()
      : storage_(dispatcher()),
        encryption_service_(dispatcher()),
        page_cloud_(page_cloud_ptr_.NewRequest()),
        task_runner_(dispatcher()) {
    auto test_backoff = std::make_unique<backoff::TestBackoff>(kBackoffInterval);
    backoff_ = test_backoff.get();
    page_upload_ = std::make_unique<PageUpload>(&task_runner_, &storage_, &encryption_service_,
                                                &page_cloud_ptr_, this, std::move(test_backoff));
  }
  ~PageUploadTest() override = default;

 protected:
  void SetOnNewStateCallback(fit::closure callback) { new_state_callback_ = std::move(callback); }

  void SetUploadState(UploadSyncState sync_state) override {
    states_.push_back(sync_state);
    if (new_state_callback_) {
      new_state_callback_();
    }
  }

  bool IsDownloadIdle() override { return is_download_idle_; }

  TestPageStorage storage_;
  encryption::FakeEncryptionService encryption_service_;
  cloud_provider::PageCloudPtr page_cloud_ptr_;
  TestPageCloud page_cloud_;
  std::vector<UploadSyncState> states_;
  std::unique_ptr<PageUpload> page_upload_;
  backoff::TestBackoff* backoff_;
  bool is_download_idle_ = true;

 private:
  fit::closure new_state_callback_;
  callback::ScopedTaskRunner task_runner_;
  FXL_DISALLOW_COPY_AND_ASSIGN(PageUploadTest);
};

// Verifies that the backlog of commits to upload returned from
// GetUnsyncedCommits() is uploaded to PageCloudHandler.
TEST_F(PageUploadTest, UploadBacklog) {
  storage_.NewCommit("id1", "content1");
  storage_.NewCommit("id2", "content2");
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();

  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);

  ASSERT_EQ(page_cloud_.received_commits.size(), 2u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id1")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content1");
  EXPECT_EQ(page_cloud_.received_commits[1].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id2")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[1].data()),
            "content2");
  EXPECT_EQ(storage_.commits_marked_as_synced.size(), 2u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id1"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id2"), 1u);
}

// Verifies that the backlog of commits to upload is not uploaded until there's
// only one local head.
TEST_F(PageUploadTest, UploadBacklogOnlyOnSingleHead) {
  // Verify that two local commits are not uploaded when there is two local
  // heads.
  bool upload_is_paused = false;
  storage_.head_count = 2;
  storage_.NewCommit("id0", "content0");
  storage_.NewCommit("id1", "content1");
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();

  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  EXPECT_EQ(page_cloud_.received_commits.size(), 0u);
  EXPECT_EQ(storage_.commits_marked_as_synced.size(), 0u);

  // Add a new commit and reduce the number of heads to 1.
  upload_is_paused = false;
  storage_.head_count = 1;
  auto commit = storage_.NewCommit("id2", "content2");
  storage_.watcher_->OnNewCommits(commit->AsList(), storage::ChangeSource::LOCAL);
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);

  // Verify that all local commits were uploaded.
  ASSERT_EQ(page_cloud_.received_commits.size(), 3u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id0")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content0");
  EXPECT_EQ(page_cloud_.received_commits[1].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id1")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[1].data()),
            "content1");
  EXPECT_EQ(page_cloud_.received_commits[2].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id2")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[2].data()),
            "content2");
  EXPECT_EQ(storage_.commits_marked_as_synced.size(), 3u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id0"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id1"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id2"), 1u);
}

TEST_F(PageUploadTest, UploadExistingCommitsOnlyAfterBacklogDownload) {
  // Verify that two local commits are not uploaded when download is in
  // progress.
  storage_.NewCommit("local1", "content1");
  storage_.NewCommit("local2", "content2");

  page_cloud_.commits_to_return.push_back(MakeTestCommit(&encryption_service_, "content3"));
  page_cloud_.commits_to_return.push_back(MakeTestCommit(&encryption_service_, "content4"));
  page_cloud_.position_token_to_return = fidl::MakeOptional(MakeToken("44"));

  is_download_idle_ = false;
  bool upload_wait_remote_download = false;
  SetOnNewStateCallback([this, &upload_wait_remote_download] {
    if (states_.back() == UPLOAD_WAIT_REMOTE_DOWNLOAD) {
      upload_wait_remote_download = true;
    }
  });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_wait_remote_download);

  EXPECT_EQ(page_cloud_.received_commits.size(), 0u);
  EXPECT_EQ(storage_.commits_marked_as_synced.size(), 0u);

  is_download_idle_ = true;
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);

  ASSERT_EQ(page_cloud_.received_commits.size(), 2u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("local1")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content1");
  EXPECT_EQ(page_cloud_.received_commits[1].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("local2")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[1].data()),
            "content2");
  ASSERT_EQ(storage_.commits_marked_as_synced.size(), 2u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("local1"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("local2"), 1u);
}

// Verfies that the new commits that PageSync is notified about through storage
// watcher are uploaded to PageCloudHandler, with the exception of commits that
// themselves come from sync.
TEST_F(PageUploadTest, UploadNewCommits) {
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;

  auto commit1 = storage_.NewCommit("id1", "content1");
  storage_.watcher_->OnNewCommits(commit1->AsList(), storage::ChangeSource::LOCAL);

  // The commit coming from sync should be ignored.
  auto commit2 = storage_.NewCommit("id2", "content2", false);
  storage_.watcher_->OnNewCommits(commit2->AsList(), storage::ChangeSource::CLOUD);

  auto commit3 = storage_.NewCommit("id3", "content3");
  storage_.watcher_->OnNewCommits(commit3->AsList(), storage::ChangeSource::LOCAL);

  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);

  ASSERT_EQ(page_cloud_.received_commits.size(), 2u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id1")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content1");
  EXPECT_EQ(page_cloud_.received_commits[1].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id3")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[1].data()),
            "content3");
  EXPECT_EQ(storage_.commits_marked_as_synced.size(), 2u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id1"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id3"), 1u);
}

// Verifies that new commits being added to storage are only uploaded while
// there is only a single head.
TEST_F(PageUploadTest, UploadNewCommitsOnlyOnSingleHead) {
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;

  // Add a new commit when there's only one head and verify that it is
  // uploaded.
  storage_.head_count = 1;
  auto commit0 = storage_.NewCommit("id0", "content0");
  storage_.watcher_->OnNewCommits(commit0->AsList(), storage::ChangeSource::LOCAL);
  EXPECT_FALSE(page_upload_->IsPaused());
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;
  ASSERT_EQ(page_cloud_.received_commits.size(), 1u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id0")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content0");
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id0"), 1u);

  // Add another commit when there's two heads and verify that it is not
  // uploaded.
  page_cloud_.received_commits.clear();
  storage_.head_count = 2;
  auto commit1 = storage_.NewCommit("id1", "content1");
  storage_.watcher_->OnNewCommits(commit1->AsList(), storage::ChangeSource::LOCAL);
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;
  ASSERT_EQ(page_cloud_.received_commits.size(), 0u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id1"), 0u);

  // Add another commit bringing the number of heads down to one and verify that
  // both commits are uploaded.
  storage_.head_count = 1;
  auto commit2 = storage_.NewCommit("id2", "content2");
  storage_.watcher_->OnNewCommits(commit2->AsList(), storage::ChangeSource::LOCAL);
  EXPECT_FALSE(page_upload_->IsPaused());
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  ASSERT_EQ(page_cloud_.received_commits.size(), 2u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id1")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content1");
  EXPECT_EQ(page_cloud_.received_commits[1].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id2")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[1].data()),
            "content2");
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id1"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id2"), 1u);
}

// Verifies that existing commits are uploaded before the new ones.
TEST_F(PageUploadTest, UploadExistingAndNewCommits) {
  storage_.NewCommit("id1", "content1");
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;

  auto commit = storage_.NewCommit("id2", "content2");
  storage_.watcher_->OnNewCommits(commit->AsList(), storage::ChangeSource::LOCAL);
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);

  ASSERT_EQ(page_cloud_.received_commits.size(), 2u);
  ASSERT_THAT(page_cloud_.received_commits, Each(Truly(CommitHasIdAndData)));
  EXPECT_EQ(page_cloud_.received_commits[0].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id1")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[0].data()),
            "content1");
  EXPECT_EQ(page_cloud_.received_commits[1].id(),
            convert::ToArray(encryption_service_.EncodeCommitId("id2")));
  EXPECT_EQ(encryption_service_.DecryptCommitSynchronous(page_cloud_.received_commits[1].data()),
            "content2");
  EXPECT_EQ(storage_.commits_marked_as_synced.size(), 2u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id1"), 1u);
  EXPECT_EQ(storage_.commits_marked_as_synced.count("id2"), 1u);
}

// Verifies that failing uploads are retried.
TEST_F(PageUploadTest, RetryUpload) {
  page_upload_->StartOrRestartUpload();
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  SetOnNewStateCallback(nullptr);

  page_cloud_.commit_status_to_return = cloud_provider::Status::NETWORK_ERROR;
  auto commit1 = storage_.NewCommit("id1", "content1");
  storage_.watcher_->OnNewCommits(commit1->AsList(), storage::ChangeSource::LOCAL);
  RunLoopFor(kHalfBackoffInterval);
  EXPECT_GE(backoff_->get_next_count, 0);
  RunLoopFor(kBackoffInterval);
  EXPECT_GE(backoff_->get_next_count, 1);
  RunLoopFor(kBackoffInterval);
  EXPECT_GE(backoff_->get_next_count, 2);

  // Verify that the commit is still not marked as synced in storage.
  EXPECT_TRUE(storage_.commits_marked_as_synced.empty());
}

// Verifies that the idle status is returned when there is no pending upload
// task.
TEST_F(PageUploadTest, UploadIdleStatus) {
  int on_idle_calls = 0;

  storage_.NewCommit("id1", "content1");
  storage_.NewCommit("id2", "content2");

  SetOnNewStateCallback([this, &on_idle_calls] {
    if (states_.back() == UPLOAD_IDLE) {
      on_idle_calls++;
    }
  });
  page_upload_->StartOrRestartUpload();

  // Verify that the idle callback is called once both commits are uploaded.
  RunLoopUntilIdle();
  EXPECT_EQ(page_cloud_.received_commits.size(), 2u);
  EXPECT_EQ(on_idle_calls, 1);
  EXPECT_TRUE(page_upload_->IsPaused());

  // Notify about a new commit to upload and verify that the idle callback was
  // called again on completion.
  auto commit3 = storage_.NewCommit("id3", "content3");
  storage_.watcher_->OnNewCommits(commit3->AsList(), storage::ChangeSource::LOCAL);
  EXPECT_FALSE(page_upload_->IsPaused());
  RunLoopUntilIdle();
  EXPECT_EQ(page_cloud_.received_commits.size(), 3u);
  EXPECT_EQ(on_idle_calls, 2);
  EXPECT_TRUE(page_upload_->IsPaused());
}

// Verifies that if listing the original commits to be uploaded fails, the
// client is notified about the error.
TEST_F(PageUploadTest, FailToListCommits) {
  EXPECT_FALSE(storage_.watcher_set);
  int error_calls = 0;
  storage_.should_fail_get_unsynced_commits = true;
  SetOnNewStateCallback([this, &error_calls] {
    if (states_.back() == UPLOAD_PERMANENT_ERROR) {
      error_calls++;
    }
  });

  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  EXPECT_EQ(error_calls, 1);
  EXPECT_EQ(page_cloud_.received_commits.size(), 0u);
}

// Verifies that already synced commits are not re-uploaded.
TEST_F(PageUploadTest, DoNotUploadSyncedCommits) {
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;

  auto commit = std::make_unique<TestCommit>("id", "content");
  storage_.watcher_->OnNewCommits(commit->AsList(), storage::ChangeSource::LOCAL);
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);

  // Commit is already synced.
  ASSERT_EQ(page_cloud_.received_commits.size(), 0u);
}

// Verifies that commits that are received between the first upload and the
// retry are not sent.
TEST_F(PageUploadTest, DoNotUploadSyncedCommitsOnRetry) {
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] {
    upload_is_paused = page_upload_->IsPaused();
    if (states_.back() == UploadSyncState::UPLOAD_TEMPORARY_ERROR) {
      QuitLoop();
    }
  });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;

  page_cloud_.commit_status_to_return = cloud_provider::Status::NETWORK_ERROR;

  auto commit = storage_.NewCommit("id", "content");
  storage_.watcher_->OnNewCommits(commit->AsList(), storage::ChangeSource::LOCAL);

  // The page upload should run into temporary error.
  RunLoopUntilIdle();
  EXPECT_EQ(states_.back(), UploadSyncState::UPLOAD_TEMPORARY_ERROR);
  EXPECT_GT(page_cloud_.add_commits_calls, 0u);

  // Configure the cloud to accept the next attempt to upload.
  page_cloud_.commit_status_to_return = cloud_provider::Status::OK;
  page_cloud_.add_commits_calls = 0u;

  // Make storage report the commit as synced (not include it in the list of
  // unsynced commits to return).
  storage_.unsynced_commits_to_return.clear();

  RunLoopFor(kHalfBackoffInterval);
  EXPECT_EQ(states_.back(), UploadSyncState::UPLOAD_TEMPORARY_ERROR);
  EXPECT_TRUE(upload_is_paused);
  RunLoopFor(kBackoffInterval);
  EXPECT_EQ(states_.back(), UploadSyncState::UPLOAD_IDLE);
  EXPECT_TRUE(upload_is_paused);

  // Verify that no calls were made to attempt to upload the commit.
  EXPECT_EQ(page_cloud_.add_commits_calls, 0u);
}

// Verifies that concurrent new commit notifications do not crash PageUpload.
TEST_F(PageUploadTest, UploadNewCommitsConcurrentNoCrash) {
  bool upload_is_paused = false;
  SetOnNewStateCallback([this, &upload_is_paused] { upload_is_paused = page_upload_->IsPaused(); });
  page_upload_->StartOrRestartUpload();
  RunLoopUntilIdle();
  ASSERT_TRUE(upload_is_paused);
  upload_is_paused = false;

  storage_.head_count = 2;
  auto commit0 = storage_.NewCommit("id0", "content0");
  storage_.watcher_->OnNewCommits(commit0->AsList(), storage::ChangeSource::LOCAL);

  auto commit1 = storage_.NewCommit("id1", "content1");
  storage_.watcher_->OnNewCommits(commit1->AsList(), storage::ChangeSource::LOCAL);
  RunLoopUntilIdle();
}

// Verifies that if upload fails when sending the object, we don't create a new batch and call
// GetUnsyncedCommits again.
TEST_F(PageUploadTest, RetryOnError) {
  storage_.NewCommit("id", "content");
  auto id = encryption_service_.MakeObjectIdentifier(storage_.GetObjectIdentifierFactory(),
                                                     storage::ObjectDigest("obj_digest"));
  storage_.unsynced_objects_to_return[id] =
      std::make_unique<storage::fake::FakePiece>(id, "obj_data");

  int failed_upload_count = 30;
  page_cloud_.object_status_to_return = cloud_provider::Status::NETWORK_ERROR;
  // Fail the upload |failed_upload_count| times.
  SetOnNewStateCallback([this, &failed_upload_count] {
    if (states_.back() == UploadSyncState::UPLOAD_TEMPORARY_ERROR) {
      ASSERT_GE(failed_upload_count, 0);
      failed_upload_count--;
      if (failed_upload_count == 0) {
        page_cloud_.object_status_to_return = cloud_provider::Status::OK;
      }
    }
  });
  page_upload_->StartOrRestartUpload();
  RunLoopFor(kBackoffInterval * 30);

  EXPECT_EQ(failed_upload_count, 0);
  // GetUnsyncedCommits should be called twice: once when creating the batch and once just before
  // uploading the commits.
  EXPECT_EQ(storage_.get_unsynced_commits_calls, 2u);
  EXPECT_EQ(page_cloud_.add_commits_calls, 1u);
  EXPECT_EQ(states_.back(), UploadSyncState::UPLOAD_IDLE);
}

}  // namespace
}  // namespace cloud_sync

repository: winksaville/fuchsia

repo_name: winksaville/fuchsia

extension: cc


text:
package behaviour

import (
	"behaviourtree/src/baseai"
)

//Behaviourer behaviourer
type Behaviourer struct {
	executor *baseai.Tree
}

//Init init
func (b *Behaviourer) Init() {
	b.executor = baseai.NewTree()
	root := baseai.NewRootNode()

	seq := baseai.NewSequence()
	action1 := NewAction1()
	action2 := NewAction2()
	seq.AddNode(action1, action2)

	root.AddNode(seq)
	b.executor.SetRoot(*root)
}

//Run run
func (b *Behaviourer) Run() {
	b.executor.Run()
}

gha_language: Go

extension: go


text:
package request

import (
	"testing"

	"github.com/rs/zerolog/log"
	"github.com/stretchr/testify/assert"
)

func TestNotPanicMarshalZerologObject(t *testing.T) {
	tests := []struct {
		name string
		id   ID
	}{
		{
			name: "New ID",
			id:   newID(),
		},
		{
			name: "Empty ID",
			id:   ID{},
		},
	}

	for _, test := range tests {
		assert.NotPanics(t, func() { log.Debug().EmbedObject(test.id) }, test.name)
	}
}

repository: arquivei/foundationkit

repo_name: arquivei/foundationkit


text:
@INPROCEEDINGS{9672401,
  author={Guo, Huaqun and Wei, Meng and Huang, Ping and Chekole, Eyasu Getahun},
  booktitle={2021 IEEE International Conference on Service Operations and Logistics, and Informatics (SOLI)},
  title={Enhance Enterprise Security through Implementing ISO/IEC 27001 Standard},
  year={2021},
  volume={},
  number={},
  pages={1-6},
  doi={10.1109/SOLI54607.2021.9672401}
}


text:
SUMMARY = "Xen Image Builder"
SECTION = "xen"
LICENSE = "MIT"

DEPENDS += "u-boot-mkimage-native"
inherit deploy

RDEPENDS_${PN} += "bash"

LIC_FILES_CHKSUM = "file://LICENSE;md5=d2794c0df5b907fdace235a619d80314"
SRC_URI = "git://github.com/Xilinx/imagebuilder.git;protocol=https"
BRANCH ??= "master"
SRCREV ??= "7760210b3c0e4ac29b7a7e5e2daba86f34ca79c2"
S = "${WORKDIR}/git"

do_install () {
	install -d ${D}${bindir}
	chmod -R 777 ${S}/scripts/*
	install -m 0755 ${S}/scripts/* ${D}${bindir}
	ln -sf ${D}${bindir}/uboot-script-gen uboot-script-gen
}

do_deploy() {
	:
}

do_deploy_class-native() {
	install -d ${DEPLOYDIR}
	install -m 0755 ${S}/scripts/uboot-script-gen ${DEPLOYDIR}/
}

addtask do_deploy after do_install

BBCLASSEXTEND = "native nativesdk"

repository: fullstackfpga/meta-petalinux

repo_name: fullstackfpga/meta-petalinux


text:
package main

func mergeInBetween(list1 *ListNode, a int, b int, list2 *ListNode) *ListNode {
	list2Tail := list2
	for ; list2Tail.Next != nil; list2Tail = list2Tail.Next {
	}
	var head, tail *ListNode
	for i, node := 0, list1; node != nil; i, node = i+1, node.Next {
		if i == a-1 {
			head = node
		} else if i == b {
			tail = node.Next
			break
		}
	}
	head.Next = list2
	list2Tail.Next = tail
	return list1
}

repository: ldsink/LeetCode

repo_name: ldsink/LeetCode