ttk 0.1.576

data/ruby_ex/checkout.rb

@@ -0,0 +1,12 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: checkout.rb 159 2005-02-18 12:07:23Z polrop $
+
+require 'uri_ex' 
+require 'uri/http_ex'
+require 'uri/ftp_ex'
+require 'uri/file'
+require 'uri/svn'

data/ruby_ex/config_file.rb

@@ -0,0 +1,96 @@
+# 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

@@ -0,0 +1,59 @@
+# 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

@@ -0,0 +1,134 @@
+# 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

@@ -0,0 +1,667 @@
+# 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
+