uttk 0.3.1.2

data/test/functional/iterate.yml

@@ -0,0 +1,99 @@
+Test the Iterate strategy: !S::Suite
+  contents:
+    - Iterate over a range: !S::Iterate
+        over: !range 0...4
+        with: each
+        iter: it
+        test:
+          Test on turn <<it>>: !S::Assert
+            test: |
+              assert_equal('<<it>>', '<<it:i>>')
+              assert_equal('<<it>>', '<<it:0>>')
+
+    - Iterate over a range of Error: !S::Iterate
+        over: !range 0...4
+        with: each
+        iter: it
+        test:
+          Test on turn <<it>>: !S::Error
+            weight: -1
+
+    - Nested iterations: !S::Iterate
+        over: !range 0..2
+        iter: ita
+        test:
+          Sub iteration <<ita>>: !S::Iterate
+            over: !range 0..1
+            iter: itb
+            test:
+              Iteration (<<ita>>, <<itb>>): !S::Pass {}
+
+    - Setup a ruby extension for tests: !S::Block
+        test: |
+          module ::Enumerable
+            def uttk_test_iterate_each ( *a, &b )
+              uttk_each { |a| b[*(a.to_a)] }
+            end
+          end
+          true
+
+    - Many iterators can be used: !S::Suite
+        symbols:
+          results: []
+        contents:
+          - Feed the result list: !S::Iterate
+              over: [it, [ita, itb, itc, itd, ite]]
+              with: uttk_test_iterate_each
+              iter: pit
+              test:
+                Iterate with this iterator <<*pit>>: !S::Iterate
+                  over: !ruby |
+                    [0..4, 2..2, 'a'..'c']
+                  with: uttk_test_iterate_each
+                  iter: <<*pit>>
+                  test:
+                    Many iterators <<<<pit>>:i>>: !S::Block
+                      test: |
+                        @symtbl[:results] << '<<<<pit>>:i>>, <<*<<pit>>>>, ' +
+                          '"<<<<pit>>>>", "<<<<pit>>:1>>", "<<<<pit:2>>>>"'
+
+          - Check the results contents: !S::Assert
+              symbols:
+                ref_results:
+                  - '0, [0, 1, 2, 3, 4], "0", "1", "<<<<pit:2>>>>"'
+                  - '1, [2], "2", "1", "<<<<pit:2>>>>"' # the 2nd "1" is undef
+                  - '2, ["a", "b", "c"], "a", "b", "<<<<pit:2>>>>"'
+                  - '0, [0, 1, 2, 3, 4], "0", "1", "2"'
+                  - '1, [2], "2", "1", "2"'
+                  - '2, ["a", "b", "c"], "a", "b", "c"'
+              test: |
+                assert_equal(@symtbl[:ref_results], @symtbl[:results])
+
+    - Iterate can deal with many structures: !S::Suite
+        symbols:
+          results: []
+        attributes: !S::Iterate
+          iter: it
+          test:
+            Iterate over many structures <<it:i>>: !S::Block
+              test: |
+                @symtbl[:results] << '<<*it>>'
+        contents:
+          - Iterate over arrays:
+              over: [1, 3, 7, 1042]
+          - Iterate over ranges:
+              over: !ruby "'p'..'r'" # FIXME !range
+          - Iterate over a pathname list:
+              over: !filelist <<pwd>>/../fixtures/ball/*-mini-lib.tar.*
+          - Iterate over a hash:
+              over:
+                foo: bar
+                bar: baz
+                qux: foo
+          - Iterate over a Ruby value:
+              over: !ruby |
+                [2] * 3
+
+          - Check the results contents: !S::Assert
+              test: |
+                assert_equal(17, @symtbl[:results].size)

data/test/functional/killall.yml

@@ -0,0 +1,31 @@
+#FIXME: return always 83% with the new input format.
+---
+
+The KillAll test suite: !S::Suite
+  attributes: !S::KillAll {}
+  contents:
+
+    - Kill when nothing to kill:
+        regexp: !re unexisting_process
+
+    - Killall sleep 1:
+        regexp: !re sleep 42
+        weight: 0
+
+    - Killall sleep 2:
+        regexp: !re sleep 42
+
+    - Launch a long command in background: !S::Cmd
+        command: sleep 42 &
+        fatal: true
+
+    - Killall sleep 3:
+        regexp: !re sleep 42
+        weight: -1
+
+    - Wait a little bit: !S::Sleep
+        delay: 0.1
+
+    - Zombie Verification Killall: !S::Cmd
+        exit: 1
+        command: killall -v sleep

data/test/functional/pkg.yml

@@ -0,0 +1,14 @@
+---
+
+Test the Package strategy: !S::Suite
+  attributes: !S::Package {}
+  contents:
+    - Test the foo package:
+        url: file://<<pwd>>/../fixtures/package/pkg_foo.tar.gz
+        test:
+          Test yo: !S::Cmd
+            dir: '<<extract_dir>>'
+            command: ./foo.sh
+            output: |
+              Foo !!!
+            exit: 0

data/test/functional/probability_threshold.yml

@@ -0,0 +1,35 @@
+---
+
+Test the ProbabilityThreshold strategy: !S::Suite
+
+    attributes: !S::ProbabilityThreshold
+        test:
+            Simple test (0.625): !S::Fail
+                value: 0.625
+
+    contents:
+
+        - bad too high:
+            threshold: 1.1
+            weight: -1
+
+        - bad too low:
+            threshold: -0.1
+            weight: -1
+
+        - strict threshold:
+            threshold: 1
+            weight: -1
+
+        - easy threshold:
+            threshold: 0
+
+        - exact:
+            threshold: 0.625
+
+        - too high:
+            threshold: 0.9
+            weight: -1
+
+        - low:
+            threshold: 0.5

data/test/functional/r_unit.yml

@@ -0,0 +1,26 @@
+---
+RUnit strategy test suite: !S::RMatch
+  symbols:
+    unit_dir: <<pwd>>/../fixtures/unit
+  test: !S::Suite
+    attributes: !S::RUnit {}
+    contents:
+      - good:
+          input: !path <<unit_dir>>/good.rb
+      - bad:
+          input: !path <<unit_dir>>/bad.rb
+      - error:
+          input: !path <<unit_dir>>/error.rb
+      - good directory:
+          input: !path fixtures/unit/good.rb
+          dir: <<pwd>>/..
+          verbose: true
+      - bad directory:
+          input: !path fixtures/unit/bad.rb
+          dir: <<pwd>>/..
+  match:
+    - ///good/status/PASS
+    - ///^bad$/status/FAIL
+    - ///^bad directory$/status/FAIL
+    - ///error/status/ERROR
+    - //status/FAIL\(40%\)

data/test/functional/rmatch.yml

@@ -0,0 +1,122 @@
+Test the rmatch strategy: !S::Suite
+
+  contents:
+    - Basic test suite: !S::Suite
+
+        attributes: !S::RMatch
+          test: &basic_stub
+            a: !S::Stub
+              returned_value:
+                b:
+                  - c: d
+                  - e: very_long_one
+                g: h
+
+        contents:
+          - Simple good test:
+              match:
+                - /
+                - /a
+                - /a/b
+                - ///
+                - /a/b/c
+                - /a/b/c/d
+                - /a/b/e/very_long_one
+                - /a/b/e/very_.*_one
+                - /a/g
+                - /a/g/h
+              dont_match:
+                - /c
+                - /a/b/c/d/e
+                - ///////
+                - /a/gh
+
+          - Simple bad test 1:
+              weight: -1
+              match:
+                - /
+                - /a/b/c/d/e
+                - /a/b
+
+          - Simple bad test 2:
+              weight: -1
+              dont_match:
+                - /c
+                - /a/b/c/d
+                - /a/b/c/d/e
+
+    - Bootstrapped test suite: !S::Suite
+        contents:
+          - good test 1: !S::RMatch
+              test:
+                x: !S::RMatch
+                  test: *basic_stub
+                  match:
+                    - /a/b/e/very_long_one
+                    - /a/b/e/very_.*_one
+                    - /a/g
+                  dont_match:
+                    - /c
+                    - /a/b/c/d/e
+              dont_match:
+                - //some_wanted_paths_are_missing
+                - //some_unwanted_paths_are_present
+
+
+          - bad test 1: !S::RMatch
+              test:
+                x: !S::RMatch
+                  test: *basic_stub
+                  match:
+                    - /
+                    - /a/b/c/d/e
+                    - /a/b
+              match:
+                - //some_wanted_paths_are_missing/\/a\/b\/c\/d\/e
+              dont_match:
+                - //some_unwanted_paths_are_present
+
+          - bad test 2: !S::RMatch
+              test:
+                x: !S::RMatch
+                  test: *basic_stub
+                  dont_match:
+                    - /c
+                    - /a/b/c/d
+                    - /a/b/c/d/e
+              match:
+                - //some_unwanted_paths_are_present/^\/a\/b\/c\/d$
+              dont_match:
+                - //some_wanted_paths_are_missing
+
+    - Simple status checker: !S::RMatch
+        test:
+          First output of cache simple.yml: !S::Stub
+            returned_value:
+              root: !S::Suite
+                contents:
+                  - Relaunch 5 times this test with the cache feature to obtain a PASS: !S::Suite
+                      timeout: 1.2
+                      attributes:
+                        strategy: Uttk::Strategies::Sleep
+                        delay: 1
+                      contents:
+                        - first: !S::Sleep
+                            symbols:
+                              foo: a
+                            status: PASS
+                        - second: !S::Sleep
+                            symbols:
+                              foo: a/b
+                            status: ABORT
+                            reason: abort `second' with timeout 1.2s
+                      status: ABORT
+                      reason: abort `second' with timeout 1.2s
+                status: FAIL
+        match:
+          - /F/r/c/R
+          - /////contents/first/status/PASS
+          - /////contents/second/status/ABORT
+          - /////status/ABORT
+        dont_match:
+          - /////contents/(third|(four|fi|six)th)

data/test/functional/signal_cmd.yml

@@ -0,0 +1,22 @@
+Check SignalCmd Strategy: !S::Suite
+  attributes: !S::SignalCmd
+    command: |
+      <<ruby>> -e 'Process.kill("SEGV", $$)'
+  contents:
+
+    - Test a simple Cmd:
+        command: echo toto
+        exit   : 1
+        weight : -1
+
+    - Test a ABRT binary:
+        exit   : 0
+        weight : -1
+
+    - Test a ABRT binary and check signal:
+        signal : SEGV
+        exit   : 0
+        weight : -1
+
+    - Test a ABRT binary with good signal:
+        signal : ABRT

data/test/functional/sub.yml

@@ -0,0 +1,15 @@
+---
+
+Test sub (sub.yml): !S::Suite
+  attributes: !S::SubCmd {}
+  contents:
+    - test sub pass:
+        input: --- !S::Pass {}
+    - test sub fail: !S::RMatch
+        test: !S::SubCmd
+          input: --- !S::Fail {}
+        match:
+          - /test/root/status/FAIL
+          - /test/status/FAIL
+    - test sub with args: { args: <<pwd>>/wc.yml }
+    - test sub with input: { input: !path <<pwd>>/wc.yml }

data/test/functional/test.yml

@@ -0,0 +1,25 @@
+---
+
+Test test suite: !S::Suite
+  contents:
+    - simple digit key: !S::Test
+        expected_status: PASS
+        expected_log:
+          0: tata
+        ignored_value:
+          - benchmark
+        test:
+          simple digit key stub: !S::Stub
+            returned_value:
+              0: tata
+    - simple digit key fail: !S::Test
+        expected_status: PASS
+        expected_log:
+          0: toto
+        ignored_value:
+          - benchmark
+        test:
+          simple digit key stub: !S::Stub
+            returned_value:
+              0: tata
+        weight: -1

data/test/functional/timeout.yml

@@ -0,0 +1,20 @@
+---
+
+Test timeout option (timeout.yml): !S::Suite
+
+  attributes: !S::Cmd
+    command: sleep
+    exit: 0
+    timeout: 1
+
+  contents:
+
+    - I am suppose to FAIL:
+        args: 42
+        weight: -1
+
+    - I am suppose to PASS:
+        args: 0
+
+    - Zombie Verification Killall: !S::KillAll
+        regexp: !re sleep

data/test/functional/wc.yml

@@ -0,0 +1,26 @@
+---
+
+Test the wc command (wc.yml): !S::Suite
+  attributes: !S::Cmd
+    command: "wc -c"
+    exit: 0
+  contents:
+    - good foo:
+        input: 'foo'
+        output: !re \s*3\n$
+
+    - bad foo:
+        input: 'foo'
+        output: !re \s*4\n$
+        weight: -1
+
+    - good foo foo:
+        input: "foo\n foo"
+        output: !re \s*8\n$
+
+    - useless foo:
+        input: "foo"
+
+    - from file test:
+        input: !path '<<pwd>>/../fixtures/text/1.txt'
+        output: !re \s*272\s