vcs 0.2.148 → 0.3.0

data/ruby_ex/commands/runners/runner.rb

@@ -1,107 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
-# License::   GNU General Public License (GPL).
-# Revision::  $Id: runner.rb 221 2005-05-09 12:40:57Z ertai $
-
-module Commands
-
-  module Runners
-
-    class Runner
-
-      abstract
-
-      include Hookable
-      include Hooker
-
-
-      #
-      # Hooks declaration
-      #
-
-      hook_declare :display_command
-      hook_declare :data
-      hook_declare :before_open
-      hook_declare :before_chdir
-      hook_declare :before_exec
-      hook_declare :exec
-
-
-      #
-      # Construction methods.
-      #
-
-      def initialize
-        @command_data_factory = Datas::Factory.new
-        hooker_subscribe self
-        # hooker_subscribe VerboseHooker.new
-      end
-
-
-      #
-      # Methods.
-      #
-
-      def run ( aCommand )
-        unless aCommand.is_a? Commands::Command
-          raise ArgumentError, 'Need a Runner::Command'
-        end
-
-        hook_trigger :display_command, aCommand
-
-        data = @command_data_factory.create
-        data.input = aCommand.input
-        data.output = aCommand.output
-        data.error = aCommand.error
-        hook_trigger :data, aCommand, data
-
-        run_impl(aCommand, data)
-
-        data
-      end
-
-      def run_impl ( aCommand, data )
-        hook_trigger :before_open, data
-        STDIN.reopen(data.input.to_io) unless data.input.nil?
-        STDOUT.reopen(data.output.to_io) unless data.output.nil?
-        STDERR.reopen(data.error.to_io) unless data.error.nil?
-
-        hook_trigger :before_chdir, data
-        Dir.chdir(aCommand.dir) unless aCommand.dir.nil?
-
-        hook_trigger :before_exec, aCommand, data
-        hook_trigger :exec, aCommand, data
-      end
-
-      class VerboseHooker
-        include Hooker
-
-        def log ( m, *a )
-          STDERR.puts
-          STDERR.puts "#{m}: #{a.inspect}"
-        end
-
-        hook_default_method :log
-
-      end # class VerboseHooker
-
-
-    end # class Runner
-
-
-
-    if $0 == __FILE__
-      require 'test/unit'
-
-      class RunnerTest < Test::Unit::TestCase
-
-        def test_abstract
-          assert_raise(TypeError) { Runner.new }
-        end
-
-      end # class RunnerTest
-    end
-
-  end # module Runners
-
-end # module Commands

data/ruby_ex/commands/seq.rb

@@ -1,27 +0,0 @@
-# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
-# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
-# License::   GNU General Public License (GPL).
-# Revision::  $Id: seq.rb 221 2005-05-09 12:40:57Z ertai $
-
-module Commands
-
-  class Seq < Command
-
-    def initialize ( *cmds )
-      @cmds = cmds
-    end
-
-    def run ( *a )
-      @cmds.each do |cmd|
-        cmd.run(*a)
-      end
-    end
-
-    def to_sh
-      strs = @cmds.map { |cmd| "(#{cmd.to_sh})" }
-      "(#{strs.join(' ; ')})#{sh_args}"
-    end
-
-  end # class Seq
-
-end # module Commands

data/ruby_ex/config_file.rb

@@ -1,96 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: ertai $
-# $Id: config_file.rb 186 2005-04-03 00:07:45Z ertai $
-
-
-require 'pathname'
-require 'yaml'
-require 'delegate'
-
-
-class ConfigFile < SimpleDelegator
-
-  protected :__setobj__
-
-  class FormatError < RuntimeError; end
-
-  attr_reader :default_config
-
-  def initialize(filename, default_config=nil)
-    @filename = Pathname.new(filename)
-    @default_config = default_config.freeze
-    __load__
-  end
-
-  def __load__(&block)
-    config = nil
-    if @filename.exist?
-      @filename.open do |f|
-        f.flock(File::LOCK_EX)
-        config = real_load(f)
-        f.flock(File::LOCK_UN)
-      end
-      block ? block[config] : check_config(config)
-      config.freeze
-    else
-      if $VERBOSE
-        Kernel.warn('warning: use default configuration because no ' +
-                    'configuration file has been found')
-      end
-      config = @default_config
-    end
-    __setobj__(config)
-  end
-
-  # Raise a FormatError if the loaded configuration do not fit the format
-  protected
-  def check_config(config)
-  end
-
-  # You can override it to change arguments or Yaml parsing command.
-  protected
-  def real_load(io)
-    YAML::load(io)
-  end
-
-
-end # class ConfigFile
-
-
-if (not defined? CONFIG_FILE_TESTED) and (defined? TEST_MODE or __FILE__ == $0)
-CONFIG_FILE_TESTED = true
-
-require 'test/unit/ui/console/testrunner'
-require 'tempfile'
-
-
-class ConfigFileTest < Test::Unit::TestCase
-
-  def test_config_file
-    tmp_file = nil
-    Tempfile.open('config_file') do |f|
-      f.puts '---'
-      f.puts 'key1: val1'
-      f.puts 'key2: val2'
-      tmp_file = f
-    end
-    raise 'no temp file' if tmp_file.nil?
-    default_config = { 'key1' => 'def1', 'key2' => 'def2' }
-    config_file = ConfigFile.new('/toto', default_config)
-    assert_equal(default_config, config_file.__getobj__)
-    assert_raises(NoMethodError) { config_file.__setobj__(nil) }
-    config_file = ConfigFile.new(tmp_file.path, default_config)
-    assert_equal({ 'key1' => 'val1', 'key2' => 'val2' },
-                 config_file.__getobj__)
-    assert(config_file.__getobj__.frozen?)
-  end
-
-end # class ConfigFileTest
-
-
-end
-
-

data/ruby_ex/const_regexp.rb

@@ -1,59 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: polrop $
-# $Id: const_regexp.rb 83 2004-12-16 13:06:42Z polrop $
-
-
-module ConstRegexp
-
-  RB_INST_VAR = /^@[A-Za-z_][A-Za-z0-9_]*$/
-  RB_CLASS_VAR = /^@@[A-Za-z_][A-Za-z0-9_]*$/ #FIXME: concat with RB_INST_VAR
-  RB_LOCAL_VAR = /^[a-z_][A-Za-z0-9_]*$/
-  RB_METHOD = /^[a-z_][A-Za-z0-9_]*[=?!]?$/
-  RB_REGEXP = /^\/([^\\]|\\.)*\/$/
-  RB_CONST = /^[A-Z][a-zA-Z0-9_]*$/
-
-  CRYPTED_STRING = /^[A-Za-z0-9.\/]{13}$/
-
-  DRB_URI = /^([^:]+):\/\/([^:]+):(\d+)$/
-
-
-
-end # module ConstRegexp
-
-
-#
-# Unit test suite
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-
-require 'test/unit/ui/yaml/testrunner'
-
-
-class ConstRegexpTest < Test::Unit::TestCase
-
-  include ConstRegexp
-
-  #
-  # Tests
-  #
-  def test_rb_regexp
-    assert_match(RB_REGEXP, '//')
-    assert_no_match(RB_REGEXP, '')
-    assert_match(RB_REGEXP, '/\//')
-    assert_match(RB_REGEXP, '/\/\//')
-    assert_match(RB_REGEXP, '/reg\/e/')
-    assert_no_match(RB_REGEXP, '/\\/')
-    assert_match(RB_REGEXP, '/\\\\/')
-    assert_match(RB_REGEXP, '/\e/')
-    assert_no_match(RB_REGEXP, '/\/')
-  end
-
-end # class ConstRegexpTest
-
-
-end
-

data/ruby_ex/daemon.rb

@@ -1,134 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: polrop $
-# $Id: daemon.rb 144 2005-01-30 14:12:16Z polrop $
-
-
-require 'pathname'
-require 'singleton'
-
-require 'observable'
-require 'observable_pool'
-require 'service_manager'
-
-
-class Daemon
-  include Singleton
-  include ServiceManager
-  include Observable
-  include ObservablePool
-
-  module Notification
-
-    START         = :daemon_notification_start
-    STOP          = :daemon_notification_stop
-    WORKDIR       = :daemon_notification_workdir
-    CONFIG        = :daemon_notification_config
-    CLEAN_WORKDIR = :daemon_notification_clean_workdir
-    DETACH        = :daemon_notification_detach
-    SIGNAL_TRAPS  = :daemon_notification_signal_traps
-    RELOAD_CONFIG = :daemon_notification_reload_config
-
-  end # module Notification
-
-  def initialize
-    @config = nil
-    @workdir = Pathname.new('')
-    @detached = false
-    add_observable(self)
-    @logger = nil
-  end
-
-  def config=(config)
-    unless config.nil? or config.respond_to?(:__load__)
-      raise(NoMethodError, 'configuration class need to respond to `load\'')
-    end
-    @config = config
-    changed
-    notify_observers(Notification::CONFIG, @config)
-    @config
-  end
-
-  attr_reader :config
-
-  def workdir=(workdir)
-    unless workdir.to_s.empty?
-      unless File.directory?(workdir)
-        raise(ArgumentError, "`#{workdir}' - not a directory")
-      end
-      Dir.chdir(workdir)
-    end
-    @workdir = Pathname.new(workdir)
-    changed
-    notify_observers(Notification::WORKDIR, @workdir)
-    @workdir
-  end
-
-  attr_reader :workdir
-
-  def clean_workdir
-    @workdir.each_entry do |p|
-      next if p.to_s =~ /^\./
-      (@workdir + p).rmtree
-    end
-    changed
-    notify_observers(Notification::CLEAN_WORKDIR)
-    nil
-  end
-
-  def detach
-    return if @detached
-    @detached = true
-    if pid = fork # father
-      exit
-    else # son
-      Dir.chdir(@workdir.to_s.empty? ? '/' : @workdir.to_s)
-      Process.setsid
-      STDIN.close
-      STDOUT.close
-      STDERR.close
-    end
-    changed
-    notify_observers(Notification::DETACH)
-    nil
-  end
-
-  def detached?
-    @detached
-  end
-
-  def logger=(logger)
-    delete_global_observer(@logger) unless @logger.nil?
-    @logger = logger
-    add_global_observer(@logger)
-    changed
-    notify_observers(Notification::START)
-  end
-
-  attr_reader :logger
-
-  def stop_daemon
-    stop_services
-    changed
-    notify_observers(Notification::STOP)
-    exit
-  end
-
-  def reload_config
-    unless @config.nil?
-      @config.__load__
-      changed
-      notify_observers(Notification::RELOAD_CONFIG)
-      @config
-    end
-  end
-
-  def start_daemon(*args)
-  end
-
-end # class Daemon
-
-
-#FIXME: test me somehow

data/ruby_ex/diff.rb

@@ -1,667 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: ertai $
-# $Id: diff.rb 186 2005-04-03 00:07:45Z ertai $
-
-
-module Diff
-
-  def diff(other, recursive=true)
-    gen_diff(other, recursive) {|a, b| a == b}
-  end
-
-  def gen_diff(other, recursive=true, &comp)
-    result = {
-      :similar => {},
-      :different => {},
-      :missing => {},
-      :additional => {}
-    }
-    if not other.is_a?(self.class)
-      result[:different] = {:self => self.class, :other => other.class}
-      return result
-    end
-    self.each_pair do |k, v|
-      if other.has_key?(k)
-        if comp[v, other[k]]
-          result[:similar][k] = v
-        else
-          if recursive and v.respond_to?(:gen_diff)
-            diff_result = v.gen_diff(other[k], recursive, &comp)
-          else
-            diff_result = {:self => v, :other => other[k]}
-          end
-          result[:different][k] = diff_result unless diff_result.no_diff?
-        end
-      else
-        result[:additional][k] = v
-      end
-    end
-    other.each_pair do |k, v|
-      if not self.has_key?(k)
-        result[:missing][k] = v
-      end
-    end
-    result
-  end
-
-  def no_diff?
-    self[:different] == {} and self[:missing] == {} and self[:additional] == {}
-  end
-
-end # module Diff
-
-
-class Array
-
-  include Diff
-
-  def each_pair
-    for i in 0...length do
-      yield(i, self[i])
-    end
-  end
-
-  def has_index?(i)
-    0 <= i and i < length
-  end
-
-  alias has_key? has_index?
-
-end # class Array
-
-
-class Hash
-
-  include Diff
-
-  def no_diff?
-    self[:different] == {} and self[:missing] == {} and self[:additional] == {}
-  end
-
-end # class Hash
-
-
-#
-# Unit test suite
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-
-#FIXME: Tidy me because some of my test are duplicated.
-
-
-require 'test/unit/ui/yaml/testrunner'
-
-
-class DiffTest < Test::Unit::TestCase
-
-  #
-  # Setup
-  #
-  class A < Array ; end
-  class H < Hash ; end
-
-  #
-  # Tests
-  #
-  def test_empty
-    h = []
-    other_h = []
-    result_h = h.diff(h)
-    assert_equal(true, result_h.no_diff?)
-    assert_equal({}, result_h[:similar])
-  end
-
-  def test_simple_similar
-    other_h = h = [ 'toto' => 'tata' ]
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => { 0 => { 'toto' => 'tata' } },
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_additional
-    h = [ 'toto' => 'tata' ]
-    other_h = []
-    result_h = {
-      :additional => { 0 => { 'toto' => 'tata' } },
-      :missing => {},
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing
-    h = []
-    other_h = [ 'toto' => 'tata' ]
-    result_h = {
-      :additional => {},
-      :missing => { 0 => { 'toto' => 'tata' } },
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_different
-    h = [ 'tutu' ]
-    other_h = [ 'tata' ]
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {0 => {:self => 'tutu', :other => 'tata'}},
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_similar
-    other_h = h = [ 'toto', 'tata']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {0 => 'toto', 1 => 'tata'},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_additional
-    h = [ 'toto', 'tata' ]
-    other_h = []
-    result_h = {
-      :additional => {0 => 'toto', 1 => 'tata'},
-      :missing => {},
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_missing
-    h = []
-    other_h = [ 'toto', 'tata' ]
-    result_h = {
-      :additional => {},
-      :missing => {0 => 'toto', 1 => 'tata'},
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_different
-    h = [ 'foo', 'tutu' ]
-    other_h = [ 'bar', 'tata' ]
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {
-        0 => {:self => 'foo', :other => 'bar'},
-        1 => {:self => 'tutu', :other => 'tata'},
-      }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing_missing
-    h = []
-    other_h = []
-    h[0] = 'toto'
-    other_h[1] = 'foo'
-    result_h = {
-      :additional => {},
-      :missing => {1 => 'foo'},
-      :similar => {},
-      :different => {0 => {:self => 'toto', :other => nil}}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_additional_similar
-    h = [ 'foo', 'toto' ]
-    other_h = [ 'foo' ]
-    result_h = {
-      :additional => {1 => 'toto'},
-      :missing => {},
-      :similar => {0 => 'foo'},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_additional_different
-    h = [ 'toto', 'tata' ]
-    other_h = [ 'foo' ]
-    result_h = {
-      :additional => {1 => 'tata'},
-      :missing => {},
-      :similar => {},
-      :different => {0 => { :self => 'toto', :other => 'foo' } }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing_similar
-    h = [ 'foo' ]
-    other_h = [ 'foo', 'toto' ]
-    result_h = {
-      :additional => {},
-      :missing => {1 => 'toto'},
-      :similar => {0 => 'foo'},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing_different
-    h = ['foo']
-    other_h = ['bor', 'toto']
-    result_h = {
-      :additional => {},
-      :missing => {1 => 'toto'},
-      :similar => {},
-      :different => {0 => {:self => 'foo', :other => 'bor'}}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_similar_different
-    h = ['bar', 'toto']
-    other_h = ['bor', 'toto']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {1 => 'toto'},
-      :different => {0 => {:self => 'bar', :other => 'bor'}}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_nested_similar_different
-    h = [['toto', 'bar'], 'tata']
-    other_h = [['toto', 'bor'], 'tata']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {1 => 'tata'},
-      :different => {0 => {
-          :additional => {},
-          :missing => {},
-          :similar => {0 => 'toto'},
-          :different => {1 => {:self => 'bar', :other => 'bor'}}
-        }
-      }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_nested_different_different
-    h = [['toto', 'bar'], 'tata']
-    other_h = [['toto', 'bor'], 'tutu']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {
-        0 => {
-          :additional => {},
-          :missing => {},
-          :similar => {0 => 'toto'},
-          :different => {1 => {:self => 'bar', :other => 'bor'}}
-        },
-        1 => {:self => 'tata', :other => 'tutu'}
-      }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_similar_different_additional
-    h = ['goo', 'wrong', 'add']
-    other_h = ['goo', 'bar']
-    result_h = {
-      :additional => {2 => 'add'},
-      :missing => {},
-      :similar => {0 => 'goo'},
-      :different => {1 => {:self => 'wrong', :other => 'bar'}}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_diff_class
-    h = ['bar', 'tata']
-    other_h = {0 => 'bar', 1 => 'tata'}
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {:self => Array, :other => Hash}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_diff_inherited_class
-    h = A.new(['bar', 'tata'])
-    other_h = {0 => 'bar', 1 => 'tata'}
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {:self => A, :other => Hash}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_array_in_hash
-    h = {'toto' => 'tata', 'foo' => ['goo', 'wrong', 'add']}
-    other_h = {'toto' => 'tata', 'foo' => ['goo', 'bar']}
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {'toto' => 'tata'},
-      :different => {'foo' => {
-          :additional => {2 => 'add'},
-          :missing => {},
-          :similar => {0 => 'goo'},
-          :different => {1 => {:self => 'wrong', :other => 'bar'}}
-        }
-      }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_no_recursion
-    h = [['toto', 'bar'], 'tata']
-    other_h = [['toto', 'bor'], 'tutu']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {0 => {
-          :self => ['toto', 'bar'],
-          :other => ['toto', 'bor']
-        },
-                     1 => {
-          :self => 'tata',
-          :other => 'tutu'
-        }
-      }
-    }
-    assert_equal(result_h, h.diff(other_h,false))
-  end
-
-  def test_other_comp_fun
-    h = [['false']]
-    other_h = [[false]]
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => { 0 => ['false']},
-      :different => {}
-    }
-    assert_equal(result_h, h.gen_diff(other_h, true) {|a, b| a.to_s == b.to_s})
-  end
-
-  def test_empty2
-    other_h = h = {}
-    diff_h = h.diff(h)
-    assert_equal(true, diff_h.no_diff?)
-    assert_equal({}, diff_h[:similar])
-  end
-
-  def test_simple_similar2
-    other_h = h = { 'toto' => 'tata' }
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => { 'toto' => 'tata' },
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_additional2
-    h = { 'toto' => 'tata' }
-    other_h = {}
-    result_h = {
-      :additional => { 'toto' => 'tata' },
-      :missing => {},
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing2
-    h = {}
-    other_h = { 'toto' => 'tata' }
-    result_h = {
-      :additional => {},
-      :missing => { 'toto' => 'tata' },
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_different2
-    h = { 'toto' => 'tutu' }
-    other_h = { 'toto' => 'tata' }
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => { 'toto' => { :self => 'tutu', :other => 'tata' } }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_similar2
-    other_h = h = { 'toto' => 'tata', 'foo' => 'bar' }
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => { 'toto' => 'tata', 'foo' => 'bar' },
-      :different => {}
-    }
-    diff = h.diff(other_h)
-    assert_equal(result_h, diff)
-    assert_equal(true, diff.no_diff?)
-  end
-
-  def test_several_additional2
-    h = { 'toto' => 'tata', 'foo' => 'bar' }
-    other_h = {}
-    result_h = {
-      :additional => { 'toto' => 'tata', 'foo' => 'bar' },
-      :missing => {},
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_missing2
-    h = {}
-    other_h = { 'toto' => 'tata', 'foo' => 'bar' }
-    result_h = {
-      :additional => {},
-      :missing => { 'toto' => 'tata', 'foo' => 'bar' },
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_several_different2
-    h = { 'toto' => 'tutu', 'foo' => 'bor' }
-    other_h = { 'toto' => 'tata', 'foo' => 'bar' }
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {
-        'toto' => { :self => 'tutu', :other => 'tata' },
-        'foo' => { :self => 'bor', :other => 'bar' },
-      }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing_missing2
-    h = { 'toto' => 'tata' }
-    other_h = { 'foo' => 'bar' }
-    result_h = {
-      :additional => { 'toto' => 'tata' },
-      :missing => { 'foo' => 'bar' },
-      :similar => {},
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_additional_similar2
-    h = { 'toto' => 'tata', 'foo' => 'bar' }
-    other_h = { 'foo' => 'bar' }
-    result_h = {
-      :additional => { 'toto' => 'tata' },
-      :missing => {},
-      :similar => { 'foo' => 'bar' },
-      :different => {}
-    }
-    diff = h.diff(other_h)
-    assert_equal(result_h, diff)
-    assert_equal(false, diff.no_diff?)
-  end
-
-  def test_simple_additional_different2
-    h = { 'toto' => 'tata', 'foo' => 'bar' }
-    other_h = { 'foo' => 'bor' }
-    result_h = {
-      :additional => { 'toto' => 'tata' },
-      :missing => {},
-      :similar => {},
-      :different => { 'foo' => { :self => 'bar', :other => 'bor' } }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing_similar2
-    h = { 'foo' => 'bar' }
-    other_h = { 'foo' => 'bar', 'toto' => 'tata' }
-    result_h = {
-      :additional => {},
-      :missing => { 'toto' => 'tata' },
-      :similar => { 'foo' => 'bar' },
-      :different => {}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_missing_different2
-    h = { 'foo' => 'bar' }
-    other_h = { 'foo' => 'bor', 'toto' => 'tata' }
-    result_h = {
-      :additional => {},
-      :missing => { 'toto' => 'tata' },
-      :similar => {},
-      :different => { 'foo' => { :self => 'bar', :other => 'bor' } }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_simple_similar_different2
-    h = { 'foo' => 'bar', 'toto' => 'tata' }
-    other_h = { 'foo' => 'bor', 'toto' => 'tata' }
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => { 'toto' => 'tata' },
-      :different => { 'foo' => { :self => 'bar', :other => 'bor' } }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_nested_similar_different2
-    h = {'foo' => {'toto' => 'tata', 'foo' => 'bar'}, 'toto' => 'tata'}
-    other_h = {'foo' => {'toto' => 'tata', 'foo' => 'bor'}, 'toto' => 'tata'}
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {'toto' => 'tata'},
-      :different => {'foo' => {
-          :additional => {},
-          :missing => {},
-          :similar => {'toto' => 'tata'},
-          :different => {'foo' => {:self => 'bar', :other => 'bor'}}
-        }
-      }
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_diff_class2
-    h = {0 => 'bar', 1 => 'tata'}
-    other_h = ['bar', 'tata']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {:self => Hash, :other => Array}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_diff_inherited_class2
-    h = H.new(0 => 'bar', 1 => 'tata')
-    other_h = ['bar', 'tata']
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {},
-      :different => {:self => H, :other => Array}
-    }
-    assert_equal(result_h, h.diff(other_h))
-  end
-
-  def test_no_recursion2
-    h = {'foo' => {'toto' => 'tata', 'foo' => 'bar'}, 'toto' => 'tata'}
-    other_h = {'foo' => {'toto' => 'tata', 'foo' => 'bor'}, 'toto' => 'tata'}
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {'toto' => 'tata'},
-      :different => {'foo' => {
-          :self => {'toto' => 'tata', 'foo' => 'bar'},
-          :other => {'toto' => 'tata', 'foo' => 'bor'}
-        }
-      }
-    }
-    assert_equal(result_h, h.diff(other_h, false))
-  end
-
-  def test_other_comp_fun2
-    h = {'foo' => {'toto' => 'false', 'foo' => '0'}}
-    other_h = {'foo' => {'toto' => false, 'foo' => 0}}
-    result_h = {
-      :additional => {},
-      :missing => {},
-      :similar => {'foo' => {'toto' => 'false', 'foo' => '0'}},
-      :different => {}
-    }
-    assert_equal(result_h, h.gen_diff(other_h, true) {|a, b| a.to_s == b.to_s})
-  end
-
-end # class DiffTest
-
-
-end
-