project('bmcweb', 'cpp',
        version : '1.0',
        meson_version: '>=0.63.0',
        default_options: [
            'b_lto_mode=default',
            'b_lto_threads=0',
            'b_lto=true',
            'b_ndebug=if-release',
            'buildtype=debugoptimized',
            'cpp_std=c++20',
            'warning_level=3',
            'werror=true',
           ])

cxx = meson.get_compiler('cpp')

if get_option('mtls-grpc').enabled()
  # For JWT-CPP
  add_project_arguments('-DJWT_DISABLE_PICOJSON', language : 'cpp')

  # Build time is spent linking. Making pattern_to_entity_array constexpr fixes the problem but
  # requires this compile flag to increase the constexpr limit
  if (cxx.get_id() == 'gcc' and cxx.version().version_compare('>8.0'))
    add_project_arguments('-fconstexpr-ops-limit=4294967295', language : 'cpp')
  endif
  if (cxx.get_id() == 'clang' and cxx.version().version_compare('>9.0'))
    add_project_arguments('-fconstexpr-steps=4294967295', language : 'cpp')
    add_project_arguments('-fclang-abi-compat=17', language : 'cpp')
  endif
endif

add_project_arguments('-DGBMCWEB_COMPILATION', language : 'cpp')

# Project related links
if (not get_option('plugins-headers').enabled())
  project_pretty_name = 'bmcweb'
  project_url = 'https://github.com/openbmc/' + project_pretty_name
  project_issues_url = project_url + '/issues/new'
  summary('Issues',project_issues_url, section: 'Report Issues')

  # Validate the c++ Standard

  if get_option('cpp_std') != 'c++20'
      error('This project requires c++20 support')
  endif

  # Get compiler and default build type

  cxx = meson.get_compiler('cpp')
  build = get_option('buildtype')
  optimization = get_option('optimization')
  summary('Build Type',build, section : 'Build Info')
  summary('Optimization',optimization, section : 'Build Info')


  # remove debug information for minsize buildtype
  if(get_option('buildtype') == 'minsize')
    add_project_arguments(['-fdata-sections', '-ffunction-sections'], language : 'cpp')
    add_project_arguments('-DNDEBUG', language : 'cpp')
  endif

  # Disable lto when compiling with no optimization
  if(get_option('optimization') == '0')
    add_project_arguments('-fno-lto', language: 'cpp')
    message('Disabling lto & its supported features as optimization is disabled')
  endif

  # Include Directories

  incdir = include_directories(
    '.',
    'tlbmc',
    'include',
    'plugins',
    'redfish-core/include',
    'redfish-core/include/utils',
    'redfish-core/lib',
    'http',
    'g3',
    'redfish_authorization',
  )

  # Get the options and enable the respective features
  ## create a MAP of  "options : feature_flag"

  feature_map = {
    'basic-auth'                                  : '-DBMCWEB_ENABLE_BASIC_AUTHENTICATION',
    'cookie-auth'                                 : '-DBMCWEB_ENABLE_COOKIE_AUTHENTICATION',
    'google-api'                                  : '-DBMCWEB_ENABLE_GOOGLE_API',
    'health-populate'                             : '-DHEALTH_POPULATE',
    'host-serial-socket'                          : '-DBMCWEB_ENABLE_HOST_SERIAL_WEBSOCKET',
    'ibm-management-console'                      : '-DBMCWEB_ENABLE_IBM_MANAGEMENT_CONSOLE',
    'insecure-disable-auth'                       : '-DBMCWEB_INSECURE_DISABLE_AUTHX',
    'insecure-disable-csrf'                       : '-DBMCWEB_INSECURE_DISABLE_CSRF_PREVENTION',
    'insecure-disable-ssl'                        : '-DBMCWEB_INSECURE_DISABLE_SSL',
    'insecure-push-style-notification'            : '-DBMCWEB_INSECURE_ENABLE_HTTP_PUSH_STYLE_EVENTING',
    'insecure-tftp-update'                        : '-DBMCWEB_INSECURE_ENABLE_REDFISH_FW_TFTP_UPDATE',
    'insecure-ignore-content-type'                : '-DBMCWEB_INSECURE_IGNORE_CONTENT_TYPE',
    'kvm'                                         : '-DBMCWEB_ENABLE_KVM' ,
    'mutual-tls-auth'                             : '-DBMCWEB_ENABLE_MUTUAL_TLS_AUTHENTICATION',
    'redfish-aggregation'                         : '-DBMCWEB_ENABLE_REDFISH_AGGREGATION',
    'redfish-allow-deprecated-power-thermal'      : '-DBMCWEB_ALLOW_DEPRECATED_POWER_THERMAL',
    'redfish-bmc-journal'                         : '-DBMCWEB_ENABLE_REDFISH_BMC_JOURNAL',
    'redfish-cpu-log'                             : '-DBMCWEB_ENABLE_REDFISH_CPU_LOG',
    'redfish-dbus-log'                            : '-DBMCWEB_ENABLE_REDFISH_DBUS_LOG_ENTRIES',
    'redfish-dump-log'                            : '-DBMCWEB_ENABLE_REDFISH_DUMP_LOG',
    'redfish-external-storer'                     : '-DBMCWEB_ENABLE_REDFISH_EXTERNAL_STORER',
    'redfish-event-log'                           : '-DBMCWEB_ENABLE_REDFISH_EVENT_LOG',
    'redfish-host-logger'                         : '-DBMCWEB_ENABLE_REDFISH_HOST_LOGGER',
    'redfish-host-cper-log'                       : '-DBMCWEB_ENABLE_REDFISH_HOST_CPER_LOG',
    'redfish-ppr'                                 : '-DBMCWEB_ENABLE_PPR',
    'redfish-rasmanager-log'                      : '-DBMCWEB_ENABLE_RASMANAGER_EVENT_LOG',
    'redfish-system-fault-log'                    : '-DBMCWEB_ENABLE_REDFISH_SYSTEM_FAULT_LOG',
    'redfish-new-powersubsystem-thermalsubsystem' : '-DBMCWEB_NEW_POWERSUBSYSTEM_THERMALSUBSYSTEM',
    'redfish-oem-manager-fan-data'                : '-DBMCWEB_ENABLE_REDFISH_OEM_MANAGER_FAN_DATA',
    'redfish-provisioning-feature'                : '-DBMCWEB_ENABLE_REDFISH_PROVISIONING_FEATURE',
    'redfish-post-to-old-updateservice'           : '-DBMCWEB_ENABLE_REDFISH_UPDATESERVICE_OLD_POST_URL',
    'redfish'                                     : '-DBMCWEB_ENABLE_REDFISH',
    'rest'                                        : '-DBMCWEB_ENABLE_DBUS_REST',
    'session-auth'                                : '-DBMCWEB_ENABLE_SESSION_AUTHENTICATION',
    'static-hosting'                              : '-DBMCWEB_ENABLE_STATIC_HOSTING',
    'vm-websocket'                                : '-DBMCWEB_ENABLE_VM_WEBSOCKET',
    'xtoken-auth'                                 : '-DBMCWEB_ENABLE_XTOKEN_AUTHENTICATION',
    'platform-plugins'                            : '-DPLATFORM_PLUGINS_ENABLED',
    'google-common-plugins'                       : '-DGOOGLE_COMMON_PLUGINS_ENABLED',
    'google-plugins-internal'                     : '-DGOOGLE_PLUGINS_INTERNAL_ENABLED',
    'efficient-expand'                            : '-DEFFICIENT_EXPAND_ENABLED',
    'loas3-validation'                            : '-DENABLE_LOAS3_VALIDATION',
    'redfish-boot-time-log'                       : '-DBMCWEB_ENABLE_REDFISH_BOOT_TIME_LOG',
    'redfish-boot-time'                           : '-DBMCWEB_ENABLE_REDFISH_BOOT_TIME',
  }

  # Create a "bm_config.h" header which sets the #define BM_SIGNAL_PATH
  bm_conf_data = configuration_data()
  bm_conf_data.set_quoted('BM_SIGNAL_PATH', get_option('bm-signal-path'))
  # sets the #define BIOS_BLOB_FILE_PATH
  bm_conf_data.set_quoted('BIOS_SETTING_FILE_PATH', get_option('bios-setting-file-path'))
  # sets the #define BIOS_SETTING_FILE_HANDLE
  bm_conf_data.set('BIOS_SETTING_FILE_HANDLE', get_option('bios-setting-file-handle'))
  # sets the #define ENABLE_BIOS_PEER_AUTH_BYPASS
  bm_conf_data.set10('ENABLE_BIOS_PEER_AUTH_BYPASS', get_option('bios-peer-auth-bypass').enabled())
  bm_conf_h = configure_file(
    output: 'bm_config.h',
    configuration: bm_conf_data)

  # gRPC Features
  feature_map += {'mtls-grpc' : '-DBMCWEB_ENABLE_GRPC'}
  feature_map += {'insecure-grpc' : '-DBMCWEB_ENABLE_INSECURE_GRPC'}


  # stateful-bmcweb feature
  feature_map += {'stateful-bmcweb' : '-DBMCWEB_ENABLE_STATEFUL_BMCWEB'}

  # AMD bmcweb feature
  feature_map += {'amd' : '-DBMCWEB_ENABLE_AMD'}

  # RDE-device feature
  feature_map += {'rde-device': '-DBMCWEB_ENABLE_RDE_DEVICE'}

  # CPER and Crashdump EntryID use FaultLogID
  feature_map += {'cper-crashdump-use-faultlog-id': '-DBMCWEB_ENABLE_CPER_CRASHDUMP_USE_FAULTLOG_ID'}

  # Get the options status and build a project summary to show which flags are
  # being enabled during the configuration time.

  foreach option_key,option_value : feature_map
    if(get_option(option_key).enabled())
      if(option_key == 'mutual-tls-auth' or option_key == 'insecure-disable-ssl')
        if(get_option('insecure-disable-ssl').disabled() or get_option('mutual-tls-auth').disabled())
          add_project_arguments(option_value,language:'cpp')
          summary(option_key,option_value, section : 'Enabled Features')
        endif
      elif (option_key in ['basic-auth', 'cookie-auth', 'session-auth', 'xtoken-auth', 'mutual-tls-auth'])
        if (get_option('insecure-disable-auth').disabled())
          add_project_arguments(option_value, language:'cpp')
          summary(option_key,option_value, section : 'Enabled Features')
        endif
      else
        summary(option_key,option_value, section : 'Enabled Features')
        add_project_arguments(option_value,language:'cpp')
      endif
    else
        if(option_key == 'insecure-disable-ssl')
          summary('ssl','-DBMCWEB_ENABLE_SSL', section : 'Enabled Features')
          add_project_arguments('-DBMCWEB_ENABLE_SSL', language : 'cpp')
        endif
    endif
  endforeach

  if(get_option('tests').enabled())
    summary('unittest','NA', section : 'Enabled Features')
    add_project_arguments('-DUNIT_TEST_BUILD', language : 'cpp')
  endif

  # Add compiler arguments

  # -Wpedantic, -Wextra comes by default with warning level
  add_project_arguments(
    cxx.get_supported_arguments([
    '-Wcast-align',
    '-Wformat=2',
    '-Wold-style-cast',
    '-Wsign-conversion',
    '-Wunused',
    '-Wno-attributes',
    '-Wno-shadow',
    ]),
    language: 'cpp'
  )

  if (cxx.get_id() == 'clang' and cxx.version().version_compare('>9.0'))
  add_project_arguments(
    cxx.get_supported_arguments([
      '-Wno-c++98-compat-pedantic',
      '-Wno-c++98-compat',
      '-Wno-documentation-unknown-command',
      '-Wno-documentation',
      '-Wno-exit-time-destructors',
      '-Wno-global-constructors',
      '-Wno-newline-eof',
      '-Wno-padded',
      '-Wno-used-but-marked-unused',
      '-Wno-weak-vtables',
      '-Wno-switch-enum',
      '-Wno-unused-parameter', # Flags when params are actually used
    ]),
    language:'cpp')
  endif

  # if compiler is gnu-gcc , and version is > 8.0 then we add few more
  # compiler arguments , we know that will pass

  if (cxx.get_id() == 'gcc' and cxx.version().version_compare('>8.0'))
    add_project_arguments(
      cxx.get_supported_arguments([
       '-Wduplicated-cond',
       '-Wduplicated-branches',
       '-Wlogical-op',
       '-Wnull-dereference',
       '-Wunused-parameter',
       '-Wdouble-promotion',
       '-Wno-psabi',
       ]),
      language:'cpp')
  endif

  if (get_option('buildtype') != 'plain')
    if (get_option('b_lto') == true and get_option('optimization')!='0')
      # Reduce the binary size by removing unnecessary
      # dynamic symbol table entries

      add_project_arguments(
       cxx.get_supported_arguments([
       '-fno-fat-lto-objects',
       '-fvisibility=hidden',
       '-fvisibility-inlines-hidden'
       ]),
       language: 'cpp')

      if cxx.has_link_argument('-Wl,--exclude-libs,ALL')
        add_project_link_arguments('-Wl,--exclude-libs,ALL', language: 'cpp')
      endif
    endif
  endif

  if( get_option('bmcweb-logging').enabled() or \
      get_option('buildtype').startswith('debug'))
   add_project_arguments([
     '-DBMCWEB_ENABLE_LOGGING',
     '-DBMCWEB_ENABLE_DEBUG'
     ],
    language : 'cpp')

    summary({'debug' :'-DBMCWEB_ENABLE_DEBUG',
       'logging' : '-DBMCWEB_ENABLE_LOGGING',

      },section : 'Enabled Features')
  endif

  # Set Compiler Security flags

  security_flags = [
    '-fstack-protector-strong',
    '-fPIE',
    '-fPIC',
    '-D_FORTIFY_SOURCE=2',
    '-Wformat',
    '-Wformat-security'
  ]

  ## Add security flags for builds of type 'release','debugoptimized' and 'minsize'

  if not (get_option('buildtype') == 'plain' or get_option('buildtype').startswith('debug'))
    add_project_arguments(
     cxx.get_supported_arguments([
      security_flags
    ]),
    language: 'cpp')
  endif

  #  dependency configuration

  add_project_arguments(
  cxx.get_supported_arguments([
    '-DBOOST_ALL_NO_LIB',
    '-DBOOST_ALLOW_DEPRECATED_HEADERS',
    '-DBOOST_ASIO_SEPARATE_COMPILATION',
    '-DBOOST_BEAST_SEPARATE_COMPILATION',
    '-DBOOST_URL_NO_SOURCE_LOCATION',
    '-DBOOST_SYSTEM_NO_DEPRECATED',
    '-DBOOST_ERROR_CODE_HEADER_ONLY',
    '-DBOOST_ASIO_HAS_FILE',
    '-DBOOST_ASIO_HAS_IO_URING',
    '-DJSON_NOEXCEPTION',
    '-DOPENSSL_NO_FILENAMES',
  ]),
  language : 'cpp')

  # Find the dependency modules, if not found use meson wrap to get them
  # automatically during the configure step
  bmcweb_dependencies = []

  pam = cxx.find_library('pam', required: true)
  atomic =  cxx.find_library('atomic', required: true)
  openssl = dependency('openssl', required : true, version : '>=3.0.1')
  bmcweb_dependencies += [pam, atomic, openssl]

  sdbusplus = dependency('sdbusplus', required : false, include_type: 'system')
  if not sdbusplus.found()
    sdbusplus_proj = subproject('sdbusplus', required: true)
    sdbusplus = sdbusplus_proj.get_variable('sdbusplus_dep')
    sdbusplus = sdbusplus.as_system('system')
  endif
  bmcweb_dependencies += sdbusplus

  tinyxml = dependency('tinyxml2',
      default_options: ['tests=false'],
      include_type: 'system',
  )
  bmcweb_dependencies += tinyxml

  systemd = dependency('systemd')
  zlib = dependency('zlib')
  bmcweb_dependencies += [systemd, zlib]

  if cxx.has_header('nlohmann/json.hpp')
      nlohmann_json = declare_dependency()
  else
      nlohmann_json_proj = subproject('nlohmann', required: true)
      nlohmann_json = nlohmann_json_proj.get_variable('nlohmann_json_dep')
      nlohmann_json = nlohmann_json.as_system('system')
  endif
  bmcweb_dependencies += nlohmann_json

  boost = dependency('boost', modules: ['url', 'filesystem'], version : '>=1.82.0', required : false, include_type: 'system')
  if boost.found()
    bmcweb_dependencies += [boost]
  else
    cmake = import('cmake')
    opt = cmake.subproject_options()
    opt.set_override_option(
      'werror',
      'false',
    )
    opt.set_override_option(
      'warning_level',
      '0',
    )
    boost = cmake.subproject('boost', required: true, options: opt)
    boost_url = boost.dependency('boost_url', include_type: 'system')
    boost_headers = boost.dependency('boost_headers', include_type: 'system')
    boost_beast = boost.dependency('boost_beast', include_type: 'system')
    boost_callable_traits = boost.dependency('boost_callable_traits', include_type: 'system')
    boost_contract = boost.dependency('boost_contract', include_type: 'system')
    boost_compute = boost.dependency('boost_compute', include_type: 'system')
    boost_process = boost.dependency('boost_process', include_type: 'system')
    bmcweb_dependencies += [
      boost_url,
      boost_headers,
      boost_beast,
      boost_callable_traits,
      boost_contract,
      boost_compute,
      boost_process,
    ]
  endif

  if get_option('tests').enabled()
    gtest = dependency('gtest', main: true,disabler: true, required : false)
    gmock = dependency('gmock', required : false)
    if not gtest.found() and get_option('tests').enabled()
      gtest_proj = subproject('gtest', required: true)
      gtest = gtest_proj.get_variable('gtest_main_dep')
      gmock = gtest_proj.get_variable('gmock_dep')
    endif
    gtest = gtest.as_system('system')
    gmock = gmock.as_system('system')
  endif

  systemd_system_unit_dir = systemd.get_variable(pkgconfig: 'systemdsystemunitdir')

  bindir = get_option('prefix') + '/' +get_option('bindir')

  summary({
            'prefix' : get_option('prefix'),
            'bindir' : bindir,
            'systemd unit directory' : systemd_system_unit_dir
          }, section : 'Directories')


  # disable static hosting
  # install_subdir('static', install_dir : 'share/www', strip_directory : true)

  # Config subdirectory

  subdir('config')
  bmcweb_dependencies += conf_h_dep

  abseils = [
  'base',
  'flags',
  'flags_internal',
  'flags_marshalling',
  'flags_parse',
  'flags_reflection',
  'log_entry',
  'log_flags',
  'log_globals',
  'log_initialize',
  'log_internal_check_op',
  'log_internal_conditions',
  'log_internal_format',
  'log_internal_globals',
  'log_internal_log_sink_set',
  'log_internal_message',
  'log_severity',
  'log_sink',
  'strings',
  'status',
  'statusor',
  'random_distributions',
  'random_seed_sequences',
  'random_internal_randen',
  'random_internal_pool_urbg',
  'random_internal_randen_slow',
  'random_internal_randen_hwaes',
  'random_internal_randen_hwaes_impl',
  'hash',
  ]

  abseil_deps = []

  foreach absl : abseils
    abseil_deps += dependency('absl_' + absl)
  endforeach

  bmcweb_dependencies += abseil_deps

  # Source files
  fs = import('fs')

  srcfiles_bmcweb = files(
    'http/app.cpp',
    'http/app_singleton.cpp',
    'http/http_request.cpp',
    'http/http_response.cpp',
    'http/routing.cpp',
    'http/smart_router.cc',
    'http/utility.cpp',
    'include/dbus_utility.cpp',
    'include/sessions.cpp',
    'include/async_resp.cpp',
    'redfish-core/include/query.cpp',
    'redfish-core/lib/chassis.cpp',
    'redfish-core/lib/external_storer.cpp',
    'redfish-core/lib/log_services.cpp',
    'redfish-core/lib/log_services_eventlog.cpp',
    'redfish-core/lib/systems.cpp',
    'redfish-core/src/error_messages.cpp',
    'redfish-core/src/registries.cpp',
    'redfish-core/src/utils/boot_time_utils.cpp',
    'redfish-core/src/utils/json_utils.cpp',
    'redfish-core/src/utils/subprocess_utils.cpp',
    'src/boost_asio_ssl.cpp',
    'src/boost_asio.cpp',
    'src/boost_beast.cpp',
    'g3/managed_store.cpp',
    'g3/subscription_backend_impl.cpp',
    'g3/event_store.cc',
    'g3/subscription.cc',
    'g3/subscription_impl.cc',
    'g3/subscription_store_impl.cc',
    'src/managed_store_http.cpp',
    'g3/managed_store_types.cpp',
    'g3/managed_store_serialization.cc',
    'src/request_stats.cpp',
    'src/request_stats_store_http.cpp',
    'g3/server.cc',
  )

  if get_option('mtls-grpc').enabled()
    subdir('redfish_authorization')
  endif

  if get_option('platform-plugins').enabled()
    platform_plugin = dependency('gbmcweb_platform_plugin')
    bmcweb_dependencies += platform_plugin
  endif

  if get_option('google-common-plugins').enabled()
    platform_plugin = dependency('gbmcweb_google_common_plugin')
    bmcweb_dependencies += platform_plugin
  endif

  if get_option('google-plugins-internal').enabled()
    platform_plugin = dependency('gbmcweb_google_plugins_internal')
    bmcweb_dependencies += platform_plugin
  endif

  if get_option('loas3-validation').enabled()
    bmcweb_dependencies += dependency('authentication_policy_validation')
  endif

  libs_link_with = []

  if get_option('mtls-grpc').enabled()
    subdir('tlbmc')
  endif

  bmcweblib = static_library(
    'bmcweblib',
    srcfiles_bmcweb,
    include_directories : incdir,
    dependencies: bmcweb_dependencies,
    link_with: libs_link_with,
  )

  libs_link_with += bmcweblib

  # Build with gtest/gmock if test build
  if(get_option('tests').enabled())
    bmcweb_dependencies += [
              gtest,
              gmock,
    ]
  endif

  executable(
    'bmcweb',
    'src/webserver_main.cpp',
    include_directories : incdir,
    dependencies: bmcweb_dependencies,
    link_with: libs_link_with,
    link_args: '-Wl,--gc-sections',
    install: true,
    install_dir: bindir,
  )

  srcfiles_unittest = [
    'src/managed_store_http_test.cpp',
    'test/g3/mock_managed_store_test.cpp',
    'test/http/crow_getroutes_test.cpp',
    'test/http/http_response_test.cpp',
    'test/http/router_test.cpp',
    'test/http/utility_test.cpp',
    'test/http/verb_test.cpp',
    'test/include/dbus_utility_test.cpp',
    'test/include/google/google_service_root_test.cpp',
    'test/include/http_utility_test.cpp',
    'test/include/human_sort_test.cpp',
    'test/include/ibm/configfile_test.cpp',
    'test/include/ibm/lock_test.cpp',
    'test/include/multipart_test.cpp',
    'test/include/request_stats_test.cpp',
    'test/include/openbmc_dbus_rest_test.cpp',
    'test/include/str_utility_test.cpp',
    'test/redfish-core/include/privileges_test.cpp',
    'test/redfish-core/include/redfish_aggregator_test.cpp',
    'test/redfish-core/include/registries_test.cpp',
    'test/redfish-core/include/query_test.cpp',
    'test/redfish-core/include/utils/boot_time_utils_test.cpp',
    'test/redfish-core/include/utils/hex_utils_test.cpp',
    'test/redfish-core/include/utils/ip_utils_test.cpp',
    'test/redfish-core/include/utils/json_utils_test.cpp',
    'test/redfish-core/include/utils/location_utils_test.cpp',
    'test/redfish-core/include/utils/stl_utils_test.cpp',
    'test/redfish-core/include/utils/time_utils_test.cpp',
    'test/redfish-core/lib/external_storer_test.cpp',
    'test/redfish-core/lib/log_services_eventlog_test.cpp',
    'test/redfish-core/lib/log_services_test.cpp',
    'test/redfish-core/lib/service_root_test.cpp',
    'test/redfish-core/lib/system_test.cpp',
    'test/redfish-core/lib/thermal_subsystem_test.cpp',
    'test/redfish-core/lib/power_test.cpp',
    'test/redfish-core/lib/power_supply_test.cpp',
    'test/redfish-core/lib/power_subsystem_test.cpp',
    'test/redfish-core/lib/processor_test.cpp',
    'test/redfish-core/lib/assembly_test.cpp',
    'test/redfish-core/lib/power_supply_metrics_test.cpp',
    'test/redfish-core/lib/chassis_test.cpp',
    'test/redfish-core/lib/cable_test.cpp',
    'test/redfish-core/lib/component_integrity_test.cpp',
    'test/redfish-core/lib/trusted_component_test.cpp',
    'test/redfish-core/lib/snapshot_fixture_test.cpp',
    'test/redfish-core/lib/storage_test.cpp',
    'test/redfish-core/lib/fan_test.cpp',
    'test/redfish-core/lib/manager_test.cpp',
    'test/redfish-core/lib/manager_diagnostic_data_test.cpp',
    'test/redfish-core/lib/network_adapter_test.cpp',
    'test/redfish-core/lib/pcie_test.cpp',
    'test/redfish-core/lib/ports_test.cpp',
    'test/redfish-core/lib/port_metrics_test.cpp',
    'test/redfish-core/lib/update_service_test.cpp',
    'test/redfish-core/lib/boot_time_test.cpp',
    'test/redfish-core/lib/bios_test.cpp',
    'test/redfish-core/lib/bios_multi_host_test.cpp',
    'plugins/macros_test.cpp',
  ]

  message(get_option('b_sanitize'))

  if (not get_option('b_sanitize').contains('address'))
    srcfiles_unittest += 'test/src/webserver_main_setup_smoke_test.cpp'
  endif

  message(srcfiles_unittest)

  if(get_option('tests').enabled())
      # generate the test executable
      foreach test_src : files(srcfiles_unittest)
        test_bin = executable(
          fs.stem(test_src),
          test_src,
          link_with: libs_link_with,
          include_directories : incdir,
          install_dir: bindir,
          dependencies: bmcweb_dependencies + [
            gtest,
            gmock,
          ]
        )
        test(fs.stem(test_src), test_bin, timeout: 600)
      endforeach
  endif

# Pacemaker depends on grpc redfish for frontend service.
if get_option('mtls-grpc').enabled()
  executable(
    'tlbmc_pacemaker',
    'tlbmc/pacemaker/pacemaker.cc',
    'tlbmc/pacemaker/pacemaker_main.cc',
    link_args: '-Wl,--gc-sections',
    include_directories : incdir,
    dependencies: bmcweb_dependencies,
    link_with: libs_link_with,
    install: get_option('tlbmc-pacemaker').enabled(),
  )
  executable(
    'shared_mem_metrics_server',
    'tlbmc/hal/shared_mem/demo/shared_mem_metrics_server.cc',
    link_args: '-Wl,--gc-sections',
    include_directories : incdir,
    dependencies: bmcweb_dependencies,
    link_with: libs_link_with,
    install: false,
  )
  executable(
    'shared_mem_metrics_client',
    'tlbmc/hal/shared_mem/demo/shared_mem_metrics_client.cc',
    link_args: '-Wl,--gc-sections',
    include_directories : incdir,
    dependencies: bmcweb_dependencies,
    link_with: libs_link_with,
    install: false,
  )
  executable(
    'shared_mem_cli',
    'tlbmc/hal/shared_mem/demo/shared_mem_cli.cc',
    link_args: '-Wl,--gc-sections',
    include_directories : incdir,
    dependencies: bmcweb_dependencies,
    link_with: libs_link_with,
    install: true,
  )
endif

else
  gbmcweb_plugin_headers = files(
    'include/sessions.hpp',
    'http/app_interface.h',
    'http/app.hpp',
    'http/app_singleton.hpp',
    'http/common.hpp',
    'http/http_request.hpp',
    'http/http_response.hpp',
    'http/logging.hpp',
    'http/router_interface.h',
    'http/routing.hpp',
    'http/smart_router.h',
    'http/utility.hpp',
    'http/verb.hpp',
    'http/websocket.hpp',
    'include/async_resp.hpp',
    'include/dbus_utility.hpp',
    'include/human_sort.hpp',
    'g3/managed_store.hpp',
    'g3/managed_store_types.hpp',
    'g3/managed_store_serialization.h',
    'g3/managed_store_clock.hpp',
    'g3/subscription.h',
    'include/request_stats.hpp',
    'include/source_location.hpp',
    'include/str_utility.hpp',
    'plugins/interface.hpp',
    'plugins/macros.hpp',
    'redfish-core/include/registries/privilege_registry.hpp',
    'redfish-core/include/utils/dbus_utils.hpp',
    'redfish-core/include/error_messages.hpp',
    'redfish-core/include/query.hpp',
    'redfish-core/include/privileges.hpp',
    'redfish-core/include/utils/json_utils.hpp',
    'redfish-core/include/utils/location_utils.hpp',
    'redfish-core/include/utils/time_utils.hpp',
    'redfish-core/include/utils/chassis_utils.hpp',
    'redfish-core/include/utils/storage_utils.hpp',
    'redfish-core/include/utils/nvme_metric_utils.hpp',
    'redfish-core/lib/log_services.hpp',
  )
  install_headers(
    gbmcweb_plugin_headers,
    install_dir : get_option('includedir') / 'bmcweb_plugins',
  )
endif