framework_gem 0.1.0

data/lib/lib/platform/roku/roku.rb

@@ -0,0 +1,96 @@
+require './lib/platform/platform'
+require './lib/screens/roku/roku_screens'
+require './lib/rois/roku/roku_rois'
+require './lib/platform_libs/roku/roku_controller'
+require './lib/keys/roku/roku_keys'
+
+# Roku adds to or modifies Platform with Roku-specific functionality
+
+class Roku < Platform
+
+  # Public: Initializes a Roku.
+  def initialize(*args)
+    super(*args)
+    @screens = RokuScreens.new(self)
+    @roi = RokuRois.new(self)
+    set_keys(RokuKeys.new)
+  end
+
+  # Public: Ensures device is on and can nav to home screen.
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?
+    super do
+      if has_power?
+        # exit to the home screen
+        2.times { press_key.MENU(sleep_time: 2.sec) }
+        return false unless screens.home.displayed?(timeout: 10.sec)
+      else
+        # device was powered off. power on and wait up to 2 mins for "No Signal" to go away.
+        power_on
+        return false unless roi.text.no_input_signal.wait_until_not_displayed?(2.min)
+        return false unless screens.home.displayed?(timeout: 2.min)
+      end
+      # leaving incase we need it back
+      # start = Time.now
+      # loop do
+      #   return false if (Time.now - start) > 180  # timeout 3 mins
+      #   if roi.image.respond_to?("#{app_slot_roi}_1")
+      #     if roi.image.send("#{app_slot_roi}_1").displayed?
+      #       press_key.SELECT(sleep_time: 2.sec)
+      #       break
+      #     elsif roi.image.send("#{app_slot_roi}_2").displayed?
+      #       press_key.ARROW_RIGHT(sleep_time: 2.sec)
+      #       press_key.SELECT(sleep_time: 2.sec)
+      #       break
+      #     elsif roi.image.send("#{app_slot_roi}_3").displayed?
+      #       #elsif roi.image.dev_app_slot_3.displayed?
+      #       2.times { press_key.ARROW_RIGHT(sleep_time: 2.sec) }
+      #       press_key.SELECT(sleep_time: 2.sec)
+      #       break
+      #     end
+      #   elsif roi.image.send(app_slot_roi).displayed?
+      #     press_key.SELECT(sleep_time: 2.sec)
+      #     break
+      #   end
+      #   press_key.ARROW_DOWN(sleep_time: 2.sec)
+      # end
+      # if screens.home.is_spectrum_loading_screen_displayed?
+      #   # wait for loading screen to go away
+      #   return false unless screens.home.wait_till_loading_screen_not_displayed?(30.sec)
+      # end
+      # if screens.home.is_spectrum_launch_screen_displayed?
+      #   # wait for launch screen to go away
+      #   return false unless screens.home.wait_till_launch_screen_not_displayed?(30.sec)
+      # end
+      # if roi.text.welcome_screen_text.displayed?
+      #   # dismiss welcome screen
+      #   press_key.SELECT(sleep_time: 3.sec)
+      #   return false unless roi.text.welcome_screen_text.wait_until_not_displayed?(30.sec)
+      # end
+      # if screens.login.is_username_page_displayed?
+      #   # sign in
+      #   return false unless screens.login.login?
+      # end
+      true
+    end
+  end
+
+  # Public: Gets the controller.
+  #
+  # Returns the RokuController instance.
+  def controller
+    if @controller.nil?
+      @controller = RokuController.new(:dut => self)
+    end
+    @controller
+  end
+
+  # Public: Gets the device software version.
+  #
+  # Returns the String software version.
+  def software_version
+    super || @test_case.options[:current_roku_version] || '2.0.34'
+  end
+
+end

data/lib/lib/platform/roku/roku_720/roku_720.rb

@@ -0,0 +1,16 @@
+require './lib/platform/roku/roku'
+require './lib/screens/roku/roku_screens'
+require './lib/rois/roku/roku_720/roku_720_rois'
+
+# Roku 720 adds to or modifies the Roku platform with Roku 720p-specific functionality
+
+class Roku720 < Roku
+
+  # Public: Initializes a Roku 720p.
+  def initialize(*args)
+    super(*args)
+    # @screens = Roku720Screens.new(self)  # if ever needed...
+    @roi = Roku720Rois.new(self)
+  end
+
+end

data/lib/lib/platform/roku_tv/roku_tv.rb

@@ -0,0 +1,33 @@
+require './lib/platform/platform'
+require './lib/screens/roku_tv/roku_tv_screens'
+require './lib/rois/roku_tv/roku_tv_rois'
+require './lib/keys/roku_tv/roku_tv_keys'
+
+# Adds to or modifies the platform with RokuTv-specific functionality.
+
+class RokuTv < Platform
+
+  # Public: Initializes an Roku TV device.
+  def initialize(*args)
+    super(*args)
+    @screens = RokuTvScreens.new(self)
+    @roi = RokuTvRois.new(self)
+    set_keys(RokuTvKeys.new)
+  end
+
+  # Public: Initializes the Roku TV and brings it to the Live TV screen.
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?
+    super do
+      logger.warn('INIT NOT IMPLEMENTED')
+      true
+      #screens.main_menu.navigate_to_samsungApps
+      #2.times { press_key.ARROW_RIGHT(:sleep_time => 2.sec) }
+      #press_key.ARROW_DOWN(:sleep_time => 2.sec)
+      #press_key.SELECT
+      #roi.text.livetv_text.wait_until_displayed?(25.sec)  # returns this
+    end
+  end
+
+end

data/lib/lib/platform/roku_tv/roku_tv_1080/roku_tv_1080.rb

@@ -0,0 +1,14 @@
+require './lib/platform/roku_tv/roku_tv'
+require './lib/rois/roku_tv/roku_tv_1080/roku_tv_1080_rois'
+
+# Adds to or modifies the RokuTv platform with 1080p-specific functionality.
+
+class RokuTv1080 < RokuTv
+
+  # Public: Initializes an RokuTv 1080p device.
+  def initialize(*args)
+    super(*args)
+    @roi = RokuTv1080Rois.new(self)
+  end
+
+end

data/lib/lib/platform/roku_tv/roku_tv_720/roku_tv_720.rb

@@ -0,0 +1,14 @@
+require './lib/platform/roku_tv/roku_tv'
+require './lib/rois/roku_tv/roku_tv_720/roku_tv_720_rois'
+
+# Adds to or modifies the RokuTv platform with 720p-specific functionality.
+
+class RokuTv720 < RokuTv
+
+  # Public: Initializes an RokuTv 720p device.
+  def initialize(*args)
+    super(*args)
+    @roi = RokuTv720Rois.new(self)
+  end
+
+end

data/lib/lib/platform/samsung_tv/samsung_tv.rb

@@ -0,0 +1,31 @@
+require './lib/platform/platform'
+require './lib/screens/samsung_tv/samsung_tv_screens'
+require './lib/rois/samsung_tv/samsung_tv_rois'
+require './lib/keys/samsung_tv/samsung_tv_keys'
+
+# Adds to or modifies the platform with Samsung TV-specific functionality.
+
+class SamsungTv < Platform
+
+  # Public: Initializes a Samsung TV device.
+  def initialize(*args)
+    super(*args)
+    @screens = SamsungTvScreens.new(self)
+    @roi = SamsungTvRois.new(self)
+    set_keys(SamsungTvKeys.new)
+  end
+
+  # Public: Initializes the Samsung TV and brings it to the Live TV screen.
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?
+    super do
+      screens.main_menu.navigate_to_samsungApps
+      2.times { press_key.ARROW_RIGHT(:sleep_time => 2.sec) }
+      press_key.ARROW_DOWN(:sleep_time => 2.sec)
+      press_key.SELECT
+      roi.text.livetv_text.wait_until_displayed?(25.sec)  # returns this
+    end
+  end
+
+end

data/lib/lib/platform/samsung_tv/samsung_tv_1080/samsung_tv_1080.rb

@@ -0,0 +1,14 @@
+require './lib/platform/samsung_tv/samsung_tv'
+require './lib/rois/samsung_tv/samsung_tv_1080/samsung_tv_1080_rois'
+
+# Adds to or modifies the Samsung TV platform with 1080p-specific functionality.
+
+class SamsungTv1080 < SamsungTv
+
+  # Public: Initializes a Samsung TV 1080p device.
+  def initialize(*args)
+    super(*args)
+    @roi = SamsungTv1080Rois.new(self)
+  end
+
+end

data/lib/lib/platform/samsung_tv/samsung_tv_720/samsung_tv_720.rb

@@ -0,0 +1,14 @@
+require './lib/platform/samsung_tv/samsung_tv'
+require './lib/rois/samsung_tv/samsung_tv_720/samsung_tv_720_rois'
+
+# Adds to or modifies the Samsung TV platform with 720p-specific functionality.
+
+class SamsungTv720 < SamsungTv
+
+  # Public: Initializes a Samsung TV 720p device.
+  def initialize(*args)
+    super(*args)
+    @roi = SamsungTv720Rois.new(self)
+  end
+
+end

data/lib/lib/platform/sara/sara.rb

@@ -0,0 +1,42 @@
+
+  require './lib/platform/platform'
+  require './lib/screens/sara/sara_screens'
+  require './lib/rois/sara/sara_rois'
+  require './lib/keys/sara/sara_keys'
+  
+  # Adds to or modifies the platform with Sara-specific functionality.
+  
+  class Sara < Platform
+  
+    # Public: Initializes a Sara device.
+    def initialize(*args)
+      super(*args)
+      @screens = SaraScreens.new(self)
+      @roi = SaraRois.new(self)
+      set_keys(SaraKeys.new)
+    end
+  
+    # Public: Initializes the Sara and brings it to the Live TV screen.
+    #
+    # Returns a Boolean true if the device was initialized, otherwise false.
+    def init?
+      super do
+        tries = 2
+        count = 0
+        while tries > count do
+          if has_power? 
+            return true
+          elsif power_on
+            sleep(2000)
+            #do nothing
+          end
+        end
+
+        if has_power? 
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end

data/lib/lib/platform/sara/sara_1080/sara_1080.rb

@@ -0,0 +1,15 @@
+
+  require './lib/platform/sara/sara'
+  require './lib/rois/sara/sara_1080/sara_1080_rois'
+  
+  # Adds to or modifies the Sara platform with 1080p-specific functionality.
+  
+  class Sara1080 < Sara
+  
+    # Public: Initializes an Sara 1080p device.
+    def initialize(*args)
+      super(*args)
+      @roi = Sara1080Rois.new(self)
+    end
+  
+  end

data/lib/lib/platform/sara/sara_720/sara_720.rb

@@ -0,0 +1,15 @@
+
+  require './lib/platform/sara/sara'
+  require './lib/rois/sara/sara_720/sara_720_rois'
+  
+  # Adds to or modifies the Sara platform with 720p-specific functionality.
+  
+  class Sara720 < Sara
+  
+    # Public: Initializes an Sara 720p device.
+    def initialize(*args)
+      super(*args)
+      @roi = Sara720Rois.new(self)
+    end
+  
+  end

data/lib/lib/platform/stb/iguide/iguide.rb

@@ -0,0 +1,18 @@
+require './lib/platform/stb/stb'
+require './lib/screens/stb/iguide/iguide_screens'
+require './lib/rois/stb/iguide/iguide_rois'
+require './lib/keys/stb/iguide/iguide_keys'
+
+# Adds to or modifies the Stb platform with Iguide-specific functionality.
+
+class Iguide < Stb
+
+  # Public: Initializes Iguide. NOT FOR USE IN TESTS.
+  def initialize(*args)
+    super(*args)
+    @screens = IguideScreens.new(self)
+    @roi = IguideRois.new(self)
+    set_keys(IguideKeys.new)
+  end
+
+end

data/lib/lib/platform/stb/iguide/iguide_1080/iguide_1080.rb

@@ -0,0 +1,14 @@
+require './lib/platform/stb/iguide/iguide'
+require './lib/rois/stb/iguide/iguide_1080/iguide_1080_rois'
+
+# Adds to or modifies the Iguide platform with Iguide1080-specific functionality.
+
+class Iguide1080 < Iguide
+
+  # Public: Initializes Iguide1080. NOT FOR USE IN TESTS.
+  def initialize(*args)
+    super(*args)
+    @roi = Iguide1080Rois.new(self)
+  end
+
+end

data/lib/lib/platform/stb/iguide/iguide_720/iguide_720.rb

@@ -0,0 +1,14 @@
+require './lib/platform/stb/iguide/iguide'
+require './lib/rois/stb/iguide/iguide_720/iguide_720_rois'
+
+# Adds to or modifies the Iguide platform with Iguide720-specific functionality.
+
+class Iguide720 < Iguide
+
+  # Public: Initializes Iguide720. NOT FOR USE IN TESTS.
+  def initialize(*args)
+    super(*args)
+    @roi = Iguide720Rois.new(self)
+  end
+
+end

data/lib/lib/platform/stb/odn/odn.rb

@@ -0,0 +1,480 @@
+require './lib/platform/stb/stb'
+require './lib/screens/stb/odn/odn_screens'
+require './lib/rois/stb/odn/odn_rois'
+require './lib/keys/stb/odn/odn_keys'
+
+# Adds to or modifies the Stb platform with Odn-specific functionality.
+
+class Odn < Stb
+
+  def initialize(*args)
+    super(*args)
+    @screens = OdnScreens.new(self)
+    @roi = OdnRois.new(self)
+    set_keys(OdnKeys.new)
+  end
+
+  # Public: Initializes the Spectrum STB and brings it to the Live TV screen.
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?
+    if super
+      press_key.EXIT(:sleep_time => 3.sec)  # exit the banner which prevents us from doing some operations
+      true
+    else
+      false
+    end
+  end
+
+  # Public: get current channel number (string) from the guide
+  #
+  # returns current channel number (string)
+  def get_channel_number_from_guide()
+    fail("Failed to launch guide") unless screens.guide.navigate?
+    current_channel_number = screens.guide.get_current_channel_number()
+    press_key.EXIT    # exit from the guide
+    current_channel_number
+  end
+
+  # Public: get current channel number (string) from the info banner
+  #
+  # returns current channel number (string)
+  def get_channel_number_from_info_banner()
+    current_channel_number = screens.live_tv.get_current_channel_number()
+    current_channel_number
+  end
+
+  # Public: verify if we are in the expected channel by checking with the guide or the info banner
+  #
+  # channel_number - channel number user is expecting
+  #
+  # Returns true if verified, false otherwise
+  def verify_expected_channel?(channel_number)
+    rti_flag = options.fetch(:rti_flag, 'false')
+    $rti_flag = (rti_flag == 'true')
+
+    current_channel_number = -1
+    if ($rti_flag == false)
+      logger.info("Before guide_banner_verify_channel_number")
+      current_channel_number = get_channel_number_from_guide()
+    else
+      logger.info("Before info_banner_launch_and_verify_channel_number")
+      current_channel_number = get_channel_number_from_info_banner()
+    end
+    if current_channel_number.match(/^\d+$/)
+      current_channel_number = current_channel_number.to_i
+    else
+      current_channel_number = -1
+    end
+    fail("Failed to get the current channel number") if (current_channel_number <= 0)
+    current_channel_number == channel_number
+  end
+
+  # Public: measure tune time
+  #
+  # from_channel_type - type of channel we are starting from
+  # to_channel_type   - type of channel we are going to tune to
+  # from_channel      - channel number we are starting from
+  # to_channel        - channel number we are going to tune to
+  # tune_type         - type of tune we are performing (direct or guide)
+  # cache_clear       - flag to indicate if we need to clear the cache
+  #
+  # Returns nothing but posts results of the start time and the end time
+  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
+    debug_log = false
+    if (from_channel_type == 'analog' or to_channel_type == 'analog')
+      error("Box['#{fetch_stb_model}'] not supported.") unless stb_capable_of? 'ANALOG'
+    end
+    fail("From and to channels cannot be the same") if (from_channel == to_channel)
+    fail("Failed to initialize STB") unless init?
+    logger.info("#{tune_type} tune from channel: #{from_channel} to channel: #{to_channel}")
+    #Verify video on from_channel
+    if (cache_clear)
+      start_clear_chan=(@test_case.test_data[:clear_tuner_cache_start_channel] == nil)? 516 : @test_case.test_data[:clear_tuner_cache_start_channel]
+      fail("Could not clear tuner cache") unless clear_tuner_caches?(start_clear_chan, 6)
+    end
+    fail("Could not get video on from_channel: #{from_channel}") if (initialize_execution(from_channel) == false)
+    fail("Tuned to wrong from channel: #{from_channel}") if (!verify_expected_channel?(from_channel))
+
+    press_key.EXIT
+    if (tune_type == 'guide')
+      sleep(10.sec)
+      press_key.GUIDE
+      screens.guide.set_channel?(to_channel, :press_select => false)
+      sleep(4.sec)
+      logger.info("Screen before pressing select", :screenshot => true, :use_last_image => false, :image_suffix => "guide")
+      press_key.SELECT( :sleep_time => 0.sec )
+    else
+      screens.live_tv.set_channel?(to_channel)
+      logger.info("Screen before channel starts changing", :screenshot => true, :use_last_image => false, :image_suffix => "guide")
+    end
+    startTime = Time.now
+    fail("Video did not go black after #{tune_type} tuning to channel: #{to_channel}") unless roi.black.channel_tune_black_screen.wait_until_displayed?(timeout=5000)
+
+    stopTime = Time.now
+    tuneTime = time_diff_milli(startTime, stopTime)
+    logger.info("Video froze after: #{tuneTime.to_s}")
+    fail("Video not playing after #{tune_type} tuning to channel: #{to_channel}") unless roi.black.channel_tune_black_screen.wait_until_displayed?(timeout=15000)
+    stopTime = Time.now
+    tuneTime = time_diff_milli(startTime, stopTime)
+    fail("Test took too long") if (tuneTime > 15000)
+    logger.info("Long tune time") if (tuneTime > 5000)
+    press_key.EXIT
+    fail("Could not verify to channel: #{to_channel}: for #{tune_type} tune") unless verify_expected_channel?(to_channel)
+    report_result(:start_time => startTime, :stop_time => stopTime)
+    logger.duration(tuneTime, :message => "#{from_channel_type} to #{to_channel_type} #{tune_type} tune|")
+  end
+
+  # Public:  measures tune in guide from MOD to MOD
+  #
+  # from_channel_type - type of channel we are starting from
+  # to_channel_type   - type of channel we are going to tune to
+  # from_channel      - channel number we are starting from
+  # to_channel        - channel number we are going to tune to
+  # tune_type         - type of tune we are performing (direct or guide)
+  #
+  # Returns nohting
+  def measure_tune_guide_mod_mod(from_channel_type, to_channel_type, from_channel, to_channel, tune_type='direct')
+    debug_log = false
+    fail("From and to channels cannot be the same") if (from_channel == to_channel)
+    screenROI = roi.image.guide_info
+
+    logger.info("#{tune_type} tune from channel: #{from_channel} to channel: #{to_channel}")
+    #Verify video on from_channel
+    fail("Failed to initialize STB") unless init?
+    screens.live_tv.navigate?
+    screens.live_tv.set_channel(from_channel)
+    fail("Tuned to wrong from channel: #{from_channel}") unless verify_expected_channel?(from_channel)
+    fail("Could not get video on from_channel: #{from_channel}") unless screens.live_tv.displayed?
+    press_key.EXIT
+
+    if (tune_type == 'guide')
+      press_key.GUIDE
+      sleep(4.sec)
+      screens.guide.set_channel?(to_channel)
+      sleep(4.sec)
+      filename = capture_screen("tmp_stb_#{$stb_id}.jpg")
+      screenROI.ref_img = filename
+      logger.info("Screen before pressing select", :screenshot => true, :use_last_image => false, :image_suffix => "image")
+      press_key.SELECT(:sleep_time => 0.sec)
+    else
+      sleep(2.sec)
+      filename = capture_screen("tmp_stb_#{$stb_id}.jpg")
+      screenROI.ref_img = filename
+      logger.info("Screen before pressing tuning to channel", :screenshot => true, :use_last_image => false, :image_suffix => "image")
+      screens.live_tv.set_channel?(to_channel)
+    end
+    times[0] = Time.now
+    if screenROI.wait_until_not_displayed?(timeout=15000, :priority => :high)
+      times[1] = Time.now
+    else
+      times[1] = times[0]   # failed case
+    end
+    dataValue = time_diff_milli(times[0], times[1])
+    fail("Failed to go to channel #{to_channel}") if (dataValue == 0)
+    dataValue = dataValue.to_s
+    report_result(:start_time => times[0], :stop_time => times[1])
+    logger.duration(dataValue, :message => "#{from_channel_type} to #{to_channel_type} #{tune_type} tune|")
+    press_key.EXIT
+  end
+
+  # Public: measures tuning in guide
+  #
+  # from_channel - channel number we are starting from
+  # to_channel   - channel number we are going to tune to
+  #
+  # Returns nothing
+  def measure_guide_tune(from_channel, to_channel)
+    logger.info("Guide tune from channel #{from_channel} to #{to_channel}")
+    screenROI = roi.image.guide_network_logo
+    timeout=15
+    fail("Failed to launch guide") unless screens.guide.navigate?
+    screens.guide.set_channel?(from_channel, :press_select => false)
+    sleep(3.sec)
+    filename = capture_screen("tmp_stb_#{$stb_id}.jpg")
+    screenROI.ref_img = filename
+    sleep(5.sec)
+    logger.info("Initial screen", :screenshot => true, :use_last_image => false, :image_suffix => "image")
+    screens.guide.set_channel?(to_channel, :press_select => false)
+    times[0] = Time.now
+    if screenROI.wait_until_not_displayed?(timeout=15000, :priority => :high)
+      times[1] = Time.now
+    else
+      times[1] = times[0]  # failed case
+    end
+    dataValue = time_diff_milli(times[0], times[1])
+    fail("Failed to go to channel #{to_channel}") if (dataValue == 0)
+    report_result(:start_time => times[0], :stop_time => times[1])
+    logger.duration(dataValue, :message => "Time to channel #{to_channel}")
+  end
+
+  # Public: measure burst tune
+  #
+  # channels   -
+  # burst_type -
+  #
+  # Returns nothing
+  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 = roi.text.guide_focused_program_channel
+    guide_chan_ROI.expectedText = final_chan.to_s
+
+    logger.info("Initializing on channel: #{start_chan}") if (debug_log)
+    screens.live_tv.set_channel?(from_channel)
+    fail("Could not get initial video displayed on channel #{start_chan}") unless (verify_expected_channel?(start_chan))
+    logger.info("Initial channel displayed") if (debug_log)
+
+    startTime = Time.now
+    (1..channel_tunes).each do |k|
+      if chan_up
+        press_key.CHANNEL_UP( :sleep_time => 0.sec )
+        dir = 'up'
+      else
+        press_key.CHANNEL_DOWN( :sleep_time => 0.sec )
+        dir = 'down'
+      end
+      if (k == 1)
+        logger.info("Warning: Video did not pause") unless roi.video.fullscreen_video.wait_until_not_displayed?(timeout=2000, :priority => :high)
+      end
+      sleep(500.ms)
+    end
+    fail("Video not playing") unless roi.video.fullscreen_video.displayed?
+    stopTime = Time.now
+
+    logger.info("Video playing", :screenshot => true, :use_last_image => false)
+    (1..3).each do |i|
+      press_key.GUIDE
+      break if guide_chan_ROI.displayed?
+      fail("Could not verify final channel number") if (i > 2)
+      press_key.EXIT
+    end
+    dataValue = time_diff_milli(startTime, stopTime).to_s
+    logger.duration(dataValue, :message => "Burst tune #{burst_type} | #{dataValue}")
+    report_result(:start_time => startTime, :stop_time => stopTime)
+  end
+
+  # Public:  compares 2 time values and returns the difference in milliseconds
+  #
+  # t1 - start time
+  # t2 - end time
+  #
+  # return delta (in ms) of the 2 timestamps
+  def time_diff_milli(t1, t2)
+    if t1.is_a?(DateTime)
+      delta_s = (t2 - t1) * 24.0 * 60 * 60  # convert DateTime delta from days to seconds
+    elsif t1.is_a?(Time)
+      delta_s = t2 - t1  # Time delta already in seconds
+    else
+      return time_diff_milli(to_time(t1), to_time(t2))  # Unknown -- try to convert values to Time or DateTime
+    end
+    delta_s * 1000.0  # convert to ms
+  end
+
+  # Public:  use this to clear tuner caches
+  #
+  # start_channel       - starting channel number
+  # num_channel_changes - number of channel changes to perform
+  #
+  # return true if number of successful channels equals to the number of expected channel changes (num_channel_changes), false otherwise
+  def clear_tuner_caches?(start_channel=511, num_channel_changes=6)
+    logger.info("Clearing tuner cache...")
+    screens.live_tv.set_channel?(start_channel)
+    sleep(6.sec)
+    cur_chan_num = start_channel
+    good_tunes = 0
+    tries = 0
+    while (good_tunes < num_channel_changes and tries < 30)
+      press_key.CHANNEL_UP( :sleep_time => 5.sec )
+      next_chan_num = get_channel_number_from_info_banner()
+      if (next_chan_num == -1)
+        tries += 1
+        next
+      end
+      if (next_chan_num > cur_chan_num)
+        good_tunes += 1
+      end
+      cur_chan_num = next_chan_num
+      tries += 1
+    end
+
+    good_tunes == num_channel_changes
+  end
+
+  # Public: Use it to get last reboot time from web server
+  #
+  #   stb_ip -> IP address of box
+  #
+  # Returns last reboot time string
+  def odn_web_server_odn_diags_last_reboot(stb_ip = fetch_ip, last_reboot = "")
+    begin
+      logger.info("Establishing connection to ip: #{stb_ip}")
+      http = Net::HTTP.new(stb_ip)
+      resp = http.get("/odnDiagnostics").body
+      if resp.include?("Last Boot Time:")
+        resp = resp.slice((resp.index('Last Boot Time:')+'Last Boot Time:'.length)..resp.length-1)
+        resp = resp.slice((resp.index('value_white">')+'value_white">'.length)..resp.length-1)
+        resp = resp.slice(0..resp.index('</td>')-1)
+        #logger.info("Reboot time read from STB:#{resp}")
+        resp
+      else
+        logger.info("Reboot time not read from STB")
+        last_reboot
+      end
+    rescue
+      logger.info("Error reading Reboot time from STB")
+      last_reboot
+    end
+  end
+
+  # Public:  sleep for the minutes provided and check for reboot time (and report it to sword)
+  #
+  # duration_min - number of minutes to sleep
+  #
+  # return last reboot in minutes
+  def sleep_while_check_for_reboots(duration_min=30, last_reboot="")
+    test_duration = true
+    while (duration_min > 0)
+      last_reboot_read = odn_web_server_odn_diags_last_reboot(ip_address, last_reboot)
+      if (last_reboot != "") and (last_reboot_read != "") and (last_reboot_read != nil) and (last_reboot != nil)
+        if ((!last_reboot_read.eql?(last_reboot)) and (last_reboot.length>10) and (last_reboot_read.length>10))
+          begin
+            reboot_time = Time.parse(last_reboot_read)
+            # post_reboot_result(reboot_time)
+            report_result(:start_time => reboot_time, :stop_time => reboot_time, :return_value => reboot_time, :return_title => 'REBOOT', :message => 'REBOOT')
+          rescue
+            # post_reboot_result(Time.now)
+            report_result(:start_time => Time.now, :stop_time => Time.now, :return_value => Time.now, :return_title => 'REBOOT', :message => 'REBOOT')
+          end
+          logger.info("***STB Rebooted:#{last_reboot_read};;;;;;;#{last_reboot}***")
+          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)
+          sleep(90.sec)
+        else
+          sleep(15.min)
+        end
+      else
+        if (test_duration)
+          sleep((duration_min/10).sec)
+        else
+          sleep(duration_min.min)
+        end
+      end
+      # TO DO:  are we sure about the following line?  Based on the about if-block, we don't always sleep for 15 minutes...
+      duration_min = duration_min - 15
+    end
+
+    if (last_reboot == "" or last_reboot == nil)
+      last_reboot_read
+    else
+      last_reboot
+    end
+  end
+
+  # Public:  get largest block data in the STB via snmp
+  #
+  # Returns the largest block value
+  def get_largest_block()
+    begin
+      r = snmp_get(".1.3.6.1.4.1.4491.2.3.1.1.4.7.1.0")
+      logger.info("largest_block=#{r}")
+      r.to_i
+    rescue StandardError => e
+      0
+    end
+  end
+
+  # Public:  get heap size data in the STB via snmp
+  #
+  # Returns the heap size value
+  def get_heap_size()
+    begin
+      r = snmp_get(".1.3.6.1.4.1.4491.2.3.1.1.4.8.1.0")
+      logger.info("heap_size=#{r}")
+      r.to_i
+    rescue StandardError => e
+      0
+    end
+  end
+
+  # Public:  get available heap size data in the STB via snmp
+  #
+  # Returns the available heap value
+  def get_available_heap()
+    begin
+      r = snmp_get(".1.3.6.1.4.1.4491.2.3.1.1.4.8.2.0")
+      logger.info("available_heap=#{r}")
+      r.to_i
+    rescue StandardError => e
+      0
+    end
+  end
+
+  # Public:  get largest block data and report to sword
+  #
+  # Returns nothing
+  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)
+      report_result(:start_time => startTime, :stop_time => endTime, :return_value => largest_block, :return_title => "largest block", :message => "largest block")
+    end
+    logger.duration(largest_block, :message => "Largest block|#{largest_block}")
+  end
+
+  # Public:  get heap size data and report to sword
+  #
+  # Returns nothing
+  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)
+      report_result(:start_time => startTime, :stop_time => endTime, :return_value => heap_size, :return_title => "heap size", :message => "heap size")
+    end
+    logger.duration(heap_size, :message => "Heap size|#{heap_size}")
+  end
+
+  # Public:  get available heap size data and report to sword
+  #
+  # Returns nothing
+  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)
+      report_result(:start_time => startTime, :stop_time => endTime, :return_value => available_heap, :return_title => "available heap", :message => "available heap")
+    end
+    logger.duration(available_heap, :message => "Available heap|#{available_heap}")
+  end
+end