framework_gem 0.1.0

data/lib/dsllib/common/utils/tmc_utils.rb

@@ -0,0 +1,2944 @@
+#Test automation script version# TA-5.5.mdn released time stamp: 12-03-12 14:40:20
+
+require 'rubygems'
+require 'net/telnet'
+require 'nokogiri'
+require 'timeout'
+require 'yaml'
+require './dsllib/common/dncs/dncs_utils'
+require './dsllib/common/mas_db/mas_utils'
+require './dsllib/common/utils/stb_health_check_utils'
+require './dsllib/common/utils/sword_utils'
+require './dsllib/common/mas_db/mas_db'
+require './dsllib/common/mas_db/mas_conductor'
+require './dsllib/common/remote_diagnostics/mdn_remote_diagnostics'
+require './dsllib/common/remote_diagnostics/odn_web_server'
+require './lib/selenium/appium/appium'
+require './lib/extensions/extensions'
+
+module LegacyLogging
+  # Public: DEPRECATED
+  def loginfo m, c=false, l=false, _="OCR", i=nil
+    p = '*WARNING* The `loginfo\' method is deprecated. '
+    logger.info(p + m, screenshot: c, use_last_image: l, screen_image: i)
+  end
+
+  # Public: DEPRECATED
+  def loginfo2 m, c=false, l=false, _="OCR", i=nil
+    p = '*WARNING* The `loginfo2\' method is deprecated. '
+    logger.info(p + m, screenshot: c, use_last_image: l, screen_image: i)
+  end
+
+  # Public: DEPRECATED
+  def loginfo3 m, c=true, l=true, _="OCR", i=nil
+    p = '*WARNING* The `loginfo3\' method is deprecated. '
+    # Update screen capture flag according to global flag
+    logger.info(p + m, screenshot: c, use_last_image: l, screen_image: i)
+  end
+
+  # Public: DEPRECATED
+  def loginfo4 m, c=true, l=false, _="OCR", i=nil
+    p = '*WARNING* The `loginfo4\' method is deprecated. '
+    # Update screen capture flag according to global flag
+    logger.info(p + m, screenshot: c, use_last_image: l, screen_image: i)
+  end
+
+  # Public: DEPRECATED
+  def logdebug m, c=false, l=false
+    p = '*WARNING* The `logdebug\' method is deprecated. '
+    # Update screen capture flag according to global flag
+    logger.info(p + m, screenshot: c, use_last_image: l)
+  end
+end
+
+module TmcUtils
+  include SwordUtils
+
+# below file no longer exists. what was the purpose of requiring it here?
+# require_lib_file 'test_cases/libraries/mobile/common/common'
+  def append_to_file (filename, text)
+    File.open(filename, 'a') do |f|
+      f.puts text
+    end
+  end
+
+  def read_from_file (filename)
+    text_read=""
+    File.open(filename, "r") do |f|
+      f.each_line do |line|
+        text_read+= line
+      end
+    end
+    return text_read
+  end
+
+  def write_to_file (filename, text)
+    File.open(filename, 'w') do|f|
+      f.write(text)
+    end
+  end
+
+# Override exec_mas_cmd to use script option values over TMC configured values
+  def exec_mas_cmd(command, immediately: false)
+    mas_ip = test_data[:mas_server_ip]
+    mas_prompt = test_data[:mas_server_prompt]
+    mas_username = test_data[:mas_username]
+    mas_password = test_data[:mas_password]
+    retry_count = 3
+    begin
+      # Random sleep to avoid connection failure
+      unless immediately
+        sleep_time = rand(60)
+        logger.debug("Random sleep for MAS command : [#{sleep_time}] seconds")
+        sleep sleep_time.sec
+      end
+      if @ssh_to_mas.nil?
+        @ssh_to_mas = ssh_to(mas_ip, mas_username, password: mas_password)
+      end
+      @ssh_to_mas.send_command(command, timeout: 10.sec)#, prompt: mas_prompt, expect: nil)
+    rescue StandardError => e
+      retry_count = retry_count - 1
+      retry if retry_count > 0
+      raise e
+    end
+  end
+
+# Override exec_dncs_cmd to use script option values over TMC configured values
+  def exec_dncs_cmd(command, immediately: false)
+    dncs_ip = test_data[:dncs_server_ip]
+    dncs_prompt = test_data[:dncs_server_prompt]
+    dncs_username = test_data[:dncs_username]
+    dncs_password = test_data[:dncs_password]
+    retry_count = 3
+    begin
+      # Random sleep to avoid connection failure
+      unless immediately
+        sleep_time = rand(60)
+        logger.debug("Random sleep for DNCS command : [#{sleep_time}] seconds")
+        sleep sleep_time.sec
+      end
+      if @ssh_to_dncs.nil?
+        @ssh_to_dncs = ssh_to(dncs_ip, dncs_username, password: dncs_password)
+      end
+      full_cmd = ". ./.profile > /dev/null 2>&1 && #{command}"
+      @ssh_to_dncs.send_command(full_cmd, timeout: 10.sec)#, prompt: dncs_prompt, expect: nil)
+    rescue StandardError => e
+      retry_count = retry_count - 1
+      retry if retry_count > 0
+      raise e
+    end
+  end
+
+# Override reboot_stb_from_mas to use script option values over TMC configured values
+  def reboot_stb_from_mas(delay = 0)
+    mas_reboot_stb_with_delay(delay)
+  end
+
+
+# Use this to convert epoch time back to seconds since the epoch
+# * *Returns* :
+#   - seconds since the specifed epoch as a float
+  def from_epoch_time(epoch_time)
+    epoch_time.to_f / 1000
+  end
+
+# Use it to verify vendor of the stb
+# * *Args*    :
+#   - +vendor+ -> Vendor to be verified ('cisco', 'samsung', 'motorola', 'pace', 'pioneer')
+# * *Returns* :
+#   - true if stb is of given vendor else false
+  def stb_vendor? vendor
+    stb_model = fetch_stb_model
+    if vendor.casecmp('cisco') == 0
+      return true if stb_model.start_with?('SA') || stb_model == "Spectrum101_C"
+    elsif vendor.casecmp('samsung') == 0
+      return true if stb_model.start_with?('SMTH')
+    elsif vendor.casecmp('motorola') == 0
+      return true if stb_model.start_with?('DCX')
+    elsif vendor.casecmp('pace') == 0
+      return true if stb_model.start_with?('P')
+    elsif vendor.casecmp('pioneer') == 0
+      return true if stb_model.start_with?('V')
+    else
+      loginfo2 "Vendor not recognized [#{vendor}]"
+    end
+
+    return false
+  end
+
+# Use it to check whether stb is capable of ODN, MDN, DVR, etc or not
+# * *Args*    :
+#   - +args+ -> check options list (comma separated)
+# * *Returns* :
+#   - true if stb is capable for options else false
+  def stb_capable_of? (*args)
+    #return !$rti_flag if(args[0]=="ODN")
+    return stb_model_capable_of?(fetch_stb_model, *args)
+  end
+
+# Use it to check whether given stb is capable of ODN, MDN, DVR, etc or not
+# * *Args*    :
+#   - +model+ -> model name of STB
+#   - +args+ -> check options list (comma separated)
+# * *Returns* :
+#   - true if stb is capable for options else false
+  def stb_model_capable_of? (stbmodel, *args)
+    result = true
+    #TODO: put these options in the test data? restore STB registry? etc.
+    return false
+    args.each{|option|
+      if (option.casecmp('ODN') == 0 && !StbRegistry.odn?(stbmodel))
+        result = false
+        #logdebug "ODN : false"
+      elsif (option.casecmp('MDN') == 0 && !StbRegistry.mdn?(stbmodel))
+        result = false
+        #logdebug "MDN : false"
+      elsif (option.casecmp('DVR') == 0 && !StbRegistry.dvr_capable?(stbmodel))
+        result = false
+        #logdebug "DVR : false"
+      elsif (option.casecmp('NONDVR') == 0 && StbRegistry.dvr_capable?(stbmodel))
+        result = false
+        #logdebug "NONDVR : false"
+      elsif (option.casecmp('HD') == 0 && !StbRegistry.hd_capable?(stbmodel))
+        result = false
+        #logdebug "HD : false"
+      elsif (option.casecmp('SD') == 0 && StbRegistry.hd_capable?(stbmodel))
+        result = false
+        #logdebug "SD : false"
+      elsif (option.casecmp('LOWMEMORY') == 0 && !StbRegistry.low_memory_box?(stbmodel))
+        result = false
+        #logdebug "Low memory : false"
+      elsif (option.casecmp('ADSG') == 0 && !StbRegistry.adsg_capable?(stbmodel))
+        result = false
+        #logdebug "ADSG : false"
+      elsif (option.casecmp('ANALOG') == 0 && !StbRegistry.analog_channels_supported?(stbmodel))
+        result = false
+        #logdebug "Analog channel supported : false"
+      elsif (option.casecmp('HDMI') == 0 && !StbRegistry.hdmi_supported?(stbmodel))
+        result = false
+        #logdebug "HDMI port : false"
+      elsif (option.casecmp('NONHDMI') == 0 && StbRegistry.hdmi_supported?(stbmodel))
+        result = false
+        #logdebug "Does not have HDMI port : false"
+      elsif (option.casecmp('TUNERCOUNT1') == 0 && StbRegistry.tuner_count(stbmodel) != 1)
+        result = false
+        #logdebug "TUNERCOUNT 1 : false"
+      elsif (option.casecmp('TUNERCOUNT2') == 0 && StbRegistry.tuner_count(stbmodel) != 2)
+        result = false
+        #logdebug "TUNERCOUNT 2 : false"
+      elsif (option.casecmp('PIP') == 0 && !StbRegistry.pip_capable?(stbmodel))
+        result = false
+        #logdebug "PIP capable : false"
+      elsif (option.casecmp('MOCA') == 0 && !StbRegistry.moca_capable?(stbmodel))
+        result = false
+        #logdebug "MOCA capable : false"
+      end
+    }
+
+    return result
+  end
+
+# Use it to reset packages on current STB
+# * *Returns* :
+#   - true if successfully reset packages else false
+  def _reset_packages_for_stb
+    loginfo "Resetting packages on STB ..."
+    begin
+      # Get default package list from config file
+      required_packages = StbRegistry.required_packages fetch_stb_model
+      not_required_packages = StbRegistry.not_required_packages fetch_stb_model
+      # Reset packages
+      (return false unless add_pkg_on_dncs(required_packages,false)) unless required_packages.empty?
+      (return false unless remove_pkg_from_dncs(not_required_packages,false)) unless not_required_packages.empty?
+    rescue StandardError => e
+      loginfo2 "Exception raised while adding/removing packages",false
+      loginfo2 "Error msg : #{e.message}",false
+      logdebug e.backtrace.join("\n")
+      return false
+    end
+
+    loginfo2 "Successfully reset packages",false
+    return true
+  end
+
+# Use it to reset packages on current STB
+# * *Returns* :
+#   - true if successfully reset packages else false
+  def _reset_credit_limit_for_stb
+    loginfo "Resetting credit limit to 65000 ..."
+    begin
+      return false unless set_credit_limit_for_stb_from_dncs(65000,false)
+    rescue StandardError => e
+      loginfo2 "Exception raised while setting credit limit to - 65000",false
+      loginfo2 "Error msg : #{e.message}",false
+      logdebug e.backtrace.join("\n")
+      return false
+    end
+
+    loginfo2 "Successfully reset credit limit",false
+    return true
+  end
+
+# Private method
+# Use it to reset pin to 0000 (either PC pin or purchase pin)
+  def _reset_pin_to_4_zeros
+    # Verify that PIN entry has come up.
+    unless settings_screen_pin_entry_banner_appears?
+      loginfo2 'Pin entry screen does not appear',true
+      return false
+    end
+
+    pin = '0000'
+    pin_numbers = pin.chars.to_a
+    return false unless _settings_screen_enter_pin_and_verify_asterisks(pin_numbers)
+
+    if settings_screen_pin_entry_banner_title_message 'Incorrect'
+      loginfo2 "Incorrect pin:  #{pin}",true,true
+
+      pin = '1234'
+      pin_numbers = pin.chars.to_a
+      return false unless _settings_screen_enter_pin_and_verify_asterisks(pin_numbers)
+
+      if settings_screen_pin_entry_banner_title_message 'Incorrect'
+        loginfo2 "Invalid pin [0000] or [1234]"
+        return false
+      end
+    else
+      loginfo2 "Pin [0000] verified no need to change"
+      return true
+    end
+
+    # Verify message for new pin entry screen
+    unless settings_screen_pin_entry_banner_title_message 'Enter'
+      loginfo2 "Failed to verify pin entry banner message - Enter your new PIN", true
+      return false
+    end
+
+    # Enter new pin
+    loginfo2 "New pin : 0000"
+    new_pin = '0000'
+    pin_numbers = new_pin.chars.to_a
+    return false unless _settings_screen_enter_pin_and_verify_asterisks(pin_numbers)
+
+    # Verify re-enter pin screen
+    unless (settings_screen_pin_entry_banner_title_message 'Re-Enter')
+      loginfo2 "Failed to verify pin entry banner message - Re-Enter your new PIN", true
+      return false
+    end
+
+    # Re-enter new pin
+    return false unless _settings_screen_enter_pin_and_verify_asterisks(pin_numbers)
+    return true
+  end
+
+# Private method
+# Use it to reset PC pin
+# Assumption !! - OLD pin will be either 0000 or 1234
+  def _reset_pc_pin
+    # try to set to 0000 from 1234
+    reset_pin_from_mas = false
+    begin
+      settings_launch_and_verify
+      return false unless settings_screen_navigate_to_tab('PARENTAL CONTROL')
+      return false unless settings_screen_navigate_vertically_to('Blocking PIN', 10, 5)
+      press_select_sleep
+
+      unless _reset_pin_to_4_zeros
+        tcfail "Failed to reset pin to 0000"
+      end
+      press_exit_sleep # exit to full screen
+
+      loginfo2 "PC pin verified successfully",false
+      return true
+    rescue TestException => e
+      loginfo2 e.message
+      unless reset_pin_from_mas
+        change_parental_control_pin_from_mas('0000')
+        loginfo2 "Sleeping for 2 min ..."
+        sleep 2.min
+        reset_pin_from_mas = true
+        retry
+      end
+      loginfo2 "Failed to reset PC pin",true,false
+      return false
+    end
+  end
+
+# Private method
+# Use it to reset purchase pin
+# Assumption !! - OLD pin will be either 0000 or 1234
+  def _reset_purchase_pin
+    # try to set to 0000 from 1234
+    reset_pin_from_mas = false
+    begin
+      settings_launch_and_verify
+      return false unless settings_screen_navigate_to_tab('Purchases')
+      return false unless settings_screen_navigate_vertically_to('Purchase PIN', 10, 5)
+
+      if settings_verify_status?('OFF')
+        press_select_sleep # to navigate to option to enable purchase pin
+        press_select_sleep # to enable purchase pin
+        return false unless settings_verify_status?('ON')
+      end
+
+      press_select_sleep # to select purchase pin option
+
+      return false unless settings_navigate_to_option('Change PIN',10)
+      press_select_sleep
+
+      return false unless _reset_pin_to_4_zeros
+      press_exit_sleep # exit to full screen
+
+      loginfo2 "Purchase pin verified successfully",false
+      return true
+    rescue TestException => e
+      loginfo2 e.message
+      unless reset_pin_from_mas
+        loginfo2 "Resetting pin using mas command ..."
+        change_purchase_pin_from_mas('0000')
+        loginfo2 "Sleeping for 2 min ..."
+        sleep 2.min
+        reset_pin_from_mas = true
+        retry
+      end
+      loginfo2 "Failed to reset purchase pin",true,false
+      return false
+    end
+  end
+
+# Private method
+# Use it to rest STB state
+  def _reset_stb(ignore_dvr_setup=false)
+    # Reset packages and credit limit for STB
+    _reset_stb_failed "Failed to reset packages" unless _reset_packages_for_stb
+    _reset_stb_failed "Failed to reset credit limit" unless _reset_credit_limit_for_stb
+
+    # Reboot STB to reset it's state
+    loginfo2 "Rebooting stb to reset state ...",false
+    (_reset_stb_failed "Failed to reboot STB using AC power") unless stb_reboot_using_ac_power
+    (_reset_stb_failed "Failed to Reboot STB") unless stb_wait_till_finish_rebooting(true)
+    loginfo2 "Successfully rebooted STB",false
+
+    # check whether STB is having valid ip or not
+    loginfo2 "Verifying valid IP ..."
+    unless has_valid_ip?
+      _reset_stb_failed "STB is not having valid IP, Please check STB MAC"
+    end
+
+    # Change default language to english if it's SPANISH
+    loginfo "Changing default launguage to English if it is Spanish"
+    _reset_stb_failed 'Failed to set language to English.' unless settings_screen_launch_and_reset_language_from_spanish_to_english
+
+    # Reset PC pin
+    loginfo2 "Resetting PC pin to [0000]"
+    _reset_stb_failed "Failed to reset PC pin to 0000" unless _reset_pc_pin
+    loginfo2 "Resetting Purchase pin to [0000]"
+    _reset_stb_failed "Failed to reset purchase pin to 0000" unless _reset_purchase_pin
+    loginfo2 "Enabling IPPV from DNCS ..."
+    _reset_stb_failed "Failed to enable IPPV flag" unless enable_ippv_from_dncs(false)
+    loginfo2 "Sleeping for 2 mins so that STB will get message from MAS and reset PIN ..."
+    sleep 2.min
+    loginfo2 "Successfully reset PC pin to [0000]"
+    loginfo2 "Successfully reset Purchase pin to [0000]"
+
+    # Reset PIP
+    if stb_capable_of?('PIP')
+      loginfo2 "Resetting PIP by powering OFF and ON STB ..."
+      _reset_stb_failed "Unable to power off STB" unless power_off_stb?
+      _reset_stb_failed "Unable to power on STB" unless power_on_stb?
+      loginfo2 "Successfully reset PIP window"
+    end
+
+    # Tuning to home channel
+    loginfo2 "Tuning to home channel : [#{fetch_option(:a_home_channel)}] ..."
+    press_exit_sleep
+    tune_immediately_to fetch_option(:a_home_channel)
+    # Resolved tuning conflict for DVR STBs
+    if stb_capable_of?('DVR') and record_screen_tuning_conflict_banner_appears?
+      if (stb_capable_of?('ODN') or stb_capable_of?('MDN'))
+        press_down_arrow_sleep
+      else
+        _reset_stb_failed "Not a valid STB type : #{fetch_stb_model}"
+        return false
+      end
+    end
+    press_exit_sleep
+
+    # Ignore pc pin error and continue with test case execution
+    loginfo2 "Turning OFF parental control"
+    begin
+      # set pc off
+      settings_launch_and_verify(true)
+      _reset_stb_failed "[Setup] failed to set parental control - OFF" unless settings_screen_set_parental_control_status('OFF')
+      # setting set transparency off (Not available in ODN52)
+      (_reset_stb_failed "[Setup] failed to set transparency - OFF" unless settings_screen_set_transparency('OFF')) if (fetch_option(:transparency_modifiable).casecmp('true') == 0) and stb_capable_of?('ODN')
+      press_exit_sleep
+      loginfo2 "Successfully turned OFF parental control and transparency"
+    rescue TestException => e
+      _reset_stb_failed "Settings error : #{e.message}"
+      press_exit_sleep
+    end
+
+    return if ignore_dvr_setup # return if dvr setup is not required
+
+    # Cleanup recordings for DVR STBs
+    begin
+      dvr_setup
+    rescue StandardError => e
+      _reset_stb_failed "[DVR setup] : #{e.message}"
+    end
+  end
+
+# Private method
+# Use it to clean up existing scheculed recordings and last two days recorded programs
+  def _stb_clean_up_recordings
+    # Launch show list
+    show_list_launch_and_verify
+
+    # remove all series reocrdings
+    tcfail "Failed to clear series recordings" unless show_list_screen_clear_all_series_recordings
+
+    # remove all scheduled recordings
+    tcfail "Failed to clear Scheduled recordings" unless show_list_screen_clear_all_scheduled_recordings
+
+    # remove all recorded programs
+    tcname = (($user_log.getTestCase).split("/")).last
+    ignore_test_cases = fetch_option(:ignore_last_two_days_recordings_for_scripts).to_s.split(",")
+    if ignore_test_cases.include?(tcname)
+      loginfo2 "Ignored last two days recording for : #{tcname}, Removing inprogress recordings ..."
+      tcfail "Failed to clear in progress recordings" unless show_list_delete_inprogress_recordings
+    else
+      tcfail "Failed to clear last two days recordings " unless show_list_delete_last_two_days_recordings
+    end
+
+    #Exit ot full screen
+    press_exit_sleep
+  end
+
+# Initial Setup for dvr/recording test scripts
+# Remove all Series Recording.
+# Remove all Scheduled Recording.
+# Remove last two day Recorded contented (including in progress) from show list
+  def dvr_setup
+    # DVR check
+    return unless stb_capable_of? 'DVR'
+
+    loginfo2 "DVR setup [START]",false
+    show_list_launch_and_verify
+    hdd_status_high_water_mark = fetch_option(:hdd_status_high_water_mark).to_s.to_i
+    hdd_status_high_water_mark = 90 if hdd_status_high_water_mark.eql?(0)
+    loginfo2 "Verifying HDD status is less than high water mark : #{hdd_status_high_water_mark}% full ..."
+    hdd_status = _percentage_hdd_full
+    hdd_status = 0 if hdd_status.nil?
+    if hdd_status > hdd_status_high_water_mark
+      hdd_status_low_water_mark = fetch_option(:hdd_status_low_water_mark).to_s.to_i
+      hdd_status_low_water_mark = 60 if hdd_status_low_water_mark.eql?(0)
+      loginfo2 "HDD [#{hdd_status}]% full more than high water mark level : #{hdd_status_high_water_mark}%, Removing recorded program to make it lower than [#{hdd_status_low_water_mark}]%"
+      tcfail "Failed to remove recording from STB to make HDD %{hdd_status_high_water_mark} % full" unless make_hdd_empty(hdd_status_low_water_mark)
+    end
+    loginfo2 "HDD status check successful"
+    _stb_clean_up_recordings
+    loginfo2 "DVR setup [END]",false
+  end
+
+# Clean up for dvr/recording test scripts
+# Remove all Series Recording.
+# Remove all Scheduled Recording.
+# Remove last two day Recorded contented (including in progress) from show list
+  def dvr_cleanup
+    # DVR check
+    return unless stb_capable_of? 'DVR'
+
+    loginfo2 "DVR cleanup [START]",false
+    _stb_clean_up_recordings
+    loginfo2 "DVR cleanup [END]",false
+  end
+
+# Initial setup method to reset common STB settings
+  $execution_count = {}
+
+# Private method to get execution count for active STB
+  def execution_count(count=nil, stb_id=$stb_id)
+    unless $execution_count.has_key?(stb_id.to_s)
+      $execution_count[stb_id.to_s] = 0
+    end
+
+    return $execution_count[stb_id.to_s]
+  end
+
+# Private method to update execution count for active STB
+  def update_execution_count(count, stb_id=$stb_id)
+    unless $execution_count.has_key?(stb_id.to_s)
+      $execution_count[stb_id.to_s] = 0
+    end
+
+    $execution_count[stb_id.to_s] = count
+  end
+
+  $internal_iteration=2 # max iterations
+
+  def setup(ignore_dvr_setup=false)
+    # increase execution count
+    update_execution_count(execution_count + 1)
+
+    run_mode = fetch_option(:execution_mode).strip.downcase
+
+    # Do not run setup for first execution
+    if run_mode.eql?('advanced')
+      if execution_count == 1
+        loginfo2 "Executing test case using advanced mode ...",false
+
+        # Power on stb if required
+        tcfail "Failed to power ON STB" unless power_on_stb?
+
+        # Tuning to home channel
+        loginfo2 "Tuning to home channel : [#{fetch_option(:a_home_channel)}] ..."
+        press_exit_sleep
+        tune_immediately_to fetch_option(:a_home_channel)
+
+        loginfo2 "STB reset not required for first execution"
+        return
+      end # run setup subset for first run only
+    elsif run_mode.eql?('classic')
+      $internal_iteration = 1 # run test case with setup
+      loginfo2 "Executing test case using classic mode ...",false
+    else
+      $internal_iteration = 1 # run test case without setup
+      loginfo2 "Unknown execution mode, executing test case without setup",false
+      return
+    end
+
+    loginfo2 "Setup [START]"
+
+    begin
+      # Reset STB state
+      _reset_stb(ignore_dvr_setup)
+
+      # verify health check
+      # Home channel
+      tcfail "[STB health check failed] : Home channel" unless _verify_home_channel
+
+      # Screen launch and verify
+      tcfail "[STB health check failed] : Screens launch and verify" unless _verify_screen_launch
+
+      test_data[:stb_ip] = fetch_ip
+    rescue StandardError => e
+      _setup_failed e.message
+    end
+
+    loginfo2 "Setup [END]"
+  end
+
+# Initial setup method to reset PIP window in second Quadrant
+# * *Returns* :
+#   - true if PIP window successfully reset else false
+  def pip_setup
+    loginfo2 "PIP setup [START]",false
+    loginfo2 'Ensuring that pip will have video'
+    tune_immediately_to(fetch_option(:a_live_channel_1))
+    unless info_banner_launch_and_verify_channel_number(fetch_option(:a_live_channel_1), 10)
+      loginfo2 "Failed to tune to live channel: #{(fetch_option(:a_live_channel_1))}"
+      return false
+    end
+    unless fullscreen_video_playing?(20)
+      loginfo2 "Failed to verify video on live channel: #{(fetch_option(:a_live_channel_1))}"
+      return false
+    end
+
+    # Sleep for few seconds so that current channel will be last tuned channel
+    sleep 30.sec
+
+    tune_immediately_to(fetch_option(:a_live_channel_2))
+    unless info_banner_launch_and_verify_channel_number(fetch_option(:a_live_channel_2), 10)
+      loginfo2 "Failed to tune to live channel: #{(fetch_option(:a_live_channel_2))}"
+      return false
+    end
+    unless fullscreen_video_playing?(20)
+      loginfo2 "Failed to verify video on live channel: #{(fetch_option(:a_live_channel_2))}"
+      return false
+    end
+
+    press_pip_onoff_sleep
+    unless pip_window_appears?
+      loginfo2 "PIP window does not appeared after pressing PIP ON/OFF"
+      return false
+    end
+
+    unless pip_window_reset_quadrant
+      loginfo2 "Unable to Reset PIP window in second quadrant"
+      return false
+    end
+
+    press_pip_onoff_sleep
+    if pip_window_appears?
+      loginfo2 "PIP window appears after pressing PIP ON/OFF"
+      return false
+    end
+
+    loginfo2 "PIP setup [END]",false
+    return true
+  end
+
+# Clenup methods for PIP
+# * *Returns* :
+#   - true if PIP window successfully reset else false
+  def pip_cleanup
+    loginfo2 "PIP cleanup [START]",false
+    # Reset PIP
+    if stb_capable_of?('PIP')
+      loginfo2 "Resetting PIP by powering OFF and ON STB ..."
+      tcfail "Unable to power off STB" unless power_off_stb?
+      tcfail "Unable to power on STB" unless power_on_stb?
+      loginfo2 "Successfully reset PIP window"
+    end
+    loginfo2 "PIP cleanup [END]",false
+  end
+
+# ADSG setup
+# 1.) Add DSG package, in not present.
+# 2.) Reboot STB.
+# 3.) Verify if STB is up in DSG mode from host diags.
+# (host_diags_verify_OOB_mode can be used)
+  def adsg_setup
+    begin
+      unless verify_package_on_dncs(['ADSGB'])
+        return false unless add_pkg_on_dncs(['ADSGB'], false)
+        return false unless stb_reboot_using_ac_power
+        return false unless stb_wait_till_finish_rebooting(true)
+        host_diags_launch_and_verify
+        return false unless host_diags_verify_OOB_mode('DSG')
+      else
+        host_diags_launch_and_verify
+        unless host_diags_verify_OOB_mode('DSG')
+          return false unless stb_reboot_using_ac_power
+          return false unless stb_wait_till_finish_rebooting(true) # TODO use reboot stb : line 710-111
+          host_diags_launch_and_verify
+          return false unless host_diags_verify_OOB_mode('DSG')
+        else
+          loginfo2 "STB already in 'ADSG' mode"
+        end
+      end
+      return true
+    rescue StandardError => e
+      loginfo2 e.message
+      return false
+    end
+  end
+
+# ADSG cleanup
+# 1.) Remove DSG package, if present.
+# 2.) Reboot STB.
+  def adsg_cleanup
+    begin
+      if verify_package_on_dncs(['ADSGB'])
+        return false unless remove_pkg_from_dncs(['ADSGB'], false)
+        return false unless stb_reboot_using_ac_power
+        return false unless stb_wait_till_finish_rebooting(true)  # TODO use reboot stb : line 710-111
+        host_diags_launch_and_verify
+        return false unless host_diags_verify_OOB_mode('OOB(SCTE55)')
+      else
+        loginfo2 "Package already removed"
+      end
+      return true
+    rescue StandardError => e
+      loginfo2 e.message
+      return false
+    end
+  end
+
+# Use it to compare two string using string similarity
+# * *Args*    :
+#   - +expected_text+ -> expected text
+#   - +ocr_text+ -> ocr text
+#   - +similarity_level=0.75+ -> similarity level (e.g. 0.75 is 75% similar)
+# * *Returns* :
+#   - true if string similar else false
+  def string_similar?(expected_text, ocr_text, similarity_level=0.75)
+    # nil or empty check for OCR and expected text
+    if (ocr_text.nil? or ocr_text.empty? or expected_text.nil? or expected_text.empty?)
+      loginfo2 "Empty string : OCR text -> #{ocr_text}, Expected text -> #{expected_text}"
+      return false
+    end
+
+    similarity = (string_similarity expected_text, ocr_text)
+    logdebug "[#{expected_text}] Similarity : #{similarity}"
+    return similarity >= similarity_level
+  end
+
+# Use it to compare two string using sub-string similarity
+# * *Args*    :
+#   - +expected_text+ -> expected text
+#   - +ocr_text+ -> ocr text
+#   - +similarity_level=0.75+ -> similarity level (e.g. 0.75 is 75% similar)
+# * *Returns* :
+#   - true if string similar else false
+  def sub_string_similar?(expected_text, ocr_text, similarity_level=0.75)
+    # nil or empty check for OCR and expected text
+    if (ocr_text.nil? or ocr_text.empty? or expected_text.nil? or expected_text.empty?)
+      loginfo2 "Empty string : OCR text -> #{ocr_text}, Expected text -> #{expected_text}}"
+      return false
+    end
+
+    similarity = (substring_similarity expected_text, ocr_text)
+    logdebug "[#{expected_text}] Similarity(SubStr) : #{similarity}"
+    return similarity >= similarity_level
+  end
+
+# Use it to tune to given channel
+  def tune_immediately_to (channel)
+    key_seq = channel.to_s.chars.to_a
+    key_seq.push('SELECT') unless key_seq.length.eql?(4) # only for less than 4 digits channels
+    _press_key_sequence key_seq
+
+    sleep 3.sec
+    loginfo3 "Numeric tuning to channel : [#{channel}]",true,false,"TUNE_TO_#{channel}"
+  end
+
+# Use it to verify if screensaver is active
+  def screensaver_active? retries = 5
+    # Brightness calibration will not work for black screen verification so removing it temporary
+    brightness_correction_status = get_stb_brightness_correction_status
+    loginfo2 "Brightness correction status : #{brightness_correction_status}",false
+    # Disable brightness correction
+    set_stb_brightness_correction_status('false')
+
+    roi_name = :screen_saver_roi
+    icon_file_path = golden_roi(:screensaver_twc_logo).referenceImage
+    result = false
+    if (screen_matches_for_icon_roi roi_name, icon_file_path, retries)
+      loginfo2 "Screen saver is displayed", true, false
+      result = true
+    else
+      loginfo2 "Failed to verify screensaver",true,false
+      result = false
+    end
+
+    # Restoring old value
+    set_stb_brightness_correction_status(brightness_correction_status.to_s)
+
+    return result
+  end
+
+# Use it to verify if screensaver is dismissed.
+  def screensaver_inactive? retries = 5
+    # Brightness calibration will not work for black screen verification so removing it temporary
+    brightness_correction_status = get_stb_brightness_correction_status
+    loginfo2 "Brightness correction status : #{brightness_correction_status}",false
+    # Disable brightness correction
+    set_stb_brightness_correction_status('false')
+
+    roi_name = :screen_saver_inactive_roi
+    icon_file_path = golden_roi(:screensaver_twc_logo).referenceImage
+    result = false
+    if (screen_matches_for_icon_roi roi_name, icon_file_path, retries)
+      loginfo2 "Failed to verify screensaver dismissed",true,false
+      result = false
+    else
+      loginfo2 "Screen saver is dismissed", true, false
+      result = true
+    end
+
+    # Restoring old value
+    set_stb_brightness_correction_status(brightness_correction_status.to_s)
+
+    return result
+  end
+
+# Use to to get mas db time zone difference in minutes
+# * *Returns* :
+#   - GMT offset in minutes (integer)
+  def mas_db_time_zone_diff_in_min
+    tzbk = ENV['TZ'] # backup current time zone
+    tz = test_data[:mas_db_time_zone]
+    tz = tzbk if tz.nil? # Use system timezone
+
+    ENV['TZ'] = tz
+    result = (Time.now.gmt_offset / 60)
+    ENV['TZ'] = tzbk # restore backup current time zone
+
+    logdebug "MAS DB time zone difference in min : #{result}",false
+
+    return result
+  end
+
+# Use to to get mas conductor time zone difference in minutes
+# * *Returns* :
+#   - GMT offset in minutes (integer)
+  def mas_conductor_time_zone_diff_in_min
+    tz = test_data[:mas_conductor_time_zone]
+    unless tz.nil?
+      db_tz_diff = mas_db_time_zone_diff_in_min
+
+      tzbk = ENV['TZ'] # backup current time zone
+
+      ENV['TZ'] = tz
+      tz_diff = (Time.now.gmt_offset / 60)
+
+      result = (db_tz_diff - tz_diff)
+      ENV['TZ'] = tzbk # restore backup current time zone
+
+      logdebug "MAS Conductor time zone difference in min : #{result}",false
+
+      return result
+    else
+      return 0
+    end
+  end
+
+# Use it to get current date from MAS
+# * *Returns* :
+#   - date object that contains hashmap
+#   - e.g { day => 07, month => 06, year => 2011, hour => 05, min => 06, sec => 56 }
+  def mas_current_date
+    time_arr = mas_db_get_curr_date[0]['NOW'].split('/')
+
+    loginfo2 "MASDate : #{time_arr[0].to_i}/#{time_arr[1].to_i}/#{time_arr[2].to_i} #{time_arr[3].to_i}:#{time_arr[4].to_i}:#{time_arr[5].to_i}"
+
+    return Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+  end
+
+# Use it to get week days array
+# * *Returns* :
+#   - array of weekdays
+  def week_days
+    return ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
+  end
+
+# Use it to get week day of today
+# * *Returns* :
+#   - weekday, e.g. "SUN", "MON", "TUE", etc.
+  def mas_current_date_week_day
+    wdays = week_days
+    t = mas_current_date
+    return wdays[t.wday]
+  end
+
+# Use it to get channels list from mas
+# * *Returns* :
+#   - Array of channel
+#   - each channel is array [integer, string] (number, name), e.g. [2, dstk]
+  def mas_channels_list
+    result_array = []
+    channel_hash_array = mas_db_get_channels
+    channel_hash_array.each {|channel|
+      result_array.push([channel['DISPLAY_CHANNEL'].to_s.to_i, channel['DISPLAY_NAME'].to_s.downcase])
+    }
+    return result_array
+  end
+
+# Use it to get genre names from genre codes
+# * *Args*    :
+#   - +genre_codes+ -> codes list (e.g. ":17:18:") (get using db query)
+#   - +valid_genre+ -> valid genre codes array
+# * *Returns* :
+#   - array of genre names
+  def genre_names_from (genre_codes="", valid_genre = valid_genre_codes)
+
+    names = []
+    genre_codes.split(":").each {|genre|
+      next if genre.empty?
+      index = valid_genre.index {|code| (code[0] == genre.to_i)}
+      names.push(valid_genre[index][1]) unless index.nil?
+    }
+
+    return names
+  end
+
+# Private function
+# Use it to get genre codes from genre names
+# * *Args*    :
+#   - +genre_names+ -> comma separated genre names. (e.g, "News, Weather")
+#   - +valid_genre+ -> valid genre codes array
+# * *Returns* :
+#   - array of genre codes
+  def _genre_codes_from (genre_names="", valid_genre = valid_genre_codes)
+    codes = []
+    genre_names.split(",").each {|genre|
+      next if genre.empty?
+      index = valid_genre.index {|code| (code[1].to_s.casecmp(genre.to_s) == 0)}
+      codes.push(valid_genre[index][0]) unless index.nil?
+    }
+
+    return codes
+  end
+
+# Use it to valid genre codes with description from MAS DB
+# * *Returns* :
+#   - array of genre codes, genre desc
+  def valid_genre_codes
+    genre_arr = []
+    mas_db_genre.each {|data_hash|
+      genre_arr.push([data_hash['GENRE_CODE'].to_s.to_i, data_hash['GENRE_CODE_DESC'].to_s])
+    }
+
+    return genre_arr
+  end
+
+# Private method
+# Use to convert date and time to 'TO_DATE' format
+# * *Args*    :
+#   - +date_arr+ -> first element will be days (e.g. 0 for today, 1 for tomorrow) and
+#                   second element will be time in 24hrs format (e.g 18:00)
+# * *Returns* :
+#   - 'TO_DATE' format date and time. (e.g TO_DATE('2011-07-20 07:00:00'))
+  def _parse_date date_arr, curr_date = mas_current_date
+    time_zone_diff = mas_db_time_zone_diff_in_min
+
+    if(date_arr.class == Time)
+      new_time = (Time.local(date_arr.year,date_arr.month,date_arr.day,date_arr.hour,date_arr.min,0) - (time_zone_diff * 60)).strftime("%Y-%m-%d %H:%M:00")
+      return "TO_DATE('#{new_time}')"
+    end
+
+    if date_arr.length == 2
+      hour = date_arr[1][0..(date_arr[1].index(':') - 1)]
+      mins = date_arr[1][(date_arr[1].index(':') + 1)..(date_arr[1].length)]
+      new_time = (Time.local(curr_date.year,curr_date.month,curr_date.day,hour,mins,0) + (date_arr[0]*24*3600) - (time_zone_diff * 60)).strftime("%Y-%m-%d %H:%M:00")
+
+      return "TO_DATE('#{new_time}')"
+    elsif date_arr.length == 1
+      mins = curr_date.min > 30 ? 30 : 0
+      curr_time = (Time.local(curr_date.year,curr_date.month,curr_date.day,curr_date.hour,mins,0) + (date_arr[0]*24*3600) - (time_zone_diff * 60)).strftime("%Y-%m-%d %H:%M:00")
+      return "TO_DATE('#{curr_time}')"
+    else
+      return "''"
+    end
+  end
+
+# Private function
+# Use it to get advisory flags from MAS db
+  def _valid_advisory_flags
+    # Avoid MAS query for static list
+    #  result = []
+    #  mas_db_advisory_flags.each{ |flag_details|
+    #    result.push([flag_details['ADVISORY_FLAG'].to_s.to_i, flag_details['ADVISORY_LONG_DESC'].to_s])
+    #  }
+    #
+    #  return result
+
+    result = [
+        [0,'No Advisories'],
+        [1,'Sexual Content'],
+        [2,'Violence'],
+        [4,'Explicit Language'],
+        [8,'Strong Dialog'],
+        [16,'Fantasy Violence'],
+        [32,'Adult Situations'],
+        [64,'Brief Nudity'],
+        [128,'Graphic Language'],
+        [256,'Graphic Violence'],
+        [512,'Language'],
+        [1024,'Mild Violence'],
+        [2048,'Nudity'],
+        [4096,'Rape'],
+        [8192,'Strong Sexual']] # TODO : database mismatch "Strong Sexual Content"
+
+    return result
+  end
+
+# Private function
+# Use it to get advisory flags from advisory code
+  def _advisory_flags_from_advisory_code advisory_code, flags = _valid_advisory_flags
+    # return first no advisory if advisory_code is 0
+    return flags[0][1] if advisory_code.nil? || advisory_code.to_s.to_i == 0
+
+    result = []
+    advisory_code_int = advisory_code
+    advisory_code = advisory_code.to_s.to_i.to_s(2).reverse # convert to string -> integer -> string base 2
+
+    counter = 1
+    advisory_code.each_char {|flag|
+      if counter >= flags.length
+        loginfo2 "advisory_code [#{advisory_code_int}] not available"
+        next
+      end
+      result.push(flags[counter][1]) if flag.casecmp('1') == 0
+      counter = counter + 1
+    }
+
+    return result.join(',')
+  end
+
+# Private function
+# Use it to get event flags from MAS db
+  def _valid_event_flags
+    # TODO fix me : EV_FLAG is not having all flags
+    #  result = []
+    #  mas_db_event_flags.each {|program_type|
+    #    result.push([program_type['EV_FLAG'].to_s.to_i, program_type['EV_FLAG_DESC'].to_s])
+    #  }
+
+    result = [
+        [0, 'RESERVED'],
+        [1, 'REPEAT'],
+        [2, 'LETTERBOX'],
+        [4, 'HDTV'],
+        [8, 'CLOSED_CAPTIONED'],
+        [16, 'ENHANCED'],
+        [32, 'STEREO'],
+        [64, 'DOLBY'],
+        [128, 'SAP'],
+        [256, 'MYSTRO_PAUSABLE'],
+        [512, 'MYSTRO_REWIND_PRIOR_TO_SESSION_START'],
+        [1024, 'MYSTRO_PAST_RESERVE'],
+        [2048, 'MYSTRO_CURRENT_RESERVE'],
+        [4096, 'MYSTRO_FUTURE_RESERVE']]
+
+    return result
+  end
+
+# Private function
+# Use it to get event flags from event code
+  def _event_flags_from_event_code event_code, flags = _valid_event_flags
+    # return first no event flag if event_code is 0
+    return flags[0][1] if event_code.nil? || event_code.to_s.to_i == 0
+
+    result = []
+    event_code_int = event_code
+    event_code = event_code.to_s.to_i.to_s(2).reverse # convert to string -> integer -> string base 2
+
+    counter = 1
+    event_code.each_char {|flag|
+      if counter >= flags.length
+        loginfo2 "event_code [#{event_code_int}] not available"
+        next
+      end
+      result.push(flags[counter][1]) if flag.casecmp('1') == 0
+      counter = counter + 1
+    }
+
+    return result.join(',')
+  end
+
+# Use it to find program on particular channel, time and duration
+# * *Args*    :
+#   - +params+ -> data hash e.g params = {{:CHANNEL_NUMBER => 85, :CHANNEL_NUMBERS => [80, 85, 45], :START_DATE_TIME => [0, '1:00'] OR ruby_time, :END_DATE_TIME => [0, '2:00'] OR ruby_time}}
+#   - all return array parameters can be passed as argument
+#   - GENRE_NAMES are comma separated names(e.g, News, Weather)
+#   - Valid PROGRAM_TYPE = EP, MV, Miniseries, Paid Programming, SH, SP, Series, Special
+# * *Returns* :
+#   - Array of programs each array will contain CHANNEL_NUMBER, CHANNEL_NAME, PROGRAM_START_TIME, PROGRAM_END_TIME, PROGRAM_SHORT_TITLE, PROGRAM_LONG_TITLE
+#   PROGRAM_RATING_SHORT, PROGRAM_RATING_LONG, PROGRAM_STAR_RATING, PROGRAM_GENRE_CODES, PROGRAM_SHORT_DESC, PROGRAM_LONG_DESC, PROGRAM_TYPE, PROGRAM_CONTENT_TYPE, PROGRAM_FLAG, EVENT_DETAIL_ID, SERVICE_SCHEDULE_ID, MYSTRO_SERVICE_ID
+  def find_programs(params={}, curr_date = mas_current_date)
+    where_clause = ''
+    where_clause << " AND MYSTRO_CHANNEL.DISPLAY_CHANNEL = #{params[:CHANNEL_NUMBER]}" if (!params[:CHANNEL_NUMBER].nil? && params[:CHANNEL_NUMBER].to_s.to_i >= 0)
+    where_clause << " AND MYSTRO_CHANNEL.DISPLAY_CHANNEL IN (#{params[:CHANNEL_NUMBERS].join(',')})" if (!params[:CHANNEL_NUMBERS].nil? && params[:CHANNEL_NUMBERS].class == Array && !(params[:CHANNEL_NUMBERS].empty?))
+    where_clause << " AND UPPER(MYSTRO_SERVICE.DISPLAY_NAME) LIKE '%#{params[:CHANNEL_NAME].to_s.upcase}%'" if (!params[:CHANNEL_NAME].nil? && params[:CHANNEL_NAME].strip != '')
+    where_clause << " AND (SERVICE_SCHEDULE.TMS_ENDAIR_TIME > #{_parse_date(params[:START_DATE_TIME], curr_date)})" if (!params[:START_DATE_TIME].nil? && params[:END_DATE_TIME].nil?)
+    where_clause << " AND (SERVICE_SCHEDULE.TMS_AIR_DATETIME < #{_parse_date(params[:END_DATE_TIME], curr_date)})" if (!params[:END_DATE_TIME].nil? && params[:START_DATE_TIME].nil?)
+    where_clause << " AND (SERVICE_SCHEDULE.TMS_ENDAIR_TIME > #{_parse_date(params[:START_DATE_TIME], curr_date)} AND SERVICE_SCHEDULE.TMS_AIR_DATETIME < #{_parse_date(params[:END_DATE_TIME], curr_date)})" if (!params[:END_DATE_TIME].nil? && !params[:START_DATE_TIME].nil?)
+    where_clause << " AND UPPER(EVENT.EVENT_SHORT_TITLE) LIKE '%#{params[:PROGRAM_SHORT_TITLE].to_s.upcase}%'" if (!params[:PROGRAM_SHORT_TITLE].nil? && params[:PROGRAM_SHORT_TITLE].strip != '')
+    where_clause << " AND UPPER(EVENT.EVENT_LONG_TITLE) LIKE '%#{params[:PROGRAM_LONG_TITLE].to_s.upcase}%'" if (!params[:PROGRAM_LONG_TITLE].nil? && params[:PROGRAM_LONG_TITLE].strip != '')
+    where_clause << " AND UPPER(RATING_FLAG.RATING_FLAG_SHORT_DESC) LIKE '%#{params[:PROGRAM_RATING_SHORT].to_s.upcase}%'" if (!params[:PROGRAM_RATING_SHORT].nil? && params[:PROGRAM_RATING_SHORT].strip != '')
+    where_clause << " AND UPPER(RATING_FLAG.RATING_FLAG_LONG_DESC) LIKE '%#{params[:PROGRAM_RATING_LONG].to_s.upcase}%'" if (!params[:PROGRAM_RATING_LONG].nil? && params[:PROGRAM_RATING_LONG].strip != '')
+    where_clause << " AND UPPER(STAR_RATING_CODE.STAR_RATING_CODE_DESC) LIKE '%#{params[:PROGRAM_STAR_RATING].to_s.upcase}%'" if (!params[:PROGRAM_STAR_RATING].nil? && params[:PROGRAM_STAR_RATING].strip != '')
+    where_clause << " AND UPPER(EVENT_DETAIL.EVENT_SHORT_DESCRIPTION) LIKE '%#{params[:PROGRAM_SHORT_DESC].to_s.upcase}%'" if (!params[:PROGRAM_SHORT_DESC].nil? && params[:PROGRAM_SHORT_DESC].strip != '')
+    where_clause << " AND UPPER(EVENT_DETAIL.EVENT_LONG_DESCRIPTION) LIKE '%#{params[:PROGRAM_LONG_DESC].to_s.upcase}%'" if (!params[:PROGRAM_LONG_DESC].nil? && params[:PROGRAM_LONG_DESC].strip != '')
+    where_clause << " AND UPPER(EVENT.EVENT_TYPE) LIKE '%#{params[:PROGRAM_TYPE].to_s.upcase}%'" if (!params[:PROGRAM_TYPE].nil? && params[:PROGRAM_TYPE].strip != '')
+    where_clause << " AND EVENT_DETAIL.ADVISORY_CODE NOT IN ('0')" if (!params[:HAS_CONTENT_TYPES].nil? && params[:HAS_CONTENT_TYPES] == true)
+    where_clause << " AND (SERVICE_SCHEDULE.TMS_ENDAIR_TIME > #{_parse_date(params[:DATE_TIME], curr_date)} AND SERVICE_SCHEDULE.TMS_AIR_DATETIME <= #{_parse_date(params[:DATE_TIME], curr_date)})" if (!params[:DATE_TIME].nil?)
+    where_clause << " AND EVENT.EVENT_ID like '#{params[:EVENT_ID]}'" if (!params[:EVENT_ID].nil? && params[:EVENT_ID].strip != '')
+    # hidden channel check, clock channel check
+    if (!params[:CHANNEL_HIDDEN].nil? && params[:CHANNEL_HIDDEN] == true)
+      where_clause << " AND MYSTRO_CHANNEL.CHANNEL_FLAGS >= 32 "
+    elsif !params[:CHANNEL_NUMBER].nil? && params[:CHANNEL_NUMBER].to_s == fetch_option(:a_clock_channel).to_s
+      # Do nothing
+      loginfo2 "Query for clock channel data (hidden channel)"
+    else
+      where_clause << " AND MYSTRO_CHANNEL.CHANNEL_FLAGS < 32 "
+    end
+
+    if (!params[:GENRE_NAMES].nil? && !params[:GENRE_NAMES].strip.empty?)
+      where_clause << " AND ( "
+      _genre_codes_from(params[:GENRE_NAMES]).each{|code|
+        where_clause << "EVENT_DETAIL.GENRE_CODE LIKE '%:#{code}:%' OR "
+      }
+      where_clause = "#{where_clause[0..(where_clause.length - 4)]} )"
+    end
+
+    if (!params[:PROGRAM_FLAGS].nil? && !params[:PROGRAM_FLAGS].empty?)
+      valid_flags = _valid_event_flags
+      result = 0
+      params[:PROGRAM_FLAGS].each{|flag|
+        index = valid_flags.index{|v_flag| v_flag[1].delete(' ').downcase.casecmp(flag.delete(' ').downcase) == 0}
+        result = result + valid_flags[index][0]
+      }
+
+      where_clause << "AND BITAND(SERVICE_SCHEDULE.MYSTRO_EVENT_CODE, #{result}) = #{result}"
+    end
+
+    if (!params[:PROGRAM_CONTENT_TYPES].nil? && params[:PROGRAM_CONTENT_TYPES].empty?)
+      valid_adflags = _valid_advisory_flags
+      result = 0
+      params[:PROGRAM_CONTENT_TYPES].each{|flag|
+        index = valid_adflags.index{|v_flag| v_flag[1].delete(' ').downcase.casecmp(flag.delete(' ').downcase) == 0}
+        result = result + valid_adflags[index][0]
+      }
+
+      where_clause << "AND BITAND(EVENT_DETAIL.ADVISORY_CODE, #{result}) = #{result}"
+    end
+
+    loginfo2 "WhereClause : #{where_clause}"
+
+    data_arr = mas_db_guide_data where_clause
+    result_arr = []
+    return result_arr if data_arr.nil?
+
+    # Advisory flags
+    flags = _valid_advisory_flags
+    types = _valid_event_flags
+
+    data_arr.each {|data_hash|
+      time_arr =  data_hash['PROGRAM_START_TIME'].split('/')
+      prog_start_time = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr =  data_hash['PROGRAM_END_TIME'].split('/')
+      prog_end_time = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      content_type = _advisory_flags_from_advisory_code(data_hash['CONTENT_TYPE'], flags)
+      event_type = _event_flags_from_event_code(data_hash['EVENT_CODE'],types)
+
+      result_arr.push([data_hash['CHANNEL_NUMBER'].to_s.to_i, data_hash['CHANNEL_NAME'], prog_start_time, prog_end_time, data_hash['PROGRAM_SHORT_TITLE'], data_hash['PROGRAM_LONG_TITLE'], data_hash['PROGRAM_RATING_SHORT'], data_hash['PROGRAM_RATING_LONG'], data_hash['PROGRAM_STAR_RATING'], data_hash['PROGRAM_GENRE_CODES'], (data_hash['PROGRAM_SHORT_DESC'] || ""), (data_hash['PROGRAM_LONG_DESC'] || ""), data_hash['PROGRAM_TYPE'], content_type, event_type, data_hash['EVENT_DETAIL_ID'], data_hash['SERVICE_SCHEDULE_ID'], data_hash['MYSTRO_SERVICE_ID'], data_hash['EVENT_ID']])
+    }
+    return result_arr
+  end
+
+# Use it to fetch option from YAML file
+# * *Args*    :
+#   - +option+ -> option name (e.g. :a_live_channel1)
+# * *Returns* :
+#   - Option value as string
+  def fetch_option(option, default=:__fetch_option_default)
+    if default == :__fetch_option_default
+      result = test_data[option]
+      raise "Test data missing attribute: :#{option}" if result.nil?
+    else
+      result = test_data.fetch(option, default)
+    end
+    result
+  end
+
+  # DEPRECATED
+  def set_option(option, value)
+    loginfo2 "WARNING: set_option is deprecated",false
+    option = option.to_sym
+    old_value = test_data[option]
+    unless old_value.nil?
+      loginfo2 "Option[#{option}] : OLD value [#{old_value}] - New value[#{value}]",false
+      test_data[option] = value
+    else
+      loginfo2 "Option missing from test data: #{option}",false
+    end
+  end
+
+  def fetch_stb
+    return $stb
+  end
+
+# Use it to get rack ip
+  def fetch_rack_ip
+    return $ip_address
+  end
+
+# Use it to undo black and white screen using long select + 1 key sequence
+  def stb_undo_black_n_white
+    return false unless power_off_stb?
+
+    key_seq = [['SEL_LONG', 10000], ['1', 200], ['POWER', 200]]
+    _press_key_sequence key_seq
+
+    sleep 5.sec
+
+    return true
+  end
+
+# Use it to fetch ip address of STB from its MAC address
+# * *Args*    :
+# * *Returns* :
+#   - IP address or nil if IP unavailable
+  def fetch_ip
+    #if test_data[:sword_override_tmc] == "true"
+    #return test_data[:stb_ip]
+    #end
+    return "00:00:00:00" if $rti_flag==false
+    ip_addr = nil
+    begin
+      mac_addr = fetch_stb_mac_address
+      loginfo2 "Mac address: #{mac_addr}",false
+
+      # TODO : mac address check
+      #    if mac_addr.to_s.scan(/(\s*)([0-9A-F]{12})(\s*)/).empty?
+      #      loginfo2 "STB is not having valid MAC address",false
+      #      return nil
+      #    end
+      if(mac_addr.gsub(':','').length > 12)
+        loginfo2 "Executing mas command 'mdiags stb unitaddr2ip #{mac_addr}'",false
+        result = (exec_mas_cmd "mdiags stb unitaddr2ip #{mac_addr}")
+      else
+        loginfo2 "Executing mas command 'mdiags stb mac2ip #{mac_addr}'",false
+        result = (exec_mas_cmd "mdiags stb mac2ip #{mac_addr}")
+      end
+
+      loginfo2 "MAS Command Result : #{result}",false
+
+      tcfail 'MAS command result is nil or empty' if result.nil? or result.empty?
+
+      ip_add_array = result.to_s.scan(/(\d{1,3})(.)(\d{1,3})(.)(\d{1,3})(.)(\d{1,3})/)
+
+      if ip_add_array.empty?
+        loginfo2 "MAS command result (output) is not having valid IP address",false
+      else
+        ip_addr = ip_add_array[0].to_s
+        loginfo2 "IP address : #{ip_addr}",false
+      end
+    rescue => e
+      loginfo2 "EXEC MAS command error : #{e.message}",false
+    end
+
+    return ip_addr
+  end
+
+# Use it to fetch screensaver timeout from MAS via selenium
+  def screen_saver_timeout_in_millis
+    time_in_min = fetch_screensaver_timeout
+    loginfo2 "Screen saver timeout is #{time_in_min} minutes"
+    return time_in_min.to_i.min
+  end
+
+# Use it to check that box has a valid IP Address.
+  def has_valid_ip?(stb_ip = fetch_ip,retries=5)
+    if stb_ip.nil?
+      loginfo2 'Box has not been assigned any IP Address.',false
+      return false
+    else
+      loginfo2 "IP of the box is #{stb_ip}",false
+
+      retries.times do
+        ping_cmd = "/bin/ping -c 3 #{stb_ip}"
+        result = exec_mas_cmd ping_cmd
+        loginfo2 "Ping result : #{result}",false
+
+        packets_received = result.scan(/(\d+)(\s+)(received)/)
+        if packets_received.empty?
+          loginfo2 "Ping command output is not having packet received count",false
+          return false
+        else
+          return true if (packets_received[0][0].to_s.to_i > 0)
+          loginfo2 "100 % packet loss, IP[#{stb_ip}] is not reachable",false
+          # sleep for 10 sec and try again
+          sleep 10.sec
+          next
+        end
+      end
+
+      loginfo2 "Failed to validate STB ip",false
+      return false
+    end
+  end
+
+# Use to verify whether STB is having valid MAC address or not (syntax)
+  def has_valid_mac?
+    mac_add = fetch_stb_mac_address.to_s.strip
+
+    re1='((?:[0-9A-F][0-9A-F]:){5}(?:[0-9A-F][0-9A-F]))(?![:0-9A-F])' # Mac Address 1
+    re2='(([0-9A-F][0-9A-F]){5}([0-9A-F][0-9A-F]))(?![0-9A-F])' # Mac Address 2
+
+    m1=Regexp.new(re1,Regexp::IGNORECASE);
+    m2=Regexp.new(re2,Regexp::IGNORECASE);
+    if m1.match(mac_add) or m2.match(mac_add)
+      loginfo2 "STB is having valid MAC address (Syntax)",false
+      return true
+    else
+      loginfo2 "STB is not having valid MAC address (Syntax)",false
+      return false
+    end
+  end
+
+# Use it to verify whether STB is having valid MODEL defined or not (settop box config)
+# Verify from stb registry
+  def has_valid_model?
+    stbmodel = fetch_stb_model.to_s.upcase
+
+    if StbRegistry.model_exists?(stbmodel)
+      loginfo2 "STB model #{stbmodel} exists in STB Registry",false
+      return true
+    else
+      loginfo2 "STB model #{stbmodel} does not exist in STB Registry",false
+      return false
+    end
+  end
+
+# Use it check whether STB is able to response commands from DNCS to check connectivity
+# This method will send call to STB and verify whether STB is getting calling message or not
+  def has_connectivity?
+    # add caller id package
+    return false unless add_pkg_on_dncs(fetch_option(:caller_id_package_name))
+
+    begin
+      caller_id_prompt_on
+      press_exit_sleep
+    rescue StandardError => e
+      loginfo2 "Failed to set caller id prompt to ON : #{e.message}"
+      return false
+    end
+
+    # send call to STB
+    caller_name = "AAA_#{dut.id.to_s}"
+    caller_number = "0" << dut.id.to_s(2)
+    callee_number = "0000"
+
+    return false unless send_call_to_stb(caller_name, caller_number, callee_number)
+
+    # verify caller id screen
+    if ocr_text_similar_for_roi(:caller_id_call_log_roi,'Call Log',3,true,false,0.75,true)
+      result1 = ocr_text_includes_for_roi(:caller_id_caller_name_roi,caller_name,3,true,false,1.0,true)
+      result2 = ocr_text_includes_for_roi(:caller_id_caller_number_roi,caller_number,3,true,false,1.0,true)
+      if result1 or result2
+        press_exit_sleep
+        return true
+      end
+    end
+
+    loginfo2 "Failed to verify caller name / caller number : [#{caller_name},#{caller_number}]"
+    return false
+  end
+
+# Use it to get all parental rating values
+# * *Returns* :
+# - array of ratings, each rating is array of short description and long description
+# e.g. [['TV-Y','All Children'], ['TV-Y7','Children Age 7 and Above'] .. etc
+  def valid_parental_ratings
+    # Avoid MAS Query for static list
+    #  result = []
+    #  mas_db_parental_ratings.each { |rating_hash|
+    #    result.push([rating_hash['RATING_FLAG_SHORT_DESC'].to_s, rating_hash['RATING_FLAG_LONG_DESC'].to_s])
+    #  }
+    #
+    #  return result
+
+    result = [
+        ['NR','No Mystro Rating'],
+        ['TV-Y','All Children'],
+        ['TV-Y7','Children Age 7 and Above'],
+        ['TV-G','General Audience'],
+        ['G','General Audience'],
+        ['TV-PG','Parental Guidence Suggested'],
+        ['PG','Parental Guidence Suggested'],
+        ['PG-13','Parents Strongly Cautioned'],
+        ['TV-14','Parents Strongly Cautioned'],
+        ['TV-MA','Mature Audiences Only'],
+        ['R','Restricted'],
+        ['NC-17','No One Under 17'],
+        ['AO','Adults Only']]
+
+    return result
+  end
+
+# Use to get index of given rating
+# * *Args*    :
+#   - +rating+ -> rating string to get index of
+#   - +flags+ -> valid rating flags
+# * *Returns* :
+#   - index of specified rating flag , nil for invalid rating flag
+  def parental_rating_index rating, flags = valid_parental_ratings
+    index = flags.index{|flag| flag[0].casecmp(rating) == 0}
+    loginfo2 "Invalid rating flag : #{rating}" if index.nil?
+    return index
+  end
+
+# Use it to verify the catalog info from web-based Diagnostics page for the STB and MAS.
+# * *Returns* :
+#   - true if atleast one value of catalog info from web-based Diagnostics page for the STB matches with MAS"
+  def verify_mas_catalogs_with_stb_catalogs?
+    ip = fetch_ip
+    if ip.nil?
+      loginfo2 'STB does not have an IP address'
+      return false
+    end
+    return false unless has_valid_ip?(ip)
+    web_diag_catalog = []
+    loginfo2 "Fetching catalogs directory from web diags"
+    if stb_capable_of? 'MDN'
+      web_diag_catalog = _fetch_mdn_airtime_catalog_id ip
+    elsif stb_capable_of? 'ODN'
+      web_diag_catalog = _fetch_odn_airtime_catalog_id ip
+    end
+    if web_diag_catalog.empty?
+      loginfo2 "Unable to fetch catalog directory from web diagnostics"
+      return false
+    end
+    loginfo2 "Successfully fetched airtime catalogs directory from web diagnostics"
+
+    loginfo2 "Fetching catalogs list from MAS"
+    mas_catalog = []
+    mas_catalog = _fetch_catalog_info
+    if mas_catalog.empty?
+      loginfo2 "Unable to fetch catalog list from MAS"
+      return false
+    end
+    loginfo2 "Successfully fetched airtime catalogs listing from MAS"
+
+    web_diag_catalog.each do |catalog|
+      if mas_catalog.include?(catalog)
+        loginfo2 "Airtime catalog ID [#{catalog}] matched in MAS cataogs list and Web diags catalogs directory"
+        return true
+      end
+    end
+    return false
+  end
+
+# Use it to read value of Instant replay jump value in seconds from MAS
+# * *Returns* :
+#   - value of "Instant replay jump value in seconds"
+  def mas_instant_replay_jump
+    result = fetch_dvr_parameters
+
+    return '' if result.empty?
+    loginfo2 "Instant Replay Jump(seconds): [#{result[2]}]"
+    return result[2]
+  end
+
+# Use it to read value of Time Shift Buffer length from MAS
+# * *Returns* :
+#   - value of "Time Shift Buffer length"
+  def mas_tsb_length
+    result = fetch_dvr_parameters
+
+    return '' if result.empty?
+    loginfo2 "Time Shift Buffer length: [#{result[0]}]"
+    return result[0]
+  end
+
+# Use it to read value of Paused session timeout from MAS
+# * *Returns* :
+#   - value of "Paused session timeout" in seconds
+  def mas_paused_session_timeout
+    result = fetch_timeout_parameters
+
+    return '' if result.empty?
+    loginfo2 "Paused Session Timeout (seconds) : [#{result[13]}]"
+    return result[13]
+  end
+
+# Use it to read value of Menu timeout in seconds from MAS
+# * *Returns* :
+#   - value of "Menu timeout" in seconds
+  def mas_menu_timeout
+    result = fetch_timeout_parameters
+
+    return '' if result.empty?
+    loginfo2 "Menu Timeout (seconds) : [#{result[2]}]"
+    return result[2]
+  end
+
+# Use it to read value of # of Hours of Inactivity to Enter Low Power State(hours) from MAS
+# * *Returns* :
+#   - value of "# of Hours of Inactivity to Enter Low Power State(hours)"
+  def mas_hours_of_inactivity_to_enter_low_power
+    result = fetch_power_save_settings
+
+    return '' if result.empty?
+    loginfo2 "No. of Hours of Inactivity to Enter Low Power State(hours) : [#{result[0]}]"
+    return result[0]
+  end
+
+# Use it to clear buffer for currently tuned channel by navigating 2 channels up and then move back to current channel
+# * *Returns* :
+#   - true if successfully else false
+  def clear_buffer_for_current_channel
+    # Move up two channels
+    channel_up_count = 0
+    video_channels_count = 0
+    max_count = 50 # to avoid infinite loop
+
+    # tune channel up until 2 channels with video found
+    max_count.times do
+      press_channel_up_sleep
+      sleep_for_last_tuned_channel
+
+      video_channels_count+=1 if fullscreen_video_playing? # increment video channel count
+      channel_up_count+=1 # increment channel up count
+
+      break if video_channels_count >= 2
+    end
+
+    if video_channels_count < 2
+      loginfo2 "Failed to get 2 video channels",true,true
+      return false
+    end
+
+    # tune back to home channel
+    channel_up_count.times do
+      sleep_for_last_tuned_channel
+      press_channel_down_sleep
+    end
+
+    loginfo2 "Successfully cleared buffer for current channel"
+    return true
+  end
+
+# Use convert time in seconds to hour:min format
+# * *Args*    :
+#   - +seconds+ -> number of seconds
+# * *Returns* :
+#   - time text string in "hour:min" format
+  def seconds_to_hour_min_text seconds
+    # convert seconds to integer
+    seconds = seconds.to_s.to_i
+
+    hours = (seconds / (60 * 60)).to_s.to_i
+    mins = ((seconds - (hours * 60 * 60)) / 60).to_s.to_i
+    mins = "0#{mins}" if mins < 10 # add prefix '0' for single digit mins
+    return "#{hours}:#{mins}"
+  end
+
+# Use it to switch-off the STB power.
+  def stb_power_off
+    ac_power_sleep = fetch_option(:stb_ac_power_on_off_wait_in_seconds)
+    if ac_power_sleep.nil?
+      loginfo2 "Config parameter [:stb_ac_power_on_off_wait_in_seconds] is not set"
+      return false
+    end
+    ac_power_sleep = ac_power_sleep.to_s.to_i
+
+    begin
+      ac_power(false)
+      loginfo2 "Sleeping for AC power OFF ...(#{ac_power_sleep} seconds)"
+      sleep ac_power_sleep.sec
+      loginfo2 "Successfully AC powered OFF STB"
+
+      return true
+    rescue StandardError => e
+      logdebug "Exception : #{e.message}"
+      logdebug e.backtrace.join("\n")
+
+      loginfo2 "Failed to powered off STB using AC power"
+      return false
+    end
+  end
+
+# Use it to verify whether STB bootup screen appears or not
+  def stb_reboot_loading_message_appears?(retries=2)
+    icon1 = :fullscreen_reboot_message_icon1 # cisco or powertv or samsung
+    icon2 = :fullscreen_reboot_message_icon2 # mystro
+
+    if stb_capable_of?('ODN')
+      return true if (screen_matches_for_icon_roi(icon1,icon1,retries) or screen_matches_for_icon_roi(icon2,icon2,retries))
+    else
+      return true if (screen_matches_for_icon_roi(icon1,icon1,retries) or golden_copy_matches_for_roi(icon2,retries))
+    end
+
+    loginfo2 "Reboot loading message does not appear on the screen",true
+    return false
+  end
+
+# Use it to reboot STB using AC power on/off
+  def stb_reboot_using_ac_power
+#  ac_power_sleep = fetch_option(:stb_ac_power_on_off_wait_in_seconds)
+#  if ac_power_sleep.nil?
+#    loginfo2 "Config parameter [:stb_ac_power_on_off_wait_in_seconds] is not set"
+#    return false
+#  end
+#  ac_power_sleep = ac_power_sleep.to_s.to_i
+    ac_power_sleep = 3
+    begin
+      ac_power(false)
+      loginfo2 "Sleeping for AC power OFF ...(#{ac_power_sleep} seconds)"
+      sleep ac_power_sleep.sec
+      loginfo2 "Successfully AC powered OFF STB"
+
+      ac_power(true)
+      #loginfo2 "Sleeping for AC power ON ...(#{ac_power_sleep} seconds)"
+      #sleep ac_power_sleep.sec
+      loginfo2 "Successfully AC powered ON STB"
+
+      return true
+    rescue StandardError => e
+      logdebug "Exception : #{e.message}"
+      logdebug e.backtrace.join("\n")
+
+      loginfo2 "Failed to reboot STB using AC power"
+      return false
+    end
+  end
+
+# Use it to power on stb within given duration
+# * *Args*    :
+#   - +duration+ -> duration in minutes
+# * *Returns* :
+#   - true if successfully else false
+  def _power_on_stb_within_duration(duration=1)
+    # Power on STB (within [x] min)
+    failed_to_power_on_retry_count = (duration * 60) / 10
+    failed_to_power_on_retry_count.times do
+      if power_on_stb?
+        return true
+      end
+      sleep 10.sec # wait for few seconds
+    end
+    return false
+  end
+
+# Use it to power on stb and verify loading message/icon
+# * *Returns* :
+#   - true if successfully else false
+  def _power_on_stb_and_verify_reboot_loading_screen
+    2.times do
+      _power_on_stb_within_duration
+      return true if stb_reboot_loading_message_appears?(1) # only 1 retry
+    end
+    return false
+  end
+
+# Private method
+# Use it to reset application screen back to stretched mode
+  def _stb_p550hd_reset_application_aspect_ratio(retries=3)
+    retries.times do
+      press_exit_sleep
+      press_settings_sleep
+      sleep 10.sec # wait for STB to load settings screen
+      # Navigate to aspect ratio
+      4.times do
+        press_right_arrow_sleep
+      end
+      # Select focused setting (aspect ratio)
+      press_select_sleep
+      # Select default setting
+      press_select_sleep
+      # Exit to fullscreen
+      press_exit_sleep
+      # Verify using info banner
+      return true if info_banner_launch_and_verify(true,true)
+    end
+
+    loginfo2 "Failed to reset aspect ratio"
+    return false
+  end
+
+# Use it to wait till STB finished rebooting
+# * *Args*    :
+#   - +apc_reboot+ -> reboot STB again using AC power if failed to reboot
+# * *Returns* :
+#   - true if successfully finished rebooting else false
+  def stb_wait_till_finish_rebooting(apc_reboot = false)
+    waiting_time = fetch_option(:stb_reboot_wait_time_in_minutes).to_s.to_i
+
+    failed_to_power_on_retry_count = 6
+
+    waiting_time.times do
+      # Power on STB (within 1 min)
+      unless _power_on_stb_within_duration(1)
+        if apc_reboot
+          loginfo2 "Failed to power ON STB, rebooting STB using AC power ..."
+          return false unless stb_reboot_using_ac_power
+          return stb_wait_till_finish_rebooting
+        else
+          loginfo2 "Failed to power on STB"
+          return false
+        end
+      end
+
+      # exit to fullscreen
+      press_exit_sleep
+
+      if _power_on_stb_and_verify_reboot_loading_screen
+        loginfo2 "STB booting up, Please wait ...", true
+        sleep 1.min
+      else
+        unless power_on_stb? # it may possible that STB will switch to standby mode after reboot
+          loginfo2 "Failed to power on STB"
+          return false
+        end
+        loginfo2 "STB is ON",true
+        # Reset Aspect ratio for P550HD
+        (return false unless _stb_p550hd_reset_application_aspect_ratio) if fetch_stb_model.upcase.eql?('P550HD')
+        (return false unless stb_undo_black_n_white) if check_models?('SA8010HD')
+        return true # successfully finished rebooting
+      end
+    end
+
+    # if STB still loading then reboot the STB again
+    if apc_reboot
+      loginfo2 "STB still loading, rebooting again",true
+      return false unless stb_reboot_using_ac_power
+      return stb_wait_till_finish_rebooting
+    else
+      loginfo2 "STB has not finished loading within [#{waiting_time}] minutes, Please check",true
+      return false
+    end
+  end
+
+# Use it to switch-on the STB power.
+# * *Args* :
+#   - +return_when_up+ -> if true, this method waits till STB properly boots up.
+# * *Returns* :
+#   - true, if STB seems operational, false otherwise.
+  def stb_power_on(return_when_up = false)
+    ac_power_sleep = fetch_option(:stb_ac_power_on_off_wait_in_seconds)
+    if ac_power_sleep.nil?
+      loginfo2 "Config parameter [:stb_ac_power_on_off_wait_in_seconds] is not set"
+      return false
+    end
+    ac_power_sleep = ac_power_sleep.to_s.to_i
+
+    begin
+      ac_power(true)
+      loginfo2 "Sleeping for AC power ON ...(#{ac_power_sleep} seconds)"
+      sleep ac_power_sleep.sec
+      loginfo2 "Successfully AC powered ON STB"
+    rescue StandardError => e
+      logdebug "Exception : #{e.message}"
+      logdebug e.backtrace.join("\n")
+
+      loginfo2 "Failed to powered on STB using AC power"
+      return false
+    end
+
+    return true unless return_when_up
+
+    return stb_wait_till_finish_rebooting(false)
+  end
+
+# Use it to verify the STB operational mode.
+# * *Args* :
+#   - +mode+ -> adsg or davic
+# * *Returns* :
+#   - true, if STB operational in the mode(adsg/davic) passed, false otherwise.
+  def verify_stb_mode(mode='adsg')
+    ip = fetch_ip
+    return false if ip.nil?
+    return false unless has_valid_ip?(ip)
+    return (get_snmp("#{ip}", '1.3.6.1.4.1.4491.2.3.1.1.4.5.3.0', 'public') == '2') if mode.casecmp('adsg') == 0
+    return (get_snmp("#{ip}", '1.3.6.1.4.1.4491.2.3.1.1.4.5.3.0', 'public') != '2') if mode.casecmp('davic') == 0
+  end
+
+# Use it to find details of PPV program on particular channel, time, name, duration etc
+# * *Args*    :
+#   - +params+ -> data hash e.g params = {{:CHANNEL_NUMBER => 85, :CHANNEL_NUMBERS => [80, 85, 45], :START_DATE_TIME => [0, '1:00'] OR ruby_time, :END_DATE_TIME => [0, '2:00'] OR ruby_time}}
+#   - all return array parameters can be passed as argument
+#   - Valid PROGRAM_WINDOW_NAME = 'LIFETIME_WINDOW', 'PREVIEW_WINDOW', 'BUY_WINDOW', 'CANCEL_WINDOW', 'ADVERTISING_WINDOW', 'MARKETING_WINDOW', 'FREE_CANCEL_WINDOW'
+# * *Returns* :
+#   - Returns an Array of programs as a MultiHashMap each hash will contain the following keys CHANNEL_NUMBER, CHANNEL_NAME, PROGRAM_SHORT_TITLE, PROGRAM_COST, PROGRAM_TYPE, PROGRAM_EVENT_ID, ADVERTISING_WINDOW,  BUY_WINDOW,  CANCEL_WINDOW,  LIFETIME_WINDOW,  MARKETING_WINDOW,  PREVIEW_WINDOW
+#   - Each window type will contain a Hash Map with start time and duration as keys
+  def find_ppv_programs(params={}, curr_date = mas_current_date)
+
+    where_clause = ''
+    where_clause << " AND MYSTRO_CHANNEL.DISPLAY_CHANNEL = #{params[:CHANNEL_NUMBER]}" if (!params[:CHANNEL_NUMBER].nil? && params[:CHANNEL_NUMBER].to_s.to_i >= 0)
+    where_clause << " AND MYSTRO_CHANNEL.DISPLAY_CHANNEL IN (#{params[:CHANNEL_NUMBERS].join(',')})" if (!params[:CHANNEL_NUMBERS].nil? && params[:CHANNEL_NUMBERS].class == Array && !(params[:CHANNEL_NUMBERS].empty?))
+    where_clause << " AND UPPER(MYSTRO_SERVICE.DISPLAY_NAME) LIKE '%#{params[:CHANNEL_NAME].to_s.upcase}%'" if (!params[:CHANNEL_NAME].nil? && params[:CHANNEL_NAME].strip != '')
+    where_clause << " AND UPPER(PPV_EVENT_INFO.EVENT_TITLE) LIKE '%#{params[:PROGRAM_SHORT_TITLE].to_s.upcase}%'" if (!params[:PROGRAM_SHORT_TITLE].nil? && params[:PROGRAM_SHORT_TITLE].strip != '')
+    where_clause << " AND (( PPV_TIME_WINDOW.START_TIME + (PPV_TIME_WINDOW.DURATION/(24*60*60))) > #{_parse_date(params[:START_DATE_TIME], curr_date)})" if (!params[:START_DATE_TIME].nil?)
+    where_clause << " AND WINDOW_TYPE.WINDOW_NAME = '#{params[:WINDOW_NAME].to_s.upcase}'" if (!params[:WINDOW_NAME].nil?)
+    where_clause << " AND PPV_EVENT_INFO.PPV_TYPE=2" # 2 means RPPV events
+
+    loginfo2 "WhereClause : #{where_clause}"
+
+    data_arr = mas_db_guide_data_for_ppv_programs where_clause
+
+    channels = []
+    channels.push(params[:CHANNEL_NUMBER].to_s.to_i) unless params[:CHANNEL_NUMBER].nil?
+    channels = channels + params[:CHANNEL_NUMBERS].to_i_arr unless params[:CHANNEL_NUMBERS].nil?
+
+    airing_and_future_programs = guide_screen_airing_and_future_programs(channels)
+    logdebug "Total PPV programs [Guide] : #{airing_and_future_programs.length}"
+    result_arr = []
+
+    return result_arr if data_arr.nil?
+
+    data_arr.each do |data_hash|
+      time_arr = data_hash['ADVERTISING_WINDOW'].to_s.split('/')
+      advertising_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr = data_hash['BUY_WINDOW'].to_s.split('/')
+      buy_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr = data_hash['CANCEL_WINDOW'].to_s.split('/')
+      cancel_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr = data_hash['FREE_CANCEL_WINDOW'].to_s.split('/')
+      free_cancel_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr = data_hash['LIFETIME_WINDOW'].to_s.split('/')
+      lifetime_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr = data_hash['MARKETING_WINDOW'].to_s.split('/')
+      marketing_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      time_arr = data_hash['PREVIEW_WINDOW'].to_s.split('/')
+      preview_window_start_time = time_arr.empty? ? nil : Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      guide_prog = airing_and_future_programs.select{|prog| prog[2].to_i.eql?(lifetime_window_start_time.to_i) and prog[0].to_i.eql?(data_hash['CHANNEL_NUMBER'].to_s.to_i)}[0]
+
+      # ignore asset/event if no matching guide data found
+      next if guide_prog.nil?
+
+      prog_long_title = guide_prog[5]
+      prog_short_title = guide_prog[4]
+
+      ppv_program = {
+          :event_id => data_hash['PPV_EVENT_INFO_ID'],
+          :channel_number => data_hash['CHANNEL_NUMBER'].to_s.to_i,
+          :channel_name => data_hash['CHANNEL_NAME'].to_s,
+          :short_title => prog_short_title,
+          :long_title => prog_long_title,
+          :prog_cost => data_hash['PPV_EVENT_COST'].to_s.to_f,
+          :prog_type => data_hash['PPV_TYPE'].to_s,
+      }
+
+      ppv_program[:ADVERTISING_WINDOW] = {:start_time => advertising_window_start_time, :duration => data_hash['ADVERTISING_WINDOW_DURATION'].to_s.to_i} if advertising_window_start_time
+      ppv_program[:BUY_WINDOW] = {:start_time => buy_window_start_time, :duration => data_hash['BUY_WINDOW_DURATION'].to_s.to_i} if buy_window_start_time
+      ppv_program[:CANCEL_WINDOW] = {:start_time => cancel_window_start_time, :duration => data_hash['CANCEL_WINDOW_DURATION'].to_s.to_i} if cancel_window_start_time
+      ppv_program[:FREE_CANCEL_WINDOW] = {:start_time => free_cancel_window_start_time, :duration => data_hash['FREE_CANCEL_WINDOW_DURATION'].to_s.to_i} if free_cancel_window_start_time
+      ppv_program[:LIFETIME_WINDOW] = {:start_time => lifetime_window_start_time, :duration => data_hash['LIFETIME_WINDOW_DURATION'].to_s.to_i} if lifetime_window_start_time
+      ppv_program[:MARKETING_WINDOW] = {:start_time => marketing_window_start_time, :duration => data_hash['MARKETING_WINDOW_DURATION'].to_s.to_i} if marketing_window_start_time
+      ppv_program[:PREVIEW_WINDOW] = {:start_time => preview_window_start_time, :duration => data_hash['PREVIEW_WINDOW_DURATION'].to_s.to_i} if preview_window_start_time
+
+      result_arr.push(ppv_program)
+    end
+
+    logdebug "Total PPV programs : #{result_arr.length}"
+    return result_arr
+  end
+
+# Use it to find lookback program on given channel using MAS query
+# * *Args*    :
+#   - +channel_number+ -> integer channel number
+#   - +without_multiple_listing+ -> true to filtered out programs with multiple listing
+#   - +expire_after+ -> program expiry time is after [x] minutes
+# * *Returns* :
+#   - Array of lookback programs
+#   - each program is hash of program details
+#( day, day_sequence, program_name, program_desc, program_sequence,program_duration_mins,program_rating,program_start_time,program_end_time,
+#  program_content_type,program_genre,license_window_start,license_window_end)
+  def find_lookback_programs channel_number, without_multiple_listing=false, expire_after=10
+    channel_name = guide_screen_channel_info(channel_number)[:service_name].strip
+
+    menu_name = _mas_conductor_fetch_enhanced_menu_for_service(channel_name)
+
+    lookback_programs = []
+
+    return lookback_programs if menu_name.nil?
+
+    current_time = mas_current_date
+
+    # RegEx for time string
+    re1='((?:(?:[0-1][0-9])|(?:[2][0-3])|(?:[0-9])):(?:[0-5][0-9])(?::[0-5][0-9])?(?:\\s?(?:am|AM|pm|PM))?)'  # HourMinuteSec 1
+    re=(re1)
+    m=Regexp.new(re,Regexp::IGNORECASE);
+
+    # Advisory flags
+    flags = _valid_advisory_flags
+    # genre codes
+    genre_codes = valid_genre_codes
+
+    # Total asset counter
+    total_programs_count = 0
+    folder_sequence = 0
+    data_arr1 = mas_db_look_back_folders(menu_name)
+
+    if data_arr1.empty?
+      loginfo2 "Lookback data not found for channel : #{channel_number}",false
+      return lookback_programs
+    end
+
+    # check if day folder available or not
+    if(data_arr1[0]['NODE_TYPE'].to_s.to_i == 3)
+      data_arr1 = [data_arr1[0]['PARENT_NODE_ID'].to_s]
+    end
+
+    data_arr1.each {|data_hash1|
+      # default folder sequence update to false
+      update_folder_sequence = false
+
+      folder_id = ""
+      if data_hash1.is_a?String
+        folder_id = data_hash1
+        folder_sequence = -1 # no sub folder
+      else
+        folder_id = data_hash1['MENU_NODE_ID']
+      end
+
+      data_arr2 = mas_db_look_back_programs_in_folder(folder_id)
+
+      # update total programs count
+      total_programs_count += (data_arr2.length)
+
+      lookback_prog_sequence = 0
+      prev_lookback_progs_end_time = []
+      data_arr2.each {|data_hash2|
+        time_arr =  data_hash2['PROGRAM_START'].to_s.split('/')
+        program_start = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+        time_arr =  data_hash2['PROGRAM_END'].to_s.split('/')
+        program_end = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+        time_arr =  data_hash2['LICENSE_WINDOW_START'].to_s.split('/')
+        license_window_start = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+        time_arr =  data_hash2['LICENSE_WINDOW_END'].to_s.split('/')
+        license_window_end = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+        closed_captioned = (data_hash2['MYSTRO_EVENT_CODE'].to_s.empty?)? (false):(data_hash2['MYSTRO_EVENT_CODE'].to_s.to_i.to_s(2)[-4,1].eql?("1")) # 4th index from right is closed caption
+        # add to program list
+        prog_hash = {
+            :day => data_hash1['NODE_NAME'].to_s,
+            :day_sequence => folder_sequence,
+            :channel_number => channel_number.to_s.to_i,
+            :program_name => data_hash2['NODE_NAME'].to_s,
+            :program_desc => data_hash2['NODE_DESC'].to_s,
+            :program_sequence => lookback_prog_sequence,
+            :program_duration_mins => data_hash2['EVENT_DURATION'].to_s.to_i,
+            :program_rating => data_hash2['RATING'].to_s,
+            :program_start_time => program_start,
+            :program_end_time => program_end,
+            :program_content_type => _advisory_flags_from_advisory_code(data_hash2['ADVISORY_CODE'], flags),
+            :program_genre => genre_names_from(data_hash2['GENRE_CODE'].to_s,genre_codes),
+            :license_window_start => license_window_start,
+            :license_window_end => license_window_end,
+            :closed_captioned => closed_captioned,
+        }
+
+        # Push prog details to array if required
+        expiry_time_left = (prog_hash[:program_end_time] - current_time).to_i
+
+        if expiry_time_left > 0
+          # Update first prog
+          prev_lookback_progs_end_time.push(prog_hash[:program_end_time])
+
+          # increment sequence
+          lookback_prog_sequence += 1
+          update_folder_sequence = true
+        end
+
+        if (expiry_time_left > (expire_after * 60) and (prog_hash[:program_start_time] + (prog_hash[:program_duration_mins] * 60)) < current_time)
+          prog_hash[:prev_lookback_progs_end_time] = prev_lookback_progs_end_time.dup
+
+          lookback_programs.push(prog_hash) if !without_multiple_listing or (without_multiple_listing and (m.match(data_hash2['NODE_NAME'].to_s)).nil?)
+        elsif expiry_time_left > 0
+          logdebug "Program will expire in [#{expiry_time_left}] seconds : #{prog_hash}"
+        end
+      }
+
+      # Update folder sequence counter
+      folder_sequence+=1 if update_folder_sequence
+    }
+    logdebug "Total lookback programs - #{lookback_programs.length} : Lookback program(s) --> [#{lookback_programs}]"
+    return lookback_programs
+  end
+
+# Use it to find lookback folders on given channel using MAS query
+# * *Args*    :
+#   - +channel_number+ -> integer channel number
+# * *Returns* :
+#   - Array of lookback day strings (e.g. Today, Sunday, 11/22, etc.)
+  def find_lookback_folders channel_number
+    programs = find_lookback_programs(channel_number)
+    return [] if programs.empty?
+
+    if programs[0][:day_sequence]==-1
+      loginfo2 "Programs are not in sub folders"
+      return []
+    end
+
+    folders = programs.collect{|prog| prog[:day]}.uniq
+    return folders
+  end
+
+# Use it to find quick clips on given channel using MAS query
+# * *Args*    :
+#   - +channel_number+ -> integer channel number
+# * *Returns* :
+#   - Array of quick clips
+#   - each clip is hash of details ( :name, :sequence, :desc, :rating, :duration, :path, :menu_node_id)
+  def find_quickclips channel_number
+    channel_name = guide_screen_channel_info(channel_number)[:service_name].strip
+
+    menu_name = _mas_conductor_fetch_enhanced_menu_for_service(channel_name)
+    return [] if menu_name.nil?
+    quickclip_list = []
+    enhanced_menu_data = (mas_db_quickclips menu_name) # Fetch enhanced menu data
+    if enhanced_menu_data.empty? # Check for empty data
+      loginfo2 "Failed to fetch enhanced menu data for channel :[#{channel_name}]"
+      return []
+    end
+    quick_clip_nodes = enhanced_menu_data.select{|data| data['NODE_TYPE'].to_s.to_i==3} # Select playble assets
+    quick_clip_nodes.each{|clip|
+      # Get all folders with sequence for clip
+      node = clip
+      folders = []
+      while !(node['PARENT_NODE_ID'].to_s.empty?) # Find folders
+        parent = enhanced_menu_data.select{|data| data['MENU_NODE_ID']==node['PARENT_NODE_ID']}[0]
+        folders.push([parent['NODE_SEQUENCE'].to_s.to_i, parent['NODE_NAME']])
+        node = parent
+      end
+
+      data_hash = {
+          :menu_node_id => clip['MENU_NODE_ID'].to_s.to_i,
+          :path => folders.reverse,
+          :name => clip['NODE_NAME'],
+          :sequence => clip['NODE_SEQUENCE'].to_s.to_i,
+          :desc => clip['NODE_DESC'],
+      }
+
+      # Assumption !!! : all folders except lookback are quick clips and folders only (node type 3)
+      quickclip_list.push(data_hash) unless data_hash[:path].empty? or data_hash[:path][0][1].delete(' ').casecmp('lookback')==0 # Push data hash of only quick clips
+    }
+
+    if quickclip_list.empty? # Check for empty data
+      loginfo2 "Failed to fetch quick clip data for channel :[#{channel_name}]"
+      return []
+    end
+
+    # Fetch more details (e.g. rating and duration)
+    id_array = quickclip_list.collect{|clip| clip[:menu_node_id]}
+    more_info = mas_db_quickclip_more_info_for_ids id_array # Query of more info
+
+    if more_info.empty? # Check for empty data
+      loginfo2 "Failed to fetch more info for quick clips on channel :[#{channel_name}]"
+      return []
+    end
+
+    quickclip_list.each{|clip|  # Update existing data with more info
+      info = more_info.select{|x| x['MENU_NODE_ID'].to_s.to_i==clip[:menu_node_id]}[0]
+      clip[:rating] = info['RATING_FLAG_SHORT_DESC']
+      clip[:duration] = info['DURATION_SECONDS']
+    }
+
+    return quickclip_list
+  end
+
+# Use it to find enhanced menu video assets on given channel using MAS query
+# * *Args*    :
+#   - +channel_number+ -> integer channel number
+# * *Returns* :
+#   - Array of video assets
+#   - each asset is hash of details ( :name, :sequence, :desc, :rating, :duration, :path, :menu_node_id)
+  def find_enhanced_menu_video_asset channel_number
+    channel_name = guide_screen_channel_info(channel_number)[:service_name].strip
+
+    menu_name = _mas_conductor_fetch_enhanced_menu_for_service(channel_name)
+    return [] if menu_name.nil?
+
+    enhanced_menu_data = (mas_db_quickclips menu_name)
+    video_asset_nodes = enhanced_menu_data.select{|data| data['NODE_TYPE'].to_s.to_i==3 and (data['PARENT_NODE_ID'].to_s.empty?)} # Select video assets
+
+    quickclip_list = []
+    video_asset_nodes.each{|clip|
+      # Get all folders with sequence for clip
+      node = clip
+      folders = []
+
+      data_hash = {
+          :menu_node_id => clip['MENU_NODE_ID'].to_s.to_i,
+          :path => folders.reverse,
+          :name => clip['NODE_NAME'],
+          :sequence => clip['NODE_SEQUENCE'].to_s.to_i,
+          :desc => clip['NODE_DESC'],
+      }
+
+      quickclip_list.push(data_hash)# Push data hash of video assets
+    }
+
+    if quickclip_list.empty? # Check for empty data
+      loginfo2 "Failed to fetch quick clip data for channel :[#{channel_name}]"
+      return []
+    end
+
+    # Fetch more details (e.g. rating and duration)
+    id_array = quickclip_list.collect{|clip| clip[:menu_node_id]}
+    more_info = mas_db_quickclip_more_info_for_ids id_array # Query of more info
+
+    if more_info.empty? # Check for empty data
+      loginfo2 "Failed to fetch more info for quick clips on channel :[#{channel_name}]"
+      return []
+    end
+
+    filtered_list = []
+
+    quickclip_list.each{|clip|  # Update existing data with more info
+      info = more_info.select{|x| x['MENU_NODE_ID'].to_s.to_i==clip[:menu_node_id]}[0]
+      clip[:rating] = info['RATING_FLAG_SHORT_DESC']
+      clip[:duration] = info['DURATION_SECONDS']
+      clip[:is_valid] = info['IS_VALID']
+      if  clip[:is_valid].to_s == '0'
+        logdebug "Asset [#{clip[:name]}] is invalid"
+      else
+        filtered_list.push(clip)
+      end
+    }
+
+    return filtered_list
+  end
+
+# Use it to get Launch application option in enhanced menu
+#**NOTE!! Returns first level options only
+# * *Args* :
+#   - +channel_number+ -> enhanced menu channel number
+# * *Returns* :
+#   - option names as array
+  def find_enhanced_menu_applications channel_number
+    channel_name = guide_screen_channel_info(channel_number)[:service_name].strip
+
+    menu_name = _mas_conductor_fetch_enhanced_menu_for_service(channel_name)
+    return [] if menu_name.nil?
+
+    enhanced_menu_data = (mas_db_quickclips menu_name)
+
+    launch_application_data = enhanced_menu_data.select{|data| data['PARENT_NODE_ID'].to_s.empty? and data['NODE_TYPE'].to_s.to_i.eql?(4)}
+
+    if launch_application_data.empty?
+      loginfo2 "Launch application option not found"
+      return []
+    end
+    return launch_application_data.collect{|x| x['NODE_NAME'].to_s}
+  end
+
+# Use it to get Tune to service option in enhanced menu
+#**NOTE!! Returns first level options only
+# * *Args* :
+#   - +channel_number+ -> enhanced menu channel number
+# * *Returns* :
+#   - option names as array
+  def find_enhanced_menu_services channel_number
+    channel_name = guide_screen_channel_info(channel_number)[:service_name].strip
+
+    menu_name = _mas_conductor_fetch_enhanced_menu_for_service(channel_name)
+    return [] if menu_name.nil?
+
+    enhanced_menu_data = (mas_db_quickclips menu_name)
+
+    tune_to_service_data = enhanced_menu_data.select{|data| data['PARENT_NODE_ID'].to_s.empty? and data['NODE_TYPE'].to_s.to_i.eql?(2)}
+
+    if tune_to_service_data.empty?
+      loginfo2 "Tune to service option not found"
+      return []
+    end
+    return tune_to_service_data.collect{|x| x['NODE_NAME'].to_s}
+  end
+
+# Use it to empty the HDD to given threshold level
+# * *Args*    :
+#   - +percentage_empty+ -> max threshold level
+# * *Returns* :
+#   - true if successful else false
+  def make_hdd_empty percentage_empty=70
+    stb_ip = fetch_ip
+    return false if stb_ip.nil?
+
+    hdd_status = _percentage_hdd_full(stb_ip)
+
+    return false if hdd_status.nil?
+
+    if hdd_status < percentage_empty
+      loginfo2 "HDD is #{hdd_status} % full"
+      return true
+    end
+
+    # navigate to by date
+    return false unless show_list_launch_and_verify(true,false)
+    return false unless show_list_navigate_to_tab('by date')
+
+    while hdd_status >= percentage_empty
+      return false unless show_list_screen_delete_focused_recorded_program
+
+      hdd_status = _percentage_hdd_full(stb_ip)
+      return false if hdd_status.nil?
+    end
+
+    # HDD full
+    loginfo2 "HDD full #{hdd_status} %"
+    return true
+  end
+
+# Private method
+# Use to record program on given channel and verify HDD full message
+# * *Args*    :
+#   - +channel+ -> channel to recording program on
+# * *Returns* :
+#   - true if it's showing HDD full message else false
+  def _record_program_and_verify_hdd_full_message channel, retries=2
+    message = ""
+    if stb_capable_of?('MDN')
+      message = "Your program cannot be recorded now To make room, delete recordings from Show List"
+    elsif stb_capable_of?('ODN')
+      message = "No Room to Record, Storage Full To make room, delete recordings from Show List"
+    end
+
+    2.times do
+      press_exit_sleep
+      press_exit_sleep
+
+      # tune to channel
+      tune_immediately_to(channel)
+
+      # channel up/down to avoid failures where sometimes STB is not showing HDD full message
+      press_channel_up_sleep
+      press_channel_down_sleep
+
+      # exit to fullscreen
+      press_exit_sleep
+
+      # start recording
+      press_record_sleep
+
+      # sleep for 5 sec to avoid screen update lag
+      sleep 5.sec
+
+      # verify HDD full message
+      return true if ocr_text_similar_for_roi(:recording_attention_banner_storage_full_message,message,3, true, false, 0.50, true)
+    end
+
+    loginfo2 "HDD full message not showing up on screen"
+    return false
+  end
+
+# Private method
+# Use it to start instance recording on given channel and mark it as do not delete in show list
+# * *Args*    :
+#   - +channel_info+ -> channel info to record program
+# * *Returns* :
+#   - airing program object if successful else false
+  def _record_airing_program_with_do_not_delete_flag channel_info
+    sleep_till_current_time_slot_having_min_duration_left(7)
+
+    airing_progs = []
+    2.times do
+      airing_progs = channel_info[:rec_channels].collect do |chnl|
+        guide_screen_airing_program(chnl)
+      end
+
+      # filter out nil programs
+      airing_progs = airing_progs.select{|x| !x.nil?}
+
+      # filter airing programs
+      curr_time = mas_current_date
+      airing_progs = airing_progs.select{|p| (p[3] - curr_time).to_i > 300}
+
+      break unless airing_progs.empty?
+      loginfo2 "Airing program is having less then 5 min left, Sleep for 5 min"
+      sleep 5.min
+    end
+
+    return nil if airing_progs.empty?
+    shortest_prog = airing_progs.min {|a,b| a[3] <=> b[3]}
+
+    retries = ((shortest_prog[3] - mas_current_date).to_i / 60) / 5 # each interval is having 5 min sleep
+    logdebug "HDD full max retreis count : #{retries}"
+
+    rec_in_progress = nil
+    retries.times do
+      start_time = Time.now
+      airing_progs.each do |prog|
+        prog_duration = (prog[3] - mas_current_date).to_i
+        logdebug "Program duration left : [#{prog_duration/60}] minutes"
+        next if(prog_duration <= (5*60)) # break if program ends (within 5 min)
+
+        press_exit_sleep
+        press_exit_sleep
+
+        # tune to channel
+        tune_immediately_to(prog[0])
+
+        # start recording
+        press_record_sleep
+
+        # wait for record to start
+        loginfo2 "Sleeping for recording to start ..."
+        sleep 30.sec
+
+        # exit to fullscreen
+        press_exit_sleep
+        3.times do |j|
+          (return nil if j.eql?(2)) unless info_banner_launch_and_verify(true,true)
+        end
+
+        if info_banner_verify_recording_icon?(2)
+          channel_info[:current_channel] = prog[0].to_s.to_i
+          rec_in_progress = prog
+          break # recording in progress
+        end
+      end # airing programs loop
+      break if rec_in_progress
+      # tune to buffer channels
+      buffer_channels = channel_info[:buffer_channels]
+      tune_immediately_to(buffer_channels[0])
+      sleep 10.sec
+      tune_immediately_to(buffer_channels[1])
+
+      sleep_time = (300 - (Time.now - start_time).to_i)
+      loginfo2 "Sleeping for #{sleep_time} seconds ..."
+      sleep sleep_time.sec
+
+    end # retries loop
+
+    return nil unless rec_in_progress
+
+    # mark new recording as do not delete
+    return nil unless show_list_launch_and_verify(true,false)
+    return nil unless show_list_navigate_to_top_of_list
+    return nil unless show_list_navigate_to_recording_of_program(rec_in_progress)
+    unless show_list_focused_recording_has_do_not_delete_icon?(2)
+      press_select_sleep
+      unless guide_screen_navigate_to_any_of_the_options ['Record Options']
+        loginfo2 'Unable to verify if navigated to record options'
+        return nil
+      end
+      press_select_sleep
+      unless guide_screen_set_record_options({:change_save_time => 'Do not delete'})
+        loginfo2 'Unable to verify if option is set'
+        return nil
+      end
+
+      press_a_sleep
+      sleep_to_get_focus_back
+    end
+
+    # exit to fullscreen
+    press_exit_sleep
+
+    return rec_in_progress
+  end
+
+# Use it to fill the HDD using recordings
+# This method will take 1-2 days to fill HDD to full
+# * *Args*    :
+#   - +percentage_full+ -> % full hdd using recordings
+#   - +min_recording_length+ -> minimum recording lenght in minutes
+#   - +do_not_delete+ -> true to set all recordings as do not delete
+# * *Returns* :
+#   - recorded programs if successful or HDD full else nil
+  def make_hdd_full percentage_full=100, min_recording_length=10, do_not_delete=true
+    # Note : used percentage_full = 101 for 100% hdd full, so that method will record programs till HDD full banner appears
+    percentage_full = 101 if percentage_full > 99 # HDD can not be more than 100% full
+
+    stb_ip = fetch_ip
+    return nil if stb_ip.nil?
+
+    hdd_status = _percentage_hdd_full(stb_ip)
+
+    return nil if hdd_status.nil?
+
+    if hdd_status >= percentage_full
+      loginfo2 "HDD is #{percentage_full} % full"
+      return []
+    end
+
+    # recorded programs
+    recorded_programs = []
+
+    # clear in-progress recordings and scheduled recordings to avoid conflict
+    begin
+      return nil unless show_list_launch_and_verify(true,false)
+      return nil unless show_list_screen_clear_all_series_recordings
+      return nil unless show_list_screen_clear_all_scheduled_recordings
+      return nil unless show_list_cancel_inprogress_recordings
+
+      # mark all recorded programs to do not delete
+      return nil unless show_list_launch_and_verify(true,false)
+      return nil unless show_list_navigate_to_tab 'BY DATE'
+      (return nil unless show_list_screen_set_do_not_delete_for_all_recordings) unless show_list_screen_empty_list?
+
+      # start recording on two HD/SD channels
+      is_hd = stb_capable_of?('HD')
+
+      # live channels to record
+      sd_channels = fetch_option(:miscellaneous_sd_channels).to_i_arr
+      hd_channels = fetch_option(:miscellaneous_hd_channels).to_i_arr
+
+      live_channels = []
+
+      channels = is_hd ? (hd_channels + sd_channels) : sd_channels
+      # filter channles with video
+      channels.each do |chnl|
+        sd_channels = sd_channels - [chnl] # remove current channel from sd channel list
+        tune_immediately_to(chnl)
+        sleep_for_normal_tune
+        press_exit_sleep
+        next unless info_banner_launch_and_verify_channel_number(chnl)
+        if fullscreen_video_playing?
+          live_channels.push(chnl)
+        end
+
+        break if live_channels.length.eql?(2)
+      end
+
+      # filter SD channles with video,
+      # if STB failed to record HD program due to space then it can record SD program
+      sd_channels.each do |chnl|
+        tune_immediately_to(chnl)
+        sleep_for_normal_tune
+        press_exit_sleep
+        if fullscreen_video_playing?
+          live_channels.push(chnl)
+        end
+
+        break if live_channels.length.eql?(6)
+      end
+
+      if live_channels.length < 6
+        loginfo2 "Unable to get six channels having video"
+        return false
+      end
+
+      channel1_info = {
+          :rec_channels => [live_channels[0], live_channels[2], live_channels[3]],
+          :current_channel => live_channels[0],
+          :buffer_channels => [live_channels[0], live_channels[1]],
+      }
+
+      channel2_info = {
+          :rec_channels => [live_channels[1], live_channels[4], live_channels[5]],
+          :current_channel => live_channels[1],
+          :buffer_channels => [live_channels[0], live_channels[1]],
+      }
+
+      prog1 = prog2 = nil
+      start_time = nil
+
+      # max wait in minutes
+      max_wait_minutes = (36 * 60) # 36 hours
+
+      begin
+        # power on STB if required
+        unless power_on_stb?
+          loginfo2 "Unable to powre on STB"
+          return nil
+        end
+
+        current_time = mas_current_date
+        start_time = current_time if start_time.nil? # set start time for first recording
+
+        # break if wait time exceeded max wait time
+        if (current_time - start_time).to_i / 60 >= max_wait_minutes
+          loginfo2 "Not able to fillup HDD withing [#{max_wait_minutes}] minutes"
+          return nil
+        end
+
+        # verify whether recording in progress or not
+        tune_immediately_to(channel1_info[:current_channel])
+        sleep_for_normal_tune
+        press_exit_sleep
+        return nil unless info_banner_launch_and_verify(true,false)
+        rec_in_progress = info_banner_verify_recording_icon?(2)
+
+        if prog1.nil? or prog1[3] < current_time or !rec_in_progress
+          prog1 = _record_airing_program_with_do_not_delete_flag(channel1_info)
+
+          recorded_programs.push(prog1) unless prog1.nil?
+
+          # update current time
+          current_time = mas_current_date
+        end
+
+        # verify whether recording in progress or not
+        tune_immediately_to(channel2_info[:current_channel])
+        sleep_for_normal_tune
+        press_exit_sleep
+        return nil unless info_banner_launch_and_verify(true,false)
+        rec_in_progress = info_banner_verify_recording_icon?(2)
+
+        if prog2.nil? or prog2[3] < current_time or !rec_in_progress
+          prog2 = _record_airing_program_with_do_not_delete_flag(channel2_info)
+
+          recorded_programs.push(prog2) unless prog2.nil?
+
+          # update current time
+          current_time = mas_current_date
+        end
+
+        if prog1.nil? and prog2.nil?
+          return recorded_programs if _record_program_and_verify_hdd_full_message(channel2_info[:current_channel]) # verify HDD full message and its shwoing up then return true
+          loginfo2 "Unlable to record programs on HD/SD channels"
+          return nil
+        else
+          # sleep for 10 min and verify HDD percentage
+          loginfo2 "Sleeping for 5 min ...",false
+          sleep 5.min
+        end
+
+        # update HDD status
+        hdd_status = _percentage_hdd_full(stb_ip)
+        return nil if hdd_status.nil?
+      end while percentage_full  > hdd_status # while loop
+
+      # HDD full
+      loginfo2 "HDD full #{hdd_status} %"
+
+      # Sleep till program ends
+      recorded_programs = recorded_programs.sort_by{|x| x[3]} # sort by program end time
+
+      sleep_till_time(recorded_programs.last[3],1) unless recorded_programs.empty?
+
+      return recorded_programs
+    rescue TestException => e
+      logdebug e.message
+      return nil
+    end
+  end
+
+# Use it to fill / empty HDD till given level
+# This method will take 1-2 days to fill HDD to full
+# * *Args*    :
+#   - +percentage_full+ -> % full hdd using recordings
+# * *Returns* :
+#   - true if successful else false
+  def make_hdd_full_percentage percentage_full=100
+    percentage_full = 101 if percentage_full > 99 # HDD can not be more than 100% full
+
+    stb_ip = fetch_ip
+    return false if stb_ip.nil?
+
+    hdd_status = _percentage_hdd_full(stb_ip)
+
+    return false if hdd_status.nil?
+
+    if hdd_status > percentage_full
+      return make_hdd_empty(percentage_full)
+    elsif hdd_status < percentage_full
+      return !make_hdd_full(percentage_full,10,true).nil? # not nill means successful
+    else
+      loginfo2 "No need to empty or full HDD"
+      return true
+    end
+  end
+
+# Use it to check if the STB's ODN version is same or newer than the specified version.
+# ODN version is of the format 5.0.0_7 2011/10/06 14:29
+  def odn_same_or_newer_than minimum_odn
+    current_version = test_data[:current_odn_version].split()[0].split(/[._]/).map {|s| s.to_i}
+    minimum_version = minimum_odn.split()[0].split(/[._]/).map {|s| s.to_i}
+
+    current_version.each_index do |x|
+      return true if current_version[x] > minimum_version[x] # newer
+      next if current_version[x] == minimum_version[x]
+      return false # STB's ODN is older
+    end
+
+    return true # same
+  end
+
+# Use it to check if the STB's ODN version is same or newer than the specified version.
+# MDN version is of the format 3.2.0_0 2011/10/06 14:29
+  def mdn_same_or_newer_than minimum_mdn
+    current_version = test_data[:current_mdn_version].split()[0].split(/[._]/).map {|s| s.to_i}
+    minimum_version = minimum_mdn.split()[0].split(/[._]/).map {|s| s.to_i}
+
+    current_version.each_index do |x|
+      return true if current_version[x] > minimum_version[x] # newer
+      next if current_version[x] == minimum_version[x]
+      return false # STB's ODN is older
+    end
+
+    return true # same
+  end
+
+# Private method
+# Use it to find purchased od assets using MAS query
+# * *Args*    :
+#   - +params+ -> hash of parameters for filtering search. (:service_name,:channel_number)
+# * *Returns* :
+#   - Array of purchased assets
+#   - each program is hash of program details( od_asset_id,title,purchase_time,offering_window)
+  def _purchased_od_assets(params={})
+    where_clause = 'PURCHASE_STATE = 2 '
+    where_clause << "AND PRODUCT like '#{params[:service_name]}'" if (!params[:service_name].nil?)
+    where_clause << "AND PRODUCT like '#{(mas_db_get_channels("and display_channel = #{params[:channel_number]}"))[0]['DISPLAY_NAME']}'" if (!params[:channel_number].nil?)
+
+    # get mac address of current stb
+    mac = fetch_stb_mac_address.to_s
+    if mac.length == 12
+      mac_address = "#{mac[0,2]}:#{mac[2,2]}:#{mac[4,2]}:#{mac[6,2]}:#{mac[8,2]}:#{mac[10,2]}" # Inserting colons in mac address
+    else
+      mac_address = mac
+    end
+    loginfo2 "Mac address of this box is #{mac_address}"
+    where_clause << "AND TERMINAL_ID like '#{mac_address}'"
+    data_array = mas_db_purchased_assets(where_clause)
+    programs = []
+    data_array.each{ |data_hash|
+      time_arr = data_hash['PURCHASE_TIME'].split('/')
+      purchase_time = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      programs.push({
+                        :od_asset_id => data_hash['OD_ASSET_ID'],
+                        :title => data_hash['OFFER_NAME'],
+                        :purchase_time => purchase_time,
+                        :offering_window => data_hash['OFFERING_WINDOW_HRS'],
+                    })
+    }
+
+    return programs
+  end
+
+# Use it to tune to hidden channel
+# * *Args*    :
+#   - +channel+ -> channel number
+  def tune_to_hidden_channel channel
+    key_seq = [['SEL_LONG', 10000], ['RIGHT_ARROW', 200]]
+    key_seq = key_seq + channel.to_s.chars.to_a
+    key_seq.push('SELECT') unless key_seq.length.eql?(4) # only for less than 4 digits channels
+    _press_key_sequence key_seq
+
+    sleep 3.sec
+    loginfo3 "Tuned to hidden channel : [#{channel}]",true,false,"TUNE_TO_#{channel}"
+  end
+
+#Use it to enable field tools
+# * *Args*    :
+# * *Returns* :
+#   - true if enabled, else false
+  def enable_field_tools
+    if power_on_stb?
+      key_sequence = [['POWER',200],['A',200],['B',200],['C',200],['SETTINGS',200],['POWER',500]]
+      _press_key_sequence key_sequence
+
+      # wait few sec for setting to enable
+      sleep 5.sec
+      return true
+    else
+      loginfo2 'Failed to power on stb'
+      return false
+    end
+  end
+
+#Use it to enable power user
+# * *Args*    :
+# * *Returns* :
+#   - true if enabled, else false
+  def enable_power_user
+    enable_field_tools
+  end
+
+#Use it to find all shows for a program
+# * *Args*    :
+#   - +guide_program+ -> guide program
+#   - +curr_time+ -> current time
+#   - +no_of_days+ -> no. of days for which data is to be fetched
+# * *Returns* :
+#   - array of guide programs
+  def _find_all_shows_for_program guide_program, curr_time = mas_current_date, no_of_days = 5
+    event_id = guide_program[18].to_s
+    programs = find_programs({:EVENT_ID => event_id, :START_DATE_TIME => curr_time, :END_DATE_TIME => (curr_time + no_of_days*24*60*60)})
+    return programs
+  end
+
+# Use it to get percent hdd full
+# * *Args*    :
+#   - +stb_ip+ -> ip address of box
+# * *Returns* :
+#   - integer value of percent hdd full (eg. 85 for 85%)
+  def _percentage_hdd_full stb_ip = fetch_ip
+    percent_full = nil
+    return percent_full if stb_ip.nil? # return nil if failed to fetch ip
+
+    if stb_capable_of?('ODN')
+      disk_info = odn_web_server_disk_info(stb_ip)
+      if disk_info
+        percent_free = disk_info[:fractional_free_space].to_f * 100
+        percent_full = (100-percent_free).round
+      end
+    else
+      percent_full = mdn_remote_diags_get_hdd_status(stb_ip).to_i
+    end
+
+    loginfo2 "HDD status : #{percent_full}% full"
+    return percent_full
+  end
+
+# Use it to fetch stb list
+  def fetch_stb_list
+    $stbs
+  end
+
+# Use it to verify if sdv is eanbled or not from web diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of box
+# * *Returns* :
+#   - integer true if enabled, else false
+  def stb_sdv_enabled? stb_ip = fetch_ip
+    if stb_capable_of?('ODN')
+      return odn_web_server_stb_sdv_capable?(stb_ip)
+    else
+      return mdn_remode_diags_stb_sdv_capable?(stb_ip)
+    end
+  end
+
+# Use it to get sdv source id from web diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of box
+# * *Returns* :
+#   - source id as string
+  def stb_sdv_source_id stb_ip = fetch_ip
+    if stb_capable_of?('ODN')
+      return odn_web_server_source_id(stb_ip)
+    else
+      return mdn_remote_diags_source_id(stb_ip)
+    end
+  end
+
+# Use it to get sdv frequency from web diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of box
+# * *Returns* :
+#   - sdv frequency as string
+  def stb_sdv_frequency stb_ip = fetch_ip
+    if stb_capable_of?('ODN')
+      return odn_web_server_stb_frequency(stb_ip)
+    else
+      return mdn_remote_diags_sdv_frequency(stb_ip)
+    end
+  end
+
+# Use it to get sdv packets sent/recieved from web diags
+# * *Args*    :
+#   - +stb_ip+ -> ip address of box
+# * *Returns* :
+#   - array of sent recieved data [sent,recieved]
+  def stb_sdv_packets_sent_recieved stb_ip = fetch_ip
+    if stb_capable_of?('ODN')
+      return odn_web_server_sdv_packets_sent_recieved(stb_ip)
+    else
+      return mdn_remote_diags_sdv_packets_sent_recieved(stb_ip)
+    end
+  end
+
+# Use it to get channel change message for stb from sdv server
+# * *Args*    :
+#   - +no_of_logs+ -> number of logs to be fetched
+#   - +stb_ip+ -> ip address of box
+# * *Returns* :
+#   - array of logs
+  def stb_sdv_channel_change_messages no_of_logs = 5, stb_ip = fetch_ip
+    sdv_ip = fetch_option(:sdv_ip)              # 172.16.3.33
+    sdv_port = 22
+    sdv_prompt = fetch_option(:sdv_prompt)      # "]#"
+    sdv_username = fetch_option(:sdv_username)  # 'root'
+    sdv_password = fetch_option(:sdv_password)  # 'generic'
+    logdebug "SDV Prompt '#{sdv_prompt}'"
+    date = mas_current_date
+    log_file_name = date.strftime("%d%b%Y_000000.txt")
+
+    begin
+      opened = false
+      open_interactive_ssh(sdv_ip, sdv_port, sdv_prompt, sdv_username, sdv_password)
+      loginfo2 "opened ssh session"
+      opened = true
+      cmd = "tac #{fetch_option(:sdv_server_log_folder)}/#{log_file_name} | grep -m#{no_of_logs} #{stb_ip}"
+      loginfo2 "command: #{cmd}"
+      result = exec_interactive_ssh(sdv_prompt, cmd)
+      result.gsub!(cmd,'')
+      result.gsub!(/\[.*#{sdv_prompt.delete("\/")}/,'')
+      date_time_regexp = /\d{4}\/\d{2}\/\d{2}\D*\d{2}:\d{2}:\d{2}\.\d{3}/
+      result_array = result.split(date_time_regexp)
+      result_array.shift
+      return result_array
+    rescue StandardError => e
+      logdebug e.to_s
+      return []
+    ensure
+      close_interactive_ssh if opened
+    end
+  end
+
+#Private method
+# Use it to get od assets from reservation catalogs
+  def _od_rsrv_assets(params={})
+    where_clause = ''
+    if (!params[:mac].nil?)
+      where_clause << "AND TERMINAL_ID in (#{params[:mac]})"
+    else
+      mac = fetch_stb_mac_address.to_s
+      if mac.length == 12
+        mac_address = "#{mac[0,2]}:#{mac[2,2]}:#{mac[4,2]}:#{mac[6,2]}:#{mac[8,2]}:#{mac[10,2]}" # Inserting colons in mac address
+      else
+        mac_address = mac
+      end
+      where_clause << "AND TERMINAL_ID like '#{mac_address}'"
+    end
+    where_clause << "AND DISPLAY_CHANNEL = #{params[:channel_number]}" if (!params[:channel_number].nil?)
+
+    data = mas_db_od_assets_in_rsrv(where_clause)
+    assets = []
+    data.each{|data_hash|
+      time_arr =  data_hash['EXPIRATION_DATE'].split('/')
+      expiration_date = Time.local(time_arr[0].to_i, time_arr[1].to_i, time_arr[2].to_i, time_arr[3].to_i, time_arr[4].to_i, time_arr[5].to_i)
+
+      asset = {
+          :od_asset_id => data_hash['OD_ASSET_ID'],
+          :title => data_hash['ASSET_TITLE'],
+          :purchase_id => data_hash['OD_PURCHASE_ID'],
+          :mystro_service_id => data_hash['MYSTRO_SERVICE_ID'],
+          :expiration_date => expiration_date,
+      }
+      assets.push(asset)
+    }
+    return assets
+  end
+
+# Use this method to query RTI for ODN STBs.
+# * *Args*    :
+# - +rti_path+  -> The xpath for query (must begin with forward slash)
+# * *Returns* :
+#   - The body of the RTI response
+  def fetch_rti(rti_path)
+    tcinvalid "Box does not have IP for RTI." if test_data[:stb_ip].nil?
+    uri = URI.parse("http://#{test_data[:stb_ip]}/rti#{rti_path}")
+    loginfo "Fetching RTI from #{uri}"
+    response = Net::HTTP.get_response(uri)
+    return response.body.strip
+  end
+
+# Use it to get the message dialog object.
+# * *Returns* :
+#   - nil, if no message dialog is displayed
+#   - otherwise, A map object with keys
+#     :title
+  def message_dialog
+    dialog = {}
+
+    dialog_title = fetch_rti("/UI/MessageDialog/Title")[1..-1]
+    dialog[:title] = dialog_title.to_s
+    loginfo3 "RTI Message Dialog, title:#{dialog_title}", true, false, "RTI"
+
+    return dialog
+  end
+
+# Use it to get the options dialog object.
+# * *Returns* :
+#   - nil, if no options dialog is displayed
+#   - otherwise, A map object with keys
+#     :title
+  def options_dialog
+    dialog = {}
+
+    item_count = fetch_rti("/UI/MenuItemList/ItemCount")[1..-1].to_i
+    dialog[:item_count] = item_count
+    loginfo3 "RTI Options Dialog, items_count:#{item_count}", true, false, "RTI"
+    return dialog
+  end
+
+# Use it to get the enhanced menu dialog object.
+# * *Returns* :
+#   - nil, if no enhanced menu dialog is displayed
+#   - otherwise, A map object with keys
+#     :title
+  def enhanced_menu_dialog
+    dialog = {}
+
+    item_count = fetch_rti("/UI/EnhancedMenu/MenuItemList/ItemCount")[1..-1].to_i
+    dialog[:item_count] = item_count
+    loginfo3 "RTI Enhanced menu Dialog, items_count:#{item_count}", true, false, "RTI"
+
+    return dialog
+  end
+
+# Use it to get the keyboard dialog object.
+# * *Returns* :
+#   - nil, if keyboard search isn't displayed
+#   - otherwise, A map object with keys
+#     :focus_char
+  def keyboard_dialog
+    dialog = {}
+
+    focus_char = fetch_rti("/UI/Keyboard/FocusChar")[1..-1].to_s
+    dialog[:focus_char] = focus_char
+    loginfo3 "RTI Keyboard, focus_char:#{focus_char}", true, false, "RTI"
+
+    return dialog
+  end
+end