passenger 1.0.1

data/test/stub/railsapp2/config/environments/test.rb

@@ -0,0 +1,22 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell ActionMailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/test/stub/railsapp2/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/test/stub/railsapp2/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/test/stub/railsapp2/config/routes.rb

@@ -0,0 +1,35 @@
+ActionController::Routing::Routes.draw do |map|
+  # The priority is based upon order of creation: first created -> highest priority.
+
+  # Sample of regular route:
+  #   map.connect 'products/:id', :controller => 'catalog', :action => 'view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  #   map.purchase 'products/:id/purchase', :controller => 'catalog', :action => 'purchase'
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # Sample resource route (maps HTTP verbs to controller actions automatically):
+  #   map.resources :products
+
+  # Sample resource route with options:
+  #   map.resources :products, :member => { :short => :get, :toggle => :post }, :collection => { :sold => :get }
+
+  # Sample resource route with sub-resources:
+  #   map.resources :products, :has_many => [ :comments, :sales ], :has_one => :seller
+
+  # Sample resource route within a namespace:
+  #   map.namespace :admin do |admin|
+  #     # Directs /admin/products/* to Admin::ProductsController (app/controllers/admin/products_controller.rb)
+  #     admin.resources :products
+  #   end
+
+  # You can have the root of your site routed with map.root -- just remember to delete public/index.html.
+  # map.root :controller => "welcome"
+
+  # See how all your routes lay out with "rake routes"
+
+  # Install the default routes as the lowest priority.
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/test/stub/railsapp2/public/useless.txt

@@ -0,0 +1 @@
+This useless file prevents git from removing this directory.

data/test/stub/spawn_server.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib"
+require 'passenger/spawn_manager'
+
+include Passenger
+class SpawnManager
+	def handle_spawn_application(app_root, user, group)
+		client.write('ok')
+		client.write(1234, "/tmp/nonexistant.socket", false)
+		client.send_io(STDERR)
+	end
+end
+
+manager = SpawnManager.new
+input = IO.new(Passenger::SpawnManager::DEFAULT_INPUT_FD)
+manager.start_synchronously(input)
+manager.cleanup

data/test/stub/zsfa/index.html

@@ -0,0 +1,14 @@
+<table border="0">
+<tr>
+	<td rowspan="2"><img src="zsfa.png" style="vertical-align: top"></td>
+	<td style="vertical-align: top"><img src="header.png"></td>
+</tr>
+<tr>
+	<td>
+		<div style="font-size: 50pt; font-family: 'Times New Roman'; font-weight: bold">
+		<blink>Zed, you rock!</blink><br>
+		</div>
+		<small>Our integration tests like you.</small>
+	</td>
+</tr>
+</table>

data/test/support/apache2_config_writer.rb

@@ -0,0 +1,44 @@
+require 'erb'
+require 'etc'
+require 'passenger/platform_info'
+
+class Apache2ConfigWriter
+	include PlatformInfo
+	
+	def initialize
+		@stub_dir = File.expand_path(File.dirname(__FILE__) + "/../stub")
+		@server_root = "#{@stub_dir}/apache2"
+		@spawn_server = File.expand_path(File.dirname(__FILE__) + "/../../bin/passenger-spawn-server")
+		@modules_dir = `#{APXS2} -q LIBEXECDIR`.strip
+		@modules = `#{HTTPD} -l`.split("\n").grep(/\.c$/).map do |line|
+			line.strip
+		end
+		@mod_passenger = File.expand_path(File.dirname(__FILE__) + "/../../ext/apache2/mod_passenger.so")
+		@normal_user = CONFIG['normal_user_1']
+		@normal_group = Etc.getgrgid(Etc.getpwnam(@normal_user).gid).name
+	end
+	
+	def write
+		template = ERB.new(File.read("#{@stub_dir}/apache2/httpd.conf.erb"))
+		File.open("#{@stub_dir}/apache2/httpd.conf", 'w') do |f|
+			f.write(template.result(get_binding))
+		end
+	end
+	
+private
+	def get_binding
+		return binding
+	end
+	
+	def has_builtin_module?(name)
+		return @modules.include?(name)
+	end
+	
+	def has_module?(name)
+		return File.exist?("#{@modules_dir}/#{name}")
+	end
+	
+	def running_as_root?
+		return Process.uid == 0
+	end
+end

data/test/support/config.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH << File.expand_path("#{File.dirname(__FILE__)}/../../lib")
+require 'yaml'
+begin
+	CONFIG = YAML::load_file('config.yml')
+rescue Errno::ENOENT
+	STDERR.puts "*** You do not have the file test/config.yml. " <<
+		"Please copy test/config.yml.example to " <<
+		"test/config.yml, and edit it."
+	exit 1
+end

data/test/support/multipart.rb

@@ -0,0 +1,62 @@
+module Multipart
+  # From: http://deftcode.com/code/flickr_upload/multipartpost.rb
+  ## Helper class to prepare an HTTP POST request with a file upload
+  ## Mostly taken from
+  #http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/113774
+  ### WAS:
+  ## Anything that's broken and wrong probably the fault of Bill Stilwell
+  ##(bill@marginalia.org)
+  ### NOW:
+  ## Everything wrong is due to keith@oreilly.com
+  require 'rubygems'
+  require 'mime/types'
+  require 'net/http'
+  require 'cgi'
+
+  class Param
+    attr_accessor :k, :v
+    def initialize( k, v )
+      @k = k
+      @v = v
+    end
+
+    def to_multipart
+      #return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"\r\n\r\n#{v}\r\n"
+      # Don't escape mine...
+      return "Content-Disposition: form-data; name=\"#{k}\"\r\n\r\n#{v}\r\n"
+    end
+  end
+
+  class FileParam
+    attr_accessor :k, :filename, :content
+    def initialize( k, filename, content )
+      @k = k
+      @filename = filename
+      @content = content
+    end
+
+    def to_multipart
+      #return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"; filename=\"#{filename}\"\r\n" + "Content-Transfer-Encoding: binary\r\n" + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n "
+      # Don't escape mine
+      return "Content-Disposition: form-data; name=\"#{k}\"; filename=\"#{filename}\"\r\n" + "Content-Transfer-Encoding: binary\r\n" + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n"
+    end
+  end
+  class MultipartPost
+    BOUNDARY = 'tarsiers-rule0000'
+    HEADER = {"Content-type" => "multipart/form-data, boundary=" + BOUNDARY + " "}
+
+    def prepare_query (params)
+      fp = []
+      params.each {|k,v|
+        if v.respond_to?(:read)
+          fp.push(FileParam.new(k, v.path, v.read))
+        else
+          fp.push(Param.new(k,v))
+        end
+      }
+      query = fp.collect {|p| "--" + BOUNDARY + "\r\n" + p.to_multipart }.join("") + "--" + BOUNDARY + "--"
+      return query, HEADER
+    end
+  end  
+end
+

data/test/support/run_rspec_tests.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# This script runs all RSpec tests. It only exists because RubyGems
+# requires executable Ruby scripts as unit tests, and RSpec tests
+# must be run via the 'spec' tool.
+require 'rubygems'
+gem 'rspec', '>= 1.1.2'
+Dir.chdir("#{File.dirname(__FILE__)}/..")
+Object.__send__(:remove_const, 'ARGV')
+ARGV = Dir['*_spec.rb']
+load 'spec'

data/test/support/tut.h

@@ -0,0 +1,1219 @@
+/**
+ * TUT unit testing framework.
+ * http://tut-framework.sourceforge.net/
+ *
+ * Copyright 2002-2006 Vladimir Dyuzhev.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Slightly modified for use in this software package.
+
+#ifndef TUT_H_GUARD
+#define TUT_H_GUARD
+
+#include <iostream>
+#include <map>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <typeinfo>
+
+#if defined(TUT_USE_SEH)
+#include <windows.h>
+#include <winbase.h>
+#endif
+
+#define DEFINE_TEST_GROUP(name) \
+	using namespace tut; \
+	typedef test_group<name> factory; \
+	typedef factory::object object; \
+	factory name## _group(#name)
+
+#define TEST_METHOD(i) \
+	template<> template<> \
+	void object::test<i>()
+
+/**
+ * Template Unit Tests Framework for C++.
+ * http://tut.dozen.ru
+ *
+ * @author Vladimir Dyuzhev, Vladimir.Dyuzhev@gmail.com
+ */
+namespace tut
+{
+
+/**
+ * The base for all TUT exceptions.
+ */
+struct tut_error : public std::exception
+{
+    tut_error(const std::string& msg)
+        : err_msg(msg)
+    {
+    }
+    
+    ~tut_error() throw()
+    {
+    }
+    
+    const char* what() const throw()
+    {
+        return err_msg.c_str();
+    }
+    
+private:
+
+    std::string err_msg;
+};
+
+/**
+ * Exception to be throwed when attempted to execute 
+ * missed test by number.
+ */
+struct no_such_test : public tut_error
+{
+    no_such_test() 
+        : tut_error("no such test")
+    {
+    }
+    
+    ~no_such_test() throw()
+    {
+    }
+};
+
+/**
+ * No such test and passed test number is higher than
+ * any test number in current group. Used in one-by-one
+ * test running when upper bound is not known.
+ */
+struct beyond_last_test : public no_such_test
+{
+    beyond_last_test()
+    {
+    }
+    
+    ~beyond_last_test() throw()
+    {
+    }
+};
+
+/**
+ * Group not found exception.
+ */
+struct no_such_group : public tut_error
+{
+    no_such_group(const std::string& grp) 
+        : tut_error(grp)
+    {
+    }
+    
+    ~no_such_group() throw()
+    {
+    }
+};
+
+/**
+ * Internal exception to be throwed when 
+ * no more tests left in group or journal.
+ */
+struct no_more_tests
+{
+    no_more_tests()
+    {
+    }
+    
+    ~no_more_tests() throw()
+    {
+    }
+};
+
+/**
+ * Internal exception to be throwed when 
+ * test constructor has failed.
+ */
+struct bad_ctor : public tut_error
+{
+    bad_ctor(const std::string& msg) 
+        : tut_error(msg)
+    {
+    }
+    
+    ~bad_ctor() throw()
+    {
+    }
+};
+
+/**
+ * Exception to be throwed when ensure() fails or fail() called.
+ */
+struct failure : public tut_error
+{
+    failure(const std::string& msg) 
+        : tut_error(msg)
+    {
+    }
+    
+    ~failure() throw()
+    {
+    }
+};
+
+/**
+ * Exception to be throwed when test desctructor throwed an exception.
+ */
+struct warning : public tut_error
+{
+    warning(const std::string& msg) 
+        : tut_error(msg)
+    {
+    }
+    
+    ~warning() throw()
+    {
+    }
+};
+
+/**
+ * Exception to be throwed when test issued SEH (Win32)
+ */
+struct seh : public tut_error
+{
+    seh(const std::string& msg) 
+        : tut_error(msg)
+    {
+    }
+    
+    ~seh() throw()
+    {
+    }
+};
+
+/**
+ * Return type of runned test/test group.
+ *
+ * For test: contains result of test and, possible, message
+ * for failure or exception.
+ */
+struct test_result
+{
+    /**
+     * Test group name.
+     */
+    std::string group;
+
+    /**
+     * Test number in group.
+     */
+    int test;
+
+    /**
+     * Test name (optional)
+     */
+    std::string name;
+
+    /**
+     * ok - test finished successfully
+     * fail - test failed with ensure() or fail() methods
+     * ex - test throwed an exceptions
+     * warn - test finished successfully, but test destructor throwed
+     * term - test forced test application to terminate abnormally
+     */
+    enum result_type
+    { 
+        ok, 
+        fail, 
+        ex, 
+        warn, 
+        term, 
+        ex_ctor 
+    };
+    
+    result_type result;
+
+    /**
+     * Exception message for failed test.
+     */
+    std::string message;
+    std::string exception_typeid;
+
+    /**
+     * Default constructor.
+     */
+    test_result()
+        : test(0),
+          result(ok)
+    {
+    }
+
+    /**
+     * Constructor.
+     */
+    test_result(const std::string& grp, int pos,
+                const std::string& test_name, result_type res)
+        : group(grp), 
+          test(pos), 
+          name(test_name), 
+          result(res)
+    {
+    }
+
+    /**
+     * Constructor with exception.
+     */
+    test_result(const std::string& grp,int pos,
+                const std::string& test_name, result_type res,
+                const std::exception& ex)
+        : group(grp), 
+          test(pos), 
+          name(test_name), 
+          result(res),
+          message(ex.what()),
+          exception_typeid(typeid(ex).name())
+    {
+    }
+};
+
+/**
+ * Interface.
+ * Test group operations.
+ */
+struct group_base
+{
+    virtual ~group_base()
+    {
+    }
+
+    // execute tests iteratively
+    virtual void rewind() = 0;
+    virtual test_result run_next() = 0;
+
+    // execute one test
+    virtual test_result run_test(int n) = 0;
+};
+
+/**
+ * Test runner callback interface.
+ * Can be implemented by caller to update
+ * tests results in real-time. User can implement 
+ * any of callback methods, and leave unused 
+ * in default implementation.
+ */
+struct callback
+{
+    /**
+     * Virtual destructor is a must for subclassed types.
+     */
+    virtual ~callback()
+    {
+    }
+
+    /**
+     * Called when new test run started.
+     */
+    virtual void run_started()
+    {
+    }
+
+    /**
+     * Called when a group started
+     * @param name Name of the group
+     */
+    virtual void group_started(const std::string& /*name*/)
+    {
+    }
+
+    /**
+     * Called when a test finished.
+     * @param tr Test results.
+     */
+    virtual void test_completed(const test_result& /*tr*/)
+    {
+    }
+
+    /**
+     * Called when a group is completed
+     * @param name Name of the group
+     */
+    virtual void group_completed(const std::string& /*name*/)
+    {
+    }
+
+    /**
+     * Called when all tests in run completed.
+     */
+    virtual void run_completed()
+    {
+    }
+};
+
+/**
+ * Typedef for runner::list_groups()
+ */
+typedef std::vector<std::string> groupnames;
+
+/**
+ * Test runner.
+ */
+class test_runner
+{
+
+public:
+    
+    /**
+     * Constructor
+     */
+    test_runner() 
+        : callback_(&default_callback_)
+    {
+    }
+
+    /**
+     * Stores another group for getting by name.
+     */
+    void register_group(const std::string& name, group_base* gr)
+    {
+        if (gr == 0)
+        {
+            throw tut_error("group shall be non-null");
+        }
+
+        // TODO: inline variable
+        groups::iterator found = groups_.find(name);
+        if (found != groups_.end())
+        {
+            std::string msg("attempt to add already existent group " + name);
+            // this exception terminates application so we use cerr also
+            // TODO: should this message appear in stream?
+            std::cerr << msg << std::endl;
+            throw tut_error(msg);
+        }
+
+        groups_[name] = gr;
+    }
+
+    /**
+     * Stores callback object.
+     */
+    void set_callback(callback* cb)
+    {
+        callback_ = cb == 0 ? &default_callback_ : cb;
+    }
+
+    /**
+     * Returns callback object.
+     */
+    callback& get_callback() const
+    {
+        return *callback_;
+    }
+
+    /**
+     * Returns list of known test groups.
+     */
+    const groupnames list_groups() const
+    {
+        groupnames ret;
+        const_iterator i = groups_.begin();
+        const_iterator e = groups_.end();
+        while (i != e)
+        {
+            ret.push_back(i->first);
+            ++i;
+        }
+        return ret;
+    }
+
+    /**
+     * Runs all tests in all groups.
+     * @param callback Callback object if exists; null otherwise
+     */
+    void run_tests() const
+    {
+        callback_->run_started();
+
+        const_iterator i = groups_.begin();
+        const_iterator e = groups_.end();
+        while (i != e)
+        {
+            callback_->group_started(i->first);
+            try
+            {
+                run_all_tests_in_group_(i);
+            }
+            catch (const no_more_tests&)
+            {
+                callback_->group_completed(i->first);
+            }
+
+            ++i;
+        }
+
+        callback_->run_completed();
+    }
+
+    /**
+     * Runs all tests in specified group.
+     */
+    void run_tests(const std::string& group_name) const
+    {
+        callback_->run_started();
+
+        const_iterator i = groups_.find(group_name);
+        if (i == groups_.end())
+        {
+            callback_->run_completed();
+            throw no_such_group(group_name);
+        }
+
+        callback_->group_started(group_name);
+        try
+        {
+            run_all_tests_in_group_(i);
+        }
+        catch (const no_more_tests&)
+        {
+            // ok
+        }
+
+        callback_->group_completed(group_name);
+        callback_->run_completed();
+    }
+
+    /**
+     * Runs one test in specified group.
+     */
+    test_result run_test(const std::string& group_name, int n) const
+    {
+        callback_->run_started();
+
+        const_iterator i = groups_.find(group_name);
+        if (i == groups_.end())
+        {
+            callback_->run_completed();
+            throw no_such_group(group_name);
+        }
+
+        callback_->group_started(group_name);
+        try
+        {
+            test_result tr = i->second->run_test(n);
+            callback_->test_completed(tr);
+            callback_->group_completed(group_name);
+            callback_->run_completed();
+            return tr;
+        }
+        catch (const beyond_last_test&)
+        {
+            callback_->group_completed(group_name);
+            callback_->run_completed();
+            throw;
+        }
+        catch (const no_such_test&)
+        {
+            callback_->group_completed(group_name);
+            callback_->run_completed();
+            throw;
+        }
+    }
+
+protected:
+    
+    typedef std::map<std::string, group_base*> groups;
+    typedef groups::iterator iterator;
+    typedef groups::const_iterator const_iterator;
+    groups groups_;
+
+    callback  default_callback_;
+    callback* callback_;
+
+
+private:
+
+    void run_all_tests_in_group_(const_iterator i) const
+    {
+        i->second->rewind();
+        for ( ;; )
+        {
+            test_result tr = i->second->run_next();
+            callback_->test_completed(tr);
+
+            if (tr.result == test_result::ex_ctor)
+            {
+                throw no_more_tests();
+            }
+        }
+    }
+};
+
+/**
+ * Singleton for test_runner implementation.
+ * Instance with name runner_singleton shall be implemented
+ * by user.
+ */
+class test_runner_singleton
+{
+public:
+
+    static test_runner& get()
+    {
+        static test_runner tr;
+        return tr;
+    }
+};
+
+extern test_runner_singleton runner;
+
+/**
+ * Test object. Contains data test run upon and default test method 
+ * implementation. Inherited from Data to allow tests to  
+ * access test data as members.
+ */
+template <class Data>
+class test_object : public Data
+{
+public:
+
+    /**
+     * Default constructor
+     */
+    test_object()
+    {
+    }
+
+    void set_test_name(const std::string& current_test_name)
+    {
+        current_test_name_ = current_test_name;
+    }
+
+    const std::string& get_test_name() const
+    {
+        return current_test_name_;
+    }
+
+    /**
+     * Default do-nothing test.
+     */
+    template <int n>
+    void test()
+    {
+        called_method_was_a_dummy_test_ = true;
+    }
+
+    /**
+     * The flag is set to true by default (dummy) test.
+     * Used to detect usused test numbers and avoid unnecessary
+     * test object creation which may be time-consuming depending
+     * on operations described in Data::Data() and Data::~Data().
+     * TODO: replace with throwing special exception from default test.
+     */
+    bool called_method_was_a_dummy_test_;
+
+private:
+
+    std::string current_test_name_;
+};
+
+namespace
+{
+
+/**
+ * Tests provided condition.
+ * Throws if false.
+ */
+void ensure(bool cond)
+{
+    if (!cond)
+    {
+        // TODO: default ctor?
+        throw failure("");
+    }
+}
+
+/**
+ * Tests provided condition.
+ * Throws if true.
+ */
+void ensure_not(bool cond)
+{
+    ensure(!cond);
+}
+
+/**
+ * Tests provided condition.
+ * Throws if false.
+ */
+template <typename T>
+void ensure(const T msg, bool cond)
+{
+    if (!cond)
+    {
+        throw failure(msg);
+    }
+}
+
+/**
+ * Tests provided condition.
+ * Throws if true.
+ */
+template <typename T>
+void ensure_not(const T msg, bool cond)
+{
+    ensure(msg, !cond);
+}
+
+/**
+ * Tests two objects for being equal.
+ * Throws if false.
+ *
+ * NB: both T and Q must have operator << defined somewhere, or
+ * client code will not compile at all!
+ */
+template <class T, class Q>
+void ensure_equals(const char* msg, const Q& actual, const T& expected)
+{
+    if (expected != actual)
+    {
+        std::stringstream ss;
+        ss << (msg ? msg : "") 
+            << (msg ? ":" : "") 
+            << " expected '" 
+            << expected 
+            << "' actual '" 
+            << actual
+            << '\'';
+        throw failure(ss.str().c_str());
+    }
+}
+
+template <class T, class Q>
+void ensure_equals(const Q& actual, const T& expected)
+{
+    ensure_equals<>(0, actual, expected);
+}
+
+/**
+ * Tests two objects for being at most in given distance one from another.
+ * Borders are excluded.
+ * Throws if false.
+ *
+ * NB: T must have operator << defined somewhere, or
+ * client code will not compile at all! Also, T shall have
+ * operators + and -, and be comparable.
+ */
+template <class T>
+void ensure_distance(const char* msg, const T& actual, const T& expected,
+    const T& distance)
+{
+    if (expected-distance >= actual || expected+distance <= actual)
+    {
+        std::stringstream ss;
+        ss << (msg ? msg : "") 
+            << (msg? ":" : "") 
+            << " expected (" 
+            << expected-distance 
+            << " - "
+            << expected+distance 
+            << ") actual '" 
+            << actual
+            << '\'';
+        throw failure(ss.str().c_str());
+    }
+}
+
+template <class T>
+void ensure_distance(const T& actual, const T& expected, const T& distance)
+{
+    ensure_distance<>(0, actual, expected, distance);
+}
+
+/**
+ * Unconditionally fails with message.
+ */
+void fail(const char* msg = "")
+{
+    throw failure(msg);
+}
+
+} // end of namespace
+
+/**
+ * Walks through test tree and stores address of each
+ * test method in group. Instantiation stops at 0.
+ */
+template <class Test, class Group, int n>
+struct tests_registerer
+{
+    static void reg(Group& group)
+    {
+        group.reg(n, &Test::template test<n>);
+        tests_registerer<Test, Group, n - 1>::reg(group);
+    }
+};
+
+template <class Test, class Group>
+struct tests_registerer<Test, Group, 0>
+{
+    static void reg(Group&)
+    {
+    }
+};
+
+/**
+ * Test group; used to recreate test object instance for
+ * each new test since we have to have reinitialized 
+ * Data base class.
+ */
+template <class Data, int MaxTestsInGroup = 50>
+class test_group : public group_base
+{
+    const char* name_;
+
+    typedef void (test_object<Data>::*testmethod)();
+    typedef std::map<int, testmethod> tests;
+    typedef typename tests::iterator tests_iterator;
+    typedef typename tests::const_iterator tests_const_iterator;
+    typedef typename tests::const_reverse_iterator
+    tests_const_reverse_iterator;
+    typedef typename tests::size_type size_type;
+
+    tests tests_;
+    tests_iterator current_test_;
+
+    /**
+     * Exception-in-destructor-safe smart-pointer class.
+     */
+    template <class T>
+    class safe_holder
+    {
+        T* p_;
+        bool permit_throw_in_dtor;
+
+        safe_holder(const safe_holder&);
+        safe_holder& operator=(const safe_holder&);
+
+    public:
+        safe_holder() 
+            : p_(0),
+              permit_throw_in_dtor(false)
+        {
+        }
+
+        ~safe_holder()
+        {
+            release();
+        }
+
+        T* operator->() const
+        {
+            return p_;
+        }
+        
+        T* get() const
+        {
+            return p_;
+        }
+
+        /**
+         * Tell ptr it can throw from destructor. Right way is to
+         * use std::uncaught_exception(), but some compilers lack
+         * correct implementation of the function.
+         */
+        void permit_throw()
+        {
+            permit_throw_in_dtor = true;
+        }
+
+        /**
+         * Specially treats exceptions in test object destructor; 
+         * if test itself failed, exceptions in destructor
+         * are ignored; if test was successful and destructor failed,
+         * warning exception throwed.
+         */
+        void release()
+        {
+            try
+            {
+                if (delete_obj() == false)
+                {
+                    throw warning("destructor of test object raised"
+                        " an SEH exception");
+                }
+            }
+            catch (const std::exception& ex)
+            {
+                if (permit_throw_in_dtor)
+                {
+                    std::string msg = "destructor of test object raised"
+                        " exception: ";
+                    msg += ex.what();
+                    throw warning(msg);
+                }
+            }
+            catch( ... )
+            {
+                if (permit_throw_in_dtor)
+                {
+                    throw warning("destructor of test object raised an"
+                        " exception");
+                }
+            }
+        }
+
+        /**
+         * Re-init holder to get brand new object.
+         */
+        void reset()
+        {
+            release();
+            permit_throw_in_dtor = false;
+            p_ = new T();
+        }
+
+        bool delete_obj()
+        {
+#if defined(TUT_USE_SEH)
+            __try
+            {
+#endif
+                T* p = p_;
+                p_ = 0;
+                delete p;
+#if defined(TUT_USE_SEH)
+            }
+            __except(handle_seh_(::GetExceptionCode()))
+            {
+                if (permit_throw_in_dtor)
+                {
+                    return false;
+                }
+            }
+#endif
+            return true;
+        }
+    };
+
+public:
+
+    typedef test_object<Data> object;
+
+    /**
+     * Creates and registers test group with specified name.
+     */
+    test_group(const char* name)
+        : name_(name)
+    {
+        // register itself
+        runner.get().register_group(name_,this);
+
+        // register all tests
+        tests_registerer<object, test_group, MaxTestsInGroup>::reg(*this);
+    }
+
+    /**
+     * This constructor is used in self-test run only.
+     */
+    test_group(const char* name, test_runner& another_runner)
+        : name_(name)
+    {
+        // register itself
+        another_runner.register_group(name_, this);
+
+        // register all tests
+        tests_registerer<test_object<Data>, test_group, 
+            MaxTestsInGroup>::reg(*this);
+    };
+
+    /**
+     * Registers test method under given number.
+     */
+    void reg(int n, testmethod tm)
+    {
+        tests_[n] = tm;
+    }
+
+    /**
+     * Reset test position before first test.
+     */
+    void rewind()
+    {
+        current_test_ = tests_.begin();
+    }
+
+    /**
+     * Runs next test.
+     */
+    test_result run_next()
+    {
+        if (current_test_ == tests_.end())
+        {
+            throw no_more_tests();
+        }
+
+        // find next user-specialized test
+        safe_holder<object> obj;
+        while (current_test_ != tests_.end())
+        {
+            try
+            {
+                return run_test_(current_test_++, obj);
+            }
+            catch (const no_such_test&)
+            {
+                continue;
+            }
+        }
+
+        throw no_more_tests();
+    }
+
+    /**
+     * Runs one test by position.
+     */
+    test_result run_test(int n)
+    {
+        // beyond tests is special case to discover upper limit
+        if (tests_.rbegin() == tests_.rend())
+        {
+            throw beyond_last_test();
+        }
+        
+        if (tests_.rbegin()->first < n)
+        {
+            throw beyond_last_test();
+        }
+
+        // withing scope; check if given test exists
+        tests_iterator ti = tests_.find(n);
+        if (ti == tests_.end())
+        {
+            throw no_such_test();
+        }
+
+        safe_holder<object> obj;
+        return run_test_(ti, obj);
+    }
+
+private:
+
+    /**
+     * VC allows only one exception handling type per function,
+     * so I have to split the method.
+     * 
+     * TODO: refactoring needed!
+     */
+    test_result run_test_(const tests_iterator& ti, safe_holder<object>& obj)
+    {
+        std::string current_test_name;
+        try
+        {
+            if (run_test_seh_(ti->second,obj, current_test_name) == false)
+            {
+                throw seh("seh");
+            }
+        }
+        catch (const no_such_test&)
+        {
+            throw;
+        }
+        catch (const warning& ex)
+        {
+            // test ok, but destructor failed
+            if (obj.get())
+            {
+                current_test_name = obj->get_test_name();
+            }
+            test_result tr(name_,ti->first, current_test_name, 
+                test_result::warn, ex);
+            return tr;
+        }
+        catch (const failure& ex)
+        {
+            // test failed because of ensure() or similar method
+            if (obj.get())
+            {
+                current_test_name = obj->get_test_name();
+            }
+            test_result tr(name_,ti->first, current_test_name, 
+                test_result::fail, ex);
+            return tr;
+        }
+        catch (const seh& ex)
+        {
+            // test failed with sigsegv, divide by zero, etc
+            if (obj.get())
+            {
+                current_test_name = obj->get_test_name();
+            }
+            test_result tr(name_, ti->first, current_test_name, 
+                test_result::term, ex);
+            return tr;
+        }
+        catch (const bad_ctor& ex)
+        {
+            // test failed because test ctor failed; stop the whole group
+            if (obj.get())
+            {
+                current_test_name = obj->get_test_name();
+            }
+            test_result tr(name_, ti->first, current_test_name, 
+                test_result::ex_ctor, ex);
+            return tr;
+        }
+        catch (const std::exception& ex)
+        {
+            // test failed with std::exception
+            if (obj.get())
+            {
+                current_test_name = obj->get_test_name();
+            }
+            test_result tr(name_, ti->first, current_test_name, 
+                test_result::ex, ex);
+            return tr;
+        }
+        catch (...)
+        {
+            // test failed with unknown exception
+            if (obj.get())
+            {
+                current_test_name = obj->get_test_name();
+            }
+            test_result tr(name_, ti->first, current_test_name, 
+                test_result::ex);
+            return tr;
+        }
+
+        // test passed
+        test_result tr(name_,ti->first, current_test_name, test_result::ok);
+        return tr;
+    }
+
+    /**
+     * Runs one under SEH if platform supports it.
+     */
+    bool run_test_seh_(testmethod tm, safe_holder<object>& obj, 
+        std::string& current_test_name)
+    {
+#if defined(TUT_USE_SEH)
+        __try
+        {
+#endif
+        if (obj.get() == 0)
+        {
+            reset_holder_(obj);
+        }
+            
+        obj->called_method_was_a_dummy_test_ = false;
+
+#if defined(TUT_USE_SEH)
+
+            __try
+            {
+#endif
+                (obj.get()->*tm)();
+#if defined(TUT_USE_SEH)
+            }
+            __except(handle_seh_(::GetExceptionCode()))
+            {
+                // throw seh("SEH");
+                current_test_name = obj->get_test_name();
+                return false;
+            }
+#endif
+
+        if (obj->called_method_was_a_dummy_test_)
+        {
+            // do not call obj.release(); reuse object
+            throw no_such_test();
+        }
+
+        current_test_name = obj->get_test_name();
+        obj.permit_throw();
+        obj.release();
+#if defined(TUT_USE_SEH)
+        }
+        __except(handle_seh_(::GetExceptionCode()))
+        {
+            return false;
+        }
+#endif
+        return true;
+    }
+
+    void reset_holder_(safe_holder<object>& obj)
+    {
+        try
+        {
+            obj.reset();
+        }
+        catch (const std::exception& ex)
+        {
+            throw bad_ctor(ex.what());
+        }
+        catch (...)
+        {
+            throw bad_ctor("test constructor has generated an exception;"
+                " group execution is terminated");
+        }
+    }
+};
+
+#if defined(TUT_USE_SEH)
+/**
+ * Decides should we execute handler or ignore SE.
+ */
+inline int handle_seh_(DWORD excode)
+{
+    switch(excode)
+    {
+    case EXCEPTION_ACCESS_VIOLATION:
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+    case EXCEPTION_BREAKPOINT:
+    case EXCEPTION_SINGLE_STEP:
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+    case EXCEPTION_FLT_INEXACT_RESULT:
+    case EXCEPTION_FLT_INVALID_OPERATION:
+    case EXCEPTION_FLT_OVERFLOW:
+    case EXCEPTION_FLT_STACK_CHECK:
+    case EXCEPTION_FLT_UNDERFLOW:
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+    case EXCEPTION_INT_OVERFLOW:
+    case EXCEPTION_PRIV_INSTRUCTION:
+    case EXCEPTION_IN_PAGE_ERROR:
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+    case EXCEPTION_STACK_OVERFLOW:
+    case EXCEPTION_INVALID_DISPOSITION:
+    case EXCEPTION_GUARD_PAGE:
+    case EXCEPTION_INVALID_HANDLE:
+        return EXCEPTION_EXECUTE_HANDLER;
+    };
+
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+#endif
+}
+
+#endif
+