ttk 0.1.576

data/NEWS

@@ -0,0 +1,69 @@
+= 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:
+
+  TTK 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 TTK is still unstable but already provides some interesting
+  result. It is based on a specific daemon running on remote machine.
+
+* Cache system:
+
+  TTK remembers the successful test across session. Not yet fully tested, but
+  already usable.
+
+
+--
+TTK's Maintainers

data/NORM

@@ -0,0 +1,85 @@
+                                                               -*- outline -*-
+
+		    /*---------------------------.
+		    | Coding style of TestTKewl  |
+		    `---------------------------*/
+
+	      /*--------------------------------------.
+	      | ! Coding style is not about layout !  |
+	      `--------------------------------------*/
+
+     /*------------------------------------------------------------------.
+     | This document consists of a set of rules which must be respect by |
+     |                  every maintainers of TestTKewl.                  |
+     `------------------------------------------------------------------*/
+
+
+* Introduction
+
+  This text deals with the norm applied to all official TestTKewl source files
+included in the distribution. Everyone who write a peace of code into TestTKewl
+must follow the rules below.
+  Every rules mentioned below are not about the layout of ttk'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, and try to minimize block.call. |
+      `---------------------------------------------------*/
+
+  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 each2 ( &block )              |
+        @a.each do |k, v|               |
+          block.call(k, v)              |
+        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

data/README

@@ -0,0 +1,206 @@
+
+
+= TTK - TestToolKit
+
+TestToolKit, aka TTK, 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
+TTK can help you. It is written in Ruby, which is a script language one hundred
+percents dynamic and object oriented. It's inherited from Smalltalk, Python and
+Perl. TestToolKit 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.
+
+TTK's philosophy follows the principle that you can always extend already made
+test strategy to specialize it for your own case. Initially, TTK comes with a
+few test strategies and provides specially abstract test strategies. Thus, TTK
+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.
+
+TTK comes with a set of classic test strategies, statistics computation,
+a test suite manager, a pluggable loader/dumper architecture, and a distributed
+mode.
+
+
+= Roadmap
+
+- If you want to use TTK to test your command line based program, see the
+  TTK::Strategies::Cmd strategy documentation.
+- If you want to use TTK to wrap your unit test suite, see the
+  TTK::Strategies::RUnit strategy documentation.
+- If you want to try writing your own strategy, see the TTK::Strategies module
+  documentation.
+- If you want to try writing your own loader, see the TTK::Loaders module
+  documentation.
+- If you want to try writing your own dumper, see the TTK::Dumpers module
+  documentation.
+- If you want to try writing your own filter, see the TTK::Filters module
+  documentation.
+- If you want to try writing your own filter, see the TTK::Weights module
+  documentation.
+- If you want to use TTK as a library and to write your own driver, see the TTK
+  module documentation.
+
+
+= Usage
+
+TTK is invoked from the command line using:
+
+  % ttk <options> [files...]
+
+Strategies described in the files are instantiated and run. The files format
+must follow the one the chosen loader understand. By default, TTK uses the YAML
+loader. Use the -P option to use another loader. If no file are specified, TTK
+will read on the standard input. You can also use the -i option to change that.
+
+You can have a description of all TTK's options using this command:
+
+  % ttk -h
+
+TTK can show you a list of all dynamic strategies available, this way:
+
+  % ttk --strategy-list
+
+If you want to have a description of all the available attributes of a given
+strategy, use this command:
+
+  % ttk -h <the-given-strategy>
+
+If you want to see the list of all the available loader, type this command:
+
+  % ttk -L
+
+For dumpers, do that:
+
+  % ttk -P
+
+For filter:
+
+  % ttk -F
+
+And, for weight classes:
+
+  % ttk -W
+
+To set the level of severity of the TTK's logger use the -d option. Without
+argument, it will show you all the available levels:
+
+  % ttk -d
+
+Otherwise, give a correct level as argument to the -d option:
+
+  % ttk -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 TTK (the YAML loader). YAML is very easy
+to read and write. If you want to learn it, see the YAML 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
+
+TTK is still under development. Thus, there are some part of it which are still
+unstable. Of course, even some stable part are not free from bugs. Perfection
+doesn't exist!
+
+* Stable parts:
+  - The loader, dumper, strategy and logger architecture.
+  - The YAML loader.
+  - The YAML and the XML dumper.
+  - All strategies, expect those mentioned in the _unstable strategies_
+    section, are considered stable.
+
+* Unstable parts:
+  - The filter architecture is very unstable and not yet well developed. This
+    part will be fully functional in the next release. We discourage its usage.
+  - The distributed mode already provides some basic features but it is not
+    considered as really usable. We discourage its usage.
+  - 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.
+
+
+= Unstable strategies
+
+[*RUnit*] It works fine most a time, but doesn't not handle yet the abort
+          features. If you try to abort it, using the timeout features (or
+          whatever) for instance, some processes may stayed alive. You can use
+          it, otherwise.
+
+[*Test*] It works fine, but it will be redesign in the next release, because it
+         needs some upgrades. You can use it carefully.
+
+[*JUnit*] It has been stable a long time ago, but hasn't been adapted to the
+          recent strategy architecture changes yet. We discourage its usage.
+
+[*Distribute*] It is still under development and doesn't give correct results
+               yet. We discourage its usage.
+
+[*DistDuplicate*] It needs to be adapted to the recent strategy architecture
+                  changes. We discourage its usage.
+
+
+= Repository tree description
+
+[NEWS] What's new in each release of TTK.
+[AUTHORS] Present all authors and what they have done for TTK.
+[bin] Contains all drivers provided by TTK.
+[ChangeLog] Keep track of the changes of TTK for all revisions.
+[COPYING] Describe the license.
+[DESCRIPTION] A short and a long description of TTK (used for rubygem).
+[doc] Documentation directory.
+[doc/html] RDoc output directory.
+[lib] Contains the library.
+[misc] Some useful miscellaneous scripts when developing TTK.
+[NORM] Everybody who write code for TTK must follow the rules written in this
+       file.
+[Rakefile] For rubygem, doc generation and more generaly packaging operations.
+[README] This file.
+[ruby_ex] Some useful Ruby's extensions. The end user is not supposed to look
+          at this directory. Those files will be bundle in one or several
+          separated packages in the futur.
+[template] Some ERB templates to ease writting new strategies.
+[template/README] Explains how to use these templates.
+[test] Contains TTK's tests.
+[TODO] What maintainers have to do.
+[VERSION] The current version of TTK.
+[REVISION] The SubVersion repository revision.
+[DATE] The date of the SubVersion repository last update.
+
+= Bugs report and features request
+
+If you want to send us a bug report or a feature request, have a look at the
+TODO file.
+
+
+= Known bugs
+
+An exhaustive list of known bugs is available at
+http://www.feydakins.org/projects/ttk/tracker/base_view.
+
+
+= License
+
+TTK is copyright (C) 2004-2005 TTK's maintainers. It is free software, and may
+be redistributed under the terms specified in the COPYING file of the TTK
+distribution. TTK's maintainers refers to the people mentioned in the AUTHORS
+file.
+
+
+--
+TTK's maintainers

data/REVISION

@@ -0,0 +1 @@
+576

data/Rakefile

@@ -0,0 +1,120 @@
+#                                                                  -*- ruby -*-
+# Author::    The TTK Team.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Rakefile 576 2005-04-14 11:04:05Z polrop $
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+def get_svn_revision
+  rev = ''
+  `svn info`.each do |line|
+    next unless line =~ /^Revision: (\d+)$/
+    rev = $1.to_i
+  end
+  rev
+end
+
+SVN_REVISION = get_svn_revision
+PKG_VERSION = "0.1.#{SVN_REVISION}"
+
+AUTHORS = Pathname.new('AUTHORS')
+DESCRIPTION = Pathname.new('DESCRIPTION')
+
+PKG_FILES = FileList[*%w"
+  lib/**/*.rb
+  ruby_ex/**/*.rb
+  bin/**/*
+  doc/**/*
+  test/**/*
+  [A-Z]*
+"].exclude(/\b\.svn\b|\..*\.sw[op]$|~$/)
+
+desc 'Default Task'
+task :default => [ :package ]
+
+desc 'Publish to RubyForge'
+task :rubyforge do
+  Rake::RubyForgePublisher.new('ttk', 'polrop').upload
+end
+
+desc 'Update REVISION file'
+task :revision do
+  File.open('REVISION', 'w') { |io| io.puts(SVN_REVISION) }
+end
+
+desc 'Update DATE file'
+task :date do
+  `svn info`.each do |line|
+    next unless line =~ /^Last Changed Date: (.+)$/
+    File.open('DATE', 'w') { |io| io.puts($1) }
+  end
+end
+
+task :package => [ :revision, :date ]
+
+# Generate the full TTK documentation
+Rake::RDocTask.new(:doc) do |rdoc|
+  rdoc.title = 'TTK -- An extensible framework for dynamic testing.'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_dir = 'doc/html'
+  main = 'README'
+  rdoc.options << '--inline-source'
+  rdoc.main = main
+  rdoc.rdoc_files.include(main)        #FIXME: rdoc + gem fails for the main
+  rdoc.rdoc_files.include('AUTHORS')
+  rdoc.rdoc_files.include('TODO')
+  rdoc.rdoc_files.include('NEWS')
+  rdoc.rdoc_files.include('template/README')
+  rdoc.rdoc_files.include('test/examples/README')
+  rdoc.rdoc_files.include('lib/ttk')
+  #FIXME: must be the last one to avoid rdoc bugs overwritting
+  rdoc.rdoc_files.include('lib/ttk/dumpers/Dumper.rb')
+  rdoc.rdoc_files.include('lib/ttk/loaders/Loader.rb') #FIXME: no doc for me
+  rdoc.rdoc_files.include('lib/ttk/strategies/Strategy.rb')
+  rdoc.rdoc_files.include('lib/ttk/filters/Filter.rb')
+  rdoc.rdoc_files.include('lib/ttk/weights/Weight.rb')
+  rdoc.rdoc_files.include('lib/ttkd.rb')
+  rdoc.rdoc_files.include('lib/ttk.rb')
+end
+
+# The Gem specification
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = 'ttk'
+  s.version = PKG_VERSION
+  DESCRIPTION.open do |desc|
+    s.summary = desc.readline.chomp
+    raise 'bad DESCRIPTION format' unless desc.readline.chomp.empty?
+    s.description = desc.read
+  end
+  s.bindir = 'bin'
+  s.executables = %w[ ttk ttkd ttkm ]
+  s.default_executable = 'ttk'
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.author = AUTHORS.read
+  s.email = [ 'ertai@feydakins.org', 'nicolas.despres@gmail.com' ]
+  s.homepage = [
+    'http://www.feydakins.org/projects/ttk',
+    'http://rubyforge.org/projects/ttk/'
+  ]
+  s.rubyforge_project = s.name
+end
+
+# Create compressed packages
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  # p.need_tar = true
+  # p.need_zip = true
+end
+
+