framework_gem 0.1.0

data/lib/dsllib/performance/measure_tune.rb

@@ -0,0 +1,438 @@
+require './dsllib/common/utils/tmc_utils'
+require './dsllib/performance/perf_lib'
+
+def measure_tune(from_channel_type, to_channel_type, from_channel, to_channel, tune_type='direct', cache_clear=false)
+  if (from_channel_type == to_channel_type and to_channel_type == 'mod')
+    measure_tune_guide_mod_mod(from_channel_type, to_channel_type, from_channel, to_channel, tune_type='direct')
+    return
+  end
+  screen_area = stb_img_roi(:all_screen_but_info_banner)
+  debug_log = false
+  if from_channel_type == 'analog' or to_channel_type == 'analog'
+    tcunsupported "Box['#{fetch_stb_model}'] not supported." unless stb_capable_of? 'ANALOG'
+  end
+  tcfail "From and to channels cannot be the same" if (from_channel == to_channel)
+  tcfail "Failed to soft power STB" unless power_on_stb?
+  log Elog::ELogLevel::INFO2, "#{tune_type} tune from channel: #{from_channel} to channel: #{to_channel}"
+  #Verify video on from_channel
+  if(cache_clear)
+    start_clear_chan=(@test_case.options[:clear_tuner_cache_start_channel]==nil)? 516 : @test_case.options[:clear_tuner_cache_start_channel]
+    tcfail "Could not clear tuner cache" unless clear_tuner_caches?(start_clear_chan, 6)
+  end
+  tcfail "Could not get video on from_channel: #{from_channel}" if initialize_execution(from_channel) == false 
+  tcfail "Tuned to wrong from channel: #{from_channel}" if(!perf_verify_channel_tune? from_channel)
+
+  press_exit_sleep
+  if(tune_type=='guide')
+    sleep 10.sec
+    press_guide_sleep
+    perf_tune_to_channel(to_channel)
+    sleep 4.sec
+    loginfo3 "Screen before pressing select",true,false,"guide"
+    press_select 0
+  else
+    perf_tune_to_channel(to_channel)
+    loginfo3 "Screen before channel starts changing",true,false,"guide"
+  end
+  startTime = Time.now
+  #tcfail "Video did not pause after #{tune_type} tuning to channel: #{to_channel}" if (wait_till_video_freezes_playing(5000,80,2) == 0)
+  tcfail "Video did not go black after #{tune_type} tuning to channel: #{to_channel}" if (wait_till_roi_is_black(screen_area, 5000,0,2) == 0)
+  
+  stopTime = Time.now
+  tuneTime = time_diff_milli(startTime, stopTime)
+  log Elog::ELogLevel::INFO2, "Video froze after: #{tuneTime.to_s}"
+  #tcfail "Video not playing after #{tune_type} tuning to channel: #{to_channel}" if (wait_till_video_is_playing(15000,0,2) == 0)
+  tcfail "Video not playing after #{tune_type} tuning to channel: #{to_channel}" if (wait_till_roi_is_not_black(screen_area, 15000,0,2) == 0)
+  stopTime = Time.now
+  tuneTime = time_diff_milli(startTime, stopTime)
+  tcfail "Test took too long" if (tuneTime > 15000)
+  log Elog::ELogLevel::INFO2, "Long tune time" if (tuneTime > 5000)
+  press_exit_sleep
+  tcfail "Could not verify to channel: #{to_channel}: for #{tune_type} tune" unless perf_verify_channel_tune? to_channel
+  post_result(startTime.to_f, stopTime.to_f)                   
+  log Elog::ELogLevel::DURATION,from_channel_type + " to " + to_channel_type + " " + tune_type + " tune|" + tuneTime.to_s
+end
+
+def measure_tune_guide_mod_mod(from_channel_type, to_channel_type, from_channel, to_channel, tune_type='direct')
+  debug_log = false
+  tcfail "From and to channels cannot be the same" if (from_channel == to_channel)
+  #screenROI_before = DSL::ImageRoi.new(56,13,192,129,75, "")
+  #screenROI_after = DSL::ImageRoi.new(56,13,192,129,75, "")
+  screenROI_before = stb_img_roi(:guide_info)
+  screenROI_after = stb_img_roi(:guide_info)
+  
+  log Elog::ELogLevel::INFO2, "#{tune_type} tune from channel: #{from_channel} to channel: #{to_channel}"
+  #Verify video on from_channel
+  tcfail "Could not get video on from_channel: #{from_channel}" if initialize_execution(from_channel) == false 
+  press_exit_sleep
+  tcfail "Tuned to wrong from channel: #{from_channel}" if(!perf_verify_channel_tune? from_channel)
+  if(tune_type=='guide')
+    press_guide_sleep
+    sleep 4.sec
+    perf_tune_to_channel(to_channel)
+    sleep 4.sec
+    filename = (capture_screen_to("tmp_stb_#{$stb_id}.jpg"))
+    screenROI_before.referenceImage = filename
+    loginfo3 "Screen before pressing select",true,false,"image"
+    press_select 0
+  else
+    sleep 2.sec
+    filename = (capture_screen_to("tmp_stb_#{$stb_id}.jpg"))
+    screenROI_before.referenceImage = filename
+    loginfo3 "Screen before pressing tuning to channel",true,false,"image"
+    perf_tune_to_channel(to_channel)
+  end
+  times = time_for_screen_change(screenROI_before, screenROI_after, 15, false)
+  dataValue = time_diff_milli(times[0], times[1])
+  tcfail "Failed to go to channel #{to_channel}" if(dataValue == 0)
+  dataValue = dataValue.to_s
+  post_result(times[0].to_f, times[1].to_f) if @test_case.send(:is_sword?)
+  log(Elog::ELogLevel::DURATION,from_channel_type + " to " + to_channel_type + " " + tune_type + " tune|" + dataValue)
+  press_exit_sleep
+end
+
+def measure_burst_tune(channels, burst_type)
+  debug_log = false
+  start_chan = channels[0]
+  final_chan = channels[1]
+  
+  if(channels.length > 2)
+    channel_tunes = channels[2]
+  else
+    channel_tunes = "5"
+  end
+  start_chan_num = (Integer(start_chan) rescue nil)
+  final_chan_num = (Integer(final_chan) rescue nil)
+  channel_tunes = (Integer(channel_tunes) rescue nil)
+  chan_up = true
+  if start_chan_num != nil and final_chan_num != nil
+    chan_up = false if final_chan_num < start_chan_num
+  end
+  channel_tunes = 5 if channel_tunes == nil
+
+  guide_chan_ROI = lookup_ocr_roi(:guide_channel)
+  if guide_chan_ROI.class == Array
+    guide_chan_ROI.collect{|roi| roi.expectedText = final_chan.to_s}
+  else
+    guide_chan_ROI.expectedText = final_chan.to_s
+  end
+
+  #guide_chan_ROI = DSL::OcrRoi.new(98, 21, 117, 67, 6, "", final_chan.to_s)
+  log Elog::ELogLevel::INFO, "Initializing on channel:" + start_chan if(debug_log == true)
+  tcfail "Could not get initial video displayed on channel #{start_chan}" if(initialize_execution(start_chan) == false)
+
+  log Elog::ELogLevel::DEBUG, "Initial channel displayed" if(debug_log == true)
+  
+  #start timer
+  startTime = Time.now
+  for k in 1..channel_tunes
+    if chan_up
+      press_channel_up(0.ms())
+      dir = 'up'
+    else
+      press_channel_down(0.ms())
+      dir = 'down'
+    end
+    if(k==1)
+      log Elog::ELogLevel::DEBUG, "Warning: Video did not pause" if (wait_till_video_freezes_playing(2000, 50, 2) == 0)
+      #tcfail "Video did not pause" if (wait_till_video_freezes_playing(1500, 100, 3) == 0)
+    end
+    sleep 500.ms
+  end
+  tcfail "Video not playing" if (wait_till_video_is_playing(15000, 100, 2, area='all_but_info_banner') == 0)
+
+  stopTime = Time.now
+
+  _logmessage Elog::ELogLevel::INFO, "Video playing", true, false
+  for i in 1..3
+    press_guide_sleep
+    break if text_on_screen_similar guide_chan_ROI, final_chan.to_s
+    tcfail "Could not verify final channel number" if i > 2
+    press_exit_sleep
+  end
+  dataValue = time_diff_milli(startTime, stopTime).to_s
+  log Elog::ELogLevel::DURATION,"Burst tune " + burst_type + "|" + dataValue
+  post_result(startTime.to_f, stopTime.to_f)
+end
+
+def measure_guide_tune(from_channel, to_channel)
+  #colorROI = DSL::ImageRoi.new(199,313,4,4,80, "")
+  #color = [0, 115, 154]
+  #textROI = DSL::OcrRoi.new(121,52,47,28, 6, "", "")
+
+  loginfo2 "Guide tune from channel #{from_channel} to #{to_channel}"
+  screenROI_before = stb_img_roi(:guide_network_logo)
+  screenROI_after = stb_img_roi(:guide_network_logo)
+  #screenROI_before = DSL::ImageRoi.new(0,25,73,39,70, "")
+  #screenROI_after = DSL::ImageRoi.new(0,25,73,39,70, "")
+  timeout=15
+  press_guide_sleep unless guide_banner_appears?
+  sleep 5.sec
+  unless guide_banner_appears?
+    #loginfo3 "Failed to go to guide",true,false,"image"
+    tcfail "Failed to go to guide"
+  end
+  perf_tune_to_channel(from_channel)
+  sleep 3.sec
+  filename = (capture_screen_to("tmp_stb_#{$stb_id}.jpg"))
+  screenROI_before.referenceImage = filename
+  sleep 5.sec
+  loginfo3 "Initial screen",true,false,"image"
+  perf_tune_to_channel(to_channel,0)
+  #times = time_to_display_text(textROI, to_channel, 15)
+  times = time_for_screen_change(screenROI_before, screenROI_after, 15, false)
+  #times = time_to_display_color(colorROI, color, timeout)
+  #log(Elog::ELogLevel::DEBUG, "times[0]=" + times[0].to_s + " times[1]=" + times[1].to_s) if(debug_log == true)
+  dataValue = time_diff_milli(times[0], times[1])
+  tcfail "Failed to go to channel #{to_channel}" if(dataValue == 0)
+  dataValue_s = dataValue.to_s
+  #tcfail "Failed to get a valid sample #{dataValue_s} ms" if(dataValue < 100)
+  post_result(times[0].to_f, times[1].to_f) if @test_case.send(:is_sword?)
+  log(Elog::ELogLevel::DURATION,"Time to channel #{to_channel}|" + dataValue_s)
+end
+
+def measure_guide_navigate(direction, from_channel=nil)
+  debug_log = false
+  if direction == 'down' or direction == 'up'  or direction == 'page_up' or direction == 'page_down'
+    screenROI = :guide_focused_program_channel
+  else
+    screenROI = :guide_current_time_slot
+  end
+  timeout=15
+  unless guide_banner_appears?
+    press_guide_sleep
+    sleep 3.sec 
+    tcfail "Failed to go to guide" unless guide_banner_appears?
+  end
+  unless from_channel == nil
+    perf_tune_to_channel(from_channel) 
+    sleep 5.sec
+  end
+  loginfo3 "Initial screen",true,false,"image"
+  key='up_arrow'
+  if direction == 'down'
+    key='down_arrow'
+  elsif direction == 'up'
+    key='up_arrow'
+  elsif direction == 'left'
+    key='left_arrow'
+  elsif direction == 'right'
+    key='right_arrow'
+    elsif direction == 'page_up'
+    key='page_up'
+    elsif direction == 'page_down'
+    key='page_down'
+  end
+  if(direction == 'left' or direction == 'right' )
+    api_hp_time_for_screen_change screenROI, key=key, timeout=5000, log_text="Time for screen to change", screen_capture_every_ms=100, verifies=1, between_verifies_ms=0, report_to_sword=true, roi_type="GOLDENROI:Spectrum101_H_DEFAULT"
+  else
+    api_hp_time_to_number_update screenROI, original_value=nil, key=key, timeout_ms=2000, log_text="Time to arrow up", screen_capture_every_ms=10, verifies=1, between_verifies_ms=0, report_to_sword=true, roi_type="OCRROI:default"
+  end
+end
+
+def measure_guide_navigate_old(direction, from_channel=nil)
+  debug_log = false
+  if direction == 'down' or direction == 'up'  or direction == 'page_up' or direction == 'page_down'
+    screenROI_before = stb_img_roi(:guide_network_logo)
+    screenROI_after = stb_img_roi(:guide_network_logo)
+  else
+    screenROI_before = stb_img_roi(:guide_current_time_slot)
+    screenROI_after = stb_img_roi(:guide_current_time_slot)
+  end
+  timeout=15
+  unless guide_banner_appears?
+    press_guide_sleep
+    sleep 3.sec 
+    tcfail "Failed to go to guide" unless guide_banner_appears?
+  end
+  unless from_channel == nil
+    perf_tune_to_channel(from_channel) 
+    sleep 5.sec
+  end
+  filename = (capture_screen_to("tmp_stb_#{$stb_id}.jpg"))
+  screenROI_before.referenceImage = filename
+  loginfo3 "Initial screen",true,false,"image"
+  if direction == 'down'
+    press_down_arrow 0
+  elsif direction == 'up'
+      press_up_arrow 0
+  elsif direction == 'left'
+      press_left_arrow 0
+  elsif direction == 'right'
+      press_right_arrow 0
+    elsif direction == 'page_up'
+        press_page_up 0
+    elsif direction == 'page_down'
+        press_page_down 0
+  end
+  startTime=Time.now()
+  loginfo2 "Before time_for_screen_change function"
+  times = time_for_screen_change(screenROI_before, screenROI_after, 15, false)
+  stopTime = times[1]
+  
+  loginfo2 "startTime=#{startTime.strftime('%H:%M:%S.%N')}, stopTime=#{stopTime.strftime('%H:%M:%S.%N')}"
+  #log(Elog::ELogLevel::DEBUG, "times[0]=" + startTime.to_s + " times[1]=" + times[1].to_s) if(debug_log == true)
+  dataValue = time_diff_milli(startTime, times[1])
+  tcfail "Failed to navigate #{direction}" if(dataValue == 0)
+  dataValue = dataValue.to_s
+  post_result(startTime.to_f, times[1].to_f) if @test_case.send(:is_sword?)
+  log(Elog::ELogLevel::DURATION,"Time to navigate #{direction}|" + dataValue)
+end
+
+def measure_vod_portal_tune(vod_portal_channel)
+  if (stb_high_def?)
+    timeout=15
+    press_c_sleep
+    press_c_sleep
+    press_c_sleep
+    press_exit_sleep
+    tune_immediately_to @test_case.options[:channels][0]
+    sleep 5.sec
+    perf_tune_to_channel vod_portal_channel
+    api_time_to_display_image_area :vod_portal_home_logo, timeout_ms=10000, log_text="Time to display vod portal", screen_capture_every_ms=100, verifies=1, between_verifies_ms=0, report_to_sword=true, roi_type="DUALROI:MOTO"
+  else
+    debug_log = false
+    icon_roi = stb_img_roi(:vod_portal_home_logo)
+    timeout=15
+    press_c_sleep
+    press_c_sleep
+    press_c_sleep
+    press_exit_sleep
+    tune_immediately_to @test_case.options[:channels][0]
+    sleep 5.sec
+    perf_tune_to_channel vod_portal_channel
+    times = time_to_display_image(icon_roi, 15)
+    log(Elog::ELogLevel::DEBUG, "times[0]=" + times[0].to_s + " times[1]=" + times[1].to_s) if(debug_log == true)
+    dataValue = time_diff_milli(times[0], times[1])
+    tcfail "Failed to go vod portal #{vod_portal_channel}" if(dataValue == 0)
+    dataValue = dataValue.to_s
+    post_result(times[0].to_f, times[1].to_f) if @test_case.send(:is_sword?)
+    log(Elog::ELogLevel::DURATION,"Time to vod portal channel: #{vod_portal_channel}|" + dataValue)
+  end
+end
+
+
+def play_dvr_asset report_duration=false
+  if $rti_flag
+    tcunsupported "Box['#{fetch_stb_model}'] not supported." unless (stb_capable_of? 'DVR' or odn_web_server_odn_diags_mrdvr_authorized?)
+  else
+    tcunsupported "Box['#{fetch_stb_model}'] not supported." unless stb_capable_of? 'DVR'
+  end
+  tcfail "Failed to soft power STB" unless power_on_stb?
+  screen_area = stb_img_roi(:partial_screen_bottom)
+  videoROI = DSL::ImageRoi.new(70,188,526,60, 0, "")
+  tune_immediately_to @test_case.options[:channels][0]
+  #show_list_launch_and_verify
+  press_list_sleep
+  
+  if !show_list_l_tab_highlighted?
+    loginfo3 "Old DVR UI detected"
+    unless !show_list_screen_empty_list?
+      press_exit_sleep
+      #tune_immediately_to @test_case.options[:channels][0]
+      press_record_sleep
+      sleep 20.sec
+      #show_list_launch_and_verify
+      press_list_sleep
+      tcfail "List is empty" unless !show_list_screen_empty_list?
+    end
+    press_select_sleep
+    sleep 2.sec
+	sleep 2.sec
+    press_select 0
+  else
+    loginfo3 "New DVR UI detected"
+    press_select_sleep
+    unless show_list_l_menu_highlighted? 1
+      press_exit_sleep
+      #tune_immediately_to @test_case.options[:channels][0]
+      press_record_sleep
+      sleep 20.sec
+      #show_list_launch_and_verify
+      press_list_sleep
+      tcfail "List is empty" unless show_list_l_menu_highlighted? 1
+    end
+    press_select_sleep if show_list_l_menu_highlighted?
+    loginfo3 "Screen before pressing first select",true,false,"video"
+    sleep 3.sec
+#    loginfo3 "Check for show_list_series_episode_menu_item_highlighted",true,false,"video"
+#    if show_list_series_episode_menu_item_highlighted?
+#      loginfo3 "Select for show_list_series_episode_menu_item_highlighted"
+#      press_select_sleep
+#      sleep 3.sec
+#    end
+    loginfo3 "Check for show_list_episode_menu_item_highlighted",true,false,"video"
+    if show_list_episode_menu_item_highlighted?
+      loginfo3 "Select for show_list_episode_menu_item_highlighted"
+      press_select_sleep 
+      sleep 3.sec
+    end
+    press_select_sleep 
+    sleep 3.sec
+    startTime = Time.now
+    loginfo3 "Screen before pressing select, startTime=#{startTime.strftime('%H:%M:%S.%N')}",true,false,"video"
+    press_select 0
+	press_select 0
+	press_select 0
+  end
+  startTime = Time.now
+  #wait_till_black_screen(500, 0)
+#  if (wait_till_roi_is_black(videoROI, 5000,50,1,45) == 0)
+#    press_stop_sleep
+#    tcfail "Screen did not transition to black within 5 seconds" 
+#  end
+
+  #tcfail "No video" if(wait_till_video_is_playing(15000, 100, 2, 'bottom',:dvr_vod_starting) == 0)
+  #if (wait_till_roi_is_not_black(videoROI, 15000,50,1, 45) == 0)
+  if(wait_till_video_is_playing(15000, 50, 2, 'side') == 0)
+    press_stop_sleep
+    tcfail "No video" 
+  end
+
+  endTime = Time.now
+  press_stop_sleep
+  loginfo3 "StopTime=#{endTime.strftime('%H:%M:%S.%N')}"
+#  if (wait_till_roi_is_black(videoROI, 1000,50,1,45) != 0)
+#    tcfail "No video" if (wait_till_roi_is_not_black(videoROI, 5000,50,1, 45) == 0)
+#    endTime = Time.now
+#    loginfo3 "New StopTime=#{endTime.strftime('%H:%M:%S.%N')}"
+#  end
+#  tcfail "No video" if(wait_till_video_is_playing(4000, 100, 2, 'all_screen_but_info_banner') == 0)
+  #press_select_sleep
+  if report_duration==true
+    dataValue = time_diff_milli(startTime, endTime).to_s
+    post_result(startTime.to_f, endTime.to_f)
+    log Elog::ELogLevel::DURATION,"DVR start time|" + dataValue
+  end
+end
+
+def eos_pop_time it=1,resume_play=true
+  if $rti_flag
+    tcunsupported "Box['#{fetch_stb_model}'] not supported." unless (stb_capable_of? 'DVR' or odn_web_server_odn_diags_mrdvr_authorized?)
+  else
+    tcunsupported "Box['#{fetch_stb_model}'] not supported." unless stb_capable_of? 'DVR'
+  end
+ 
+  colorROI = stb_img_roi(:end_of_dvr_session_highlight)
+  color = [0,101,156]
+  play_dvr_asset false
+  
+  dvr_eos_menu_roi = lookup_ocr_roi(:dvr_stop_and_save)
+  if text_on_screen_similar dvr_eos_menu_roi, "Stop and Save"
+    press_down_arrow_sleep
+    press_down_arrow_sleep
+    press_select 3.sec
+  else
+    sim = color_similarity_to_screen colorROI, color[0], color[1], color[2]
+    tcfail "Did not display start menu" if sim < 0.8
+    press_select 3.sec
+  end
+
+  press_stop 0
+  times = time_to_display_color(colorROI, color, 10)
+  dataValue = time_diff_milli(times[0], times[1])
+  tcfail "Failed to display dvr end of session screen" if(dataValue == 0)
+  dataValue = dataValue.to_s
+  post_result(times[0].to_f, times[1].to_f) if @test_case.send(:is_sword?)
+  log(Elog::ELogLevel::DURATION,"Time to dvr end of session #{it}|" + dataValue)
+end

data/lib/dsllib/performance/perf_lib.rb

@@ -0,0 +1,660 @@
+require './dsllib/common/utils/tmc_utils'
+require './dsllib/performance/measure_tune'
+require 'json'
+require 'date'
+require 'base64'
+require './lib/helpers/tmc_helpers/tmc_helpers'
+
+module PerfLib
+#### Reset the STB for performace test execution ####
+  def _perf_reset_stb()
+    # Reset packages and credit limit for STB
+    _reset_stb_failed "Failed to reset packages" unless _reset_packages_for_stb
+
+    loginfo2 "Resetting NVRAM...",false
+
+    reset_nvram_from_mas
+    sleep 5.min
+
+    # 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
+
+    # 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)
+    press_exit_sleep
+  end
+
+#
+# Split array from a CSV in options[plural_symbol] into an array and put
+# it back in options[plural_symbol]. Then put options[plural_symbol][stbid]
+# into options[singular_symbol] If options[singular_symbol] is already
+# populated, this function will not change anything
+#
+# IE: split_array_to(stbid, :models, :model)#
+
+  def split_array_to(stbid, plural_symbol, singular_symbol, mandatory = true)
+    if (options[singular_symbol] == nil)
+
+      if (options[plural_symbol] == nil)
+        if (mandatory)
+          raise new Exception("No :" + plural_symbol.to_s + " or :" + singular_symbol.to_s + " in script options. At least one is required")
+        else
+          loginfo(":" + plural_symbol.to_s + " or :" + singular_symbol.to_s + " not found but is not mandatory for this test.")
+          return
+        end
+      end
+      # If we're here, we have an options[plural_symbol]
+      if (options[plural_symbol].class == String)
+        options[plural_symbol] = options[plural_symbol].split(",")
+      end
+      if (options[plural_symbol].length < stbid)
+        err = "Not enough " + plural_symbol.to_s + " to assign one to stb ID " + stbid.to_s
+        if (mandatory)
+          raise new Exception(err)
+        else
+          loginfo(err + " but they were not mandatory for this test.");
+          return
+        end
+      end
+      options[singular_symbol] = options[plural_symbol].at(stbid - 1)
+    end
+  end
+
+  def get_channels(channel_type)
+    channel_type = fetch_option(:head_end).downcase.strip + "_" + channel_type.downcase.strip + "_channels"
+    return fetch_option(channel_type.to_sym).strip.to_arr
+  end
+
+  def perf_initialize_execution()
+    press_exit(5.sec())
+
+    perf_tune_to_channel($initial_tune_channel, 5)
+
+    return true if (perf_verify_video_playing?)
+
+    #loginfo "WARN: Video not playing for INTIAL channel "+$initial_tune_channel+"; Unable to INITIALIZE"
+    loginfo "WARN: Video not playing for INITIAL channel #{$initial_tune_channel}; Unable to INITIALIZE"
+
+    return false
+  end
+
+  def perf_verify_video_playing?  time_out_in_milli_sec=1500, retries=10, sleepTimeInSec=1, area='all_but_info_banner'
+    result = false
+    case
+      when (test_case.dut.box_code == 'hnav')
+        videoROI = stb_img_roi(:fullscreen_roi)
+      when area == 'bottom'
+        videoROI = stb_img_roi(:partial_screen_bottom)
+      #videoROI = DSL::ImageRoi.new(8, 217, 630, 128, 0, "")
+      when area == 'top'
+        videoROI = stb_img_roi(:partial_screen_top3)
+      #videoROI = DSL::ImageRoi.new(1, 1, 630, 249, 0, "")
+      when area == 'side'
+        videoROI = stb_img_roi(:partial_screen_side)
+      #videoROI = DSL::ImageRoi.new(7, 10, 296, 333, 0, "")
+      when area == 'top2'
+        videoROI = stb_img_roi(:partial_screen_top2)
+      #videoROI = DSL::ImageRoi.new(10, 60, 610, 197, 0, "")
+      when area == 'all_but_info_banner'
+        videoROI = stb_img_roi(:all_screen_but_info_banner)
+      #videoROI = DSL::ImageRoi.new(1,1,630,345, 0, "")
+    end
+    retries.times do
+      return true if (video_playing? videoROI, time_out_in_milli_sec)
+      #return true if (video_playing? stb_img_roi(:fullscreen_ignore_info_roi), time_out_in_milli_sec)
+      sleep sleepTimeInSec.to_s.to_i.sec unless sleepTimeInSec==0
+    end
+
+    return false
+  end
+
+  def perf_verify_channel_tune?  channel_number
+    if $rti_flag == false
+      loginfo3 "Before guide_banner_verify_channel_number"
+      return(guide_banner_verify_channel_number? channel_number)
+    else
+      loginfo3 "Before info_banner_launch_and_verify_channel_number"
+      return(info_banner_launch_and_verify_channel_number channel_number)
+    end
+  end
+
+  def perf_time_to_go_to_menu(menu_name)
+    #get values
+    theseROIvalues = eval("fetch_option(:#{menu_name}_roi).to_i_arr(',')")
+    thisTarget = eval("fetch_option(:#{menu_name}_target)")
+    thisKey = eval("fetch_option(:#{menu_name}_keypress)")
+
+    thisROI = OcrRoi.new(theseROIvalues[0], theseROIvalues[1], theseROIvalues[2], theseROIvalues[3], 0, "", thisTarget)
+    times = time_to_go_to_menu(thisROI)
+    if(times[1] > 0)
+      return(times[1] - times[0])
+    else
+      return(0)
+    end
+  end
+
+  def time_to_go_to_menu(menu,thisROI, text)
+    #default keypress time
+    key_wait_time = 200.ms()
+    timeout = 15000 #seconds
+    next_error_report_time = 300
+
+    times = Array.new(2)
+    startTime = Time.now()
+    times[0] = startTime;
+    if(menu == "guide")
+      loginfo3 "Screen before pressing 'Guide' button",true,false,"video"
+      press_guide 0
+    elsif(menu == "show_list")
+      loginfo3 "Screen before pressing 'List' button",true,false,"video"
+      press_list 0
+    elsif(menu == "search")
+      loginfo3 "Screen before pressing 'B' button",true,false,"video"
+      press_b 0
+    end
+    #eval("#{thisKey}(key_wait_time)")
+    begin
+      target_found1 = false
+      target_found2 = false
+      target_found1 = screen_matches_for_icon_roi thisROI, thisROI.referenceImage, 1
+      if(target_found1 == true)
+        times[1] = Time.now()
+        sleep 40.ms
+        target_found2 = screen_matches_for_icon_roi thisROI, thisROI.referenceImage, 1
+      end
+      nowTime = Time.now()
+      if (time_diff_milli(startTime, nowTime) > next_error_report_time) and !target_found2 #capture screenshot after each second
+        next_error_report_time+=300
+        loginfo3 "Image still not found, Region=#{thisROI.left}:#{thisROI.top}:#{thisROI.width}:#{thisROI.height}, Threshold=#{thisROI.threshold},",true,true,"menu"
+      end
+    end while time_diff_milli(startTime, nowTime) < timeout and !target_found2
+    if target_found2
+      loginfo3 "Image found, Region=#{thisROI.left}:#{thisROI.top}:#{thisROI.width}:#{thisROI.height}, Threshold=#{thisROI.threshold},",true,true,"menu"
+    else
+      loginfo3 "Image not found, Region=#{thisROI.left}:#{thisROI.top}:#{thisROI.width}:#{thisROI.height}, Threshold=#{thisROI.threshold},",true,true,"menu"
+      times[1] = startTime;
+    end
+    return times
+  end
+
+  def time_to_go_to_guide()
+    #guideROI = DSL::ImageRoi.new(282, 407, 50, 38, 85, "tsimages/icons/odn52/hd/a_icon.JPG")
+    guideROI = stb_img_roi(:guide_screen_b_icon)
+
+    #guideROI = DSL::OcrRoi.new(330, 408, 125, 34, 6, "", "Find Channels")
+    return(time_to_go_to_menu("guide", guideROI, "Find Channels"))
+  end
+
+  def time_to_go_to_show_list()
+    #show_listROI = DSL::OcrRoi.new(45, 22, 79, 40, 6, "", "DVR")
+    #tcunsupported "Box['#{fetch_stb_model}'] not supported." unless stb_capable_of? 'DVR'
+    tcunsupported "Box['#{fetch_stb_model}'] not supported." unless stb_capable_of? 'DVR' or odn_web_server_odn_diags_mrdvr_authorized?
+    show_listROI = lookup_ocr_roi(:show_list_dvr)
+
+    press_list 0
+    #return(time_to_go_to_menu("show_list", show_listROI, "DVR"))
+    return(time_to_display_text(show_listROI, "DVR"))
+
+
+  end
+
+  def perf_tune_to_channel(channel, sleep_time_after_tune=0)
+    loginfo3 "Changed per_key_wait_time to 400 ms"
+    total_wait_time = 0
+    per_key_wait_time = 400
+    key_seq = []
+    channel_arr = channel.to_s.chars.to_a
+    channel_length = channel_arr.length
+    for i in 0..(channel_length-1)
+      #press_key channel_arr[i]
+      instance_eval "press_#{channel_arr[i]}  0"
+      success_log_key_press "#{channel_arr[i]}", per_key_wait_time
+      sleep per_key_wait_time #unless i == channel_length-1
+    end
+    press_select 0 unless channel_length == 4
+    sleep sleep_time_after_tune.to_s.to_i.sec if (sleep_time_after_tune!=0)
+  end
+
+  def perf_tune_to_channel_seq(channel, sleep_time_after_tune=0,add_zeros=true)
+    total_wait_time = 0
+    per_key_wait_time = 200
+    key_seq = []
+    channel_arr = channel.to_s.chars.to_a
+
+    if(add_zeros==true)
+      for i in 1..(4-channel_arr.length)
+        key_seq.push(["0", per_key_wait_time])
+        total_wait_time = total_wait_time + per_key_wait_time
+      end
+    end
+    for i in 0..(channel_arr.length-1)
+      per_key_wait_time = 0 if (i == (channel_arr.length-1))
+      key_seq.push([channel_arr[i], per_key_wait_time])
+      total_wait_time = total_wait_time + per_key_wait_time
+    end
+
+    _press_key_sequence key_seq
+    sleep total_wait_time
+
+    sleep sleep_time_after_tune.to_s.to_i.sec if !(sleep_time_after_tune==0)
+  end
+  def perf_tune_to_random_channel(channels, sleep_time_after_tune=0)
+    chan = get_random_channel(options[:channels])
+    if (chan == nil)
+      loginfo "WARN: No channel to random tune to"
+      return
+    end
+    perf_tune_to_channel(chan, sleep_time_after_tune)
+  end
+
+  def initialize_execution(chan)
+    #videoROI = DSL::ImageRoi.new(1, 1, 630, 270, 0, "")
+    videoROI = stb_img_roi(:video_playing_fullscreen_roi)
+    for retryCount in 1..3
+      press_exit_sleep
+      sleep 4.sec
+      perf_tune_to_channel(chan, 5)
+      sleep 4.sec
+      return(true) if (video_playing? videoROI, 2000)
+      #return(true) if ( wait_till_video_is_playing(time_out_in_ms=5000, between_samples_ms=1000, samples=1, area='all_but_info_banner'))
+      loginfo3 "No video",true,true,"video"
+      press_power(8.sec())
+    end
+    return false
+  end
+
+  def get_random_channel(channels)
+    return nil if (channels == nil)
+    return(channels[rand(channels.length)])
+  end
+
+  def get_largest_block()
+    begin
+      loginfo(options[:stb_ip])
+      r =  get_snmp(options[:stb_ip], ".1.3.6.1.4.1.4491.2.3.1.1.4.7.1.0", 'public')
+      loginfo("largest_block=" + r)
+      return r.to_i
+    rescue StandardError => e
+      return(0)
+    end
+  end
+
+  def get_heap_size()
+    begin
+      loginfo(options[:stb_ip])
+      r =  get_snmp(options[:stb_ip], ".1.3.6.1.4.1.4491.2.3.1.1.4.8.1.0", 'public')
+      loginfo("heap_size=" + r)
+      return r.to_i
+    rescue StandardError => e
+      return(0)
+    end
+  end
+
+  def get_available_heap()
+    begin
+      loginfo(options[:stb_ip])
+      r =  get_snmp(options[:stb_ip], ".1.3.6.1.4.1.4491.2.3.1.1.4.8.2.0", 'public')
+      loginfo("available_heap=" + r)
+      return r.to_i
+    rescue StandardError => e
+      return(0)
+    end
+  end
+
+=begin
+MSD 2016-01-12 this is not used and should be deleted on next pass
+def record_stats_to_sword(startTime,endTime)
+  startTime = Time.now if startTime == 0
+  endTime = Time.now if endTime == 0
+  largest_block = get_largest_block().to_s
+  heap_size = get_heap_size().to_s
+  available_heap = get_available_heap().to_s
+  if(options[:db_write] == "true")
+    writeNumericalResult(startTime.to_i, endTime.to_i, largest_block)
+    writeNumericalResult(startTime.to_i, endTime.to_i, heap_size)
+    writeNumericalResult(startTime.to_i, endTime.to_i, available_heap)
+  end
+  log(Elog::ELogLevel::DURATION,"Largest block|" + largest_block)
+  log(Elog::ELogLevel::DURATION,"Heap size|" + heap_size)
+  log(Elog::ELogLevel::DURATION,"Available heap|" + available_heap)
+end
+=end
+
+  def report_largest_block_to_sword(startTime,endTime)
+    startTime = Time.now if startTime == 0
+    endTime = startTime if endTime == 0
+    largest_block = get_largest_block().to_s
+    if is_sword?
+      post_result(startTime.to_f, endTime.to_f, :return_no => largest_block)
+      #writeNumericalResult(startTime.to_i, endTime.to_i, largest_block)
+    end
+    log(Elog::ELogLevel::DURATION,"Largest block|" + largest_block)
+  end
+
+  def report_heap_size_to_sword(startTime,endTime)
+    startTime = Time.now if startTime == 0
+    endTime = startTime if endTime == 0
+    heap_size = get_heap_size().to_s
+    if is_sword?
+      post_result(startTime.to_f, endTime.to_f, :return_no => heap_size)
+      #writeNumericalResult(startTime.to_i, endTime.to_i, heap_size)
+    end
+    log(Elog::ELogLevel::DURATION,"Heap size|" + heap_size)
+  end
+
+  def report_available_heap_to_sword(startTime,endTime)
+    startTime = Time.now if startTime == 0
+    endTime = startTime if endTime == 0
+    available_heap = get_available_heap().to_s
+    if is_sword?
+      post_result(startTime.to_f, endTime.to_f, :return_no => available_heap)
+      #writeNumericalResult(startTime.to_i, endTime.to_i, available_heap)
+    end
+    log(Elog::ELogLevel::DURATION,"Available heap|" + available_heap)
+  end
+
+  def change_roi_file(file=nil)
+    $roi_class_file=file
+    loginfo "Changing roi file to:#{file}"
+    TwcNavRoi.fetch_attribute('OCRROI')
+  end
+
+  def after_test(status=nil)
+    log Elog::ELogLevel::SUCCESS, "Test Passed" if status == :pass
+    log Elog::ELogLevel::STOP, "Test completed"
+  end
+
+  def test_error(msg, post)
+    return if msg == "TCUNSUPPORTED";
+    post_error_result(msg) if post == true
+    _logmessage Elog::ELogLevel::FAIL,  _failure_message(msg), true, false
+  end
+
+=begin
+MSD 2016-01-12 this is not used and should be deleted on next pass
+def writeNumericalResult(startTime, stopTime, dataValue)
+  return send_results(startTime, stopTime, "","" + dataValue, "")
+end
+=end
+
+  def test_plan_end
+    params = {
+        :test_plan_result_id => @sword_test_plan_result_id,
+    }
+    begin
+      url = "#{@sword_base_url}/test_plan_results/tmc_dsl_end_plan?"
+      url = url.concat(params.collect { |k,v| "#{k}=#{URI::escape(v.to_s)}" }.join('&'))
+      logger.debug url
+      web_get(url)
+    rescue => ex
+      logger.error "Failed to report end of plan to Sword #{ex}"
+    end
+  end
+
+  def current_tests
+    if @sword_report_grouping.nil?
+      [@sword_test_cycle_test_case_id]
+    else
+      # If tests are grouped then actions should affect all of the tests
+      @sword_report_grouping.map {|g| g[:test_cycle_test_case_id]}
+    end
+  end
+
+  #post result to SWORD
+  # TODO: NO SCRIPT SHOULD CALL THIS METHOD
+  def post_result(start_ts, stop_ts, return_no, args = {})
+    return unless is_sword?
+    #######################################################
+    #mbarnes I think this signifies that it's the first test case in the cycle
+    if args[:execution_metric].nil?
+      tctc_id = @sword_test_cycle_test_case_id
+    else
+      # If an execution metric is given, use the corresponding test cycle test case id
+      logger.debug("Report grouping for post_result: #{@sword_report_grouping}")
+      tctc_id = @sword_report_grouping.find {|g| g[:execution_metric] = args[:execution_metric]}[:test_cycle_test_case_id]
+    end
+    data = {
+        'test_plan_result_id' => @sword_test_plan_result_id,
+        'test_cycle_test_case_id' => tctc_id,
+        'hardware_unit_id' => @sword_hardware_unit_id,
+        'result'=> {
+            'start_ts' => start_ts,
+            'stop_ts' => stop_ts
+        }
+    }
+    unless args[:return_title].nil?
+      data['return_title'] = args[:return_title]
+    end
+    unless return_no.nil?
+      data['result']['return_no'] = return_no
+    end
+    post_json(data)
+  end
+
+  def post_error_result(tcr_auto_detail_text)
+    #Turned off for now, because graph does not filter these. sword does not ingest result_value:
+    # https://gitlab-test.enwd.co.sa.charterlab.com/sword_grp/sword/blob/master/app/models/tcr_auto_detail.rb#L27
+    return
+    return unless is_sword?
+    now = Time.now.to_f
+    current_tests.each do |tctc_id|
+      data = {
+          'test_plan_result_id' => @sword_test_plan_result_id,
+          'test_cycle_test_case_id' => tctc_id,
+          'hardware_unit_id' => @sword_hardware_unit_id,
+          'result' => {
+              'start_ts' => now,
+              'stop_ts' => now,
+              'result_value' => 'ERROR',
+              'tcr_auto_detail_text' => tcr_auto_detail_text
+          }
+      }
+      post_json(data)
+    end
+  end
+
+  def post_reboot_result(reboot_time)
+    #TODO: sword disregards result_value, so whatever this posts will be considered a measurement and will skew results
+    return unless is_sword?
+    #now = Time.now.to_f
+    #json = '{"test_plan_result_id":"30643","test_cycle_test_case_id":"107165","hardware_unit_id":"1067","result":{"start_ts":1370643834.329,"stop_ts":1370643837.849}}'
+    current_tests.each do |tctc_id|
+      data = {
+          'test_plan_result_id' => @sword_test_plan_result_id,
+          'test_cycle_test_case_id' => tctc_id,
+          'hardware_unit_id' => @sword_hardware_unit_id,
+          'result' => {
+              'start_ts' => reboot_time,
+              'stop_ts' => reboot_time,
+              'result_value' => 'REBOOT',
+              'return_value' => reboot_time,
+              'return_no' => 1
+          }
+      }
+      post_json(data)
+    end
+  end
+
+  def post_end_of_test_case()
+    return unless is_sword?
+    current_tests.each do |tctc_id|
+      data = {
+          'test_plan_result_id' => @sword_test_plan_result_id,
+          'test_cycle_test_case_id' => tctc_id,
+          'hardware_unit_id' => @sword_hardware_unit_id,
+          'case_complete' => 'true'
+      }
+      post_json(data)
+    end
+  end
+
+  def post_end_of_test_plan()
+    return unless is_sword?
+    data = {"test_plan_result_id" => @sword_test_plan_result_id,
+            "finished"=> 'true'
+    }
+    post_json(data)
+  end
+
+  #post json to SWORD
+  # TODO: NO SCRIPT SHOULD CALL THIS METHOD
+  def post_json(data)
+    url = @sword_base_url + @sword_result_url
+    logger.debug "SWORD POST URL :: #{url}"
+    tcrad_data = {
+        "test_plan_result_id" => @sword_test_plan_result_id,
+        "test_case_result_id" => @sword_test_case_result_id,
+        "hardware_unit_id" => @sword_hardware_unit_id,
+        "sword_iteration" => iteration
+    }
+    if (nil != data["return_title"])
+      tcrad_data["return_title"] = data["return_title"]
+    end
+    tcrad_id = @sword_tcr_auto_detail_id
+    if (nil != tcrad_id && !tcrad_id.empty?)
+      logger.info "post_json: Using tcrad #{tcrad_id} for TCRAD"
+      tcrad_data["tcrad_id"] = tcrad_id
+      data["tcrad_id"] = tcrad_id
+    end
+    data["tcrad_data"] = tcrad_data
+    headers = {'Content-Type' => 'application/json', 'Accept' => '*/*'}
+    resp = web_post(url, json: data, headers: headers)
+    logger.debug "Resp :: #{resp.body}"
+    if (resp.body.include?("Success:"))
+      tcrad = resp.body.split("=")[1]
+      @sword_tcr_auto_detail_id = tcrad
+    end
+  end
+
+  def clear_tuner_caches?(start_channel=516, num_channel_changes=6)
+    log Elog::ELogLevel::INFO2, "Clearing tuner cache..."
+    perf_tune_to_channel(start_channel.to_s, sleep_time_after_tune=6)
+    cur_chan_num=start_channel
+    good_tunes=0
+    tries=0
+    while good_tunes<num_channel_changes and tries<30
+      press_channel_up(0)
+      sleep 3.sec
+      if $rti_flag == false
+        good_tunes+=1
+      else
+        next_chan_num=rti_get_channel_number.to_i
+        if(next_chan_num>cur_chan_num)
+          good_tunes+=1
+        end
+      end
+      cur_chan_num=next_chan_num
+      tries+=1
+    end
+    return true if good_tunes==num_channel_changes
+    return false
+  end
+
+  def show_guide_days(number_of_days)
+    press_guide_sleep unless guide_banner_appears?
+    sleep 3.sec
+    if guide_banner_appears?
+      loginfo2 "Moving to #{number_of_days} days ahead."
+      press_key number_of_days
+      press_right_arrow_sleep
+      loginfo2 'Moving back to current date.'
+      press_key number_of_days
+      press_left_arrow_sleep
+    end
+    press_exit_sleep
+  end
+
+  def play_vod()
+    broadcast_channel = fetch_option(:a_live_channel_1)
+    tune_immediately_to broadcast_channel
+    tcfail "Failed to tune on channel: [#{broadcast_channel}]" unless info_banner_launch_and_verify_channel_number broadcast_channel
+    mod_channel = mod_channel_number
+    tcfail "Failed to tune to MOD Channel: [#{mod_channel}]" unless od_screen_tune_to_channel mod_channel
+    loginfo "The STB tunes to the MOD menu screen."
+
+    loginfo "Performing Step 1.B: Select a movie and purchase it via selecting the Buy option and entering a valid Purchase PIN."
+    asset = od_screen_locate_and_navigate_asset mod_channel
+    tcfail "Invalid Execution unpurchased OD asset not available" if asset == nil
+    tcfail "Unable to purchase focused asset #{asset}" unless od_screen_purchase_focused_asset true,false
+    tcfail 'OD asset unavailable' if od_asset_unavailable_barker_appears?
+    tcfail 'OD asset could not be purchased' unless od_screen_focused_asset_purchased?
+    loginfo "Completed Step 1.B: The movie is purchased."
+
+    sleep_for_ondemand_asset_play
+    cancellation_window = asset[:cancellation_window_in_minutes].to_s.to_i
+    sleep (cancellation_window+1).min
+    tcfail "The purchase for asset [#{asset[:title]}] was unsuccessful." unless od_screen_asset_verify_successful_purchase asset
+
+    loginfo "Allow the asset to stream for about 5 minutes."
+    tcfail 'OD asset unavailable' if od_asset_unavailable_barker_appears?
+    tcfail "Video is not playing after purchasing asset" unless fullscreen_video_playing?
+    if cancellation_window<5
+      sleep (5-cancellation_window).min
+    end
+    loginfo "The movie streamed for about 5 minutes."
+  end
+
+  def sleep_while_check_for_reboots(duration_min=30, last_reboot="")
+    test_duration = true
+    while duration_min > 0
+      #last_reboot_read = last_stb_reboot_time false
+      last_reboot_read = odn_web_server_odn_diags_last_reboot(options[:stb_ip], last_reboot)
+      #loginfo "Reboot1:last_reboot_read=#{last_reboot_read}, last_reboot=#{last_reboot}"
+      if (last_reboot != "") and (last_reboot_read != "") and (last_reboot_read != nil) and (last_reboot != nil)
+        #loginfo "Reboot2:last_reboot_read=#{last_reboot_read}, last_reboot=#{last_reboot_read}"
+
+        #      if last_reboot.include? "m"
+        #        resp = last_reboot.slice(0..last_reboot.index('m'))
+        #      else
+        #        resp = last_reboot
+        #      end
+        if ((!last_reboot_read.eql?(last_reboot)) and (last_reboot.length>10) and (last_reboot_read.length>10))
+          #loginfo "Reboot3:last_reboot_read=#{last_reboot_read}, last_reboot=#{last_reboot_read}"
+          begin
+            reboot_time = Time.parse(last_reboot_read)
+            post_reboot_result(reboot_time)
+          rescue
+            post_reboot_result(Time.now)
+          end
+          loginfo "***STB Rebooted:#{last_reboot_read};;;;;;;#{last_reboot}***"
+#        loginfo "***STB Rebooted:#{last_reboot_read.length.to_s};;;;;;;#{last_reboot.length.to_s}***"
+#        last_reboot_read.split("").each do |i|
+#          loginfo "***STB Rebooted1:#{i}"
+#        end
+#        last_reboot.split("").each do |i|
+#          loginfo "***STB Rebooted2:#{i}"
+#        end
+          last_reboot = last_reboot_read
+          File.open("tmp/Last_reboot_stb_#{$stb_id}.txt", 'w') do |f|
+            f.puts last_reboot
+          end
+        end
+      end
+      if duration_min > 15
+        if test_duration == true
+          sleep 90.sec
+        else
+          sleep 15.min
+        end
+      else
+        if test_duration == true
+          sleep (duration_min/10).sec
+        else
+          sleep duration_min.min
+        end
+      end
+      #    if test_duration == true
+      #      duration_min = duration_min - 15
+      #    else
+      duration_min = duration_min - 15
+      #    end
+    end
+    last_reboot = last_reboot_read if (last_reboot == "" or last_reboot == nil)
+    return last_reboot
+  end
+end