testability-driver 0.9.2 → 1.0.0

data/lib/tdriver/base/sut/generic/behaviours/switchbox_behaviour.rb

@@ -44,10 +44,25 @@ module MobyBehaviour
 
     include MobyBehaviour::Behaviour
 
+    # == description
     # Instructs the SUT to reboot
-    # === params
-    # === returns
-    # === raises
+    # == returns
+    # NilClass
+    #  description: -
+    #  example: -
+    # == exceptions
+    # BehaviourError
+    #  description: switchbox_sleep_before_powerup_in_reboot not defined for sut in tdriver_parameters.xml
+    # BehaviourError
+    #  description: switchbox_sleep_after_powerup_in_reboot not defined for sut in tdriver_parameters.xml
+    # BehaviourError
+    #  description: switchbox_sleep_before_powerup_in_reboot need to be non-negative integer smaller than 50 seconds
+    # BehaviourError
+    #  description: switchbox_sleep_in_reboot could not be converted to integer
+    # BehaviourError
+    #  description: switchbox_sleep_after_powerup_in_reboot need to be non-negative integer smaller than 500 seconds
+    # BehaviourError
+    #  description: switchbox_sleep_after_powerup_in_reboot could not be converted to integer
     def reset
       str_sleep_time_before_powerup = parameter(:switchbox_sleep_before_powerup_in_reboot)
       Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_before_powerup_in_reboot not defined for sut in tdriver_parameters.xml") if str_sleep_time_before_powerup == nil
@@ -72,8 +87,6 @@ module MobyBehaviour
       rescue
         Kernel::raise BehaviourError.new("reboot", "switchbox_sleep_after_powerup_in_reboot could not be converted to integer")
       end
-
-      
       
       power_down
       begin
@@ -86,7 +99,7 @@ module MobyBehaviour
 
       MobyUtil::Retryable.until( :timeout => 60, :retry_timeout => 5 ) {
         system(str_commands_after_powerup) if str_commands_after_powerup != nil
-        if MobyUtil::Parameter[ :ats4_error_recovery_enabled, false ]=='true'
+        if MobyUtil::Parameter[ :ats4_error_recovery_enabled, false ]!='true'
           MobyUtil::Logger.instance.log "behaviour" , "PASS;TDriver attempting reconnect"
           self.connect(self.id)
           MobyUtil::Logger.instance.log "behaviour" , "PASS;TDriver connected"
@@ -97,10 +110,15 @@ module MobyBehaviour
       }
     end
 
+    # == description
     # Instructs the switchbox to power down the sut
-    # === params
-    # === returns
-    # === raises
+    # == returns
+    # Boolean
+    #  description: Current power status
+    #  example: false
+    # == exceptions
+    # BehaviourError
+    #  description: Failed to power down    
     def power_down
       str_command_arr = []
 
@@ -129,10 +147,16 @@ module MobyBehaviour
       @switch_box_power_status = false
     end
 
+
+    # == description
     # Instructs the switchbox to power up the sut
-    # === params
-    # === returns
-    # === raises
+    # == returns
+    # Boolean
+    #  description: Current power status
+    #  example: true
+    # == exceptions
+    # BehaviourError
+    #  description: Failed to power up    
     def power_up
       str_command_arr = []
 
@@ -161,10 +185,12 @@ module MobyBehaviour
       @switch_box_power_status = true
     end
 
+    # == description
     # Gets the current power status of the switchbox
-    # === params
-    # === returns
-    # === raises
+    # == returns
+    # Boolean
+    #  description: Current power status
+    #  example: true
     def power_status
       if @switch_box_power_status == nil
         false

data/lib/tdriver/base/sut/generic/behaviours/verification.rb

@@ -20,7 +20,7 @@
 module MobyBehaviour
  
   # == description
-  # Defines methods for verification of sut and test object state 
+  # Defines methods for verification of test object state. These methods can only be called from non-sut objects
   #
   # == behaviour
   # GenericVerification
@@ -38,31 +38,58 @@ module MobyBehaviour
   # *
   #
   # == objects
-  # *;sut
+  # *
   #
 	module Verification
 
 		include MobyBehaviour::Behaviour
 
 		# == description
-		# Checks if a child test object matching the given criteria can be found on the sut   
-		# === params
-		# type:: String defining the type of the object
-		# attributes:: (optional) Hash containing attributes that the object must have
-		# === returns
-		# Boolean:: true if the object exists on the sut display
-		# === raises
-		# ArgumentError:: The type argument was not a non-empty String or attributes argument (if provided) was not a Hash
-		# === example
-		# @calc = @sut.run(:name => 'calculator') # launches calculator  
-		# testobj_exists =  @calc.test_object_exists?('Button',{:text => '+',:objectName => 'plusButton'} # check if  test object  with given criteria exists in calculator
-		
-		def test_object_exists?(type, attributes = Hash.new)
-
-			Kernel::raise ArgumentError.new "The type argument must be a non empty String." unless (type.kind_of? String and !type.empty?) 
-			Kernel::raise ArgumentError.new "The attributes argument must be a Hash." unless attributes.kind_of? Hash
+		# Checks if a child test object matching the given criteria can be found, under this application object or test object.
+		#
+		# == arguments
+		# type
+		#  String
+		#   description: String defining the type of the object
+		#   example: "Button"
+		#
+		# attributes
+		#  Hash
+		#   description: Optional hash containing attributes that the object must have
+		#   example: {}
+		#
+		# == returns
+		# TrueClass
+		#   description: if the object exists on the sut display
+		#   example: true
+		# FalseClass
+		#   description: if the object exists on the sut display
+		#   example: false
+    #
+		# == exceptions
+		# TypeError
+		#  description: Wrong argument type %s for test object type (expected String)
+		#
+		# ArgumentError
+		#  description: The test object type argument must not be empty
+		#
+		# TypeError
+		#  description: Wrong argument type %s for test object attributes (expected Hash)
+		def test_object_exists?(type, attributes = {} )
+
+      # verify type
+			#Kernel::raise ArgumentError.new "The type argument must be a non empty String." unless (type.kind_of? String and !type.empty?) 
+      type.check_type( String, "Wrong argument type $1 for test object type (expected $2)" )
+
+      # verify that type is not empty string
+      type.not_empty( "The test object type argument must not be empty" )
+
+      # verify type
+			#Kernel::raise ArgumentError.new "The attributes argument must be a Hash." unless attributes.kind_of?( Hash )
+      attributes.check_type( Hash, "Wrong argument type $1 for test object attributes (expected $2)")
 
 			#attributes_with_type = {}.merge attributes
+
 			attributes_with_type = attributes.clone
 			attributes_with_type[:type] = type
 			attributes_with_type.delete(:__logging)
@@ -70,7 +97,8 @@ module MobyBehaviour
 			#translate the symbol values into string using sut's localisation setting
 			translate!( attributes_with_type )
 
-			identificator = MobyBase::TestObjectIdentificator.new( attributes_with_type )
+      # JKo: is there some reason for the line below?
+			#identificator = MobyBase::TestObjectIdentificator.new( attributes_with_type )
 
 			original_logging = MobyUtil::Logger.instance.enabled
 			desired_logging = (attributes[:__logging] == nil || attributes[:__logging] == 'false') ? false : true
@@ -80,6 +108,7 @@ module MobyBehaviour
 			begin
 
 				self.child( attributes_with_type )
+
 				MobyUtil::Logger.instance.enabled = desired_logging
 				MobyUtil::Logger.instance.log "behaviour" , "PASS;Test object of type #{type} with attributes #{attributes.inspect} was found.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s : ''};test_object_exist;"
 

data/lib/tdriver/base/sut/generic/commands/fixture.rb

@@ -0,0 +1,47 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of TDriver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+
+
+module MobyCommand
+
+  class Fixture < MobyCommand::CommandData
+
+	attr_accessor :params
+	
+	
+	# == description
+	# Fixture command holds the required parameters to execute a fixture operation in the target.
+	#
+	# == arguments
+	# params
+	#  Hash
+	#   description: 
+	#    Hash for holding the parameters need by the fixture operation.
+	#    Example: {:application_id => "", :object_id => "", :object_type => "", :name => nil, :command_name => nil, :parameters => {}, :async => false)}
+	#
+	def initialize(params)
+
+	  @params = params
+
+	end
+	
+  end # Fixture
+
+end # MobyCommand

data/lib/tdriver/base/sut/generic/commands/key_sequence.rb

@@ -17,7 +17,6 @@
 ## 
 ############################################################################
 
-
 module MobyCommand
 
 	class KeySequence < MobyCommand::CommandData
@@ -32,9 +31,9 @@ module MobyCommand
 		# Instance of KeySequence
 		def initialize( key_symbol = nil, type_symbol = :ShortPress )
 			#TODO: Review comment (OR): @sequence -> @_sequence?
-			@sequence = Array.new( 0 )
+			@sequence = [] # Array.new( 0 )
 			#@_sut = sut
-			self.append!( key_symbol, type_symbol ) unless key_symbol == nil
+			self.append!( key_symbol, type_symbol ) unless key_symbol.nil?
 		end
 
 		# Function to append a keypress with type to KeySequence.sequence array
@@ -50,28 +49,41 @@ module MobyCommand
 
 		# Function to repeat last added keypress in sequence unless count is less than one or keypress sequence is empty  
 		# == params
-		# int:: times of key repeated, default is one   
+		# count:: times of key repeated, default is one   
 		# == returns
 		# self
 		# == raises
-		# ArgumentError:: Fixnum expected as argument
-		# ArgumentError:: Positive value expected as argument
-		# IndexError:: Not allowed when empty key sequence
-		def times!( int = 1 )
-			Kernel::raise ArgumentError.new("Fixnum expected as argument") if int.class != Fixnum
-			Kernel::raise ArgumentError.new("Positive value expected as argument") if int < 0
-			Kernel::raise IndexError.new("Not allowed when empty key sequence") if @sequence.size == 0
-			int.times do | iteration |
+		# TypeError:: Wrong argument type %s for times count (expected Fixnum)
+		# ArgumentError:: Positive value expected for times count (got %i)
+		# IndexError:: Unable to multiply last given key due to key sequence is empty
+		def times!( count = 1 )
+
+      # verify count argument type
+			#Kernel::raise ArgumentError.new("Fixnum expected as argument") if count.class != Fixnum
+      count.check_type( Fixnum, "Wrong argument type $1 for times count (expected $2)" )
+
+      # verify that count is positive number
+			Kernel::raise ArgumentError.new( "Positive value expected for times count (got #{ count })" ) if count.negative?
+
+      # verify that @sequence is not empty
+			#Kernel::raise IndexError.new( "Not allowed when empty key sequence" ) if @sequence.size == 0
+			Kernel::raise IndexError.new( "Unable to multiply last given key due to key sequence is empty" ) if @sequence.empty?
+
+			count.times do | iteration |
+			
 				@sequence.push @sequence.fetch( -1 ) unless iteration == 0 
+
 			end
+
 			self
+			
 		end
 				
 		# Returns the stored sequence as an Array with Hash elements having :value and :type keys for each press.
 		# == returns
 		# Array:: Stored key sequence
 		def get_sequence
-		  return @sequence
+		  @sequence
 		end
 
 		# enable hooking for performance measurement & debug logging

data/lib/tdriver/base/sut/generic/commands/screen_capture.rb

@@ -31,23 +31,29 @@ module MobyCommand
 
 		# Constructor to ScreenCapture
 		# == params
-		# hash:: (optional) Hash of image related attributes
+		# attributes:: (optional) Hash of image related attributes
 		# == returns
 		# Instance of ScreenCapture
-		def initialize( hash = {} )
+		def initialize( attributes = {} )
 
-			# Default values
-			@command = hash[ :type ] ||= :Screen
-			@image_mime_type = hash[ :mime_type ] ||= :PNG
-			@color_depth = hash[ :color_depth ] ||= :Color4K
-			@redraw = hash[ :redraw ] ||= false
+      # verify that attributes argument is type of Hash
+      attributes.check_type( Hash, "Wrong argument type $1 for screen capture command attributes (expected $2)" )
 
-			Kernel::raise ArgumentError.new("Wrong argument type %s for command type (expected Symbol)" % hash[ :type ].class ) unless hash[ :type ].kind_of? Symbol
+      # set default values unless already defined in attributes hash
+      attributes.default_values( :type => :Screen, :mime_type => :PNG, :color_depth => :Color4K, :redraw => false )
 
-			Kernel::raise ArgumentError.new("Wrong argument type %s for image MIME type (expected Symbol)" % hash[ :mime_type ].class ) unless hash[ :mime_type ].kind_of? Symbol
+      # verify that value of :type is type of Symbol
+      ( @command = attributes[ :type ] ).check_type( Symbol, "Wrong argument type $1 for screen capture command type (expected $2)" )
 
-			Kernel::raise ArgumentError.new("Wrong argument type %s for image color depth type (expected Symbol)" % hash[ :color_depth ].class ) unless hash[ :color_depth ].kind_of? Symbol
+      # verify that value of :mime_type is type of Symbol
+      ( @image_mime_type = attributes[ :mime_type ] ).check_type( Symbol, "Wrong argument type $1 for screen capture command mime type (expected $2)" )
 
+      # verify that value of :color_depth is type of Symbol
+      ( @color_depth = attributes[ :color_depth ] ).check_type( Symbol, "Wrong argument type $1 for screen capture command image color depth type (expected $2)" )
+
+      # verify that value of :redraw is type of Symbol
+      ( @redraw = attributes[ :redraw ] ).check_type( [ TrueClass, FalseClass ], "Wrong argument type $1 for screen capture command redraw flag (expected $2)" )
+    
 		end
 
 		# enable hooking for performance measurement & debug logging

data/lib/tdriver/base/sut/generic/plugin.rb

@@ -17,9 +17,8 @@
 ## 
 ############################################################################
 
-
 # verify that plugin engine and modules is loaded
-Kernel::raise RuntimeError.new( "SUT plugin requires TDriver" ) unless defined?( MobyUtil::Plugin )
+Kernel::raise RuntimeError.new( "This SUT plugin requires Testability Driver and cannot be launched in standalone mode" ) unless defined?( MobyUtil::Plugin )
 
 module MobyPlugin
 
@@ -75,12 +74,19 @@ module MobyPlugin
 			# returns SUT object - this method will be called from MobyBase::SUTFactory
 			def self.make_sut( sut_id )
 
+#				MobyBase::SUT.new( 
+#					MobyBase::SutController.new( "", MobyController::SutAdapter.new() ), 
+#					MobyBase::TestObjectFactory.instance,
+#					sut_id
+#				)
+
 				MobyBase::SUT.new( 
 					MobyBase::SutController.new( "", MobyController::SutAdapter.new() ), 
-					MobyBase::TestObjectFactory.instance,
+					TDriver.TestObjectFactory.new( TDriver::TestObjectAdapter ),
 					sut_id
 				)
 
+
 			end
 
 			# enable hooking for performance measurement & debug logging

data/lib/tdriver/base/sut/sut.rb

@@ -20,48 +20,56 @@
 # abstract class for SUT - no behaviours
 module MobyBase
 
-	class SUT
+  class SUT
 
-		attr_accessor(
-			:id,		# id of current SUT
-			:ui_type,	# ui type
-			:ui_version,	# ui version
-			:input,		# the input method used for interacting with this sut as a symbol, eg. :key or :touch. 
-			:type		# type of object ("SUT"), used when applying behaviour
-		)
+    attr_accessor(
+      :id,          # id of current SUT
+      :ui_type,     # ui type
+      :ui_version,  # ui version
+      :input,       # the input method used for interacting with this sut as a symbol, eg. :key or :touch. 
+      :type         # type of object ("SUT"), used when applying behaviour
+    )
 
-		# Initialize SUT by giving references to the used controller and test object factory
-		# == params
-		# sut_controller:: Controller object that acts as a facade to the device represented by this SUT
-		# test_object_factory:: TestObjectFactory object, a factory for generating creating test objects for this SUT
-		# sut_id:: String representing the identification of this SUT - the identification will need to match with group id in parameters xml
-		def initialize( sut_controller, test_object_factory, sut_id )
+    # Initialize SUT by giving references to the used controller and test object factory
+    # == params
+    # sut_controller:: Controller object that acts as a facade to the device represented by this SUT
+    # test_object_factory:: TestObjectFactory object, a factory for generating creating test objects for this SUT
+    # sut_id:: String representing the identification of this SUT - the identification will need to match with group id in parameters xml
+    def initialize( sut_controller, test_object_factory, sut_id )
 
-			@_sutController = sut_controller    
-			@test_object_factory = test_object_factory
+      @_sutController = sut_controller
+      
+      @test_object_factory = test_object_factory || TDriver::TestObjectFactory.new( :test_object_adapter => TDriver::TestObjectAdapter )
 
-			@id = sut_id
-			@input = :key
-			@type = "sut"
+      @id = sut_id
+      @input = :key
+      @type = "sut"
 
-		end	
+    end  
 
-		# Interface to forward command execution to sut specific controller (SutController#execute_command)
-		# == params
-		# command:: MobyBase::CommandData descendant object defining the command
-		# == raises
-		# ?:: what ever SutController#execute_command( command ) raises
-		# == returns
-		# Boolean:: what ever SutController returns 
-		def execute_command( command )
+    # Interface to forward command execution to sut specific controller (SutController#execute_command)
+    # == params
+    # command:: MobyBase::CommandData descendant object defining the command
+    # == raises
+    # ?:: what ever SutController#execute_command( command ) raises
+    # == returns
+    # Boolean:: what ever SutController returns 
+    def execute_command( command )
 
-			@_sutController.execute_command( command )
+      @_sutController.execute_command( command )
 
-		end
+    end
 
-		# enable hooking for performance measurement & debug logging
-		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+    # TODO: document me
+    def inspect
 
-	end # SUT
+      "#<#{ self.class }:0x#{ ( "%x" % ( self.object_id.to_i << 1 ) )[ 3 .. -1 ] } @id=#{ @id.inspect } @input=\"#{ @input }\" @type=\"#{ @type }\" @ui_type=\"#{ @ui_type }\" @ui_version=\"#{ @ui_version }\">"
+
+    end
+
+    # enable hooking for performance measurement & debug logging
+    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+  end # SUT
  
 end # MobyBase