Expertiza_Wiki - User contributions [en]

User:Atmughra

2015-02-09T21:49:18Z

Atmughra: moved User:Atmughra to CSC/ECE 517 Spring 2015/ch1a 8 AT: Conform to submission requirements

#REDIRECT [[CSC/ECE 517 Spring 2015/ch1a 8 AT]]

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T21:49:18Z

Atmughra: moved User:Atmughra to CSC/ECE 517 Spring 2015/ch1a 8 AT: Conform to submission requirements

== '''New Keywords Arguments''' ==

== '''Introduction''' ==

Keyword arguments is feature that lets you specify by name, the parameter that you are going to pass to a method or a function call. Although it considered very powerful and expressive ,the ruby team didn't include it in their tool-chain until ruby 2.0.0 was introduced. One might think why you need such syntactic sugar while clearly you have alternatives like providing parameter with default values.

In the example provided below, passing default parameter in Ruby can be illustrated as the following:

<nowiki>
def foo( arg1='Hello', arg2='world', arg3='!' )

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo( 'Trying out' )
foo( 'Testing', 'this great' )
</nowiki>

One drawback of such approach is that there is no out of order passing for the parameters to the function nor we can omit any of them.
Another example of how tedious using the conventional approach, is programming using API libraries<ref>http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html</ref> that require to pass a lot of arguments, while not needing most of the arguments that we passed just in order to make it work.

Keyword arguments comes into play in a way, that it lets you specify the arguments without being concerned with their order, or number. you only need to pass the arguments that you need. On the other hand the method still maintains it's complexity without trimming its argument list.

== '''Using Keyword Argument for Ruby in Old Versions''' ==

Previously, Ruby (< 2.0.0) provided this mechanism using hashes<ref>http://ruby.about.com/od/advancedruby/qt/opthash.htm</ref>. While hashes emulate this feature it far from perfect and it has it's own issues and problems lets consider this example.

<nowiki>
def foo(args={})

defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'}.merge(args)

puts "#{defaults[:arg1]} #{defaults[:arg2]} #{defaults[:arg3]}"

end

foo
foo( :arg2 => 'AAA!' )</nowiki>

From the example shown above we can deduce the following, the technique of merging hashes is used as a way to pass the parameters you want with the default parameters. Lets go back to our example and look at the values of defaults hash before passing any parameters to it.

<nowiki>
defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'</nowiki>

but after the merger of the hash the default parameter list becomes as illustrated below, after our “foo( :arg2 => 'AAA!' )” function call.

<nowiki>
defaults={:arg1=>'It',:arg2=>'AAA!',:arg3 =>'Works!}</nowiki>

Hence the merge function replaces the key with new value obtaining a new parameters hash list.

Although this method is considered a good alternative to the real keyword argument approach it creates an over head in terms of using the merge function and adding an extra default parameter list, consequently affecting performance.

== '''Using Keyword Argument for Ruby at Newer Versions''' ==

Once Ruby 2.0.0 was released it introduced the formal way of using keyword arguments, without the need to using previous hashing methods.

Using our previously illustrated example<ref>http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/</ref> it becomes as the following.

<nowiki>
def foo(arg1:'It',arg2:'Really',arg3:'Works!')

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo(arg2:'AAA!' )</nowiki>

The example shows how different the new approach is from the hashing approach now you don't need to specify a parameter hash table, also you get an argument check for the valid parameters you can pass. For example:

<nowiki>
#hashing approach( foo function is called with invalid argument)

foo( :arg4 => 'invalid!' )

#=> nothing happens</nowiki>

<nowiki>
#proper approach (Ruby 2.0.0

foo( arg4:'invalid!' )

#=>ArgumentError: unknown keyword: arg5</nowiki>

Furthermore using this approach is more convenient in many ways as it produces lesser code, thus affecting performance.

Using this feature in Ruby (>= 2.0.0) some needs to take the following into consideration<ref>http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html</ref>.

*All keyword arguments must be located at the end of the argument list<ref>http://chriszetter.com/blog/2012/11/02/keyword-arguments-in-ruby-2-dot-0/</ref>, for example:
<nowiki>
foo(arg1:'It',arg2:'Really',arg3:'Works!', argument )</nowiki>
The previous call is considered illegal. With an only exception which are block arguments<ref>http://ruby.about.com/od/beginningruby/a/blocks.htm</ref> as those are located at the end of the argument list.

*Furthermore, keyword arguments behavior is different form default arguments. You have to speciy the name of the argument when calling a method, for example.
<nowiki>
Def foo(a, b=10)
end

#calling:
foo(1,2)</nowiki>

<nowiki>
def foo(a, b:10)
end

#calling:
foo(1,b:2)</nowiki>

== '''conclusion''' ==

Eventually keyword arguments have their own trade-offs, on the positive side they provide an easer way for the developer to call on methods. Furthermore, providing better clarity and maintainability of the code. But on the other hand using position arguments provide more expressiveness for presenting methods. Looking at the function with all it arguments can provide explanatory means to understand what it does.

== '''references''' ==
<references/>

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T21:45:42Z

Atmughra:

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T21:45:31Z

Atmughra:

== '''New Keywords Arguments''' ==

----

== '''Introduction''' ==

Keyword arguments is feature that lets you specify by name, the parameter that you are going to pass to a method or a function call. Although it considered very powerful and expressive ,the ruby team didn't include it in their tool-chain until ruby 2.0.0 was introduced. One might think why you need such syntactic sugar while clearly you have alternatives like providing parameter with default values.

In the example provided below, passing default parameter in Ruby can be illustrated as the following:

<nowiki>
def foo( arg1='Hello', arg2='world', arg3='!' )

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo( 'Trying out' )
foo( 'Testing', 'this great' )
</nowiki>

One drawback of such approach is that there is no out of order passing for the parameters to the function nor we can omit any of them.
Another example of how tedious using the conventional approach, is programming using API libraries<ref>http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html</ref> that require to pass a lot of arguments, while not needing most of the arguments that we passed just in order to make it work.

Keyword arguments comes into play in a way, that it lets you specify the arguments without being concerned with their order, or number. you only need to pass the arguments that you need. On the other hand the method still maintains it's complexity without trimming its argument list.

== '''Using Keyword Argument for Ruby in Old Versions''' ==

Previously, Ruby (< 2.0.0) provided this mechanism using hashes<ref>http://ruby.about.com/od/advancedruby/qt/opthash.htm</ref>. While hashes emulate this feature it far from perfect and it has it's own issues and problems lets consider this example.

<nowiki>
def foo(args={})

defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'}.merge(args)

puts "#{defaults[:arg1]} #{defaults[:arg2]} #{defaults[:arg3]}"

end

foo
foo( :arg2 => 'AAA!' )</nowiki>

From the example shown above we can deduce the following, the technique of merging hashes is used as a way to pass the parameters you want with the default parameters. Lets go back to our example and look at the values of defaults hash before passing any parameters to it.

<nowiki>
defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'</nowiki>

but after the merger of the hash the default parameter list becomes as illustrated below, after our “foo( :arg2 => 'AAA!' )” function call.

<nowiki>
defaults={:arg1=>'It',:arg2=>'AAA!',:arg3 =>'Works!}</nowiki>

Hence the merge function replaces the key with new value obtaining a new parameters hash list.

Although this method is considered a good alternative to the real keyword argument approach it creates an over head in terms of using the merge function and adding an extra default parameter list, consequently affecting performance.

== '''Using Keyword Argument for Ruby at Newer Versions''' ==

Once Ruby 2.0.0 was released it introduced the formal way of using keyword arguments, without the need to using previous hashing methods.

Using our previously illustrated example<ref>http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/</ref> it becomes as the following.

<nowiki>
def foo(arg1:'It',arg2:'Really',arg3:'Works!')

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo(arg2:'AAA!' )</nowiki>

The example shows how different the new approach is from the hashing approach now you don't need to specify a parameter hash table, also you get an argument check for the valid parameters you can pass. For example:

<nowiki>
#hashing approach( foo function is called with invalid argument)

foo( :arg4 => 'invalid!' )

#=> nothing happens</nowiki>

<nowiki>
#proper approach (Ruby 2.0.0

foo( arg4:'invalid!' )

#=>ArgumentError: unknown keyword: arg5</nowiki>

Furthermore using this approach is more convenient in many ways as it produces lesser code, thus affecting performance.

Using this feature in Ruby (>= 2.0.0) some needs to take the following into consideration<ref>http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html</ref>.

*All keyword arguments must be located at the end of the argument list<ref>http://chriszetter.com/blog/2012/11/02/keyword-arguments-in-ruby-2-dot-0/</ref>, for example:
<nowiki>
foo(arg1:'It',arg2:'Really',arg3:'Works!', argument )</nowiki>
The previous call is considered illegal. With an only exception which are block arguments<ref>http://ruby.about.com/od/beginningruby/a/blocks.htm</ref> as those are located at the end of the argument list.

*Furthermore, keyword arguments behavior is different form default arguments. You have to speciy the name of the argument when calling a method, for example.
<nowiki>
Def foo(a, b=10)
end

#calling:
foo(1,2)</nowiki>

<nowiki>
def foo(a, b:10)
end

#calling:
foo(1,b:2)</nowiki>

== '''conclusion''' ==

Eventually keyword arguments have their own trade-offs, on the positive side they provide an easer way for the developer to call on methods. Furthermore, providing better clarity and maintainability of the code. But on the other hand using position arguments provide more expressiveness for presenting methods. Looking at the function with all it arguments can provide explanatory means to understand what it does.

== '''references''' ==
<references/>

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T21:43:30Z

Atmughra:

== '''Introduction''' ==

Keyword arguments is feature that lets you specify by name, the parameter that you are going to pass to a method or a function call. Although it considered very powerful and expressive ,the ruby team didn't include it in their tool-chain until ruby 2.0.0 was introduced. One might think why you need such syntactic sugar while clearly you have alternatives like providing parameter with default values.

In the example provided below, passing default parameter in Ruby can be illustrated as the following:

<nowiki>
def foo( arg1='Hello', arg2='world', arg3='!' )

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo( 'Trying out' )
foo( 'Testing', 'this great' )
</nowiki>

One drawback of such approach is that there is no out of order passing for the parameters to the function nor we can omit any of them.
Another example of how tedious using the conventional approach, is programming using API libraries<ref>http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html</ref> that require to pass a lot of arguments, while not needing most of the arguments that we passed just in order to make it work.

Keyword arguments comes into play in a way, that it lets you specify the arguments without being concerned with their order, or number. you only need to pass the arguments that you need. On the other hand the method still maintains it's complexity without trimming its argument list.

== '''Using Keyword Argument for Ruby in Old Versions''' ==

Previously, Ruby (< 2.0.0) provided this mechanism using hashes<ref>http://ruby.about.com/od/advancedruby/qt/opthash.htm</ref>. While hashes emulate this feature it far from perfect and it has it's own issues and problems lets consider this example.

<nowiki>
def foo(args={})

defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'}.merge(args)

puts "#{defaults[:arg1]} #{defaults[:arg2]} #{defaults[:arg3]}"

end

foo
foo( :arg2 => 'AAA!' )</nowiki>

From the example shown above we can deduce the following, the technique of merging hashes is used as a way to pass the parameters you want with the default parameters. Lets go back to our example and look at the values of defaults hash before passing any parameters to it.

<nowiki>
defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'</nowiki>

but after the merger of the hash the default parameter list becomes as illustrated below, after our “foo( :arg2 => 'AAA!' )” function call.

<nowiki>
defaults={:arg1=>'It',:arg2=>'AAA!',:arg3 =>'Works!}</nowiki>

Hence the merge function replaces the key with new value obtaining a new parameters hash list.

Although this method is considered a good alternative to the real keyword argument approach it creates an over head in terms of using the merge function and adding an extra default parameter list, consequently affecting performance.

== '''Using Keyword Argument for Ruby at Newer Versions''' ==

Once Ruby 2.0.0 was released it introduced the formal way of using keyword arguments, without the need to using previous hashing methods.

Using our previously illustrated example<ref>http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/</ref> it becomes as the following.

<nowiki>
def foo(arg1:'It',arg2:'Really',arg3:'Works!')

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo(arg2:'AAA!' )</nowiki>

The example shows how different the new approach is from the hashing approach now you don't need to specify a parameter hash table, also you get an argument check for the valid parameters you can pass. For example:

<nowiki>
#hashing approach( foo function is called with invalid argument)

foo( :arg4 => 'invalid!' )

#=> nothing happens</nowiki>

<nowiki>
#proper approach (Ruby 2.0.0

foo( arg4:'invalid!' )

#=>ArgumentError: unknown keyword: arg5</nowiki>

Furthermore using this approach is more convenient in many ways as it produces lesser code, thus affecting performance.

Using this feature in Ruby (>= 2.0.0) some needs to take the following into consideration<ref>http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html</ref>.

*All keyword arguments must be located at the end of the argument list<ref>http://chriszetter.com/blog/2012/11/02/keyword-arguments-in-ruby-2-dot-0/</ref>, for example:
<nowiki>
foo(arg1:'It',arg2:'Really',arg3:'Works!', argument )</nowiki>
The previous call is considered illegal. With an only exception which are block arguments<ref>http://ruby.about.com/od/beginningruby/a/blocks.htm</ref> as those are located at the end of the argument list.

*Furthermore, keyword arguments behavior is different form default arguments. You have to speciy the name of the argument when calling a method, for example.
<nowiki>
Def foo(a, b=10)
end

#calling:
foo(1,2)</nowiki>

<nowiki>
def foo(a, b:10)
end

#calling:
foo(1,b:2)</nowiki>

== '''conclusion''' ==

Eventually keyword arguments have their own trade-offs, on the positive side they provide an easer way for the developer to call on methods. Furthermore, providing better clarity and maintainability of the code. But on the other hand using position arguments provide more expressiveness for presenting methods. Looking at the function with all it arguments can provide explanatory means to understand what it does.

== '''references''' ==
<references/>

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T21:30:32Z

Atmughra:

== Introduction ==

Keyword arguments is feature that lets you specify by name, the parameter that you are going to pass to a method or a function call. Although it considered very powerful and expressive ,the ruby team didn't include it in their tool-chain until ruby 2.0.0 was introduced. One might think why you need such syntactic sugar while clearly you have alternatives like providing parameter with default values.

In the example provided below, passing default parameter in Ruby can be illustrated as the following:

<nowiki>
def foo( arg1='Hello', arg2='world', arg3='!' )

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo( 'Trying out' )
foo( 'Testing', 'this great' )
</nowiki>

One drawback of such approach is that there is no out of order passing for the parameters to the function nor we can omit any of them.
Another example of how tedious using the conventional approach, is programming using API libraries that require to pass a lot of arguments, while not needing most of the arguments that we passed just in order to make it work.

Keyword arguments comes into play in a way, that it lets you specify the arguments without being concerned with their order, or number. you only need to pass the arguments that you need. On the other hand the method still maintains it's complexity without trimming its argument list.

== Using Keyword Argument for Ruby in Old Versions ==

Previously, Ruby (< 2.0.0) provided this mechanism using hashes. While hashes emulate this feature it far from perfect and it has it's own issues and problems lets consider this example.

<nowiki>
def foo(args={})

defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'}.merge(args)

puts "#{defaults[:arg1]} #{defaults[:arg2]} #{defaults[:arg3]}"

end

foo
foo( :arg2 => 'AAA!' )</nowiki>

From the example shown above we can deduce the following, the technique of merging hashes is used as a way to pass the parameters you want with the default parameters. Lets go back to our example and look at the values of defaults hash before passing any parameters to it.

<nowiki>
defaults={:arg1=>'It',:arg2=>'Really',:arg3 =>'Works!'</nowiki>

but after the merger of the hash the default parameter list becomes as illustrated below, after our “foo( :arg2 => 'AAA!' )” function call.

<nowiki>
defaults={:arg1=>'It',:arg2=>'AAA!',:arg3 =>'Works!}</nowiki>

Hence the merge function replaces the key with new value obtaining a new parameters hash list.

Although this method is considered a good alternative to the real keyword argument approach it creates an over head in terms of using the merge function and adding an extra default parameter list, consequently affecting performance.

== Using Keyword Argument for Ruby at Newer Versions ==

Once Ruby 2.0.0 was released it introduced the formal way of using keyword arguments, without the need to using previous hashing methods.

Using our previously illustrated example it becomes as the following.

<nowiki>
def foo(arg1:'It',arg2:'Really',arg3:'Works!')

puts "#{arg1} #{arg2} #{arg3}"

end

foo
foo(arg2:'AAA!' )</nowiki>

The example shows how different the new approach is from the hashing approach now you don't need to specify a parameter hash table, also you get an argument check for the valid parameters you can pass. For example:

<nowiki>
#hashing approach( foo function is called with invalid argument)

foo( :arg4 => 'invalid!' )

#=> nothing happens</nowiki>

<nowiki>
#proper approach (Ruby 2.0.0

foo( arg4:'invalid!' )

#=>ArgumentError: unknown keyword: arg5</nowiki>

Furthermore using this approach is more convenient in many ways as it produces lesser code, thus affecting performance.

Using this feature in Ruby (>= 2.0.0) some needs to take the following into consideration.

*All keyword arguments must be located at the end of the argument list, for example:
<nowiki>
foo(arg1:'It',arg2:'Really',arg3:'Works!', argument )</nowiki>
is considered illegal. With an only exception which are block arguments[2] as those are located at the end of the argument list.

*Furthermore, keyword arguments behavior is different form default arguments. You have to speciy the name of the argument when calling a method, for example.
<nowiki>
Def foo(a, b=10)
end

#calling:
foo(1,2)</nowiki>

<nowiki>
def foo(a, b:10)
end

#calling:
foo(1,b:2)</nowiki>

== conclusion ==

Eventually keyword arguments have their own trade-offs, on the positive side they provide an easer way for the developer to call on methods. Furthermore, providing better clarity and maintainability of the code. But on the other hand using position arguments provide more expressiveness for presenting methods. Looking at the function with all it arguments can provide explanatory means to understand what it does.

[1] http://brainspec.com/blog/2012/10/08/keyword-arguments-ruby-2-0/
[2] http://dev.af83.com/2013/02/18/ruby-2-0-keyword-arguments.html
[3] http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/
[4] http://chriszetter.com/blog/2012/11/02/keyword-arguments-in-ruby-2-dot-0/
[5] http://ruby.about.com/od/advancedruby/qt/opthash.htm
[6] http://ruby.about.com/od/beginningruby/a/blocks.htm

CSC/ECE 517 Spring 2014/ch1a 1i rt

2015-02-09T21:07:39Z

Atmughra:

'''New Keyword Arguments'''

QuickTest Pro is a test automation tool originally developed by Mercury Interactive and later acquired by [http://en.wikipedia.org/wiki/Hewlett_Packard Hewlett Packard].<ref>http://www.devbistro.com/articles/Testing/Mercury-QuickTest-Professional-Evaluation</ref> This software offers regression and functional test automation for buisness quality control.

[https://docs.google.com/a/ncsu.edu/document/d/1XzVu0zEuk7LP4smGZV9lRpSx5-wri6oClpUAmGYPN44/edit# Writeup page.]

=='''Features'''==
QuickTest Pro is not a command line testing solution. It offers a graphical user interface, keyboard support, multiple testing views, and scripting language.<ref>http://www.softwaretestinghelp.com/qtp-quicktest-professional-tutorial-1/</ref>

===Testing===
QuickTest allows for both [http://en.wikipedia.org/wiki/Functional_testing functional] and [http://en.wikipedia.org/wiki/Regression_testing regression] testing. It also supports data-driven testing through spreadsheet software, allowing outputs to be recorded and organized.

===Views===
QTP has two different views for testing, a keyboard view and an expert view. In keyboard view, users modify tests in a table, one row per step. Users can view output values, set loops, and add breakpoints.

Expert view displays test code using [http://en.wikipedia.org/wiki/VBScript VBScript].

===Scripting===
QuickTest Pro's VBScript allows for classes, but not other object oriented properties such as inheritance and polymorphism. It also lacks a debugger, however QTP has a debugger provided by HP.<ref>https://h20546.www2.hp.com/main/training/course_details.cfm?Course=00008165&sitepick=US</ref>

===Exception handling===
QuickTest Pro uses recovery scenarios to handle runtime exceptions, this allows testing to be uninterrupted as long as the exception did not affect the memory of the tested application.

=='''Comparison to other tools'''==
Tools such as Cucumber and Capybara run tests from the perspective of the user. Cucumber converts user stories into tests and Capybara simulates a user or web browser. QuickTest Pro is used by programmers to preform specific test cases they code themselves.<ref>Engineering Long Lasting Software p136</ref>

=='''Disadvantages'''==
QuickTest Pro is developed mainly for Windows based systems and it relies on outdated Windows tools like VBXScript. Tests can not be run outside of the QuickTest environment nor are they compatible with all browser types.<ref>http://www8.hp.com/us/en/software-solutions/unified-functional-testing-automated-testing/demos-documents.html#!&pd1=1</ref>

=='''References'''==
<references/>

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T20:39:52Z

Atmughra: Blanked the page

CSC/ECE 517 Spring 2015/ch1a 8 AT

2015-02-09T20:39:31Z

Atmughra: Created page with "aaa"

aaa