uttk 0.3.1.2

data/test/functional/weight.yml

@@ -0,0 +1,152 @@
+---
+
+Test the weight system: !S::Suite
+  contents:
+    - All or nothing (0%): !S::RMatch
+        test: !S::Suite
+          wclass: W::WMin
+          contents:
+            - Suppose to PASS 1: !S::Pass {}
+            - Suppose to PASS 2: !S::Pass {}
+            - Suppose to FAIL 3: !S::Fail {}
+        match:
+          - ///1/status/PASS$
+          - ///2/status/PASS$
+          - ///3/status/FAIL$
+          - //status/FAIL$
+
+    - All or nothing (100%): !S::RMatch
+        test: !S::Suite
+          wclass: W::WMin
+          contents:
+            - Suppose to PASS 4: !S::Pass {}
+            - Suppose to FAIL 5: !S::Fail
+                weight: -1
+            - Suppose to PASS 6: !S::Pass {}
+        match:
+          - ///4/status/PASS$
+          - ///5/status/FAIL$
+          - ///6/status/PASS$
+          - //status/PASS$
+
+    - Percentage (70%): !S::RMatch
+        test: !S::Suite
+          contents:
+            - Suppose to PASS 7: !S::Pass {}
+            - Suppose to PASS 8: !S::Pass
+                weight: 2
+            - Sub suite (25%): !S::Suite
+                contents:
+                  - Suppose to PASS 9: !S::Pass {}
+                  - Suppose to FAIL 10: !S::Fail
+                      weight: 2
+                  - Suppose to FAIL 11: !S::Fail {}
+            - Suppose to FAIL 12: !S::Fail {}
+            - Suppose to PASS 13: !S::Pass {}
+        match:
+          - ///7/status/PASS$
+          - ///8/status/PASS$
+          - ///Sub//9/status/PASS$
+          - ///Sub//10/status/FAIL$
+          - ///Sub//11/status/FAIL$
+          - ///Sub/status/FAIL\(25%\)$
+          - //status/FAIL\(70%\)$
+
+    - Fatal pass (100%): !S::RMatch
+        test: !S::Suite
+          attributes: !S::Pass {}
+          contents:
+            - Suppose to PASS 14:
+                fatal: true
+            - Suppose to PASS 15: {}
+        match:
+          - ///14/status/PASS$
+          - ///15/status/PASS$
+          - //status/PASS$
+
+    - Fatal fail (20%): !S::RMatch
+        test: !S::Suite
+          contents:
+            - Suppose to PASS 15.5: !S::Pass
+                fatal: true
+            - Suppose to FAIL 16: !S::Fail
+                fatal: true
+            - Suppose to be not tested 17: !S::Pass {}
+            - Suppose to be not tested 17.5: !S::Fail
+                weight: 2
+        match:
+          - ///15.5/status/PASS$
+          - ///16/status/FAIL$
+          - //status/FAIL\(20%\)$
+        dont_match:
+          - ///17
+
+    - Fatal pass but other fail (50%): !S::RMatch
+        test: !S::Suite
+          contents:
+            - Suppose to PASS 18: !S::Pass
+                fatal: true
+            - Suppose to FAIL 19: !S::Fail {}
+        match:
+          - ///18/status/PASS$
+          - ///19/status/FAIL$
+          - //status/FAIL\(50%\)$
+
+    - Fatal pass but no weight (100%): !S::RMatch
+        test: !S::Suite
+          attributes: !S::Pass {}
+          contents:
+            - Suppose to PASS 20:
+                weight: 0
+                fatal: true
+            - Suppose to PASS 21: {}
+            - Suppose to PASS 22: {}
+        match:
+          - ///20/status/PASS$
+          - ///21/status/PASS$
+          - ///22/status/PASS$
+          - //status/PASS$
+
+    - Fatal fail but no weight (0%): !S::RMatch
+        test: !S::Suite
+          attributes: !S::Pass {}
+          contents:
+            - Suppose to FAIL 23: !S::Fail
+                weight: 0
+                fatal: true
+            - Suppose to be not tested 24: {}
+            - Suppose to be not tested 25: {}
+        match:
+          - ///23/status/FAIL$
+          - //status/FAIL$
+        dont_match:
+          - ///24
+          - ///25
+
+    - Negative (66%): !S::RMatch
+        test: !S::Suite
+          attributes: !S::Pass {}
+          contents:
+            - Suppose to PASS 26: {}
+            - Suppose to PASS 27:
+                weight: -1
+            - Suppose to PASS 28: {}
+        match:
+          - ///26/status/PASS$
+          - ///27/status/PASS$
+          - ///28/status/PASS$
+          - //status/FAIL\(66%\)$
+
+    - Negative (100%): !S::RMatch
+        test: !S::Suite
+          attributes: !S::Pass {}
+          contents:
+            - Suppose to PASS 29: {}
+            - Suppose to PASS 30: !S::Fail
+                weight: -1
+            - Suppose to PASS 31: {}
+        match:
+          - ///29/status/PASS$
+          - ///30/status/FAIL$
+          - ///31/status/PASS$
+          - //status/PASS$

data/test/pkg-suite.yml

@@ -0,0 +1,8 @@
+---
+
+Test suite for Uttk packages: !S::Iterate
+  over: !pathlist <<pwd>>/pkg/(*).yml
+  iter: [it_file, it_name]
+  test:
+    Test <<it_name>>: !S::Import
+      import: !path <<it_file>>

data/test/pkg/cmdline.yml

@@ -0,0 +1,80 @@
+---
+
+Tests for command line Uttk options: !S::Suite
+  attributes: !S::Cmd
+    command : <<uttk>>
+    error   : ""
+    exit    : 0
+  contents:
+    - version:
+        args: --version
+        output: !re |
+          Uttk version \d+\.\d+ \{.*\} \[\w+\]
+
+          Copyright \(c\) 2004(?:, \d+)* Nicolas Despr�s, Nicolas Pouillard
+          This is free software; see the source for copying conditions\. There is NO
+          warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE\.
+
+    - authors:
+        args: --authors
+        output: !re |
+          ---
+          Uttk was written by and with the assistance of:(\n|.)*
+            - Vincent Cuissard.*:(\n|.)*
+            - Nicolas Despr�s.*:(\n|.)*
+            - Nicolas Pouillard.*:(\n|.)*
+
+    - help:
+        args: --help
+        output: !re [^---\nUsage.*Team, m]
+
+    - long help:
+        args: --long-help
+        output: !re [^---\nUsage.*Strategy options.*Team, m]
+
+    - long help on Strategy:
+        args: --long-help Strategy
+        output: !re [^Uttk::Strategies::Strategy:.*name:, m]
+
+    - unknown option:
+        args: --this-option-does-not-exists
+        error: |
+          ERROR:
+            invalid option: --this-option-does-not-exists (OptionParser)
+        exit: 1
+
+    - Strategy list:
+        args: --strategy-list
+        output: !re |
+          ^Uttk::Strategies classes hierarchy:
+          /Strategy/
+
+    - Loader list:
+        args: -L
+        output: !re |
+          ^Uttk::Loaders classes hierarchy:
+          /Loader/
+
+    - Filter list:
+        args: -F
+        output: !re |
+          ^Uttk::Logger classes hierarchy:
+          /Backend/
+
+    - Symbol option:
+        args: |
+          -L Ruby -F Yaml -S '{ foo: bar }'
+        input: |
+          S::Stub.new("stub") do
+            returned_value({ :foo => "<<foo>>" })
+          end
+        output: |
+          ---
+          root: !S::Suite
+            symbols:
+              foo: bar
+            contents:
+              - stub: !S::Stub
+                  foo: bar
+                  status: PASS
+            status: PASS

data/test/pool-suite.yml

@@ -0,0 +1,8 @@
+---
+
+Pool Test Suite for Uttk: !S::Iterate
+  over: !pathlist <<pwd>>/pool/(*).yml
+  iter: [it_file, it_name]
+  test:
+    Test <<it_name>>: !S::Import
+      import: <<it_file>>

data/test/pool/base.yml

@@ -0,0 +1,12 @@
+---
+
+A simple test of timeout on a pool: !S::Pool
+  weight: -1
+  timeout: 0.3
+  attributes: !S::Sleep
+    delay: 0.4
+  contents:
+    - a
+    - b
+    - c
+    - d

data/test/pool/pool.yml

@@ -0,0 +1,25 @@
+# Can be non deterministic if the system takes more than 2 second to kill all
+# the processes. In such a case the summary is 66%.
+---
+
+Test The Pool Feature (pool.yml): !S::Suite
+  attributes: !S::Pool
+    attributes: !S::Cmd
+      command: sleep
+      args: 2
+    contents: [ a, b, c, d, e, { f: { args: 1 } }, g, h, i, j, k, l, m, n ]
+  contents:
+
+    - I am suppose to PASS:
+        timeout: 6
+
+    - I am suppose to ABORT:
+        timeout: 0.1
+        weight: -1
+
+    - I am suppose to ABORT but with some PASS:
+        timeout: 1.9
+        weight: -1
+
+    - Zombie Verification Killall: !S::KillAll
+        regexp: !re sleep

data/test/ruby-suite.rb

@@ -0,0 +1,10 @@
+
+S::Iterate.new 'Uttk Ruby loader functional test suite' do
+  over PathList['<<pwd>>/ruby/(*.rb)']
+  iter ['path', 'basename']
+  # FIXME make the non hash version works
+  # test do
+    # S::Import.new("Test <<basename>>") { import '<<path>>' }
+  # end
+  test(S::Import.new("Test <<basename>>") { import '<<path>>' })
+end

data/test/ruby-suite.yml

@@ -0,0 +1,5 @@
+---
+
+Yaml proxy for the ruby-suite: !S::Import
+  loader: Ruby
+  import: '<<pwd>>/ruby-suite.rb'

data/test/ruby/base.rb

@@ -0,0 +1,119 @@
+
+# You are in the context of the Uttk module.
+# You can access the table of symbols with this local variable: symtbl.
+
+# You can factorize some code this way:
+def self.check_for_zombies
+  S::KillAll.new('check for zombies') do
+    regexp(/sleep/)
+  end
+end
+
+
+S::Suite.new('Test the basic features of Strategy and Suite (base.rb)') do
+  contents [
+    S::Pass.new('pass'),
+    S::Fail.new('fail') { weight(-1) },
+    S::Error.new('error') { weight(-1) },
+    S::Stub.new('stub') {
+      returned_value 'foo' => 'bar', 'toto' => 'tata'
+    },
+    S::Abort.new('abort') { weight(-1) },
+    S::Sleep.new('timeout_strategy') {
+      delay 0.5
+      timeout 0.2
+      weight(-1)
+    },
+    S::Suite.new('timeout_suite') {
+      timeout 0.3
+      weight(-1)
+      attributes :strategy => S::Sleep, :delay => 0.1
+      contents [ 'a', 'b', 'c', 'd' ]
+    },
+    S::Pool.new('timeout_pool') do
+      weight(-1)
+      timeout 0.3
+      attributes({
+        :strategy => S::Sleep,
+        :delay => 0.4
+      })
+      contents %w(a b c d)
+    end,
+    S::Cmd.new('cmd') do
+      command 'true'
+      exit 0
+    end,
+    S::Cmd.new('bad cmd') do
+      weight(-1)
+      command '/bin/unexisting_command'
+      exit 0
+    end,
+    S::Suite.new('abort cmd') do
+      contents [
+        S::Cmd.new('cmd') {
+          weight(-1)
+          timeout 0.1
+          command 'sleep'
+          args 1
+        },
+        Uttk.check_for_zombies
+      ]
+    end,
+    S::Suite.new('abort suite cmd') do
+      contents [
+        S::Suite.new('suite') {
+          weight(-1)
+          timeout 0.1
+          contents [
+            S::Cmd.new('cmd') {
+              command 'sleep'
+              args 1
+            }
+          ]
+        },
+        Uttk.check_for_zombies
+      ]
+    end,
+    S::Suite.new('timeout suite of suite') do
+      weight(-1)
+      timeout { 0.01 } # May use a block too
+      contents [
+        S::Suite.new('suite') {
+          contents [ S::Sleep.new('pass') { delay 0.1 } ]
+        }
+      ]
+    end,
+    # Must create a block for {pre,post}_assertion otherwise it is not evaluate
+    # at runtime but at creation time.
+    S::Pass.new('true pre assertion and pass') do
+      pre_assertion lambda { true }
+    end,
+    S::Fail.new('true pre assertion and fail') do
+      weight(-1)
+      pre_assertion Proc.new { true }
+    end,
+    S::Pass.new('false pre assertion and pass') do
+      weight(-1)
+      pre_assertion proc { false }
+    end,
+    S::Pass.new('exception pre assertion and pass') do
+      weight(-1)
+      pre_assertion proc { raise 'ASSERT' }
+    end,
+    S::Pass.new('true post assertion and pass') do
+      post_assertion proc { true }
+    end,
+    S::Fail.new('true post assertion and fail') do
+      weight { -1 }
+      post_assertion proc { true }
+    end,
+    S::Pass.new('false post assertion and pass') do
+      weight { -1 }
+      post_assertion proc { false }
+    end,
+    S::Pass.new('exception post assertion and pass') do
+      weight { -1 }
+      post_assertion proc { raise 'ASSERT' }
+    end
+  ]
+end

data/test/ruby/iterate.rb

@@ -0,0 +1,21 @@
+S::Suite.new 'Test the Iterate strategy (Ruby Loader)' do
+  contents [
+    S::Iterate.new('Iterate over a range of S::Pass') {
+      over 0...4
+      with :each
+      iter :it
+      test S::Pass.new('<<it>>')
+    },
+    S::Iterate.new('Iterate over a range of S::Assert') {
+      over 0...4
+      with :each
+      iter :it
+      test(S::Assert.new('Test on turn <<it>>') {
+        test("
+          assert_equal('<<it>>', '<<it:i>>')
+          assert_equal('<<it>>', '<<it:0>>')
+        ")
+      })
+    }
+  ]
+end