ttk 0.1.580 → 0.2.0

data/ruby_ex/session/test/administrable_test.rb

@@ -1,337 +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: administrable_test.rb 67 2004-12-07 01:00:10Z polrop $
-
-
-#
-# Client/Server administrable test suite
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-
-if RUBY_VERSION >= '1.9.0'
-
-
-require 'test/unit/ui/yaml/testrunner'
-require 'session/server'
-require 'session/administrable'
-require 'session/client'
-
-
-module Session
-
-  module Test
-
-    class AdministrableTest < ::Test::Unit::TestCase
-
-      class ServerAdministrable < Server
-        include Administrable
-
-      end # class ServerAdministrable
-
-      def setup
-        unless @srv_pid = fork # son
-          $stderr = File.open('/dev/null')
-          @opts = Server::OPTS
-          @opts[:usrdb] = Server::USRDB
-          @opts[:max_usr] = 2
-          @opts[:wipeout_delay] = 2
-          @srv = ServerAdministrable.new(@opts)
-          DRb.start_service("druby://localhost:42000", @srv)
-          DRb.thread.join
-        end
-      end
-
-      def teardown
-        Process.kill('TERM', @srv_pid)
-        Process.waitpid(@srv_pid)
-      end
-
-      #
-      # Tests
-      #
-      def test_normal_login_logout
-        assert_nothing_raised do
-          clt = Client.new
-          clt.logout
-        end
-      end
-
-      def test_admin_can_connect_even_if_server_full
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed')
-        assert(! clt1.online?, 'clt 1 not online')
-        assert_equal('data', clt1.request(:ping, 'data'))
-        assert(clt1.online?, 'clt 1 online')
-        clt2 = nil
-        assert_nothing_raised { clt2 = Client.new }
-        assert_not_nil(clt2, 'login 2 failed')
-        assert(! clt2.online?, 'clt 2 not online')
-        assert_equal('data', clt2.request(:ping, 'data'))
-        assert(clt2.online?, 'clt 2 online')
-        clt3 = nil
-        assert_raises(Session::FullError) do
-          clt3 = Client.new
-          assert_not_nil(clt3, 'login 3 failed')
-          assert(! clt3.online?, 'clt 3 not online')
-          assert_equal('data', clt3.request(:ping, 'data'))
-          assert(clt3.online?, 'clt 3 online')
-        end
-        clt_admin = nil
-        assert_nothing_raised do
-          clt_admin = Client.new('druby://localhost:42000',
-                                 'admin',
-                                 'admin'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt_admin, 'login admin failed')
-        assert_equal(3, clt_admin.request(:sessions).size)
-        assert_equal(2, clt_admin.request(:get_max_usr))
-        assert_nothing_raised { clt_admin.logout }
-        assert_nothing_raised { clt1.logout }
-        assert_nothing_raised { clt3 = Client.new }
-        assert_not_nil(clt3, 'login 3 failed')
-        assert_nothing_raised { clt2.logout }
-        assert_nothing_raised { clt3.logout }
-      end
-
-      def test_request_set_get_max_usr
-        clt = nil
-        assert_nothing_raised do
-          clt = Client.new('druby://localhost:42000',
-                           'root',
-                           'root'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt, 'login failed')
-        assert_nothing_raised do
-          assert_equal(2, clt.request(:get_max_usr), 'bad max_usr')
-          assert_equal(3, clt.request(:set_max_usr, 3))
-          assert_equal(3, clt.request(:get_max_usr), 'bad max_usr')
-          clt.request(:set_max_usr, 2)
-          assert_equal(2, clt.request(:get_max_usr), 'bad max_usr')
-        end
-        assert_raises(Session::ParameterError, 'set O') do
-          clt.request(:set_max_usr, 0)
-        end
-        assert_raises(Session::ParameterError, 'set -42') do
-          clt.request(:set_max_usr, -42)
-        end
-        assert_raises(Session::ParameterError, 'set 4') do
-          clt.request(:set_max_usr, '4')
-        end
-        assert_nothing_raised do
-          assert_equal(2, clt.request(:set_max_usr, '2'.to_i), 'bad max_usr')
-        end
-        assert_nothing_raised do
-          assert_equal(2, clt.request(:get_max_usr), 'bad max_usr')
-        end
-        assert_nothing_raised { clt.logout }
-      end
-
-      def test_request_set_get_wipeout_delay
-        clt = nil
-        assert_nothing_raised do
-          clt = Client.new('druby://localhost:42000',
-                           'root',
-                           'root'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt, 'login failed')
-        assert_nothing_raised do
-          assert_equal(2, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
-          assert_equal(3, clt.request(:set_wipeout_delay, 3))
-          assert_equal(3, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
-          clt.request(:set_wipeout_delay, 2)
-          assert_equal(2, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
-        end
-        assert_raises(Session::ParameterError, 'set 1') do
-          clt.request(:set_wipeout_delay, 1)
-        end
-        assert_raises(Session::ParameterError, 'set -42') do
-          clt.request(:set_wipeout_delay, -42)
-        end
-        assert_raises(Session::ParameterError, 'set 4') do
-          clt.request(:set_wipeout_delay, '4')
-        end
-        assert_nothing_raised do
-          assert_equal(2,
-                       clt.request(:set_wipeout_delay, '2'.to_i),
-                       'bad wipeout_delay')
-        end
-        assert_nothing_raised do
-          assert_equal(2, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
-        end
-        assert_nothing_raised { clt.logout }
-      end
-
-      def test_request_sessions
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed')
-        assert(! clt1.online?, 'clt 1 not online')
-        assert_equal('data', clt1.ping('data'))
-        assert(clt1.online?, 'clt 1 online')
-        clt2 = nil
-        assert_nothing_raised do
-          clt2 = Client.new('druby://localhost:42000',
-                            'root',
-                            'root'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt2, 'login 2 failed')
-        ses = clt2.request(:sessions)
-        assert_equal(2, ses.size, 'bad sessions number')
-        assert(ses.has_key?(clt1.sid), 'bad clt1 sid')
-        assert(ses.has_key?(clt2.sid), 'bad clt2 sid')
-        ses.each do |sid, prof|
-          prof[:usrname] = 'toto'
-        end
-        assert_equal(2, clt2.request(:sessions).size, 'bad sessions number')
-        clt2.request(:sessions).each do |sid, prof|
-          assert_equal('toto', ses[sid][:usrname])
-          assert_not_equal('toto', prof[:usrname])
-        end
-        assert_nothing_raised { clt1.logout }
-        assert_nothing_raised { clt2.logout }
-      end
-
-      def test_request_kick
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed')
-        assert(! clt1.online?, 'clt 1 not online')
-        assert_equal('data', clt1.ping('data'))
-        assert(clt1.online?, 'clt 1 online')
-        clt2 = nil
-        assert_nothing_raised do
-          clt2 = Client.new('druby://localhost:42000',
-                            'root',
-                            'root'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt2, 'login 2 failed')
-        ses = clt2.request(:sessions)
-        assert_equal(2, ses.size, 'bad sessions number')
-        assert(ses.has_key?(clt1.sid), 'bad clt1 sid')
-        assert(ses.has_key?(clt2.sid), 'bad clt2 sid')
-        assert_raises(Session::SessionError) do
-          clt2.request(:kick, 'toto')
-        end
-        assert_raises(Session::PermissionError) do
-          clt2.request(:kick, clt2.sid)
-        end
-        assert_nothing_raised { clt2.request(:kick, clt1.sid) }
-        assert(! clt1.online?)
-        assert_nil(clt1.sid)
-        assert_nothing_raised { assert(clt2.logout) }
-      end
-
-      def test_usr_management
-        clt2 = nil
-        assert_nothing_raised do
-          clt2 = Client.new('druby://localhost:42000',
-                            'root',
-                            'root'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt2, 'login 2 failed')
-        assert_equal(ServerAdministrable::USRDB, clt2.request(:get_usrdb))
-        assert_raises(Session::ParameterError) do
-          clt2.request(:get_usr_desc, '')
-        end
-        assert_raises(Session::UserError) do
-          clt2.request(:add_usr, 'guest', clt2.request(:get_usr_desc, 'guest'))
-        end
-        assert_raises(Session::UserError) do
-          clt2.request(:add_usr, 'root', clt2.request(:get_usr_desc, 'root'))
-        end
-        assert_raises(Session::ParameterError) do
-          clt2.request(:add_usr, 'toto)', {})
-        end
-        assert_raises(Session::ParameterError) do
-          clt2.request(:add_usr, '', {})
-        end
-        usrdesc = {
-          :allowed_requests => [ :profile, :add_hook ],
-          :allowed_hooks => [],
-          :admin => false,
-          :passwd => 'toto'.crypt(Const::SALT_KEY)
-        }
-        assert_equal(usrdesc, clt2.request(:add_usr, 'toto', usrdesc))
-        assert_equal(ServerAdministrable::USRDB.merge('toto'=>usrdesc),
-                     clt2.request(:get_usrdb))
-        assert_raises(Session::UserError) do
-          clt2.request(:del_usr, 'foo')
-        end
-        assert_raises(Session::UserError) do
-          clt2.request(:del_usr, 'root')
-        end
-        assert_raises(Session::UserError) do
-          clt2.request(:del_usr, 'admin')
-        end
-        prof = Profile.new('toto', usrdesc, DRb.uri, nil)
-        clt1 = nil
-        assert_nothing_raised do
-          clt1 = Client.new('druby://localhost:42000',
-                            'toto',
-                            'toto'.crypt(Const::SALT_KEY), true)
-        end
-        assert_not_nil(clt1, 'login 1 failed')
-        prof[:uri] = clt1.local_uri
-        prof[:protocol], prof[:hostname], prof[:port] = Profile.parse_uri(clt1.local_uri)
-        prof[:hooks] = [ clt1 ]
-        comp_profile(prof, clt1.profile, :dispatcher)
-        assert_raises(Session::PermissionError) { clt1.help }
-        new_usrdesc = {
-          :allowed_requests => [ :profile, :help, :add_hook ],
-          :allowed_hooks => [],
-          :admin => false,
-          :passwd => 'toto'.crypt(Const::SALT_KEY)
-        }
-        assert_equal(new_usrdesc,
-                     clt2.request(:set_usr_desc, 'toto', new_usrdesc))
-        assert_raises(Session::PermissionError) { clt1.help }
-        assert_nothing_raised { clt1.logout }
-        clt1 = nil
-        assert_nothing_raised do
-          clt1 = Client.new('druby://localhost:42000',
-                            'toto',
-                            'toto'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt1, 'login 1 new failed')
-        assert_nothing_raised('help is allowed now') { clt1.help }
-        assert_nothing_raised { clt1.logout }
-        assert_equal(new_usrdesc,
-                     clt2.request(:del_usr, 'toto'),
-                     'bad usrdesc returned')
-        assert_equal(ServerAdministrable::USRDB, clt2.request(:get_usrdb))
-        assert_nothing_raised { clt2.logout }
-      end
-
-      #
-      # Utilities
-      #
-      protected
-      def comp_profile(ref_prof, prof, *ignore)
-        ref_prof.each do |k, v|
-          next if ignore.include?(k)
-          if k == :login_time or k == :last_request_time
-            assert(ref_prof[k] <= prof[k], "bad time for #{k}")
-          else
-            assert_equal(ref_prof[k], prof[k], "bad value for #{k}")
-          end
-        end
-      end
-
-    end # class AdministrableTest
-
-  end # module Test
-
-end # module Session
-
-
-else
-  STDERR.puts('need ruby1.9')
-end
-
-
-end

data/ruby_ex/session/test/basic_test.rb

@@ -1,523 +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: basic_test.rb 67 2004-12-07 01:00:10Z polrop $
-
-
-#
-# Client/Server basic test suite
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-if RUBY_VERSION >= '1.9.0'
-
-
-require 'test/unit/ui/yaml/testrunner'
-require 'session/server'
-require 'session/client'
-
-
-module Session
-
-  module Test
-
-    class BasicTest < ::Test::Unit::TestCase
-
-      USRDB = Server::USRDB.merge('no_rights' => {
-                                    :passwd => 'no_rights'.crypt(Const::SALT_KEY),
-                                    :allowed_requests => [],
-                                    :admin => false},
-                                  'tester' => {
-                                    :passwd => 'tester'.crypt(Const::SALT_KEY),
-                                    :allowed_requests => [ :testme ],
-                                    :admin => false})
-
-      class MyServer < Server
-
-        protected
-        def request_testme(sid, profile, test_obj)
-          ret = test_obj.run
-          return test_obj, ret
-        end
-
-      end
-
-      def setup
-        unless @srv_pid = fork # son
-          $stderr = File.open('/dev/null')
-          @opts = MyServer::OPTS
-          @opts[:usrdb] = USRDB
-          @opts[:max_usr] = 2
-          @opts[:wipeout_delay] = 2
-          @srv = MyServer.new(@opts)
-          DRb.start_service('druby://localhost:42000', @srv)
-          DRb.thread.join
-          exit(0)
-        end
-      end
-
-      def teardown
-        Process.kill('TERM', @srv_pid)
-        Process.waitpid(@srv_pid)
-      end
-
-      #
-      # Tests
-      #
-      def test_single_login_logout
-        assert_nothing_raised do
-          clt = Client.new
-          assert(! clt.online?, 'clt online 1')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt online 2')
-          assert('data', clt.request(:ping, 'data'))
-          assert(clt.online?, 'clt online 3')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt online 4')
-        end
-      end
-
-      def test_single_force_login_logout
-        assert_raises(ArgumentError) do
-          clt = Client.new(Client::URI,
-                           Client::USRNAME,
-                           Client::PASSWD,
-                           nil)
-        end
-        assert_nothing_raised do
-          clt = Client.new(Client::URI,
-                           Client::USRNAME,
-                           Client::PASSWD,
-                           true)
-          assert(clt.online?, 'clt online 1')
-          assert('data', clt.request(:ping, 'data'))
-          assert(clt.online?, 'clt online 3')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt online 2')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt online 2')
-        end
-      end
-
-      def test_several_login_logout
-        assert_nothing_raised do
-          clt = Client.new(Client::URI,
-                           Client::USRNAME,
-                           Client::PASSWD,
-                           true)
-          assert(clt.online?, 'clt online? 1')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt not online? 1')
-          assert(clt.login)
-          assert(clt.online?, 'clt online? 2')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt not online? 2')
-          assert(clt.login)
-          assert(clt.online?, 'clt online? 3')
-          assert(clt.logout)
-          assert(! clt.online?, 'clt not online? 3')
-        end
-      end
-
-      class Hook
-        include Session::Hookable
-
-        def initialize
-          @online = nil
-        end
-
-        def online?
-          @online
-        end
-
-        protected
-        def hook_logout(sid, profile)
-          @online = false
-        end
-
-        protected
-        def hook_login(sid, profile)
-          @online = true
-        end
-
-      end
-
-      def test_hook
-        hook = Hook.new
-        assert_nil(hook.online?)
-        clt = nil
-        assert_raises(ArgumentError) do
-          clt = Client.new(Client::URI,
-                           Client::USRNAME,
-                           Client::PASSWD,
-                           true,
-                           nil)
-        end
-        assert_nothing_raised do
-          clt = Client.new(Client::URI,
-                           Client::USRNAME,
-                           Client::PASSWD,
-                           true,
-                           hook)
-          assert(clt.online?, 'clt online? 1')
-        end
-        assert_not_nil(clt, 'login failed')
-        assert_equal(true, hook.online?, 'bad hook online?')
-        assert_nothing_raised { assert(clt.logout) }
-      end
-
-      def test_bad_usr_name
-        clt = nil
-        assert_raises(Session::AuthError) do
-          clt = Client.new('druby://localhost:42000',
-                           'nobody',
-                           'prout'.crypt(Const::SALT_KEY),
-                           true)
-        end
-      end
-
-      def test_bad_passwd
-        assert_raises(Session::AuthError) do
-          clt = Client.new('druby://localhost:42000',
-                           'guest',
-                           'prout'.crypt(Const::SALT_KEY),
-                           true)
-        end
-      end
-
-      def test_permission_denied
-        clt = nil
-        assert_nothing_raised do
-          clt = Client.new
-        end
-        assert_not_nil(clt, 'login failed')
-        assert_raises(Session::PermissionError) do
-          clt.request(:get_usr_profile, 'toto')
-        end
-        assert_nothing_raised { assert(clt.logout) }
-      end
-
-      def test_bad_request
-        clt = nil
-        assert_nothing_raised { clt = Client.new }
-        assert_not_nil(clt, 'login failed')
-        assert_raises(Session::RequestError) do
-          clt.request(:foo)
-        end
-        assert_nothing_raised { assert(clt.logout) }
-      end
-
-      def test_no_opened_session
-        drb_srv = DRb.start_service
-        drb_obj = DRbObject.new(nil, 'druby://localhost:42000')
-        assert_raises(Session::ParameterError) do
-          drb_obj.request('mais_ou���_mon_sid', :logout)
-        end
-        assert_raises(Session::SessionError) do
-          drb_obj.request('0123456789abcdef', :foo)
-        end
-        drb_srv.stop_service
-      end
-
-      def test_cannot_call_server_protected_method
-        drb_srv = DRb.start_service
-        drb_obj = DRbObject.new(nil, 'druby://localhost:42000')
-        assert_raises(NameError) do
-          drb_obj.request_profile('sid')
-        end
-        drb_srv.stop_service
-      end
-
-      def test_max_users
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed')
-        assert(! clt1.online?, 'clt 1 not online')
-        assert_equal('data', clt1.request(:ping, 'data'))
-        assert(clt1.online?, 'clt 1 online')
-        clt2 = nil
-        assert_nothing_raised { clt2 = Client.new }
-        assert_not_nil(clt2, 'login 2 failed')
-        assert(! clt2.online?, 'clt 2 not online')
-        assert_equal('data', clt2.request(:ping, 'data'))
-        assert(clt2.online?, 'clt 2 online')
-        clt3 = nil
-        assert_raises(Session::FullError) do
-          clt3 = Client.new
-          assert_not_nil(clt3, 'login 3 failed')
-          assert(! clt3.online?, 'clt 3 not online')
-          assert_equal('data', clt3.request(:ping, 'data'))
-          assert(false, 'not reached')
-        end
-        assert_not_nil(clt3, 'login 3 failed')
-        assert_nothing_raised { assert(clt1.logout, 'clt1 logout') }
-        assert(! clt1.online?, 'clt 1 not online 2')
-        assert_nothing_raised { clt3.login }
-        assert(clt3.online?, 'clt 3 online')
-        assert_nothing_raised { assert(clt2.logout, 'clt2 logout') }
-        assert(! clt2.online?, 'clt 2 not online 2')
-        assert_nothing_raised { assert(clt3.logout, 'clt3 logout') }
-        assert(! clt3.online?, 'clt 3 not online')
-      end
-
-      def test_wipeout
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed')
-        assert(! clt1.online?, 'clt 1 not online')
-        assert_equal('data', clt1.request(:ping, 'data'))
-        assert(clt1.online?, 'clt 1 online')
-        clt2 = nil
-        assert_nothing_raised { clt2 = Client.new }
-        assert_not_nil(clt2, 'login 2 failed')
-        assert(! clt2.online?, 'clt 2 not online')
-        assert_equal('data', clt2.request(:ping, 'data'))
-        assert(clt2.online?, 'clt 2 online')
-        clt3 = nil
-        assert_raises(Session::FullError) do
-          clt3 = Client.new
-          assert_not_nil(clt3, 'login 3 failed')
-          assert(! clt3.online?, 'clt 3 not online')
-          assert_equal('data', clt3.request(:ping, 'data'))
-          assert(false, 'not reached')
-        end
-        while clt1.online? and clt2.online?
-          sleep(4)
-        end
-        assert(clt1.logout, 'clt1 already logout')
-        assert(clt2.logout, 'clt2 already logout')
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed 2')
-        assert(! clt1.online?, 'clt 1 not online')
-        assert_equal('data', clt1.request(:ping, 'data'))
-        assert(clt1.online?, 'clt 1 online')
-        clt2 = nil
-        assert_nothing_raised { clt2 = Client.new }
-        assert_not_nil(clt2, 'login 2 failed 2')
-        assert(! clt2.online?, 'clt 2 not online')
-        assert_equal('data', clt2.request(:ping, 'data'))
-        assert(clt2.online?, 'clt 2 online')
-        clt3 = nil
-        assert_raises(Session::FullError) do
-          clt3 = Client.new
-          assert_not_nil(clt3, 'login 3 failed')
-          assert(! clt3.online?, 'clt 3 not online')
-          assert_equal('data', clt3.request(:ping, 'data'))
-          assert(false, 'not reached')
-        end
-        assert_nothing_raised { assert(clt1.logout) }
-        assert_nothing_raised { assert(clt2.logout) }
-      end
-
-      def test_request_profile
-        usrname = 'guest'
-        passwd = 'guest'.crypt(Const::SALT_KEY)
-        usr = Server::USRDB
-        usr = {
-          usrname => {
-            :passwd => passwd,
-            :allowed_requests => [
-              :profile, :help, :nb_requests, :ping
-            ],
-            :admin => false
-          }
-        }
-        prof = Profile.new(usrname, usr[usrname], DRb.uri, nil)
-        clt = nil
-        assert_nothing_raised do
-          clt = Client.new('druby://localhost:42000', usrname, passwd, true)
-        end
-        assert_not_nil(clt, 'login failed')
-        prof[:uri] = clt.local_uri
-        prof[:protocol], prof[:hostname], prof[:port] = Profile.parse_uri(clt.local_uri)
-        prof[:hooks] = [clt]
-        comp_profile(prof, clt.profile, :dispatcher)
-        assert(clt.profile[:login_time] < clt.profile[:last_request_time])
-        assert_nothing_raised { assert(clt.logout) }
-      end
-
-      def test_request_help
-        clt = nil
-        assert_nothing_raised { clt = Client.new }
-        assert_not_nil(clt, 'login 1 failed')
-        ref_res = {
-          "ping"=>"no description available",
-          "help"=>"[requests...] return all or several request descriptions",
-          "detach"=>"no description available",
-          "logout_at"=>"no description available",
-          "add_hook"=>"no description available",
-          "login_at"=>"no description available",
-          "profile"=>"return the session profile",
-          "stop"=>"no description available",
-          "logout"=>"disconnect from the server",
-          "testme"=>"no description available",
-          "rsend"=>"no description available",
-          "del_hook"=>"no description available",
-          "request_at"=>"no description available",
-          "stop_all_sub_server"=>"no description available",
-          "nb_requests"=>"no description available",
-          "chdir"=>"no description available",
-          "start_sub_server"=>"no description available",
-          "stop_sub_server"=>"no description available",
-          "total_nb_requests"=>"no description available",
-          "get_usr_profile"=>"no description available",
-          "pid"=>"no description available"
-        }
-        assert_equal(ref_res, clt.help)
-        assert_equal({'profile' => ref_res['profile']}, clt.help('profile'))
-        assert_equal({
-                       'profile' => ref_res['profile'],
-                       'help' => ref_res['help']
-                     },
-                     clt.help('profile', :help, 'sessions'))
-        assert_equal({}, clt.help('toto'))
-        assert_equal({'help' => ref_res['help']}, clt.help(:help))
-        assert_nothing_raised { assert(clt.logout) }
-      end
-
-      def test_request_get_usr_profile
-        clt1 = nil
-        assert_nothing_raised { clt1 = Client.new }
-        assert_not_nil(clt1, 'login 1 failed')
-        clt2 = nil
-        assert_nothing_raised do
-          clt2 = Client.new('druby://localhost:42000',
-                            'root',
-                            'root'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt2, 'login 2 failed')
-        assert_nothing_raised do
-          comp_profile(clt1.profile,
-                       clt2.request(:get_usr_profile, 'guest'),
-                       :hooks)
-        end
-        assert_raises(Session::UserError) do
-          clt2.request(:get_usr_profile, 'toto')
-        end
-        assert_nothing_raised do
-          comp_profile(clt2.profile,
-                       clt2.request(:get_usr_profile, clt2.profile[:usrname]))
-        end
-        assert_nothing_raised { assert(clt1.logout) }
-        assert_nothing_raised { assert(clt2.logout) }
-      end
-
-      def test_nb_request
-        nb_clt = 2
-        clt = []
-        for i in 0...nb_clt do
-          assert_nothing_raised { clt[i] = Client.new }
-          assert_not_nil(clt[i], "login #{i} failed")
-        end
-        threads = []
-        for i in 0...nb_clt do
-          threads << Thread.new do
-            c = i
-            for j in 0...nb_clt do
-              clt[c].request(:nb_requests)
-            end
-          end
-        end
-        threads.each { |t| t.join }
-        for i in 0...nb_clt do
-          assert_equal(1,
-                       clt[i].request(:nb_requests),
-                       "#{i}: bad request number")
-        end
-        for i in 0...nb_clt do
-          assert_nothing_raised { assert(clt[i].logout) }
-        end
-      end
-
-      class TestObj
-
-        def run
-          DRb.uri
-        end
-
-      end
-
-      def test_object_is_runned_remotely
-        clt = nil
-        assert_nothing_raised do
-          clt = Client.new('druby://localhost:42000',
-                           'tester',
-                           'tester'.crypt(Const::SALT_KEY))
-        end
-        assert_not_nil(clt, "login failed")
-        foo = TestObj.new
-        assert_not_equal('druby://localhost:42000', clt.local_uri)
-        robj, foo_uri = clt.request(:testme, foo)
-        assert_equal('druby://localhost:42000', foo_uri)
-        comp_obj(foo, robj)
-        assert_nothing_raised { clt.logout }
-      end
-
-      def test_rsend
-        begin
-          clt = nil
-          assert_nothing_raised do
-            clt = Client.new('druby://localhost:42000',
-                             'root',
-                             'root'.crypt(Const::SALT_KEY),
-                             true)
-          end
-          assert_not_nil(clt, "login failed")
-          io = clt.request(:rsend, File, :open, '/tmp/x', 'w')
-          assert(io.is_a?(DRb::DRbObject), 'io is a DRbObject')
-          assert_equal(5,
-                       clt.request(:rsend, io, :write, "test\n"),
-                       'test write')
-          assert_nothing_raised { clt.request(:rsend, io, :close) }
-          assert(File.exist?('/tmp/x'), 'file exist')
-          assert_nothing_raised { clt.logout }
-        ensure
-          File.delete('/tmp/x') if File.exist?('/tmp/x')
-        end
-      end
-
-      #
-      # Utilities
-      #
-      protected
-      def comp_profile(ref_prof, prof, *ignore)
-        ref_prof.each do |k, v|
-          next if ignore.include?(k)
-          if k == :login_time or k == :last_request_time
-            assert(ref_prof[k] <= prof[k], "bad time for #{k}")
-          else
-            assert_equal(ref_prof[k], prof[k], "bad value for #{k}")
-          end
-        end
-      end
-
-      protected
-      def comp_obj(ref, val)
-        assert_equal(ref.class, val.class, 'bad class')
-        assert_not_equal(ref.object_id, val.object_id)
-        assert_not_equal(ref, val)
-        ref.instance_variables.each do |v|
-          assert_equal(val.instance_variable_get(v),
-                       ref.instance_variable_get(v),
-                       "bad attributes #{v}")
-        end
-        val.instance_variables.each do |v|
-          assert(ref.instance_variables.include?(v), 'addionnal attributes')
-        end
-      end
-
-    end # class BasicTest
-
-  end # module Test
-
-end # module Session
-
-else
-  STDERR.puts('need ruby1.9')
-end
-
-
-end