scoutui 2.0.5.4 → 2.0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbf796808a18143060a52ebcb6221e3d4a0bb388
-  data.tar.gz: 841d44e21a34f8f5d2db8fd55c0e27e1d9c0b710
+  metadata.gz: d6dacda3f47090eebe3db6eabf36196b344021da
+  data.tar.gz: a133fff58bd29f175a76a09dd6b84059029fa65a
 SHA512:
-  metadata.gz: 851555770f4079642021e5e9579d802e27031f4af7a8a0b88641b10ae1200ce5d4b110f315974b376aec837a9171626246eb639566c62ae0805c5f95fa5276c3
-  data.tar.gz: 75361076e0fa9eb6b02fceb7c3abe2f057edee95499d59e42aa89c2e48215f7ab1ffaa8728e197307c5dd1694963111c568892c709e53304cfdce9eec2069ec7
+  metadata.gz: a720ce6295325c4b0784368782f61b91495338d832ac70dfa68ed04fc165d35f1839b68021eab4356bf5ea9fc02a985d4d0f802e27140e00768d4a77166f1540
+  data.tar.gz: a7a47e786526d6d0a7a3e3eccd6ff86be48254d4999dbae016e3245fea9d2f3099365e0505d8b311b5d00fca640bc98cf4d89b5a884ad398a17bd6027ef4f826

data/bin/scoutui_driver.rb

@@ -10,13 +10,23 @@ require 'logger'
 # --title <Applitools Title>
 # --browser <chrome|firefox|ie>
 
-
-nav = Scoutui::Navigator.new(Scoutui::Utils::TestUtils.instance.parseCommandLine())
-
-
-runner = Scoutui::Base::TestScout.new(nav)
-
-runner.start()
-runner.report()
-
-
+results=nil
+
+begin
+  nav = Scoutui::Navigator.new(Scoutui::Utils::TestUtils.instance.parseCommandLine())
+  runner = Scoutui::Base::TestScout.new(nav)
+  runner.start()
+  results=runner.report()
+rescue => ex
+  # puts __FILE__ + (__LINE__).to_s + " #{ex.class.to_s} Error during processing: #{ex.message}"
+  puts  ex.backtrace if !ex.message.match(/^SCOUTUI/)
+end
+
+rc=0
+if results.nil?
+  rc=2
+elsif !results.nil? && !results[:rc]
+  rc=1
+end
+
+exit(rc)

data/lib/scoutui/appmodel/q_model.rb

@@ -101,32 +101,32 @@ module Scoutui::ApplicationModel
     def itemize(condition='visible_when', _action='hover', _pgObj=nil)
       @results=hits(nil, @app_model, condition, _action, _pgObj)
 
-      puts "[itemize] => #{@results}"
+      Scoutui::Logger::LogMgr.instance.debug "[itemize] => #{@results}"
 
       @results
     end
 
 
     def hits(parent, h, condition, _action, pg)
-      #  puts __FILE__ + (__LINE__).to_s + " collect_item_attributes(#{h})"
+      #  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " collect_item_attributes(#{h})"
       result = []
 
 
       if h.is_a?(Hash)
 
         h.each do |k, v|
-          puts __FILE__ + (__LINE__).to_s + " Key: #{k} => #{v}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Key: #{k} => #{v}"
           if k == condition
             #  h[k].each {|k, v| result[k] = v } # <= tweak here
             if !v.is_a?(Array) && v.match(/^\s*#{_action}\s*\((.*)\)\s*$/i)
 
               pageObject=v.match(/^\s*#{_action}\s*\((.*)\)\s*$/i)[1]
 
-              puts __FILE__ + (__LINE__).to_s + " <pg, pageObject> : <#{pg}, #{pageObject}>"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " <pg, pageObject> : <#{pg}, #{pageObject}>"
               #         result[k] = v
 
-              #          puts '*******************'
-              #          puts __FILE__ + (__LINE__).to_s + " HIT : #{h[k]}"
+              #          Scoutui::Logger::LogMgr.instance.debug '*******************'
+              #          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " HIT : #{h[k]}"
               #          result << { h[k] => v }
 
               if pg.nil?
@@ -139,14 +139,14 @@ module Scoutui::ApplicationModel
             elsif v.is_a?(Array)
 
               v.each do |vh|
-                puts " =====> #{vh}"
+                Scoutui::Logger::LogMgr.instance.debug " =====> #{vh}"
 
                 if vh.is_a?(Hash) && vh.has_key?(condition) && vh[condition].match(/^\s*#{_action}\s*/i)
 
                   pageObject=vh[condition].match(/^\s*#{_action}\s*\((.*)\)\s*$/i)[1]
 
 
-                  puts __FILE__ + (__LINE__).to_s + " matched on #{_action}, pg:#{pg}, #{pageObject}"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " matched on #{_action}, pg:#{pg}, #{pageObject}"
 
                   if pg.nil?
                     result << parent
@@ -173,8 +173,8 @@ module Scoutui::ApplicationModel
 
               result << _rc
 
-              puts __FILE__ + (__LINE__).to_s + " ADDING  #{k} : #{_rc}"
-              #           puts "====> #{k} : #{_rc.class} : #{_rc.length}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ADDING  #{k} : #{_rc}"
+              #           Scoutui::Logger::LogMgr.instance.debug "====> #{k} : #{_rc.class} : #{_rc.length}"
 
 
               result.flatten!
@@ -189,7 +189,7 @@ module Scoutui::ApplicationModel
 
 
       result=nil if result.empty?
-      puts __FILE__ + (__LINE__).to_s + " result : #{result}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " result : #{result}"
       result
     end
 
@@ -261,7 +261,7 @@ module Scoutui::ApplicationModel
               Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | id(#{path}.#{_id}.#{_k}) - #{_h}"
 
               _h.each do |k, v|
-#                puts __FILE__ + (__LINE__).to_s + " processing #{_id}.#{k}, #{v}"
+#                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processing #{_id}.#{k}, #{v}"
                 if v.is_a?(Hash) && v.has_key?('locator')
                   Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processing #{_id}.#{_k}.#{k}"
                 elsif v.is_a?(Hash) || v.is_a?(Array)

data/lib/scoutui/base/assertions.rb

@@ -13,6 +13,7 @@ module Scoutui::Base
 
     def initialize
       @assertionTypes=[
+          { :cmd => 'isChecked',   :pattern => '^\s*[!]*isChecked\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isChecked', _a) } },
           { :cmd => 'isEnabled',   :pattern => '^\s*[!]*isEnabled\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isEnabled', _a) } },
           { :cmd => 'isSelected',  :pattern => '^\s*[!]*isSelected\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isSelected', _a) } },
           { :cmd => 'isText',      :pattern => '^\s*[!]*(isText)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isText', _a) } },
@@ -39,7 +40,15 @@ module Scoutui::Base
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when.condition => #{_uservar_val} equals #{_val}"
 
       if _cond=='=='
-        _rc=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)
+
+        if _val.match(/\/.*\//)
+          _regex = Regexp.new(_val.match(/\/(.*)\//)[1].to_s)
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  Val: #{_uservar_val}  REGEX : #{_regex}  => #{!_uservar_val.match(_regex).nil?}"
+          _rc = !_uservar_val.match(_regex).nil?
+        else
+          _rc=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)
+        end
+
       else
         _rc=(!_uservar_val.match(/#{_val}/) || _uservar_val!=_val)
       end
@@ -265,6 +274,7 @@ module Scoutui::Base
 
     def isTitle(my_driver, _execute_when)
 
+      _result=Scoutui::Base::ResultAssertion.new()
       rc=nil
 
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isTitle(#{_execute_when}"
@@ -276,14 +286,48 @@ module Scoutui::Base
       expected_title = Regexp.new(_locator)
       rc=!expected_title.match(current_title).nil?
 
+      _result.setReport("Actual: #{current_title}   Expected: #{_locator}", rc)
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isTitle?(#{_execute_when}) => #{rc}"
       rc
+      _result
+    end
+
+
+
+    def isChecked?(my_driver, _execute_when)
+      rc=true
+
+      _locator = _execute_when.match(/^\s*[!]*(isChecked)\((.*)\)\s*$/i)[2].to_s
+
+      _locator = Scoutui::Base::UserVars.instance.normalize(_locator)
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isChecked => #{_locator}"
+
+      _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+
+      _state = _obj.attribute("checked")
+
+      _state = false if _state.nil? || _state.empty?
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj.checked? => #{_state}"
+
+      if _execute_when.match(/^\s*!(isChecked)/i) && _state
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isChecked(#{_locator}) : false"
+        rc=false
+      elsif _execute_when.match(/^\s*(isChecked)/i) && !_state
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isChecked(#{_locator}) : false"
+        rc=false
+      end
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isChecked?(#{_execute_when}) => #{rc}"
+      rc
     end
 
     def isValue?(my_driver, page_elt)
 
       rc = false
       _txt = nil
+      _result=Scoutui::Base::ResultAssertion.new()
 
       if page_elt.is_a?(String) && page_elt.match(/^\s*(text|value)\s*\(/)
         #
@@ -297,6 +341,8 @@ module Scoutui::Base
 
         xpath = Scoutui::Base::UserVars.instance.get(tmpObj)
 
+        xpath = Scoutui::Base::UserVars.instance.normalize(xpath)  # 5150
+
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " locator : #{xpath}"; #gets
 
         obj = Scoutui::Base::QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
@@ -314,13 +360,18 @@ module Scoutui::Base
             elsif condition.match(/^\s*value/)
               _txt = obj.attribute('value')
               Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{_txt}"
-                                                         expected_regex = Regexp.new(expectedVal)
-              rc =  !_txt.to_s.match(expected_regex).nil?
+              expected_regex = Regexp.new(expectedVal)
+              expandedExpected = Scoutui::Commands::Utils.instance.expandMacro(expectedVal)
+
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Expanded(#{expectedVal}) : #{expandedExpected}"
+              rc =  (!_txt.to_s.match(expected_regex).nil?) || _txt.to_s==expandedExpected
             else
               Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown conditon: #{condition}"
             end
 
-            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "txt/val: #{_txt}  rc => #{rc}"
+
+            _result.setReport("actual: #{_txt}  expected: #{expectedVal}")
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "txt/val: #{_txt}  expected: #{expectedVal}  rc => #{rc}"
           end
 
 
@@ -332,7 +383,9 @@ module Scoutui::Base
 
       end
 
-      rc
+      _result.setResult(rc)
+    #  rc
+      _result
     end
 
 

data/lib/scoutui/base/q_browser.rb

@@ -450,6 +450,11 @@ module Scoutui::Base
       locateBy=:xpath
       hits=nil
 
+      locator = Scoutui::Base::UserVars.instance.normalize(locator)
+      _parsed = Scoutui::Base::QBrowser.parseLocator(locator)
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{locator} ==> #{_parsed}"
+
 
       if locator.match(/^\s*css\s*\=\s*/i)
         locateBy = :css

data/lib/scoutui/base/result_assertion.rb

@@ -0,0 +1,54 @@
+
+
+module Scoutui::Base
+
+
+  class ResultAssertion
+
+    attr_accessor :result
+    attr_accessor :report
+
+    def initialize(rc=nil)
+      @result=rc
+      @report=""
+    end
+
+    def setResult(b)
+      @result=b
+    end
+
+    def setReport(_s, _result=nil)
+      @report=_s
+      if !_result.nil?
+        setResult(_result)
+      end
+    end
+
+    def report
+      @report
+    end
+
+    def executed?
+      !@result.nil?
+    end
+
+    def passed?
+      @result
+    end
+
+    def failed?
+      executed? && !passed?
+    end
+
+    def toString()
+      if !executed?
+        return "not executed"
+      end
+
+      @result.to_s
+    end
+
+
+  end
+
+end

data/lib/scoutui/base/user_vars.rb

@@ -98,7 +98,7 @@ module Scoutui::Base
 
 
 
-      if src.is_a?(TrueClass) || src.nil? || src.empty?
+      if src.is_a?(TrueClass) || src.is_a?(Fixnum) || src.nil? || src.empty?
         return src
       end
 

data/lib/scoutui/base/visual_test_framework.rb

@@ -407,9 +407,13 @@ module Scoutui::Base
         _execute_when.each do |_a|
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assert: => #{_a}"
 
+          _tmpResult=nil
+          _assertText=nil
           _rc=nil
           _bm=nil
 
+          _assertMessage = "Assert #{_a}."
+
           _assertType=Scoutui::Base::Assertions.instance.isValidAssertType(_a)
 
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assertType : #{_assertType}"
@@ -451,6 +455,11 @@ module Scoutui::Base
               _bm=Benchmark.measure {
                 _rc=Scoutui::Base::Assertions.instance.compareValue(_a)
               }
+
+            elsif _assertType[:cmd]=='isChecked'
+              _bm=Benchmark.measure {
+                _rc=Scoutui::Base::Assertions.instance.isChecked?(my_driver, _a)
+              }
             end
 
           elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)
@@ -465,13 +474,50 @@ module Scoutui::Base
             }
           elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)
             _bm=Benchmark.measure {
-              _rc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+              _tmpResult=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+              _rc=_tmpResult.passed?
             }
           elsif Scoutui::Base::Assertions.instance.isTitleCmd?(_a)
             _bm=Benchmark.measure {
-              _rc=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
+              _tmpResult=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
+              _rc=_tmpResult.passed?
             }
 
+          elsif _a.match(/^\s*count\(.*\)\s*(==|!=|>=|<=|<|>)\s*(\d+|\$\{.*\})$/)
+
+            _mResult = _a.match(/^\s*count\((.*)\)\s*(==|!=|>=|<=|<|>)\s*(\d+|\$\{.*\})$/)
+            _locator = _mResult[1]
+            _op = _mResult[2]
+            _v = Scoutui::Base::UserVars.instance.normalize(_mResult[3]).to_i
+
+            ## _v should be an integer
+
+            _bm=Benchmark.measure {
+              hits = Scoutui::Base::QBrowser.findElements( { :driver => my_driver, :locator => _locator })
+
+
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process COUNT : #{_locator} is #{_op} val #{_v}  => #{hits.length}"
+
+
+              if _op=='=='
+                _rc = hits.length == _v
+              elsif _op=='>='
+                _rc = hits.length >= _v
+              elsif _op=='<='
+                _rc = hits.length <= _v
+              elsif _op=='<'
+                _rc = hits.length < _v
+              elsif _op=='>'
+                _rc = hits.length > _v
+              elsif _op=='!='
+                _rc = hits.length != _v
+              end
+
+              _tmpResult=Scoutui::Base::ResultAssertion.new()
+              _tmpResult.setReport("Assert count(#{_locator}) #{_op} #{_v}.  Actual: #{hits.length}   Expected: #{_v}. : #{_rc}", _rc)
+            }
+
+
 
           elsif _a.match(/^\s*[fF]ocused\(.*\)\s*$/)
 
@@ -488,11 +534,12 @@ module Scoutui::Base
             }
 
             if _rc
-              puts __FILE__ + (__LINE__).to_s + "  focused() - MATCHED"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  focused() - MATCHED"
             end
 
           elsif _a.match(/^\s*([fF]ocused\.[Vv]alue\((.*)\))\s*$/)
             _expectedValue = _a.match(/^\s*([fF]ocused.[Vv]alue\((.*)\))\s*$/)[2].to_s
+            _expectedValue = Scoutui::Base::UserVars.instance.normalize(_expectedValue)
             _activeElt=nil
             _value=nil
 
@@ -504,7 +551,7 @@ module Scoutui::Base
 
                 Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  activeElt.value  : |#{_value.to_s}|"
 
-                _rc=!(_value.to_s.match(/#{_expectedValue}/).nil?)
+                _rc=!(_value.to_s.match(/#{_expectedValue}/).nil?) || (_value.to_s==_expectedValue)
               end
             }
 
@@ -534,11 +581,14 @@ module Scoutui::Base
                   Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  activeElt.value : |#{_activeElt.attribute('value').to_s}|"
                 end
 
-                _rc=!(_activeElt.text.to_s.match(/#{_targetTxt}/).nil?) # || _activeElt.text.to_s==_targetTxt.to_s
+              #  _rc=!(_activeElt.text.to_s.match(/#{_targetTxt}/).nil?) # || _activeElt.text.to_s==_targetTxt.to_s
+                _rc= (!_activeElt.text.to_s.match(Regexp.new(_targetTxt)).nil?) || (_activeElt.text.to_s==_targetTxt)
 
-                if _a.match(/^\s*!focused/)
-                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " verify #{_targetTxt} != #{_activeElt.text} => #{_rc}"
+                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " isMatch : #{_rc}"
+
+                if _a.match(/^\s*![fF]ocused\./)
                   _rc=!_rc
+                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " verify #{_targetTxt} != #{_activeElt.text} => #{_rc}"
                 end
 
                 Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  FocusedText : #{_activeElt.text} => #{_rc}"
@@ -546,6 +596,7 @@ module Scoutui::Base
             }
 
             if _activeElt.is_a?(Selenium::WebDriver::Element)
+              _assertText = "Verify #{_a} - focused: #{_activeElt.text}, expected: #{_targetTxt} - #{_rc}"
               Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ASSERT: focusTxt: #{_targetTxt} vs #{_activeElt.text} => #{_rc}"
             end
 
@@ -568,7 +619,7 @@ module Scoutui::Base
 
           elsif !_a.match(/^page\([\w\d]+\)/).nil?
 
-            puts __FILE__ + (__LINE__).to_s + "\n\n=== Validate Page ==="
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "\n\n=== Validate Page ==="
 
             _obj = processPageElement(my_driver, nil, _a)
 
@@ -576,7 +627,7 @@ module Scoutui::Base
             #puts __FILE__ + (__LINE__).to_s + " *** WHAT type of assertion => #{_obj}"; STDIN.gets
 
           elsif !_a.match(/^\s*accessibility\s*$/).nil?
-            puts __FILE__ + (__LINE__).to_s + " *** Accessibility ***"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " *** Accessibility ***"
 
 
             # 5150
@@ -586,6 +637,18 @@ module Scoutui::Base
             end
 
  #          textAreas = Scoutui::Base::QBrowser.getObjects( { :driver => my_driver, :locator => '//textarea' })
+
+
+         # elsif _a.match(/^\s*[!](existsalert|existsalert|exists\(alert\))/i)
+            elsif Scoutui::Commands::Utils.instance.isExistsAlert?(_a)
+            _bm=Benchmark.measure {
+
+              _c = Scoutui::Commands::JsAlert::ExistsAlert.new(_a)
+              _rc = _c.execute(my_driver)
+              _assertMessage = _c.getAssertText()
+              #_rc = _c.alertExists?
+              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " existsAlert => #{_rc}"
+            }
           end
 
           if !_rc.nil?
@@ -596,7 +659,21 @@ module Scoutui::Base
 
               _testcase = Scoutui::Utils::TestUtils.instance.getTC() || "visible_when"
 
-              Testmgr::TestReport.instance.getReq(_req).get_child(_testcase).add(_rc, "Assert #{_a}", _bm.real)
+#              _assertMessage = "Assert #{_a}."
+
+              if !_tmpResult.nil?
+                _assertMessage+=" #{_tmpResult.report}"
+              end
+
+              Testmgr::TestReport.instance.getReq(_req).get_child(_testcase).add(_rc, _assertMessage, _bm.real)
+
+              if Scoutui::Utils::TestUtils.instance.isFailFast? && !_rc
+
+                _assertText =  "Failed assertion: #{_a.to_s}" if _assertText.nil?
+                Scoutui::Utils::TestUtils.instance.setState(:abort, _assertText)
+
+              end
+
             end
 
             Scoutui::Commands::Utils.instance.resetFrameSearch()
@@ -1230,7 +1307,10 @@ module Scoutui::Base
 
               elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)
 
-                if !Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+                _tmpRc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+
+              #  if !Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+                if !_tmpRc.passed?
                   Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value doesnt match"
                   _executeIt = false
                 end
@@ -1397,9 +1477,12 @@ module Scoutui::Base
 
         if !isRun(e).nil?
 
-          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ========> RUN <================="
+
           tmpSettings=test_settings.dup
-          tmpSettings["dut"]=e[STEP_KEY]["run"].to_s
+          tmpSettings["dut"]=Scoutui::Base::UserVars.instance.normalize(e[STEP_KEY]["run"].to_s)
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ========> RUN #{tmpSettings['dut']} <================="
+
 
           Scoutui::Logger::LogMgr.instance.info " RUN Command file : #{tmpSettings["dut"]}"
           processFile(eyeScout, tmpSettings, strategy)
@@ -1436,7 +1519,7 @@ module Scoutui::Base
               if Scoutui::Utils::TestUtils.instance.isFailFast? && !_command.passed?
                 Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "FAIL FAST => #{_command.passed?}"
                 Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Failfast.";
-                Scoutui::Utils::TestUtils.instance.setState(:abort)
+                Scoutui::Utils::TestUtils.instance.setState(:abort, "Step #{i.to_s} : #{_name.to_s} : #{_action.to_s}")
                 takeScreenShot(my_driver, "step_#{i}.failed")
                 return
               end
@@ -1478,12 +1561,12 @@ module Scoutui::Base
 
               _shotName="step_#{i}.failed"
               if !_name.nil?
-                _shotName = "#{_name.to_s}.#{_shotName}"
+                _shotName = "#{_shotName}.#{_name.to_s}"
               end
 
               takeScreenShot(my_driver, _shotName)
 
-              Scoutui::Utils::TestUtils.instance.setState(:abort, 'Failed assertion with failfast enabled.')
+              Scoutui::Utils::TestUtils.instance.setState(:abort, "Step #{i.to_s}. #{_name.to_s}")
               return
             end
 
@@ -1524,7 +1607,7 @@ module Scoutui::Base
             if Scoutui::Utils::TestUtils.instance.screenShots? || (Scoutui::Utils::TestUtils.instance.screenShotsOnFailure? && !_assertResult)
               _shotName="step_#{i}"
               if !_name.nil?
-                _shotName = "#{_name.to_s}.#{_shotName}"
+                _shotName = "#{_shotName}.#{_name.to_s}"
               end
 
               takeScreenShot(my_driver, _shotName)