uttk 0.3.1.2

data/NEWS

@@ -0,0 +1,158 @@
+= New in 0.3, 2006-02-25:
+
+This release is a minor which provides also some interesting improvements:
+
+ * Compatibility:
+
+    Uttk is now fully compatible with Ruby 1.8.4. Backward compatibility with
+    older version of Ruby is no longer maintained.
+
+ * Templates:
+
+    They are now managed by the Rails generator. So, you need Rails installed
+    to use them.
+
+ * Select your test from the command line:
+
+    Use the --rpath option to select the tests you want to run.
+
+ * Logger/Dumpers/Filters:
+
+    Bunch all together in a powerful back-end set. Filters are reloaded!
+
+ * Distributed mode:
+
+    Not included in this release. Will be back soon!
+
+ * Uttk binary:
+    Clean the help option, split in two --help and --long-help.
+
+ * Loaders:
+
+   * Ruby: You can use the Ruby's syntax (and power) to write your test suite.
+
+ * Strategies:
+
+   * Strategy: Provides benchmark measurement.
+   * Assert:
+      This  new  strategy  based  on the strategy S::Block provides to the user
+      many   assertions  methods  to  easily  define  Ruby  verifications.  The
+      strategy S::Assert mixes-in Test::Unit::Assertions to do this job.
+  * Iterate:
+      This  new  strategy aims to provide a generic way to iterate over objects
+      to factor your test suite. It's based on ruby's `each'.
+  * CmdBase:
+      The  command  can now support a special argument %i, which is replaced by
+      the name of the input file.
+
+  * Miscellaneous:
+
+    * Ruby is now in the symbol table:
+        In your tests you now must use <<ruby>> instead of just ruby.
+        This will permit to easily control and change the running ruby.
+
+= New in 0.2, 2005-05-06:
+
+This release is mainly a BugFix release but it provides also some improvements:
+
+* Add templates to easily create your own loaders, dumpers, strategies...:
+
+  * new_strategy.rb
+  * new_dumper.rb
+  * new_loader.rb
+  * new_runit_test.rb
+
+* Strategies:
+
+  * RUnit: Add an option to make the core_ex require optional.
+          Add an `args' attribute.
+  * PackageCollection: Add a documentation.
+  * SubCmd: Use the new D::Notif output stream.
+  * CmdBase: Declare a father hook.
+  * Authors: Fix the regexp.
+  * Composite: Update to the new testify.
+  * Collection: Update testify, and log.
+  * Checkout: Set :checkout_dir like :extract_dir.
+  * RemoteCmd: Include its HostDispatcher.
+
+* Dumpers:
+
+  * Notif: Output is now a Yaml stream.
+  * Any dumpers can now easily support flushable outputs.
+
+* Logger:
+
+  * Improve the Logger adding sugars.
+  * Skip the message when the block returns nil.
+  * LoggerFactory: Make section_tree available, and clean
+                   create_section_tree.
+
+= New in 0.1, 2005-04-12:
+
+* Strategies:
+
+  Many strategies are already available.
+
+  * Concrete strategies
+    - Suite strategies: Suite, Pool, Glob
+    - Command based strategies: Cmd, SubCmd, SignalCmd
+    - Unit test strategies: RUnit, JUnit
+    - Packaging strategies: Package, Checkout, Make, PackageCollection,
+      Bootstrap, Authors, Configure, Compile, Clean
+    - Distributed mode strategies:
+      - unstable/testing: DistDuplicate, DistDelegate, Distribute
+      - stable: Tester, Fetch, Fetcher
+    - Basic and useful strategies: Sleep, Block, KillAll, Import
+    - Elementary strategies: Pass, Abort, Error, Fail, Stub
+    - Test strategies: Test, ProbabilityThreshold
+    - Database strategies: SqlQuery
+
+  * Abstract strategies:
+    - Strategy
+    - Composite
+    - Collection
+    - Proxy
+    - IOBased
+    - CmdBase
+    - DistStrategy
+
+* Loaders:
+
+  A YAML loader is provided to easily write the test suite.
+
+* Dumper:
+
+  A YAML dumper which follow the same format than the YAML loader provides a
+  human/script readable way to dump the suite result. An XML dumper is also
+  available to easily put online the suite result.
+
+* Logger:
+
+  A specific Logger which manage a severity level, a verbosity level and
+  a section tree. Dumpers and/or Filters can be plugged to it.
+
+* Filters:
+
+  Only two basic filters: Saver and BasicLogger. The filtering system is not
+  yet very developed.
+
+* Statistics computation system:
+
+  Uttk computes a weighted average of the succeed test of the test suite. This
+  system is extensible to allow other kinds of computation.
+
+* A functional environment which handle shared values between strategies.
+
+* Distributed mode:
+
+  This feature of Uttk is still unstable but already provides some interesting
+  result. It is based on a specific daemon running on remote machine.
+
+* Cache system:
+
+  Uttk remembers the successful test across session. Not yet fully tested, but
+  already usable.
+
+
+--
+Uttk's Maintainers

data/NORM

@@ -0,0 +1,137 @@
+                                                               -*- outline -*-
+
+                /*---------------------------------------.
+                | Coding style of Unified Test Tool Kit  |
+                `---------------------------------------*/
+
+     /*------------------------------------------------------------------.
+     | This document consists of a set of rules which must be respect by |
+     |      every maintainers of Unified  Unified Test Tool Kit.         |
+     `------------------------------------------------------------------*/
+
+
+* Introduction
+
+  This  text  deals with the norm applied to all official Unified Test Tool Kit
+source  files  included in the distribution. Everyone who write a peace of code
+into Unified Test Tool Kit must follow the rules below.
+  Every  rules  mentioned below are not about the layout of uttk's source file.
+In  this document some part of the ruby's standard library may be forbidden and
+some  features  of  Ruby  too.  We  do so for stability/security and efficiency
+reasons.
+  If  you  want to add a rule to this file you have to justify it with at least
+one  strong and objective argument. Any subjective rules will not be allowed in
+this  document.  The  summary  of  every  rules  must  be  scared to allow fast
+reading.
+
+* Coding style rules
+
+** String evaluation
+
+     /*--------------------------------------------------------------.
+     | You have to use the double quoted string the least possible.  |
+     `--------------------------------------------------------------*/
+
+  Ruby  has  two  level  of  string evaluation: double quoted string and single
+quoted  string. The single quoted version is faster since less substitution are
+allowed  by  Ruby.  So,  as  soon as, you do not need a full evaluation of your
+string you have to use the single quoted version for efficiency reason.
+
+** Logger utilization
+
+      /*------------------------------------------------------.
+      | You have to write your log messages using the block.  |
+      `------------------------------------------------------*/
+
+  Ruby's  logger  provides  two  ways  to write your log messages. You can pass
+your  log  string  to  the  logger  either as a function argument or as a block
+which  return a string. The second version is prefered since the block, thought
+the  string,  will not be evaluated by Ruby if the log level severity is higher
+than  the  level  of  your  message.  This  way,  time is saved for every debug
+messages when your severity level is fatal, for instance.
+
+** Using blocks
+
+          /*----------------------------------------------.
+          | Do not use yield, block_given?, iterator?     |
+          | block.call (but []) and try minimize block[]. |
+          `-----------------------------------------------*/
+
+*** Do not use yield
+
+  Ruby provides sevral ways to use blocks, and we retain the most efficient.
+
+  Examples:
+
+    # Bad                               | # Good
+                                        |
+    class A                             | class A
+      def each                          |   def each ( &block )
+        @a.each { |k, v| yield k, v }   |     @a.each(&block)
+      end                               |   end
+                                        |
+      def each_key                      |   def each_key ( &block )
+        @a.each { |k, v| yield k }      |     @a.each_key(&block)
+      end                               |   end
+                                        |
+      def each_value                    |   def each_value ( &block )
+        @a.each { |k, v| yield v }      |     @a.each_value(&block)
+      end                               |   end
+    end                                 | end
+
+
+*** Try to minimize block.call or block[]
+
+    # Bad                               | # Good
+                                        |
+    def each2 ( &block )                | def each2 ( &block )
+      @a.each do |k, v|                 |   @a.each(&block)
+        block.call(k, v)                | end
+      end                               |
+    end
+
+*** No block_given? nor iterator?
+
+  Since we do not use yield, block_given? and iterator? are useless.
+  Example:
+
+    def foo ( &block )
+      if block  # instead of block_given? or iterator?
+        ...
+      end
+    end
+
+    def foo ( &block )
+      if block.nil?  # instead of not block_given? or not iterator?
+        ...
+      end
+    end
+
+*** No block.call but block[]
+
+  The methods [] and call are aliases. But the [] one is closer to a real
+  function call.
+
+* Layout rules
+
+** Try to respect the orginal style
+
+** No Tabulations
+
+  Don't  use  tabulations. They pollute the code since editors and/or users are
+not  agree  on  the  width of a tabulation. Tell your editor to replace them by
+spaces. Expect in the ChangeLog which is handled automatically by Vcs.
+
+*** Vim
+  Just type (or add it to your .vimrc): `:set expandtab'
+
+*** Emacs
+  FIXME: FILL ME
+
+** No trailling whitespaces
+
+  Do not let trailling whitespaces in your files !!!
+
+** Newline required at the end of file
+
+  Do not let last line of file without a newline !!!

data/README

@@ -0,0 +1,180 @@
+
+
+= Uttk -  Unified Test Tool Kit
+
+Unified  Test  Tool  Kit,  aka  Uttk, is designed to ease the test stage of the
+development of your projects.
+
+Testing  is  as  important  as design and implementation of a project. But it's
+very  cumbersome  to  write tests and tester scripts. That's why a project such
+as  Uttk  can  help  you.  It  is written in Ruby, which is a high level object
+oriented  scripting  language.  Unified  Test  Tool Kit allows two ways of test
+writing:  a configuration file way (using YAML: an XML plain text format) and a
+class  extension  way  where you can extend an already made class to specialize
+it for your own project case.
+
+Uttk's  philosophy  follows  the  principle  that you can always extend already
+made  test  strategy  to specialize/extend it. Initially, Uttk comes with a few
+test  strategies  and  provides specially, abstract test strategies. Thus, Uttk
+will  become bigger only by contributions from its users who publish their test
+strategies.  At  the  end,  it  will provide enough test strategies that almost
+everybody will find the test strategy he needs.
+
+Uttk  comes  with  a  set of classic test strategies, statistics computation, a
+test  suite  manager,  a  loader  architecture,  and a back-end that supports a
+powerful filtering system.
+
+Previous  releases  were shipped with a distributed mode. This is no longer the
+case.  Uttk's  architecture has changed and the former distributed mode doesn't
+work  any  more  to  be almost rewritten from scratch. That's why we decided to
+not include it in this release. It will be back soon!
+
+
+= Roadmap
+
+- If you want to use Uttk to test your command line based program, see the
+  Uttk::Strategies::Cmd strategy documentation.
+- If you want to use Uttk to wrap your unit test suite, see the
+  Uttk::Strategies::RUnit strategy documentation.
+- If you want to try writing your own strategy, see the Uttk::Strategies module
+  documentation.
+- If you want to try writing your own loader, see the Uttk::Loaders module
+  documentation.
+- If you want to try writing your own dumper, see the Uttk::Dumpers module
+  documentation.
+- If you want to try writing your own filter, see the Uttk::Filters module
+  documentation.
+- If you want to try writing your own filter, see the Uttk::Weights module
+  documentation.
+- If you want to use Uttk as a library and to write your own driver, see the Uttk
+  module documentation.
+
+
+= Usage
+
+Uttk is invoked from the command line using:
+
+  % uttk <options> [files...]
+
+Strategies described in the files are instantiated and run. The files format
+must follow the one the chosen loader understand. By default, Uttk uses the
+YAML loader. Use the -L option to use another loader.
+
+You can have a description of all Uttk's options using this command:
+
+  % uttk --long-help
+
+A shorter help message is printed by:
+
+  % uttk -h
+
+Uttk can show you a list of all dynamic strategies available, this way:
+
+  % uttk --strategy-list
+
+If you want to have a description of all the available attributes of a given
+strategy, use this command:
+
+  % uttk -H <the-given-strategy>
+
+If you want to see the list of all the available loader, type this command:
+
+  % uttk -L
+
+For the filters/dumpers do that:
+
+  % uttk -F
+
+And, for weight classes:
+
+  % uttk -W
+
+To set the level of severity of the Uttk's logger use the -d option. Without
+argument, it will show you all the available levels:
+
+  % uttk -d
+
+Otherwise, give a correct level as argument to the -d option:
+
+  % uttk -d debug
+
+By default, the severity level is _fatal_.
+
+
+= Examples
+
+Some examples are available in the test/examples directory. These examples
+are written for the default loader of Uttk (the YAML loader). If you want to
+learn more about YAML, see its cookbook at
+http://yaml4r.sourceforge.net/cookbook/.
+
+A detailed description of these examples is available in the
+test/examples/README file.
+
+
+= Stable and unstable parts
+
+Uttk is still under development. Thus, there are some part of it which are
+still unstable. Of course, even some stable part are not bug free: Perfection
+doesn't exist!
+
+* Stable parts:
+  - The loaders, filters, dumpers, strategies and logger architecture.
+  - The YAML and Ruby loader.
+  - The YAML, XML and HTML dumper.
+  - All strategies are considered stable except if a special warning is
+    mentioned in its documentation.
+
+* Unstable parts:
+  - The timeout features provided by the abstract strategy _Strategy_ tend to
+    be stable but it may block some times. You can use it, since it works most
+    of the time.
+  - The {pre,post}_assertion features provided by the abstract strategy
+    _Strategy_ doesn't work yet.
+  - Some old YAML loader are still in the repository, for backward
+    compatibility reasons, but we discourage their usage.
+
+= Repository tree description
+
+[NEWS] What's new in each release of Uttk.
+[AUTHORS] Present all authors and what they have done for Uttk.
+[bin] Contains all drivers provided by Uttk.
+[ChangeLog] Keep track of the changes of Uttk for all revisions.
+[COPYING] Describe the license.
+[LGPL] The Gnu Lesser General Public license.
+[GUIDELINES] Some guide lines for the developers.
+[doc] Documentation directory.
+[doc/html] RDoc output directory.
+[doc/demo] Some tutorials.
+[doc/presentation] Slides of presentation.
+[lib] Contains the library.
+[misc] Some useful miscellaneous scripts when developing Uttk.
+[NORM] Everybody who write code for Uttk must follow the rules written in this
+       file.
+[Rakefile] For rubygem, doc generation and more generaly packaging operations.
+[README] This file.
+[script] Useful script for the end users and the developers similar to Rails
+         script directory).
+[test] Contains Uttk's tests.
+[TODO] What maintainers have to do.
+[VERSION] The current version of Uttk.
+
+= Bugs reports, features requests, and known bugs
+
+If you want to send us a bug report or a feature request, have a look at the
+TODO file.
+
+An exhaustive list of known bugs is available at
+http://dev.uttk.org.
+
+
+= License
+
+Uttk is copyright (C) 2004-2005 Uttk's maintainers. It is free software, and may
+be redistributed under the terms specified in the COPYING file of the Uttk
+distribution. Uttk's maintainers refers to the people mentioned in the AUTHORS
+file.
+
+
+--
+Uttk's maintainers