uttk 0.3.1.2

data/test/unit/filters/node_cut_test.rb

@@ -0,0 +1,72 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/test/unit/filters/node_cut_test.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+test_section __FILE__ do
+
+  module Uttk
+
+    module Filters
+
+      class NodeCutTest < ::Test::Unit::TestCase
+        include Mocks::Assertions
+        include NodeCut::Assertions
+
+        @@output_string = "
+        |root:
+        |  contents:
+        |    - Test1:
+        |        status: PASS
+        |    - Test2:
+        |        status: FAIL
+        |  status: FAIL(50%)
+        ".head_cut!
+
+        @@output_tree = YAML.load(@@output_string)
+
+        @@original =
+          [[[:root, [:contents, {:ordered=>true}], :Test1, :status], "PASS"],
+           [[:root, [:contents, {:ordered=>true}], :Test2, :status], "FAIL"],
+           [[:root, :status], "FAIL(50%)"]]
+
+        @@without_contents =
+          [[[:root, :Test1, :status], "PASS"],
+           [[:root, :Test2, :status], "FAIL"],
+           [[:root, :status], "FAIL(50%)"]]
+
+        @@without_test1_prune =
+          [[[:root, [:contents, {:ordered=>true}], :Test2, :status], "FAIL"],
+           [[:root, :status], "FAIL(50%)"]]
+
+        #
+        # Methods
+        #
+
+        def setup
+          super
+          @mock_object = Mocks::Observer.new
+        end
+
+        def teardown
+        end
+
+        #
+        # Tests
+        #
+
+        def test_without_contents
+          assert_node_cut @@original, @@without_contents, :skip => %r{contents}
+        end
+
+        def test_without_test1_prune
+          assert_node_cut @@original, @@without_test1_prune, :skip => %r{Test1}, :prune => true
+        end
+
+      end # class NodeCutTest
+
+    end # module Filters
+
+  end # module Uttk
+
+end

data/test/unit/filters/rpath_filter_test.rb

@@ -0,0 +1,191 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/test/unit/filters/rpath_filter_test.rb 22089 2006-02-21T16:03:00.498332Z pouillar  $
+
+
+test_section __FILE__ do
+
+  module Uttk
+
+    module Filters
+
+      class RPathFilterTest < ::Test::Unit::TestCase
+        include Mocks::Assertions
+        include RPathFilter::Assertions
+
+        #
+        # Data
+        #
+
+        @@output_string = "
+        |root:
+        |  strategy: Suite
+        |  contents:
+        |    - noname:
+        |        strategy: Suite
+        |        contents:
+        |          - Test login=joe:
+        |              strategy: Pass
+        |              status: PASS
+        |          - Test login=bar:
+        |              strategy: Pass
+        |              status: PASS
+        |          - Test login=foo:
+        |              strategy: Fail
+        |              status: FAIL
+        |              reason: Fail always fails
+        |          - Test login=yo:
+        |              strategy: Abort
+        |              status: ABORT
+        |              reason: Abort strategy always aborts
+        |          - Test login=yeah:
+        |              strategy: Fail
+        |              status: FAIL
+        |              reason: Fail always fails
+        |        status: FAIL(40%)
+        |  status: FAIL(40%)
+        ".head_cut!
+
+        @@output_tree = YAML.load(@@output_string)
+
+        #
+        # Methods
+        #
+
+        def setup
+          super
+          self.logger = Logger.new
+          self.output_tree = @@output_tree
+          self.mock_object = Mocks::Observer.new
+        end
+
+        def teardown
+          super
+          # ...
+        end
+
+        class TestFilter1 < RPathFilter
+          # display login and status
+          # no bufferization needed
+          match '/root/contents/noname/contents/login=(.*)/status/(.*)', :run
+
+          def run ( tree, login, status )
+            # here the status and the tree are equal
+            @log[login] = status
+          end
+        end
+
+        class TestFilter2 < RPathFilter
+          match '/root/contents/noname/contents/login=(.*)/status/(.*)' do
+            |obj, tree, login, status|
+            obj.log[login] = status
+          end
+        end
+
+        class TestFilter3 < RPathFilter
+          # display login and status
+          # with a buffer (see the star before login)
+          match '/root/contents/noname/contents/login=(.*)/*status$', :yeah
+
+          def yeah ( tree, login )
+            @log[login] = tree.rpath_find :first, '/status/'
+          end
+        end
+
+        class TestFilter4 < RPathFilter
+          # with a buffer (see the star before status)
+          match '//cont//ents/lo.in=(.*)/()st.tus/FAIL' do |obj, tree, login|
+            obj.log[login] = tree.rpath_find :first, '/reason/'
+          end
+        end
+
+        # With two matchers
+        # FIXME try to use only one buffer
+        class TestFilter5 < RPathFilter
+          match '//contents//contents/login=(.*)/()status/PASS', :pass
+          match '//contents//contents/login=(.*)/()status/FAIL', :fail
+          def fail ( tree, login )
+            @log[login] = "FAIL, " + tree.rpath_find(:first, '/reason/.*')
+          end
+          def pass ( tree, login )
+            @log[login] = "PASS strategy: " +
+                          tree.rpath_find(:first, '/strategy/.*')
+          end
+        end
+
+        class TestFilter6 < RPathFilter
+          # display the name of a test and it's status
+          match '(.*)/^status$/(.*)\Z', :yeah
+
+          def yeah ( tree, name, status )
+            @log[name] = status
+          end
+        end
+
+
+        #
+        # Tests
+        #
+
+        @@notifs1 = [
+          [[:joe], "PASS"],
+          [[:bar], "PASS"],
+          [[:foo], "FAIL"],
+          [[:yo], "ABORT"],
+          [[:yeah], "FAIL"]
+        ]
+
+        @@notifs2 = [
+          [[:foo], "Fail always fails"],
+          [[:yeah], "Fail always fails"]
+        ]
+
+        @@notifs3 = [
+          [[:joe], "PASS strategy: Pass"],
+          [[:bar], "PASS strategy: Pass"],
+          [[:foo], "FAIL, Fail always fails"],
+          [[:yeah], "FAIL, Fail always fails"]
+        ]
+
+        @@notifs4 = [
+          [[:root], "FAIL(40%)"],
+          [[:noname], "FAIL(40%)"],
+          [[:"Test login=joe"], "PASS"],
+          [[:"Test login=bar"], "PASS"],
+          [[:"Test login=foo"], "FAIL"],
+          [[:"Test login=yo"], "ABORT"],
+          [[:"Test login=yeah"], "FAIL"]
+        ]
+
+        def test_filter1
+          assert_rpath_filter(@@notifs1, TestFilter1)
+        end
+
+        def test_filter2
+          assert_rpath_filter(@@notifs1, TestFilter2)
+        end
+
+        def test_filter3
+          assert_rpath_filter(@@notifs1, TestFilter3)
+        end
+
+        def test_filter4
+          assert_rpath_filter(@@notifs2, TestFilter4)
+        end
+
+        def test_filter5
+          assert_rpath_filter(@@notifs3, TestFilter5)
+        end
+
+        def test_filter6
+          assert_rpath_filter(@@notifs4, TestFilter6)
+        end
+
+      end # class RPathFilterTest
+
+    end # module Filters
+
+  end # module Uttk
+
+end

data/test/unit/filters/text_filter_test.rb

@@ -0,0 +1,46 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /fey/uttk/trunk/test/unit/filters/text_filter_test.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+test_section __FILE__ do
+
+  module Uttk
+
+    module Filters
+
+      class TextFilterTest < ::Test::Unit::TestCase
+
+        #
+        # Methods
+        #
+
+        def setup
+          super
+          # ...
+        end
+
+        def teardown
+          super
+          # ...
+        end
+
+        #
+        # Tests
+        #
+
+        def test_xxx
+          # ...
+        end
+
+        def test_yyy
+          # ...
+        end
+
+      end # class TextFilterTest
+
+    end # module Filters
+
+  end # module Uttk
+
+end

data/test/unit/filters_test.rb

@@ -0,0 +1,119 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/test/unit/filters_test.rb 22057 2006-02-20T21:40:27.185401Z pouillar  $
+
+
+test_section __FILE__ do
+
+module Uttk
+
+  # Test the method provided by the Filters module.
+  class FiltersTest < Test::Unit::TestCase
+
+    def test_backend
+      # test Yaml
+      backend = Uttk::Filters['Yaml']
+      assert_equal 1, backend.size
+      assert_dumper backend.first, Uttk::Dumpers::Yaml, STDOUT
+      # test Yaml: foo
+      TempPath.new('filters_test') do |tmp|
+        io = tmp.open('w')
+        backend = Uttk::Filters["Yaml: #{tmp}"]
+        assert_equal 1, backend.size
+        assert_dumper backend.first, Uttk::Dumpers::Yaml, io
+      end
+      # test Xml: foo, Yaml: bar
+      TempPath.new('filters_test') do |tmp1|
+        io1 = tmp1.open('w')
+        TempPath.new('filters_test') do |tmp2|
+          io2 = tmp2.open('w')
+          backend = Uttk::Filters["Xml: #{tmp1}, Yaml: #{tmp2}"]
+          assert_dumpers(backend, 2,
+                         [ Uttk::Dumpers::Xml, io1 ],
+                         [ Uttk::Dumpers::Yaml, io2 ])
+        end
+      end
+      # test [{Xml: foo}, {Xml: bar}]
+      TempPath.new('filters_test') do |tmp1|
+        io1 = tmp1.open('w')
+        TempPath.new('filters_test') do |tmp2|
+          io2 = tmp2.open('w')
+          backend = Uttk::Filters["       [{Xml: #{tmp1}}, {Xml: #{tmp2}}]"]
+          assert_equal 2, backend.size
+          assert_dumper backend.first, Uttk::Dumpers::Xml, io1
+          assert_dumper backend.last, Uttk::Dumpers::Xml, io2
+        end
+      end
+      # test Xml: [ foo, bar]
+      TempPath.new('filters_test') do |tmp1|
+        io1 = tmp1.open('w')
+        TempPath.new('filters_test') do |tmp2|
+          io2 = tmp2.open('w')
+          backend = Uttk::Filters["Xml: [#{tmp1}, #{tmp2}]"]
+          assert_equal 1, backend.size
+          assert_dumper backend.first, Uttk::Dumpers::Xml, io1, io2
+        end
+      end
+      # test Basic, Xml: log.xml
+      TempPath.new('filters_test') do |tmp|
+        io = tmp.open('w')
+        backend = Uttk::Filters["Basic, Xml: #{tmp}"]
+        assert_dumpers(backend, 2,
+                       [ Uttk::Dumpers::Basic, STDOUT ],
+                       [ Uttk::Dumpers::Xml, io ])
+      end
+      # test JustStatus: Basic
+      backend = Uttk::Filters["JustStatus: Basic"]
+      assert_equal 1, backend.size
+      observers = assert_filter backend.first, Uttk::Filters::JustStatus, 1
+      assert_dumper observers.first, Uttk::Dumpers::Basic, STDOUT
+      # test JustStatus: {Basic, Xml: log.xml}
+      TempPath.new('filters_test') do |tmp|
+        io = tmp.open('w')
+        backend = Uttk::Filters["JustStatus: {Basic, Xml: #{tmp}}"]
+        assert_equal 1, backend.size
+        observers = assert_filter backend.first, Uttk::Filters::JustStatus, 2
+        assert_dumpers(observers, 2,
+                       [ Uttk::Dumpers::Yaml, STDOUT ],
+                       [ Uttk::Dumpers::Xml, io ])
+      end
+    end
+
+    protected
+
+    def assert_dumper(dumper, dumper_class, *outputs)
+      assert_kind_of dumper_class, dumper
+      dumper.each_output do |output|
+        assert_equal output.inspect, outputs.shift.inspect
+      end
+    end
+
+    def assert_dumpers(dumpers, nb_dumpers, *descs)
+      assert_equal nb_dumpers, dumpers.size
+      dumpers.each { |dumper| check_dumper_desc(dumper, descs) }
+    end
+
+    def check_dumper_desc(dumper, descs)
+      descs.each do |desc|
+        if desc.first == dumper.class
+          assert_dumper(dumper, *desc)
+          return true
+        end
+      end
+      return false
+    end
+
+    def assert_filter(filter, filter_class, nb_observers)
+      assert_kind_of filter_class, filter
+      observers = []
+      filter.instance_eval { observers = @observer_peers }
+      assert_equal nb_observers, observers.size
+      observers
+    end
+
+  end # class Filters
+
+end # module Uttk
+
+end # test_section __FILE__

data/test/unit/logger/section_node_test.rb

@@ -0,0 +1,120 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/test/unit/logger/section_node_test.rb 21975 2006-02-19T22:24:11.182512Z pouillar  $
+
+
+test_section __FILE__ do
+
+
+module Uttk
+
+  class Logger
+
+    class SectionNodeTest < ::Test::Unit::TestCase
+
+      def setup
+        foo = SectionNode.new('foo',
+                              SectionNode.new('baz',
+                                              SectionNode.new('son1'),
+                                              SectionNode.new('son2')),
+                              SectionNode.new('goo'))
+        @tree = SectionNode.new('root',
+                                foo,
+                                SectionNode.new('bar'))
+      end
+
+      def test_name=
+        s = SectionNode.new('toto')
+        assert_equal('toto', s.name)
+        s.name = 'foo'
+        assert_equal('foo', s.name)
+      end
+
+      def test_sub_sections
+        assert_equal([], SectionNode.new('foo').sub_sections)
+      end
+
+      def test_label
+        s = SectionNode.new('foo',
+                            SectionNode.new('bar'),
+                            SectionNode.new('baz', SectionNode.new('goo')))
+        assert_equal('bar', s['bar'].name)
+        assert_equal('baz', s['baz'].name)
+        assert_equal('goo', s['baz']['goo'].name)
+      end
+
+      def test_find
+        goo = SectionNode.new('goo')
+        s = SectionNode.new('foo',
+                            SectionNode.new('bar'),
+                            SectionNode.new('baz', goo))
+        assert_equal(goo, s.find('goo'))
+        assert_nil(s.find('toto'))
+      end
+
+      def test_active_tree
+        s = SectionNode.new('foo',
+                            SectionNode.new('bar'),
+                            SectionNode.new('baz', SectionNode.new('goo')))
+        assert(! s.active?)
+        s.each_section { |ss| assert(! ss.active?) }
+        assert(! s['baz']['goo'].active?)
+        section_actived = s.active_tree(true)
+        expected_section = %w(foo bar baz goo)
+        expected_section.each do |x|
+          assert(section_actived.include?(x), "#{x} not actived")
+        end
+        assert_equal(expected_section.size, section_actived.size)
+        s.each_section { |ss| assert(ss.active?) }
+        assert(s['baz']['goo'].active?)
+      end
+
+      def test_active_section
+        assert_equal([], SectionNode.new('root').active_section('toto'))
+        assert_equal(['root'], SectionNode.new('root').active_section('root'))
+        assert_equal([], @tree.active_section('toto'))
+        section_actived = @tree.active_section('baz')
+        expected_section = %w(root foo baz son1 son2)
+        expected_section.each do |x|
+          assert(section_actived.include?(x), "#{x} not actived")
+        end
+        assert_equal(expected_section.size, section_actived.size)
+      end
+
+      def test_unactive_section__easy
+        assert_equal([], SectionNode.new('root').unactive_section('toto'))
+        assert_equal([], SectionNode.new('root').unactive_section('root'))
+        section_actived = @tree.active_section('baz')
+        section_actived = @tree.unactive_section('baz')
+        expected_section = %w(root foo baz son1 son2)
+        expected_section.each do |x|
+          assert(section_actived.include?(x), "#{x} not actived")
+        end
+        assert_equal(expected_section.size, section_actived.size)
+      end
+
+      def test_unactive_section__difficult
+        section_actived = @tree.active_section('baz')
+        section_actived = @tree.active_section('goo')
+        section_actived = @tree.unactive_section('baz')
+        expected_section = %w(baz son1 son2)
+        expected_section.each do |x|
+          assert(section_actived.include?(x), "#{x} not actived")
+        end
+        assert_equal(expected_section.size, section_actived.size)
+        section_actived = @tree.unactive_section('goo')
+        expected_section = %w(goo foo root)
+        expected_section.each do |x|
+          assert(section_actived.include?(x), "#{x} not actived")
+        end
+        assert_equal(expected_section.size, section_actived.size)
+      end
+
+    end # class SectionNodeTest
+
+  end # class Logger
+
+end # module Uttk
+
+end