rautomation 2.0.1-x64-mingw32

data/lib/rautomation/window.rb

@@ -0,0 +1,248 @@
+module RAutomation
+  class UnknownElementException < RuntimeError
+  end
+  class UnknownWindowException < UnknownElementException
+  end
+  class UnknownButtonException < UnknownElementException
+  end
+  class UnknownTextFieldException < UnknownElementException
+  end
+  class UnsupportedAdapterException < RuntimeError
+  end
+
+  class Window
+    include Adapter::Helper
+    extend ElementCollections
+
+    has_many :windows, :buttons, :text_fields
+
+    class << self
+      # @param locators (see #initialize)
+      # @return [Windows] all windows. 
+      def windows(locators = {})
+        Windows.new(nil, locators)
+      end
+    end
+
+    # Retrieves all windows with similar locators to the current window.
+    # @param locators (see #initialize) 
+    # @return [Windows] all windows matching current window's _locators_ if no
+    #   explicit locators specified or windows matching the specified _locators_.
+    def windows(locators = @window.locators)
+      Windows.new(nil, locators)
+    end
+
+    # Currently used {Adapter}.
+    attr_reader :adapter
+
+    # Creates the window object.
+    #
+    # Possible window _locators_ may depend of the used platform and adapter, but
+    # following examples will use :title, :class and :hwnd.
+    #
+    # @example Use window with some title:
+    #   RAutomation::Window.new(:title => "some title")
+    #
+    # @example Use window with Regexp title:
+    #   RAutomation::Window.new(:title => /some title/i)
+    #
+    # @example Use window with handle (hwnd):
+    #   RAutomation::Window.new(:hwnd => 123456)
+    #
+    # @example Use multiple locators, every locator will be matched (AND-ed) to the window:
+    #   RAutomation::Window.new(:title => "some title", :class => "IEFrame")
+    #
+    # @note Refer to all possible _locators_ in each {Adapter} documentation.
+    #
+    # _locators_ may also include a key called :adapter to change default adapter,
+    # which is dependent of the platform, to automate windows and their controls.
+    #
+    # It is also possible to change the default adapter by using environment variable called
+    # __RAUTOMATION_ADAPTER__
+    #
+    # @note This constructor doesn't check for window's existance.
+    # @note Only visible windows are supported.
+    # @note If given _locators_ include :hwnd then every other possible _locator_ is ignored.
+    # @param [Hash] locators locators for the window.
+    def initialize(locators)
+      @adapter = locators.delete(:adapter) || ENV["RAUTOMATION_ADAPTER"] && ENV["RAUTOMATION_ADAPTER"].to_sym || default_adapter
+      unless Adapter::Helper.supported_for_current_platform?(@adapter)
+        raise UnsupportedAdapterException, "RAutomation #{@adapter} adapter is only supported on a 32bit Ruby - please use either :win32 adapter or 32bit Ruby."
+      end
+
+      @window = Adapter.const_get(normalize(@adapter)).const_get(:Window).new(self, locators)
+    end
+
+    class << self
+      # Timeout for waiting until object exists. If the timeout exceeds then an {WaitHelper::TimeoutError} is raised.
+      @@wait_timeout = 60
+
+      # Change the timeout to wait before {WaitHelper::TimeoutError} is raised.
+      # @param [Integer] timeout in seconds.
+      def wait_timeout=(timeout)
+        @@wait_timeout = timeout
+      end
+
+      # Retrieve current timeout in seconds to wait before {WaitHelper::TimeoutError} is raised.
+      # @return [Integer] timeout in seconds
+      def wait_timeout
+        @@wait_timeout
+      end
+
+    end
+
+    # @return [Integer] handle of the window which is used internally for other methods.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def hwnd
+      wait_until_present
+      @window.hwnd
+    end
+
+    # @return [Integer] process identifier (PID) of the window.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def pid
+      wait_until_present
+      @window.pid
+    end
+
+    # @return [String] title of the window.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def title
+      wait_until_present
+      @window.title
+    end
+
+    # @return [Array<String>] all {Window} class names in a sorted array.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def class_names
+      wait_until_present
+      @window.class_names
+    end
+
+    # Activates the Window, e.g. brings it to the top of other windows.
+    def activate
+      @window.activate
+    end
+
+    # Checks if the window is active, e.g. on the top of other windows.
+    # @return [Boolean] true if the window is active, false otherwise.
+    def active?
+      @window.active?
+    end
+
+    # Returns visible text of the Window.
+    # @return [String] visible text of the window.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def text
+      wait_until_present
+      @window.text
+    end
+
+    # Checks if the window exists (does have to be visible).
+    # @return [Boolean] true if the window exists, false otherwise.
+    def exists?
+      @window.exists?
+    end
+
+    alias_method :exist?, :exists?
+
+    # Checks if window is visible.
+    # @note Window is also visible, if it is behind other windows or minimized.
+    # @return [Boolean] true if window is visible, false otherwise.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def visible?
+      wait_until_exists
+      @window.visible?
+    end
+
+    # Checks if the window exists and is visible.
+    # @return [Boolean] true if window exists and is visible, false otherwise
+    def present?
+      exists? && visible?
+    end
+
+    # Maximizes the window.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def maximize
+      wait_until_present
+      @window.maximize
+    end
+
+    # Minimizes the window.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def minimize
+      wait_until_present
+      @window.minimize
+    end
+
+    # Checks if window is minimized.
+    # @return [Boolean] true if window is minimized, false otherwise.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def minimized?
+      wait_until_present
+      @window.minimized?
+    end
+
+    # Restores the window size and position.
+    # @note If the window is minimized, makes it visible again.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def restore
+      wait_until_present
+      @window.restore
+    end
+
+    # Sends keyboard keys to the window. Refer to specific {Adapter} documentation for all possible values.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def send_keys(*keys)
+      wait_until_present
+      @window.send_keys(keys)
+    end
+
+    # Closes the window if it exists.
+    def close
+      return unless @window.exists?
+      @window.close
+    end
+
+    # Retrieves {Button} on the window.
+    # @note Refer to specific {Adapter} documentation for possible _locator_ parameters.
+    # @param [Hash] locators for the {Button}.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def button(locators={})
+      wait_until_present
+      Button.new(@window, locators)
+    end
+
+    # Retrieves {TextField} on the window.
+    # @note Refer to specific {Adapter} documentation for possible _locators_ parameters.
+    # @raise [UnknownWindowException] if the window doesn't exist.
+    def text_field(locators={})
+      wait_until_present
+      TextField.new(@window, locators)
+    end
+
+    # Allows to execute specific {Adapter} methods not part of the public API.
+    def method_missing(name, *args)
+      @window.send(name, *args)
+    end
+
+    def wait_until_present
+      WaitHelper.wait_until {present?}
+    rescue WaitHelper::TimeoutError
+      raise UnknownWindowException, "Window with locator #{@window.locators.inspect} doesn't exist or is not visible!"
+    end
+
+    def wait_until_exists
+      WaitHelper.wait_until {exists?}
+    rescue WaitHelper::TimeoutError
+      raise UnknownWindowException, "Window with locator #{@window.locators.inspect} doesn't exist!"
+    end
+
+    private
+
+    def normalize adapter
+      adapter.to_s.split("_").map {|word| word.capitalize}.join
+    end
+
+  end
+end

data/lib/rautomation.rb

@@ -0,0 +1,8 @@
+require "rautomation/platform"
+require "rautomation/wait_helper"
+require "rautomation/adapter/helper"
+require "rautomation/button"
+require "rautomation/text_field"
+require "rautomation/element_collections"
+require "rautomation/window"
+require "rautomation/version"

data/rautomation.gemspec

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rautomation/adapter/helper', __FILE__)
+require File.expand_path('../lib/rautomation/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = %q{rautomation}
+  s.version = RAutomation::VERSION
+  s.authors = [%q{Jarmo Pertman}]
+  s.email = %q{jarmo.p@gmail.com}
+  s.description = %q{RAutomation is a small and easy to use library for helping out to automate windows and their controls
+for automated testing.
+
+RAutomation provides:
+* Easy to use and user-friendly API (inspired by Watir http://www.watir.com)
+* Cross-platform compatibility
+* Easy extensibility - with small scripting effort it's possible to add support for not yet
+  supported platforms or technologies}
+  s.homepage = %q{http://github.com/jarmo/RAutomation}
+  s.summary = %q{Automate windows and their controls through user-friendly API with Ruby}
+  s.license = "MIT"
+  s.platform = Gem::Platform.local if s.platform == 'ruby'
+
+  ext_locations = [
+          "ext/IAccessibleDLL/Release/IAccessibleDLL.dll",
+          "ext/UiaDll/Release/UiaDll.dll",
+          "ext/UiaDll/Release/RAutomation.UIA.dll"
+  ]
+
+  winforms_files = Dir[
+          "ext/WindowsForms/Release/*.dll",
+          "ext/WindowsForms/Release/*.exe"
+  ]
+
+  RAutomation::Adapter::Helper.find_missing_externals(ext_locations).each do |ext|
+    RAutomation::Adapter::Helper.build_solution(ext)
+  end
+
+  # move .dll files and get array containing paths
+  # send first three externals and first three characters from platform eg 'x86' from 'x86-mingw32'
+  externals = RAutomation::Adapter::Helper.move_adapter_dlls(ext_locations[0, 3], s.platform.to_s[0, 3])
+
+  s.files         = `git ls-files`.split("\n") + externals + winforms_files
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency("ffi", "~> 1.15.0")
+  s.add_development_dependency("rspec", "~> 3.9")
+  s.add_development_dependency("rake", "~> 10.5")
+  s.add_development_dependency("yard", "~> 0.9")
+  s.add_development_dependency("redcarpet", "~> 3.5")
+  s.add_development_dependency("github-markup", "~> 3.0")
+end

data/spec/adapter/autoit/mouse_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe "AutoIt::Mouse", :if => SpecHelper.adapter == :autoit do
+
+  it "#click" do
+    window = RAutomation::Window.new(:title => "MainFormWindow")
+
+    popup = RAutomation::Window.new(:title => "About")
+    popup.should_not be_present
+
+    window.maximize
+    mouse = window.mouse
+    mouse.move :x => 60, :y => 65
+    mouse.click
+
+    RAutomation::WaitHelper.wait_until {popup.present?}
+  end
+
+  it "#position" do
+    window = RAutomation::Window.new(:title => "MainFormWindow")
+    mouse = window.mouse
+
+    mouse.move :x => 13, :y => 16
+    mouse.position.should == {:x => 13, :y => 16}
+  end
+
+  it "#press/#release" do
+    window = RAutomation::Window.new(:title => "MainFormWindow")
+    window.maximize
+
+    text_field = window.text_field(:index => 2)
+    text_field.set("start string")
+    text_field.value.should == "start string"
+
+    mouse = window.mouse
+    mouse.move :x => 146, :y => 125
+    mouse.press
+    mouse.move :x => 194
+    mouse.release
+    window.send_keys "^c"
+
+    text_field.set("new string")
+    text_field.value.should == "new string"
+
+    mouse.move :x => 146
+    mouse.press
+    mouse.move :x => 194
+    mouse.release
+    window.send_keys "^v"
+
+    text_field.value.should == "start string"
+  end
+end

data/spec/adapter/autoit/window_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "AutoIt::Window", :if => SpecHelper.adapter == :autoit do
+  it "#method_missing" do
+    window = RAutomation::Window.new(:title => "MainFormWindow")
+
+    window.MouseMove(1, 1)
+    position = [window.MouseGetPosX, window.MouseGetPosY]
+    position.should_not == [100, 100]
+
+    window.MouseMove(100, 100)
+    position = [window.MouseGetPosX, window.MouseGetPosY]
+
+    position.should == [100, 100]
+  end
+end
+

data/spec/adapter/ms_uia/button_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "MsUia::Button", if: SpecHelper.adapter == :ms_uia do
+  let(:window) { RAutomation::Window.new(title: SpecHelper::DATA[:window1_title]) }
+  it "find by id" do
+    expect(window.button(id: "aboutButton").exist?).to be true
+  end
+
+  it "check for button class" do
+    expect(window.button(id: "textField").exist?).to_not be true
+  end
+
+
+  it "enabled/disabled" do
+    expect(window.button(id: "enabledButton").enabled?).to be true
+    expect(window.button(id: "enabledButton").disabled?).to_not be be true
+
+    expect(window.button(id: "disabledButton").disabled?).to be true
+    expect(window.button(id: "disabledButton").enabled?).to_not be true
+  end
+
+  it "#focus" do
+    button = window.button(id: "enabledButton")
+    expect(button.focused?).to_not be true
+
+    button.focus
+    expect(button.focused?).to be true
+  end
+
+  it "cannot click disabled button" do
+    expect { window.button(id: "disabledButton").click }.to raise_error(RuntimeError)
+  end
+
+  it "cannot set focus to disabled button" do
+    window = RAutomation::Window.new(title: SpecHelper::DATA[:window1_title])
+    expect { window.button(id: "disabledButton").focus }.to raise_error(RuntimeError)
+  end
+
+end

data/spec/adapter/ms_uia/checkbox_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "MsUia::Checkbox", if: SpecHelper.adapter == :ms_uia do
+  let(:window) { RAutomation::Window.new(title: "MainFormWindow") }
+  it "#checkbox" do
+    expect(window.checkbox(value: "checkBox").exist?).to be true
+
+    RAutomation::Window.wait_timeout = 0.1
+    expect { RAutomation::Window.new(title: "non-existing-window").checkbox(value: "Something") }.
+        to raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "check for checkbox class" do
+    expect(window.checkbox(id: "textField").exist?).to_not be true
+    expect(window.checkbox(id: "checkBox").exist?).to be true
+  end
+
+
+  it "#set? & #set" do
+    checkbox = window.checkbox(value: "checkBox")
+    expect(checkbox.set?).to_not be true
+
+    checkbox.set
+    expect(checkbox.set?).to be true
+  end
+
+  it "#value" do
+    checkbox = window.checkbox(id: "checkBox")
+    expect(checkbox.value).to be == "checkBox"
+  end
+
+  it "#clear" do
+    checkbox = window.checkbox(value: "checkBox")
+    checkbox.set
+    expect(checkbox.set?).to be true
+
+    checkbox.clear
+    expect(checkbox.set?).to_not be true
+  end
+
+  it "enabled/disabled" do
+    expect(window.checkbox(id: "checkBox").enabled?).to be true
+    expect(window.checkbox(id: "checkBox").disabled?).to_not be true
+
+    expect(window.checkbox(id: "checkBoxDisabled").enabled?).to_not be true
+    expect(window.checkbox(id: "checkBoxDisabled").disabled?).to be true
+  end
+
+  it "cannot check a disabled checkbox" do
+    expect {
+      window.checkbox(id: "checkBoxDisabled").set
+    }.to raise_error(RuntimeError)
+  end
+
+end

data/spec/adapter/ms_uia/control_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe "MsUia::Control", if: SpecHelper.adapter == :ms_uia do
+  let(:window) { RAutomation::Window.new(title: /MainFormWindow/i) }
+
+  context '#click' do
+    it 'stops trying after the window goes away' do
+      window.button(value: 'About').click { true }
+
+      RAutomation::Window.new(title: 'About').button(id: 'button1').click
+    end
+  end
+
+  it "control coordinates", special: false do
+    window.maximize
+    control = window.control(id: "radioButtonReset")
+    expect(control.bounding_rectangle).to be_all {|coord| coord.between?(200, 400)}
+  end
+
+   it "control process id", special: true do
+    control = window.control(id: "radioButtonReset")
+    expect(control.new_pid).to be == @pid1
+   end
+
+  it "has a class" do
+    control = window.control(id: "radioButtonReset")
+    expect(control.control_class).to be =~ /WindowsForms10.BUTTON.*/
+  end
+
+  it "can get tooltip information" do
+    control = window.button(value: 'Reset')
+    expect(control.help_text).to eq 'Some help text'
+  end
+
+  it "can limit the search depth" do
+    window.button(id: 'buttonDataGridView').click { true }
+    data_grid_window = RAutomation::Window.new(title: /DataGridView/i)
+
+    start = Time.new
+    data_grid_window.button(id: 'buttonClose', children_only: true).exist?
+    elapsed_time = Time.new - start
+    expect(elapsed_time).to be < 2
+  end
+
+  context RAutomation::Adapter::MsUia::UiaDll::SearchCriteria, pure_unit: true do
+    let(:window) { double('RAutomation Window').as_null_object }
+    let(:locator) { {id: 'someId'} }
+    let(:control) { RAutomation::Adapter::MsUia::Control.new(window, locator) }
+    let(:old_style_control) { RAutomation::Adapter::MsUia::Control.new(window, class: 'someClass') }
+    let(:expect_a_handle) { expect(RAutomation::Adapter::MsUia::UiaDll).to receive(:cached_hwnd).once.and_return(456) }
+    let(:expect_no_handle) { expect(RAutomation::Adapter::MsUia::UiaDll).to receive(:cached_hwnd).once.and_return(0) }
+    subject { control.search_information }
+
+    before(:each) do
+      expect(window).to receive(:hwnd).at_least(:once).and_return(123)
+      allow(RAutomation::Adapter::MsUia::Functions).to receive(:control_hwnd)
+    end
+
+    it "uses the cached window handle if it has one" do
+      expect_a_handle
+      expect(subject.how).to eq(:hwnd)
+      expect(subject.data).to eq(456)
+    end
+
+    it "only asks for the window handle once" do
+      expect_a_handle
+      2.times { control.search_information }
+    end
+
+    it "uses the locator specified when no window handle is present" do
+      expect_no_handle
+      expect(subject.how).to eq(:id)
+      expect(subject.data).to eq('someId')
+    end
+
+    it "tries the old way of locating the window handle if no UIA locator is provided" do
+      expect_no_handle
+      expect(RAutomation::Adapter::MsUia::Functions).to receive(:control_hwnd)
+                                                                .with(window.hwnd, index: 0, class: 'someClass')
+                                                                .and_return(789)
+      old_info = old_style_control.search_information
+      expect(old_info.how).to eq(:hwnd)
+      expect(old_info.data).to eq(789)
+    end
+
+  end
+
+end

data/spec/adapter/ms_uia/functions_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "MsUia::Functions", if: SpecHelper.adapter == :ms_uia do
+  context "working with expandable / collapsable items" do
+    let(:tree_view) { RAutomation::Window.new(title: "MainFormWindow").select_list(id: "treeView") }
+
+    def options
+      tree_view.options.map(&:text)
+    end
+
+    it "can be expanded by value" do
+      expect(options).to eq(["Parent One", "Parent Two"])
+      tree_view.expand "Parent One"
+      expect(options).to eq(["Parent One", "Child 1", "Child 2", "Parent Two"])
+    end
+
+    it "can be expanded by index" do
+      expect(options).to eq(["Parent One", "Parent Two"])
+      tree_view.expand(0)
+      tree_view.expand(2)
+      expect(options).to eq(["Parent One", "Child 1", "Child 2", "Grandchild 1", "Parent Two"])
+    end
+
+    it "can be collapsed by value" do
+      tree_view.expand("Parent One")
+      expect(options).to eq(["Parent One", "Child 1", "Child 2", "Parent Two"])
+      tree_view.collapse "Parent One"
+      expect(options).to eq(["Parent One", "Parent Two"])
+    end
+
+    it "can be collapsed by index" do
+      tree_view.expand(0)
+      expect(options).to eq(["Parent One", "Child 1", "Child 2", "Parent Two"])
+      tree_view.collapse(0)
+      expect(options).to eq(["Parent One", "Parent Two"])
+    end
+  end
+
+end

data/spec/adapter/ms_uia/keystroke_converter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "KeystrokeConverter", if: SpecHelper.adapter == :ms_uia do
+
+  it "converts plain ASCII" do
+    codes = RAutomation::Adapter::MsUia::KeystrokeConverter.convert("abc")
+    converted_keys = convert_keys "abc"
+    expect(codes).to be == converted_keys
+  end
+
+  it "uses caps lock for entering downcase keys" do
+    codes = RAutomation::Adapter::MsUia::KeystrokeConverter.convert("aBc")
+    converted_keys = convert_keys "abc"
+    converted_keys = converted_keys.insert(1, RAutomation::Adapter::MsUia::Constants::VK_LSHIFT)
+    expect(codes).to be == converted_keys
+  end
+
+  it "converts special keys" do
+    codes = RAutomation::Adapter::MsUia::KeystrokeConverter.convert("{tab}a{backspace}b{enter}c {left}d{right}ee{down}f{up}g{unsupported}{home}{end}{delete}")
+    expected_codes = [
+        RAutomation::Adapter::MsUia::Constants::VK_TAB,
+        convert_keys("a"),
+        RAutomation::Adapter::MsUia::Constants::VK_BACK,
+        convert_keys("b"),
+        RAutomation::Adapter::MsUia::Constants::VK_RETURN,
+        convert_keys("c"),
+        RAutomation::Adapter::MsUia::Constants::VK_SPACE,
+        RAutomation::Adapter::MsUia::Constants::VK_LEFT,
+        convert_keys("d"),
+        RAutomation::Adapter::MsUia::Constants::VK_RIGHT,
+        convert_keys("ee"),
+        RAutomation::Adapter::MsUia::Constants::VK_DOWN,
+        convert_keys("f"),
+        RAutomation::Adapter::MsUia::Constants::VK_UP,
+        convert_keys("g"),
+        convert_keys("unsupported"),
+        RAutomation::Adapter::MsUia::Constants::VK_HOME,
+        RAutomation::Adapter::MsUia::Constants::VK_END,
+        RAutomation::Adapter::MsUia::Constants::VK_DELETE
+    ].flatten
+    expect(codes).to be == expected_codes
+  end
+
+  def convert_keys keys
+    keys.split("").map { |k| k.upcase.unpack("c")[0] }
+  end
+
+end

data/spec/adapter/ms_uia/label_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe "MsUia::Label", if: SpecHelper.adapter == :ms_uia do
+  let(:window) { RAutomation::Window.new(title: "MainFormWindow") }
+  it "#exist?" do
+    expect(window.label(value: "This is a sample text").exist?).to be true
+    expect(window.label(value: "This label should not exist").exist?).to_not be true
+  end
+
+  it "check for label class" do
+    expect(window.label(id: "textField").exist?).to_not be true
+    expect(window.label(id: "label1").exists?).to be true
+  end
+
+  it "#label" do
+    expect(window.label(value: "This is a sample text").value).to be == "This is a sample text"
+  end
+end

data/spec/adapter/ms_uia/list_item_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe "MsUia::ListItem", if: SpecHelper.adapter == :ms_uia do
+  let(:window) { RAutomation::Window.new(title: "MainFormWindow") }
+  it "#exists" do
+    expect(window.list_item(value: "Apple").exist?).to be true
+    expect(window.list_item(value: "This is a sample text").exist?).to_not be true
+  end
+
+  it "#value" do
+    expect(window.list_item(value: "Apple").value).to be == "Apple"
+  end
+
+end