framework_gem 0.1.0 → 0.2.0

data/lib/User_Lib/screen/mobile/dvr_mobile.rb

@@ -1,5 +0,0 @@
-# Defines mobile-specific DVR methods
-
-module DvrMobile
-
-end

data/lib/User_Lib/screen/mobile/favorites_mobile.rb

@@ -1,5 +0,0 @@
-# Defines mobile-specific Favorites methods
-
-module FavoritesMobile
-
-end

data/lib/User_Lib/screen/mobile/guide_mobile.rb

@@ -1,5 +0,0 @@
-# Defines mobile-specific Guide methods
-
-module GuideMobile
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_devices.rb

@@ -1,43 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/devices_mobile'
-
-# Defines iOS-specific methods on the Devices screen
-
-class IosDevices < IosScreen
-  include DevicesMobile
-
-  # Public: Returns the list of devices
-  #
-  # Returns the list of deviceses
-  def get_devices
-    dut.elements({:type => 'UIATableCell', :min => 1, :info => [:name]})
-  end
-
-  # Public: Returns the elements for the enabled image areas
-  #
-  # Returns the elements for the enabled image areasas
-  def get_enabled_image_areas
-    fract = 0.2
-    dut.elements({:type => 'UIATableCell', :info => [:x, :y, :width, :height]}).map do |cell|
-      # Only the right fraction of each cell
-      new_w = cell[:width] * fract
-      new_x = (cell[:x] + cell[:width]) - new_w
-      cell[:width] = new_w
-      cell[:x] = new_x
-      cell
-    end
-  end
-
-  # Public: Selects the device given by name or index
-  #
-  # name_or_index - name or index of device
-  #
-  # Returns true if successfully selected the device given by name or index, otherwise falsese
-  def select_device?(name_or_index)
-    if name_or_index.is_a?(String)
-      name_or_index = get_devices.index(name_or_index) + 1
-    end
-    dut.tap?({:type => 'UIATableCell', :x => 0.9, :index => name_or_index})
-  end
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_dvr.rb

@@ -1,231 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/dvr_mobile'
-
-# Defines iOS-specific methods on the DVR screen
-
-class IosDvr < IosScreen
-  include DvrMobile
-
-  # Public: Taps on edit button in DVR Manager
-  #
-  # Returns true if button is successfully tapped, otherwise false
-  def edit_recordings?
-    dut.tap?({:name => 'Edit'})
-  end
-
-  # Public: Checks checkbox indicated by index number
-  #
-  # index - index number of checkbox
-  #
-  # Examples:
-  #   dut.screens.dvr.check_box?(2)
-  #   # => 'True'
-  #
-  # Returns true if successfully checked the box given by index, otherwise false
-  def check_box?(index)
-    dut.tap?({:name => 'regexp:rdvr checkBoxes', :index => index})
-  end
-
-  # Public: Returns the title of the show given by index
-  #
-  # index - index number of show title to retrieve
-  #
-  # Examples:
-  #   dut.screens.dvr.get_show_title(2)
-  #   # => 'NCIS'
-  #
-  # Returns the title of the show given by index
-  def get_show_title(index)
-    dut.element({:type => 'UIATableCell', :is_visible => true, :info => [:name], :index => index})
-  end
-
-  # Public: Click on delete button after selecting recorded shows to delete
-  #
-  # Returns true if successfully clicked Delete Recordings, otherwise false
-  def delete_recordings?
-    dut.tap?({:name => 'regexp:Delete [0-9]+ recordings'})
-  end
-
-  # Public: Taps on cancel button after selecting recorded show to delete
-  #
-  # Returns true if successfully canceled deletion, otherwise false
-  def cancel_delete?
-    dut.tap?({:description => 'No'})
-  end
-
-  # Public: Searches for specified show title
-  #
-  # title - name of show to be searched for
-  #
-  # Examples:
-  #   dut.screens.dvr.show_title?("NCIS")
-  #   # => 'True'
-  #
-  # Returns true if the given show title is found, otherwise false
-  def show_title_found?(title)
-    dut.element?({:name => title, :type => 'UIATableCell'})
-  end
-
-  # Public: Checks if DVR Manager was displayed properly
-  #
-  # Returns true if the page was displayed as required, otherwise false
-  def displayed?
-    dut.element?({:name => 'DVR Manager', :type => 'UIANavigationBar', :is_visible => true, :is_on_screen => true})
-  end
-
-  # Public: Searches for given tab name
-  #
-  # tab_name - name of tab to be searched for
-  #
-  # Examples:
-  #   dut.screens.dvr.is_tab?("My Recordings")
-  #   # => 'True'
-  #
-  # Returns true if the given tab is visible, otherwise false
-  def is_tab?(tab_name)
-    dut.element?({:name => tab_name, :is_visible => true, :is_on_screen => true})
-  end
-
-  # Public: Returns the number of devices
-  #
-  # Examples:
-  #   dut.screens.dvr.device_count
-  #   # => '3'
-  #
-  # Returns the number of devices
-  def device_count
-    tcfail('Failed to expand device list!') unless dut.tap?({:name => 'settings icon tv'})
-    dut.elements({:name => 'regexp:^icon ', :info => [:name]}).count
-  end
-
-  # Public: Returns the series title at the given index
-  #
-  # index - index of the series to get the title of
-  #
-  # Examples:
-  #   dut.screens.dvr.get_series_title(2)
-  #   # => 'NCIS'
-  #
-  # Returns the series title at the given index (1-based)
-  def get_series_title(index)
-    dut.element({:type => 'UIATableCell', :is_visible => true, :index => index, :info => [:name]})
-  end
-
-  # Public: Selects a series given by name or index
-  #
-  # name_or_index - Name or index of sereies to select
-  #
-  # Examples:
-  #   dut.screens.dvr.select_series?("NCIS")
-  #   OR
-  #   dut.screens.dvr.select_series?(2)
-  #   # => 'True'
-  #
-  # Returns true if successfully selected the series given by name or index (1-based), otherwise false
-  def select_series?(name_or_index)
-    if name_or_index.is_a?(Fixnum)
-      dut.tap?({:type => 'UIATableCell', :is_visible => true, :index => name_or_index})
-    else
-      dut.tap?({:type => 'UIATableCell', :name => name_or_index})
-    end
-  end
-
-  # Public: Selects the episode given by the name or index
-  #
-  # name_or_index - name or index of the episode to be selected
-  #
-  # Examples:
-  #   dut.screens.dvr.select_episode?("Outside")
-  #   OR
-  #   dut.screens.dvr.select_episode?(3)
-  #   # => 'True'
-  #
-  # Returns true if successfully selected the episode given by name or index (1-based), otherwise false
-  def select_episode?(name_or_index)
-    if name_or_index.is_a?(Fixnum)
-      #TODO: We need a better way to identify these so we don't have to use this silly regex
-      dut.tap?({:name => 'regexp:^S\d+ E\d+$', :index => name_or_index})
-    else
-      dut.tap?({:type => 'UIATableCell', :name => name_or_index})
-    end
-  end
-  
-  # Public: Looks to see if Cancel button exists
-  #
-  # Returns true if Cancel button exists
-  def cancel_exist?
-  dut.element?({:name => 'Cancel'})
-  end
-  
-  # Public: Checks if at least one checkbox exists
-  #
-  # Returns true if at least one delete checkbox is found
-  def delete_checkboxes_exist?
-    dut.elements?({:name => 'rdvr checkBoxes justbox', :min => 1})
-  end
-  
-  # Public: Checks if 'Date Recorded' and 'A-Z' tabs exist
-  #
-  # Returns true if 'Date Recorded' and 'A-Z' tabs exist
-  def tabs_exist?
-    dut.element?({:name => 'Date Recorded'})
-  dut.element?({:name => 'A-Z'})
-  end
-  
-  # Public: Checks to see if deletion instructions exist
-  #
-  # Returns true if deletion instructions are found
-  def instructions_exist?
-    dut.element?({:name => 'Select one or more recordings to delete from your DVR'})
-  end
-  
-  # Public: Checks a delete box indicated by index number
-  #
-  # index - index number of episode to be checked
-  #
-  # Examples:
-  #   dut.screens.dvr.select_episode_index?(2)
-  #   # => 'True'
-  #
-  # Returns true if delete box was checked successfully
-  def select_episode_index?(index)
-    dut.tap?({:name => 'regexp:rdvr checkBoxes', :index => index})
-  end
-  
-  # Public: Checks to see if delete button exists
-  #
-  # Returns true if delete button exists
-  def delete_button_exists?
-    dut.element?({:name => 'regexp:Delete [0-9]+ recording'})
-  end
-  
-  # Public: Checks to see if the checkbox has changed to a dash after some, but not all, episodes in a series are selected
-  #
-  # Returns true if checkbox changes to a dash
-  def checkbox_dash_exists?
-    dut.element?({:name => 'rdvr checkBoxes minus'})
-  end
-  
-  # Public: Gets number of episodes from text
-  #
-  # Examples:
-  #   dut.screens.dvr.get_number_episodes
-  #   # => '4'
-  #
-  # Returns text from number of episodes
-  def get_number_episodes
-    dut.element({:name => 'regexp:[0-9] Episodes', :index => 1})[:name]
-  end
-  
-  # Public: Gets text displayed on delete button
-  #
-  # Examples:
-  #   dut.screens.dvr.get_delete_button_text
-  #   # => 'Delete'
-  #
-  # Returns text on delete button
-  def get_delete_button_text
-    dut.element({:name => 'regexp:Delete [0-9]+ recording'})[:name]
-  end
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_favorites.rb

@@ -1,79 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/favorites_mobile'
-
-# Defines iOS-specific methods on the Favorites screen
-
-class IosFavorites < IosScreen
-  include FavoritesMobile
-
-  # Public: Checks if favorites screen is displayed
-  #
-  # Returns true if the Favorites screen is displayed, otherwise false
-  def displayed?
-    dut.elements?({:name => 'HeartSmall', :min => 1})
-  end
-
-  # Public: Gets the callsign of the first channel that is not a favorite
-  #
-  # Examples:
-  #   dut.screens.favorites.get_non_favorite
-  #   # => 'WBTVDT'
-  #
-  # Returns the callsign of the first channel that is not a favorite
-  # This entry can and will return nil. You should absolutely always
-  # test for nil prior to using the result.
-  def get_non_favorite
-    callsigns = []
-    static_txts = get_cached_elements.select {|e| e[:type].eql?('UIAStaticText') && e[:is_visible] && e[:is_on_screen]}
-    (2..static_txts.count - 1).step(2) do |i|
-      callsigns << static_txts[i][:text]
-    end
-    favorite_roi = dut.roi.image.highlight
-    get_cached_elements.select {|e| e[:name].eql?('HeartSmall')}.each_with_index do |elem, i|
-      # Return the first one which is not highlighted
-      favorite_roi.x = elem[:x]
-      favorite_roi.y = elem[:y]
-      favorite_roi.width = elem[:width]
-      favorite_roi.height = elem[:height]
-      return callsigns[i] unless favorite_roi.displayed?(:timeout => 30.sec)
-    end
-    nil
-  end
-
-  # Public: Clicks on callsign to toggle a Favorite
-  #
-  # callsign - text next to channel number to click on 
-  #
-  # Examples:
-  #   dut.screens.favorites.toggle?("WBTVDT")
-  #   # => 'True'
-  #
-  # Returns true if successfully clicked the given callsign to toggle a favorite
-  def toggle?(callsign)
-    dut.tap?({:name => callsign, :is_visible => true, :is_on_screen => true})
-  end
-
-  # Public: Checks a given channel to see if it is favorite
-  #
-  # callsign - text next to channel to check
-  #
-  # Examples:
-  #   dut.screens.favorites.is_favorite?("WJZYDT")
-  #   # => 'True'
-  #
-  # Returns true if the channel given by callsign is a favorite, otherwise false
-  def is_favorite?(callsign)
-    static_txts = get_cached_elements.select do |e|
-      e[:type].eql?('UIAStaticText') && e[:is_visible] && e[:is_on_screen]
-    end.map {|e| e[:text]}
-    i = (static_txts.index(callsign) - 2) / 2
-    heart = dut.element(:name => 'HeartSmall', :index => i + 1)
-    favorite_roi = dut.roi.image.highlight
-    favorite_roi.x = heart[:x]
-    favorite_roi.y = heart[:y]
-    favorite_roi.width = heart[:width]
-    favorite_roi.height = heart[:height]
-    favorite_roi.displayed?(:timeout => 30.sec)
-  end
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_guide.rb

@@ -1,53 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/guide_mobile'
-
-# Defines iOS-specific methods on the Guide screen
-
-class IosGuide < IosScreen
-  include GuideMobile
-
-  # Public: Taps the button to select filter
-  #
-  # Returns true if button is tapped successfully
-  def go_to_filter?
-    dut.tap?({:name => 'Filter'})
-  end
-
-  # Public: Checks to see if given filter is present
-  #
-  # regex - string to look for
-  #
-  # Examples:
-  #   dut.screens.guide.is_filter_present?("Favorites")
-  #   # => 'True'
-  #
-  # Returns true if the filter given by the regex is present, otherwise falsese
-  def is_filter_present?(regex)
-    raise 'Failed to determine filters for iOS! Filter elements are not retrievable!'
-  end
-
-  # Returns a list of all currently visible shows by title, i.e. ["Dr. Phil", "Maury"]
-  def get_visible_titles(args = {})
-    raise 'Failed to get visible titles for iOS! Titles are not retrievable!'
-    #titles = until_not_empty(args) do
-    #  dut.find_elements({:type => 'show'}, $sleep_time).map {|c| c['text']}
-    #end
-    #loginfo2("Visible titles: #{titles.map {|t| %Q("#{t}")}.join(', ')}")
-    #titles
-  end
-
-  # Returns the element for the scroll area
-  def get_scroll_area
-    # TODO: could move get_cached_elements into TMC server as param to find_elements, etc.
-    elements = get_cached_elements.select {|e| e[:type].eql?('UIAScrollView')}
-    tcfail 'More than one scroll area!' unless elements.count == 1
-    elements.first
-  end
-
-  # Returns the currently-displayed date as a hash with keys [:day, :date, :time]
-  def get_date
-    static_texts = dut.elements({:type => 'UIAStaticText', :is_on_screen => true, :info => [:name]})
-    {:day => static_texts[0], :date => static_texts[1], :time => static_texts[2]}
-  end
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_live_tv.rb

@@ -1,413 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/live_tv_mobile'
-
-# Defines iOS-specific methods on the Live TV screen
-
-class IosLiveTv < IosScreen
-  include LiveTvMobile
-
-  # Returns true if the mini guide is visible, otherwise false
-  def mini_guide_visible?
-    dut.element?(:name => 'channelTable', :many_elements => true)
-  end
-
-  # Returns a list of all currently visible channels' elements
-  def get_visible_channel_titles(args={})
-    elements = args.fetch(:elements, false)
-    timeout = args.fetch(:timeout, 3.min)
-    area = scroll_area
-    chans = until_not_empty(:timeout => timeout) do
-      ret = dut.elements({:type => 'UIATableCell', :name => 'regexp:.+', :is_visible => true, :is_on_screen => true,
-                          :min => 1, :timeout => timeout}) || []
-      ret = ret.select { |e| e[:y] < (area[:y] + area[:height]) }
-      ret = ret.map { |e| e[:name] } unless elements
-      ret
-    end
-    logger.info("Visible channel titles: #{(elements ? chans.map {|e| e[:name]} : chans).inspect}")
-    chans
-  end
-
-  # Returns a list of all currently visible channel numbers' elements
-  def get_visible_channel_numbers(args={})
-    elements = args.fetch(:elements, false)
-    timeout = args.fetch(:timeout, 3.min)
-    area = scroll_area
-    chans = until_not_empty(:timeout => timeout) do
-      ret = get_cached_elements(:refresh => true).select do |e|
-        e[:type].eql?('UIAStaticText') && e[:is_on_screen] && e[:is_visible] && !e[:name].match(/^Ch \d+$/).nil?
-      end
-      ret = ret.select { |e| e[:y] < (area[:y] + area[:height]) }
-      ret = ret.map {|e| e[:name]} unless elements
-      ret.uniq
-    end
-    logger.info("Visible channel numbers: #{(elements ? chans.map {|e| e[:name]} : chans).inspect}")
-    chans
-  end
-
-  # Attempts to "watch" n channels by just clicking on them. Returns a list of the watched channel numbers if
-  # successful, otherwise fails the test.
-  def watch_channels(n, args={})
-    watched = args.fetch(:already_watched, [])
-    timeout_s = args.fetch(:timeout, 600.sec) / 1.sec
-    area = scroll_area
-    start_time = Time.now
-    while (Time.now - start_time) <= timeout_s
-      # Watch all the visible channels
-      visible_chans = get_visible_channel_numbers(:elements => true)
-      visible_chans.each do |chan|
-        chan_num = chan[:name]
-        next if watched.include?(chan_num)  # no need to watch the same channel twice
-        y_pct = chan == visible_chans.first ? 0.99 : 0.01
-        tcfail "Failed to tap #{chan_num}!" unless dut.tap?({:name => chan_num, :type => 'UIAStaticText',
-                                                             :is_visible => true, :is_on_screen => true, :index => 1,
-                                                             :y => y_pct})
-        enter_pin_once
-        dismiss_hint_once
-        watched << chan_num
-        break if watched.count == n
-      end
-      break if watched.count == n
-      tcfail 'Failed to scroll down!' unless dut.screens.live_tv.scroll_down?(1, :area => area)
-    end
-    tcfail "Failed to watch #{n} channels!" unless watched.count == n
-    watched
-  end
-
-  # Returns a list of the elements for the Recently Watched channels
-  def get_all_recently_watched
-    dut.elements({:type => 'UIACollectionCell', :name => 'regexp:^(?!clear_recents_showcard)'}) || []
-  end
-
-  def select_recently_watched?(n, args={})
-    timeout = args.fetch(:timeout, 30.sec)
-    dut.tap?({:type => 'UIACollectionCell', :name => 'regexp:^(?!clear_recents_showcard)', :index => n,
-              :timeout => timeout})
-  end
-
-  # Returns true if successfully tapped the playing Live TV video content, otherwise false
-  def tap_video?
-    if dut.element?({:name => 'This show is blocked by Parental Controls', :is_visible => true, :many_elements => true})
-      tcfail 'Failed to tap highlighted channel!' unless dut.tap?(
-          {:name => get_highlighted_channel[:title], :type => 'UIATableCell', :many_elements => true})
-      tcfail 'Failed to enter PIN!' unless enter_pin?
-      sleep(5.sec)  # Give it some time, otherwise we start looking right away and it takes longer...
-    end
-    #TODO: on the tablet, the UIAScrollView is the whole screen, even if video isn't.
-    dut.tap?({:type => 'UIAScrollView', :timeout => 2.min, :index => 1})
-  end
-
-  # Returns true if video is playing, otherwise false
-  def video_playing?(args={})
-    if dut.element?({:name => 'This show is blocked by Parental Controls', :is_visible => true, :timeout => 2.min})
-      tcfail 'Failed to tap highlighted channel!' unless dut.tap?(
-          {:name => get_highlighted_channel[:title], :type => 'UIATableCell'})
-      tcfail 'Failed to enter PIN!' unless enter_pin?
-      sleep(5.sec)  # Give it some time, otherwise we start looking right away and it takes longer...
-    end
-    area = args[:area] || video_area
-    dut.roi.video.new(:element => area, :threshold => 10).displayed?(args)
-  end
-
-  # Returns true if the video is fullscreen, otherwise false
-  def fullscreen?
-    logger.info('Checking if video is full-screen')
-    exp_res = dut.resolution.values.sort
-    video_res = get_video_size.values.sort
-    new_video_res = nil
-    until new_video_res == video_res
-      new_video_res = get_video_size.values.sort
-    end
-    logger.info("Expected resolution: #{exp_res.join('x')}")
-    logger.info("Video resolution: #{video_res.join('x')}")
-    video_res == exp_res
-  end
-
-  # Returns the element for the scroll area
-  def scroll_area
-    area = dut.element({:name => 'channelTable'})
-    tcfail 'Failed to get scroll area!' if area.nil?
-    # Reduce height to account for navigation menu
-    nav = dut.element({:type => 'UIATabBar'})
-    area[:height] -= nav[:height] unless nav.nil?
-    area
-  end
-
-  # Returns true if the navigation menu is visible, otherwise false
-  def navigation_menu_visible?
-    buttons = dut.elements({:type => 'UIAButton', :is_on_screen => true, :is_visible => true, :info => [:name]})
-    ['Live', 'Guide', 'DVR Manager', 'On Demand', 'Settings'].each do |opt|
-      unless buttons.count(opt) == 1
-        return false
-      end
-    end
-    true
-  end
-
-  # Returns true if successfully chose to open filters, otherwise false
-  def open_filters?
-    dut.tap?({:name => 'live2 filter icon', :many_elements => true})
-  end
-
-  # Returns true if successfully chose to sort by title, otherwise false
-  def sort_by_title?
-    sort_by?('Show Title A - Z')
-  end
-
-  # Returns true if successfully chose to sort by channel number, otherwise false
-  def sort_by_channel_number?
-    sort_by?('Channel Number')
-  end
-
-  # Returns true if successfully chose to sort by network, otherwise false
-  def sort_by_netowrk?
-    sort_by?('Network A - Z')
-  end
-
-  def sort_by?(sort)
-    logger.info("Sorting by #{sort.inspect}")
-    filter_by?(sort)
-  end
-
-  # Returns true if successfully chose the given filter, otherwise false
-  def filter_by?(filter)
-    logger.info("Filtering by #{filter.inspect}")
-    if open_filters?
-      sleep(5.sec)  # give some time for the filters to show up
-      elements = dut.elements
-      visible_filters = elements.select do |e|
-        e[:type].eql?('UIATableCell') && e[:is_on_screen] && e[:is_visible]
-      end.map { |f| f[:name].strip }
-      logger.info("Visible filters: #{visible_filters.inspect}")
-      navbar = elements.select { |e| e[:type].eql?('UIATabBar') }.first
-      area = elements.select { |e| e[:name].eql?('channelTable') }.first
-      area[:height] -= navbar[:height]
-      scroll_dir = :down
-      last_filters = nil
-      start_time = Time.now
-      while (Time.now - start_time) <= 600  # 10 minutes
-        logger.info('Locating filter')
-        if visible_filters.include?(filter)
-          return false unless dut.tap?({:name => "regexp:#{filter}", :index => 1, :timeout => 0.sec}, :sleep_time => 2.sec)
-          return true
-        end
-        if visible_filters == last_filters
-          scroll_dir = scroll_dir.eql?(:down) ? :up : :down
-        end
-        last_filters = visible_filters
-        scroll?(scroll_dir, 1, :area => area, :sleep_time => 500.ms)
-        visible_filters = dut.elements(
-            {:type => 'UIATableCell', :is_on_screen => true, :is_visible => true, :info => [:name]})
-      end
-      logger.info('Failed to locate filter')
-    end
-    false
-  end
-
-  # Returns a hash with keys :width and :height for the video content
-  def get_video_size
-    # TODO: Rest server should round to the nearest 1/scaleFactor
-    #TODO: on the tablet, the UIAScrollView is the whole screen, even if video isn't.
-    area = dut.element({:type => 'UIAScrollView', :index => 1, :timeout => 2.min})
-    {:width => area[:width].round, :height => area[:height].round}
-  end
-
-  # Returns the element for the video area
-  def video_area
-    #TODO: on the tablet, the UIAScrollView is the whole screen, even if video isn't.
-    area = dut.element({:type => 'UIAScrollView', :index => 1, :timeout => 2.min})
-    # Bound it to the screen resolution if needed
-    res = dut.resolution
-    [[:x, :width], [:y, :height]].each do |coord, dimension|
-      if (area[coord] + area[dimension]) > res[dimension]
-        area[dimension] -= area[coord]
-      end
-    end
-    area
-  end
-
-  # Verifies Recently Watched channels contains the given channels and that it behaves as a FIFO. Fails the test if
-  # unsuccessful.
-  def verify_recently_watched(channels)
-    logger.info("Verifying Recently Watched contains: #{channels.inspect}")
-    recently_watched = get_all_recently_watched
-    tcfail("Found #{recently_watched.count} Recently Watched!") unless recently_watched.count == 8
-    # Verify required channels are in "Recently Watched"
-    area = video_area
-    last = channels.count
-    while channels.count > 0
-      # Swipe right until we can select the "oldest" recently watched channel
-      until select_recently_watched?(last, :timeout => 0.sec)
-        tcfail('Failed to scroll right!') unless dut.screens.live_tv.scroll_left?(1, :area => area)
-        sleep(5.sec)
-      end
-      # Verify the highlighted channel number matches the expected one
-      highlighted = get_highlighted_channel
-      matches = highlighted[:number].eql?(channels.first)
-      matches_str = matches ? 'matches' : 'does not match'
-      logger.info("Highlighted channel (#{highlighted[:number]}) #{matches_str} expected channel (#{channels.first})")
-      tcfail('Recently Watched verification failed!') unless matches
-      channels.shift
-    end
-  end
-
-  # Returns a hash with keys :name and :number for the highlighted channel
-  def get_highlighted_channel(args={})
-    logger.info('Getting highlighted channel')
-    sleep 15.sec
-    chan_names = until_not_empty(:timeout => 3.min) do
-      get_visible_channel_titles
-    end
-    timeout = args.fetch(:timeout, 5.min)
-    start_time = Time.now
-    while (Time.now - start_time) <= (timeout / 1.sec)
-      chan_names.each do |chan_name|
-        # There are 2 if this is the highlighted one. Pick the one that is inside the table cell of the same name.
-        cell = dut.elements({:name => chan_name, :type => 'UIATableCell'}).first
-        if (cell.nil?)
-          tcfail "Was not able to get a UIATableCell in ios_live_tv.rb function get_highlighted_channel"
-        end
-        right = cell[:x] + cell[:width]
-        bottom = cell[:y] + cell[:height]
-        logger.info("Looking for channel title")
-        chan_title = until_not_nil(:timeout => 3.min) do
-          logger.info("Looking for an element with a name of #{chan_name}")
-          chan_titles = dut.elements({:name => chan_name, :type => 'UIAStaticText', :timeout => 30.sec})
-          chan_titles.select { |c| c[:x] > cell[:x] && c[:x] < right && c[:y] > cell[:y] && c[:y] < bottom }.first
-        end
-        if (chan_title.nil?)
-          tcfail "Unable to locate channel title"
-        end
-        logger.info("Checking if #{chan_name.inspect} is highlighted")
-        highlight = dut.roi.color.new(:rgb => [27, 176, 223], :element => chan_title)
-        if highlight.displayed?(:timeout => 30.sec)
-          logger.info('Found highlighted channel title')
-          dut.elements({:name => 'regexp:^Ch \d+$', :type => 'UIAStaticText'}).each do |e|
-            logger.info("Checking if channel number #{e[:name].inspect} is highlighted")
-            highlight = dut.roi.color.new(:rgb => [27, 176, 223], :element => e)
-            if highlight.displayed?(:timeout => 30.sec)
-              logger.info('Found highlighted channel number')
-              highlight_number = e[:name]
-              logger.info("Highlighted: #{chan_name} (#{highlight_number})")
-              return {:title => chan_name, :number => highlight_number}
-            end
-          end
-        end
-      end
-    end
-    {}
-  end
-
-  def select_channel_ending_within(ms)
-    logger.info("Selecting channel ending within #{ms} ms (#{ms.to_f / 1.min} min)")
-    mins = (ms.to_f / 1000) / 60
-    start_time = Time.now
-    while (Time.now - start_time) <= 1800  # 30 minutes
-      elements = get_cached_elements(:refresh => true)
-      assets = elements.select {|e| e[:type].eql?('UIATableCell')}
-      next if assets.count == 0
-      titles = assets.map {|a| a[:name]}
-      showtimes = elements.select {|e| e[:name] =~ /^(\d+:\d+[AP]M - \d+:\d+[AP]M|On Next:.*)$/}
-      tcfail 'Failed to map titles to showtimes!' unless titles.count == showtimes.count
-      # Calculate timezone adjustment
-      local_time = Time.now.getlocal
-      edt_offset = -4.hr
-      est_offset = -5.hr
-      tz_target = local_time.dst? ? edt_offset : est_offset
-      tz_adj_hr = (tz_target - local_utc_offset) / 1.hr
-      logger.info("Adjustment for local timezone #{local_time.zone}: #{tz_adj_hr} hr")
-      all_titles = []
-      # Find a show ending within the time limit.
-      showtimes.each_with_index do |showtime, i|
-        next if showtime[:name].include?('On Next')
-        end_time = showtime[:name].split('-').last.strip
-        is_pm = end_time.match(/(?i)AM/).nil?
-        end_parts = end_time.split(':')
-        end_hr = end_parts.first.to_i
-        # Convert to 24-hr format
-        if is_pm
-          end_hr += 12 unless end_hr == 12
-        elsif end_hr == 12
-          end_hr = 0
-        end
-        end_min = end_parts.last.match(/\d+/).to_s.to_i
-        d_hr = end_hr - (local_time.hour + tz_adj_hr)
-        d_min = end_min - local_time.min
-        d_sec = 0 - local_time.sec
-        if d_hr < 0
-          # End time is tomorrow
-          d_hr += 24
-        end
-        d_total_min = ((d_hr * 60) + d_min + (d_sec / 60)).round
-        title = titles[i]
-        all_titles << title
-        logger.info("Calculated #{d_total_min} minutes to end of showtime for #{title.inspect}: #{showtime[:name]}")
-        if d_total_min < mins
-          # Now scroll to the title if necessary and tap on it
-          scroll_area = elements.select {|e| e[:name].eql?('channelTable')}.first
-          scroll_start_time = Time.now
-          while (Time.now - scroll_start_time) <= (d_total_min * 60)
-            target = dut.element({:name => title, :type => 'UIATableCell', :index => all_titles.count(title),
-                                  :many_elements => true, :info => [:x, :y, :width, :height, :is_on_screen]})
-            if target[:is_on_screen]
-              tap_x = target[:x] + (target[:width] * 0.5)
-              tap_y = target[:y] + (target[:height] * 0.5)
-              if dut.tap?({:x => tap_x, :y => tap_y, :coordinates => true})
-                enter_pin_once
-                dismiss_hint_once
-                return title, showtime[:name]
-              else
-                logger.info('Failed to tap title')
-              end
-            else
-              scroll_dir = target[:y] > dut.resolution[:height] ? :down : :up
-              tcfail 'Failed to scroll!' unless scroll?(scroll_dir, 1, :area => scroll_area)
-            end
-          end
-          # That show ended while we were trying to scroll to it, but we have time to try a different one
-          logger.info('Timed out searching for title. Trying again...')
-        end
-      end
-    end
-    tcfail "Failed to find a channel ending within #{ms / 1.min} minutes!"
-  end
-
-  # Returns true if successfully selected the channel given by title, otherwise false
-  def select_channel_title?(title)
-    dut.tap?({:name => title, :type => 'UIATableCell', :many_elements => true})
-  end
-
-  def get_showtime_for_channel(channel_title)
-    loginfo2(%Q(Getting showtime for channel title "#{channel_title}"))
-    elements = get_cached_elements(:refresh => true)
-    assets = elements.select {|e| e[:type].eql?('UIATableCell')}
-    showtimes = elements.select {|e| e[:name] =~ /^(\d+:\d+[AP]M - \d+:\d+[AP]M|On Next:.*)$/}
-    tcfail 'Failed to map titles to showtimes!' unless assets.count == showtimes.count
-    i = assets.index {|a| a[:name].eql?(channel_title)}
-    tcfail %Q(Failed to find channel playing "#{channel_title}"!) if i.nil?
-    showtime = showtimes[i]
-    tcfail 'Failed to get showtime!' if showtime.nil?
-    loginfo2("Got showtime: #{showtime[:name]}")
-    showtime[:name]
-  end
-
-  # Returns true if the given channel title is visible, otherwise false
-  def channel_title_visible?(channel_title)
-    dut.element?({:name => channel_title, :type => 'UIATableCell', :is_on_screen => true, :is_visible => true})
-  end
-
-  def is_hint?
-    sleep(10.sec)  # Give the hint time to show up
-    dut.element?({:name => 'Hint', :is_visible => true, :many_elements => true, :timeout => 0.sec})
-  end
-
-  def dismiss_hint?
-    if dut.tap?({:name => 'Hint', :is_visible => true, :many_elements => true})
-      self.dismissed_hint=(true)
-      loginfo2('Dismissed hint')
-      true
-    else
-      false
-    end
-  end
-
-end