uttk 0.3.1.2

data/test/fixtures/unit/error.rb

@@ -0,0 +1,6 @@
+
+
+
+
+
+42s

data/test/fixtures/unit/good.rb

@@ -0,0 +1,26 @@
+
+
+
+class Good
+
+
+end
+
+
+test_section __FILE__ do
+
+class GoodTest < Test::Unit::TestCase
+
+  def test_1
+    assert(true)
+  end
+
+  def test_2
+    assert(true, 'good')
+    assert(true, 'very good')
+  end
+
+end
+
+end
+

data/test/functional-suite.yml

@@ -0,0 +1,10 @@
+#FIXME: this test suite is not deterministic since timeout feature can imply
+#       an inconsistent result and so dumpers may raise an exception!
+---
+
+Uttk functional test suite: !S::Iterate
+  over: !pathlist <<pwd>>/functional/(*).yml
+  iter: [it_file, it_name]
+  test:
+    Test <<it_name>>: !S::Import
+      import: <<it_file>>

data/test/functional/author.yml

@@ -0,0 +1,11 @@
+# Test an exam tarball with an author
+---
+
+Prepare tarball and test (author.yml): !S::Suite
+  contents:
+    - Checkout the tarball: !S::Checkout
+        url: file://<<pwd>>/../fixtures/ball/20040804-exam_a1-zapngo-tessar_m.tar.gz
+        fatal: true
+    - Test the AUTHORS file: !S::Authors
+        author: tessar_m
+        dir: <<extract_dir>>

data/test/functional/base.yml

@@ -0,0 +1,119 @@
+---
+
+Test the basic features of Strategy and Suite (base.yml): !S::Suite
+  contents:
+    - pass: !S::Pass {}
+    - fail: !S::Fail
+        weight: -1
+    - error: !S::Error
+        weight: -1
+    - stub: !S::Stub
+        returned_value:
+          foo: bar
+          toto: tata
+    - abort: !S::Abort
+        weight: -1
+    - pass output: !S::RMatch
+        test: !S::Pass {}
+        match: [//status/PASS]
+    - fail output: !S::RMatch
+        test: !S::Fail {}
+        match: [//status/FAIL]
+    - error output: !S::RMatch
+        test: !S::Error {}
+        match: [//status/ERROR]
+    - stub output: !S::RMatch
+        test: !S::Stub
+          returned_value:
+            foo: bar
+            toto: tata
+        match:
+          - //foo/bar
+          - //toto/tata
+    - abort output: !S::RMatch
+        test: !S::Abort {}
+        match: [//status/ABORT]
+    - timeout sleep output: !S::RMatch
+        test: !S::Sleep
+          delay: 0.5
+          timeout: 0.2
+        match:
+          - //status/ABORT
+          - //reason/abort 'test' with timeout 0.2s
+    - timeout_suite: !S::Suite
+        timeout: 0.3
+        weight: -1
+        attributes: !S::Sleep
+          delay: 0.1
+        contents:
+          - a
+          - b
+          - c
+          - d
+    - cmd: !S::Cmd
+        command: 'true'
+        exit: 0
+    - bad cmd: !S::Cmd
+        weight: -1
+        command: /bin/unexisting_command
+        exit: 0
+    - abort cmd: !S::Suite
+        contents:
+          - cmd: !S::Cmd
+              weight: -1
+              timeout: 0.1
+              command: sleep
+              args: 1
+          - check for zombies: !S::KillAll
+              regexp: !re sleep
+    - abort suite cmd: !S::Suite
+        contents:
+          - suite: !S::Suite
+              weight: -1
+              timeout: 0.1
+              contents:
+                - cmd: !S::Cmd
+                   command: sleep
+                   args: 1
+          - check for zombies: !S::KillAll
+              regexp: !re sleep
+    - timeout suite of suite: !S::Suite
+        weight: -1
+        timeout: 0.01
+        contents:
+          - suite: !S::Suite
+              contents:
+                - pass: !S::Sleep
+                    delay: 0.1
+
+    - true pre assertion and pass: !S::Pass
+        pre_assertion: true
+
+    - true pre assertion and fail: !S::Fail
+        pre_assertion: true
+        weight: -1
+
+    - false pre assertion and pass: !S::Pass
+        pre_assertion: false
+        weight: -1
+
+    - exception pre assertion and pass: !S::Pass
+        pre_assertion: raise 'ASSERT'
+        weight: -1
+
+
+    - true post assertion and pass: !S::Pass
+        post_assertion: true
+
+    - true post assertion and fail: !S::Fail
+        post_assertion: true
+        weight: -1
+
+    - false post assertion and pass: !S::Pass
+        post_assertion: false
+        weight: -1
+
+    - exception post assertion and pass: !S::Pass
+        post_assertion: raise 'ASSERT'
+        weight: -1
+

data/test/functional/base_pool.yml

@@ -0,0 +1,13 @@
+---
+Base tests for the pool feature: !S::Suite
+  contents:
+    - Timeout Pool: !S::Pool
+        weight: -1
+        timeout: 0.3
+        attributes: !S::Sleep
+          delay: 0.4
+        contents:
+          - a
+          - b
+          - c
+          - d

data/test/functional/block.yml

@@ -0,0 +1,13 @@
+---
+
+Check Block (block.yml): !S::Suite
+  attributes: !S::Block {}
+  contents:
+    - test simple good block:
+        test: " 42 == 42 "
+    - test simple bad block:
+        test: " 42 == 43 "
+        weight: -1
+    - test simple block which raise an exception:
+        test: " fail('Explictly failed') "
+        weight: -1

data/test/functional/cat.yml

@@ -0,0 +1,16 @@
+---
+
+Test cat program: !S::Suite
+  contents:
+
+    - simple equal: !S::Cmd
+        command: cat
+        input: !path <<pwd>>/cat.yml
+        output: !path <<pwd>>/cat.yml
+
+    - simple different: !S::Cmd
+        command: cat
+        weight: -1
+        input: !path <<pwd>>/cat.yml
+        output: !path <<pwd>>/../fixtures/text/1.txt
+

data/test/functional/cmd.yml

@@ -0,0 +1,17 @@
+---
+
+Test suite for the Cmd strategy: !S::Suite
+
+  contents:
+
+# FIXME restore these tests and remove these weights
+    - segfault ruby: !S::Cmd
+       command: ruby
+       args: <<pwd>>/../fixtures/binaries/segv.rb
+       exit: 134
+       weight: -1
+
+    - segfault C: !S::Cmd
+       command: <<pwd>>/../fixtures/binaries/segv
+       exit: 139
+       weight: -1

data/test/functional/diff.yml

@@ -0,0 +1,27 @@
+---
+
+Test Cmd with StreamDiff: !S::Suite
+  attributes: !S::Cmd
+    stream_class: Diff
+    command: cat
+  contents:
+
+    - simple valid:
+        input: |
+          foo
+          bar bar
+          fuu
+        output: |
+          foo
+          bar bar
+          fuu
+
+    - simple invalid:
+        weight: -1
+        input: |
+          foo
+          bar bar
+          fuu
+        output: |
+          foo
+          fuu

data/test/functional/env_cmd.yml

@@ -0,0 +1,53 @@
+---
+
+Test the env feature in S::Cmd (env_cmd.yml): !S::Suite
+  contents:
+
+    - Check the env propagation with S::Cmd: !S::Suite
+        attributes: !S::Cmd
+          command: <<ruby>> -e "print ENV['FOO']"
+          exit: 0
+
+        contents:
+          - simple env:
+              env:
+                FOO: bar
+                DISPLAY: foo.bar:0
+              output: bar
+
+          - set symtbl[:bar] to 42: !S::Block
+              test: @symtbl[:bar] = 42
+              weight: 0
+
+          - advanced test <<bar>>:
+              env: { FOO: <<bar>> }
+              output: 42
+
+          - set symtbl[:foo] to 44: !S::Block
+              test: @symtbl[:foo] = 44
+              weight: 0
+
+          - double substitution test <<bar>>:
+              env: { FOO: <<bar>>43<<foo>> }
+              output: 424344
+
+---
+# FIXME these tests below was not ran since a long time the env feature no
+# more works on blocks.
+        symbols:
+          env:
+            A: B
+            C: <<pwd>>/D
+        attributes: !S::Block {}
+        contents:
+          - Verify A in env:
+              test: "ENV['A'] == 'B'"
+          - Verify the suffix of C in env:
+              test: "ENV['C'] =~ /\/D$/"
+          - Verify the prefix of C in env:
+              test: "ENV['C'] == '<<pwd>>/D'"
+          - Append something to A:
+              symbols:
+                env:
+                  A: $A:E
+              test: "ENV['A'] == 'B:E'"

data/test/functional/exit.yml

@@ -0,0 +1,15 @@
+---
+
+Test the exit status verification: !S::Suite
+  attributes: !S::Cmd {}
+  contents:
+    - test1 true exit 0:
+        command: 'true'
+        exit: 0
+    - test2 false exit 1:
+        command: 'false'
+        exit: 1
+    - test3 false exit 42:
+        command: 'false'
+        exit: 42
+        weight: -1

data/test/functional/fatal.yml

@@ -0,0 +1,23 @@
+---
+
+Test the fatal option (fatal.yml): !S::Suite
+  contents:
+    - 1/5 must pass: !S::Suite
+        attributes: !S::Pass {}
+        contents:
+          - test1 must fail: !S::Fail
+              weight: -1
+          - test2 must pass: {}
+          - test3 must be fatal: !S::Fail
+              fatal: true
+              weight: -1
+          - test4 not tested: { weight: -4 }
+          - test5 not tested: { weight: -4 }
+
+    - test6 must pass: !S::Pass
+        fatal: true
+
+    - test7 must fail: !S::Fail
+        weight: -1
+
+    - test8 must pass: !S::Pass {}

data/test/functional/glob.yml

@@ -0,0 +1,11 @@
+---
+
+Test a list of tarballs (glob.yml): !S::Iterate
+  over: !pathlist <<pwd>>/../fixtures/ball/(*).tar.bz2
+  iter: [ it_file, it_name ]
+  test:
+    Useless test suite for <<it_name>>: !S::Suite
+      contents:
+        - Pass 1: !S::Pass {}
+        - Fail 1: !S::Fail { weight: -1 }
+        - Pass 2: !S::Pass {}

data/test/functional/hexa-diff.yml

@@ -0,0 +1,25 @@
+---
+
+Test Cmd with StreamHexaDiff: !S::Suite
+  attributes: !S::Cmd
+    stream_class: HexaDiff
+    command: cat
+  contents:
+
+    - simple valid:
+        input: |
+          foo
+          bar bar
+          fuu
+        output: |
+          foo
+          bar bar
+          fuu
+
+    - simple invalid:
+        weight: -1
+        input: |
+          foo
+          bar bar
+          fuu
+        output: !path <<pwd>>/../fixtures/text/1.txt

data/test/functional/import.yml

@@ -0,0 +1,41 @@
+---
+
+Test the import strategy: !S::Suite
+  contents:
+
+    - Basic: !S::Import
+        import: '<<pwd>>/exit.yml'
+
+    - Generate a test: !S::Block
+        fatal: true
+        weight: 0
+        test: |
+          tmp = TempPath.new('import', 'yml')
+          @symtbl[:tmp] = tmp.expand_path
+          tmp.open('w') do |tmp|
+            tmp << '--- A bad test: !S::Fail {}'
+          end
+
+    - Test the generated test: !S::RMatch
+        test: !S::Import
+          import: '<<tmp>>'
+        match:
+          - //A bad test/status/FAIL
+          - //status/FAIL
+
+    - Clean: !S::Block
+        fatal: true
+        test: '@symtbl[:tmp].unlink'
+
+    - Bad pwd handling: !S::Suite
+
+        contents:
+
+          - Basic 1: !S::Import
+             loader: Ruby
+             import: '<<pwd>>/../ruby/wc.rb'
+
+          - Basic 2: !S::Import
+             import: '<<pwd>>/wc.yml'
+
+