rims 0.2.5 → 0.3.0

data/lib/rims/version.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 module RIMS
-  VERSION = '0.2.5'
+  VERSION = '0.3.0'
   MAILBOX_DATA_STRUCTURE_VERSION = 'mailbox.2'
 end
 

data/load_test/Rakefile

@@ -78,6 +78,8 @@ task :imap_append do
   end
 end
 
+CLOBBER.include('imap_append')
+
 desc 'run server'
 task :run_server do
   run_server_conf('imap_server', USER_CONF, *%w[ -v debug -l debug --imap-host=localhost --imap-port=14300 ]) do
@@ -85,7 +87,7 @@ task :run_server do
   end
 end
 
-CLOBBER.include('imap_append')
+CLOBBER.include('imap_server')
 
 # Local Variables:
 # mode: Ruby

data/rims.gemspec

@@ -5,10 +5,10 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rims/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rims"
+  spec.name          = 'rims'
   spec.version       = RIMS::VERSION
-  spec.authors       = ["TOKI Yoshinori"]
-  spec.email         = ["toki@freedom.ne.jp"]
+  spec.authors       = ['TOKI Yoshinori']
+  spec.email         = ['toki@freedom.ne.jp']
   spec.summary       = %q{RIMS is Ruby IMap Server}
   spec.description   = <<-'EOF'
     RIMS is Ruby IMap Server.
@@ -16,22 +16,24 @@ Gem::Specification.new do |spec|
     server can run as a daemon, mailboxes are provided and messages
     can be delivered to them.
   EOF
-  spec.homepage      = "https://github.com/y10k/rims"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/y10k/rims'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 2.0.0'
 
-  spec.add_runtime_dependency "riser", '>= 0.1.8'
-  spec.add_runtime_dependency "logger-joint"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "test-unit"
-  spec.add_development_dependency "rdoc"
+  spec.add_runtime_dependency 'rims-rfc822', '>= 0.2.2'
+  spec.add_runtime_dependency 'riser', '>= 0.2.0'
+  spec.add_runtime_dependency 'logger-joint'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency 'rdoc'
+  spec.add_development_dependency 'irb'
 end
 
 # Local Variables:

data/test/cmd/test_command.rb

@@ -119,6 +119,7 @@ module RIMS::Test
       '--no-daemonize'                   => [ %W[ -f #{BASE_DIR}/config.yml --no-daemonize ] ],
       '--daemon-debug'                   => [ %W[ -f #{BASE_DIR}/config.yml --daemon-debug ] ],
       '--no-daemon-debug'                => [ %W[ -f #{BASE_DIR}/config.yml --no-daemon-debug ] ],
+      '--daemon-umask'                   => [ %W[ -f #{BASE_DIR}/config.yml --daemon-umask=0022 ] ],
       '--status-file'                    => [ %W[ -f #{BASE_DIR}/config.yml --status-file=status.yml ] ],
       '--privilege-user'                 => [ %W[ -f #{BASE_DIR}/config.yml --privilege-user=#{Process::UID.eid} ] ],
       '--privilege-group'                => [ %W[ -f #{BASE_DIR}/config.yml --privilege-group=#{Process::GID.eid} ] ],
@@ -140,11 +141,30 @@ module RIMS::Test
       '--read-polling-interval'          => [ %W[ -f #{BASE_DIR}/config.yml --read-polling-interval=5 ] ],
       '--command-wait-timeout'           => [ %W[ -f #{BASE_DIR}/config.yml --command-wait-timeout=3600 ] ],
 
+      # protocol:
+      '--line-length-limit'              => [ %W[ -f #{BASE_DIR}/config.yml --line-length-limit=16384 ] ],
+      '--literal-size-limit'             => [ %W[ -f #{BASE_DIR}/config.yml --literal-size-limit=16777216 ] ],
+      '--command-size-limit'             => [ %W[ -f #{BASE_DIR}/config.yml --command-size-limit=16777216 ] ],
+
+      # charset aliases:
+      '--use-default-charset-aliases'    => [ %W[ -f #{BASE_DIR}/config.yml --use-default-charset-aliases ] ],
+      '--no-use-default-charset-aliases' => [ %W[ -f #{BASE_DIR}/config.yml --no-use-default-charset-aliases ] ],
+      '--add-charset-alias'              => [ %W[ -f #{BASE_DIR}/config.yml --no-use-default-charset-aliases --add-charset-alias=iso-2022-jp,CP50221 ] ],
+
+      # charset convert_options:
+      '--replace-charset-invalid'        => [ %W[ -f #{BASE_DIR}/config.yml --replace-charset-invalid ] ],
+      '--no-replace-charset-invalid'     => [ %W[ -f #{BASE_DIR}/config.yml --no-replace-charset-invalid ] ],
+      '--replace-charset-undef'          => [ %W[ -f #{BASE_DIR}/config.yml --replace-charset-undef ] ],
+      '--no-replace-charset-undef'       => [ %W[ -f #{BASE_DIR}/config.yml --no-replace-charset-undef ] ],
+      '--charset-replaced-mark'          => [ %W[ -f #{BASE_DIR}/config.yml --charset-replaced-mark=? ] ],
+
       # drb_services:
       '--drb-process-num'                => [ %W[ -f #{BASE_DIR}/config.yml --drb-process-num=4 ] ],
+      '--drb-load-limit'                 => [ %W[ -f #{BASE_DIR}/config.yml --drb-load-limit=134217728 ] ],
 
       # drb_services engine:
       '--bulk-response-count'            => [ %W[ -f #{BASE_DIR}/config.yml --bulk-response-count=128 ] ],
+      '--bulk-response-size'             => [ %W[ -f #{BASE_DIR}/config.yml --bulk-response-size=33554432 ] ],
       '--read-lock-timeout'              => [ %W[ -f #{BASE_DIR}/config.yml --read-lock-timeout=10 ] ],
       '--write-lock-timeout'             => [ %W[ -f #{BASE_DIR}/config.yml --write-lock-timeout=10 ] ],
       '--clenup-write-lock-timeout'      => [ %W[ -f #{BASE_DIR}/config.yml --write-lock-timeout=5 ] ],
@@ -334,6 +354,35 @@ module RIMS::Test
       assert_equal(0, status.exitstatus)
     end
 
+    data('default'            => [ false, %w[] ],
+         '-r'                 => [ false, %w[ -r prime ] ],
+         '--required-feature' => [ false, %w[ --required-feature=prime ] ],
+         '--format=yaml'      => [ false, %w[ --format=yaml ] ],
+         '--format=json'      => [ false, %w[ --format=json ] ],
+
+         # deplicated options
+         'deplicated:--load-library' => [ true, %w[ --load-library=prime ] ])
+    def test_environment(data)
+      deplicated, options = data
+
+      stdout, stderr, status = Open3.capture3('rims', 'environment', *options)
+      pp [ stdout, stderr, status ] if $DEBUG
+
+      assert_equal(0, status.exitstatus)
+      if (deplicated) then
+        assert_match(/^warning:/, stderr)
+      else
+        assert_equal('', stderr)
+      end
+
+      assert_match(/RIMS Environment/, stdout)
+      assert_match(/RUBY VERSION.*#{Regexp.quote(RUBY_DESCRIPTION)}/, stdout)
+      assert_match(/RIMS VERSION.*#{Regexp.quote(RIMS::VERSION)}/, stdout)
+      assert_match(/AUTHENTICATION PLUG-IN.*plain/m, stdout)
+      assert_match(/AUTHENTICATION PLUG-IN.*hash/m, stdout)
+      assert_match(/KEY-VALUE STORE PLUG-IN.*gdbm/m, stdout)
+    end
+
     tls_dir = Pathname(__FILE__).parent.parent / "tls"
     TLS_CA_CERT     = tls_dir / 'ca.cert'
     TLS_SERVER_CERT = tls_dir / 'server_localhost.cert'
@@ -1203,7 +1252,7 @@ Hello world.
           assert_equal(seqno[1],       imap_search.call([ 'ANSWERED' ]))                                              # *a
           assert_equal(seqno[3],       imap_search.call([ 'BCC', 'foo' ]))                                            # *b
           assert_equal(seqno[1],       imap_search.call([ 'BEFORE', @mpart_mail.date ]))
-          assert_equal(seqno[1, 3],    imap_search.call([ 'BODY', 'Hello world.' ]))
+          assert_equal(seqno[1, 2, 3], imap_search.call([ 'BODY', 'Hello world.' ]))
           assert_equal(seqno[3],       imap_search.call([ 'CC', 'kate' ]))
           assert_equal(seqno[],        imap_search.call([ 'DELETED' ]))
           assert_equal(seqno[2],       imap_search.call([ 'DRAFT' ]))
@@ -1277,49 +1326,112 @@ Hello world.
           envelope = lambda{|mail|
             Net::IMAP::Envelope.new(mail.header['Date'],
                                     mail.header['Subject'],
-                                    mail.from     ? mail.from.map{|addr| Net::IMAP::Address.new(*addr) }     : nil,
-                                    mail.reply_to ? mail.reply_to.map{|addr| Net::IMAP::Address.new(*addr) } : nil,
-                                    mail.sender   ? mail.sender.map{|addr| Net::IMAP::Address.new(*addr) }   : nil,
-                                    mail.to       ? mail.to.map{|addr| Net::IMAP::Address.new(*addr) }       : nil,
-                                    mail.cc       ? mail.cc.map{|addr| Net::IMAP::Address.new(*addr) }       : nil,
-                                    mail.bcc      ? mail.bcc.map{|addr| Net::IMAP::Address.new(*addr) }      : nil,
+                                    mail.from     ? mail.from.map{|addr| Net::IMAP::Address.new(*addr.to_a) }     : nil,
+                                    mail.reply_to ? mail.reply_to.map{|addr| Net::IMAP::Address.new(*addr.to_a) } : nil,
+                                    mail.sender   ? mail.sender.map{|addr| Net::IMAP::Address.new(*addr.to_a) }   : nil,
+                                    mail.to       ? mail.to.map{|addr| Net::IMAP::Address.new(*addr.to_a) }       : nil,
+                                    mail.cc       ? mail.cc.map{|addr| Net::IMAP::Address.new(*addr.to_a) }       : nil,
+                                    mail.bcc      ? mail.bcc.map{|addr| Net::IMAP::Address.new(*addr.to_a) }      : nil,
                                     mail.header['In-Reply-To'],
                                     mail.header['Message-Id'])
           }
-          body_type = lambda{|mail|
-            case (mail.media_main_type_upcase)
-            when 'TEXT'
+          body_type = lambda{|mail, extension=false|
+            body_params = lambda{|params|
+              if (params && ! params.empty?) then
+                Hash[params.map{|n, v| [ n.upcase, v ] }]
+              end
+            }
+            body_disposition = lambda{|mail|
+              if (mail.content_disposition) then
+                Net::IMAP::ContentDisposition.new(mail.content_disposition_upcase,
+                                                  body_params[mail.content_disposition_parameter_list])
+              end
+            }
+            body_language = lambda{|mail|
+              if (mail.content_language) then
+                if (mail.content_language.length > 1) then
+                  mail.content_language_upcase
+                else
+                  mail.content_language_upcase[0]
+                end
+              end
+            }
+            if (mail.text?) then
               Net::IMAP::BodyTypeText.new(mail.media_main_type_upcase,
                                           mail.media_sub_type_upcase,
-                                          Hash[mail.content_type_parameters.map{|n, v| [ n.upcase, v ] }],
+                                          body_params[mail.content_type_parameter_list],
                                           mail.header['Content-Id'],
                                           mail.header['Content-Description'],
                                           mail.header.fetch_upcase('Content-Transfer-Encoding'),
                                           mail.raw_source.bytesize,
-                                          mail.raw_source.each_line.count)
-            when 'MESSAGE'
+                                          mail.raw_source.each_line.count,
+                                          *(
+                                            if (extension) then
+                                              [ mail.header['Content-MD5'],
+                                                body_disposition[mail],
+                                                body_language[mail],
+                                                [ mail.header['Content-Location'] ]
+                                              ]
+                                            else
+                                              []
+                                            end
+                                          ))
+            elsif (mail.message?) then
               Net::IMAP::BodyTypeMessage.new(mail.media_main_type_upcase,
                                              mail.media_sub_type_upcase,
-                                             Hash[mail.content_type_parameters.map{|n, v| [ n.upcase, v ] }],
+                                             body_params[mail.content_type_parameter_list],
                                              mail.header['Content-Id'],
                                              mail.header['Content-Description'],
                                              mail.header.fetch_upcase('Content-Transfer-Encoding'),
                                              mail.raw_source.bytesize,
                                              envelope[mail.message],
-                                             body_type[mail.message],
-                                             mail.raw_source.each_line.count)
-            when 'MULTIPART'
+                                             body_type[mail.message, extension],
+                                             mail.raw_source.each_line.count,
+                                             *(
+                                               if (extension) then
+                                                 [ mail.header['Content-MD5'],
+                                                   body_disposition[mail],
+                                                   body_language[mail],
+                                                   [ mail.header['Content-Location'] ]
+                                                 ]
+                                               else
+                                                 []
+                                               end
+                                             ))
+            elsif (mail.multipart?) then
               Net::IMAP::BodyTypeMultipart.new(mail.media_main_type_upcase,
                                                mail.media_sub_type_upcase,
-                                               mail.parts.map{|m| body_type[m] })
+                                               mail.parts.map{|m| body_type[m, extension] },
+                                               *(
+                                                 if (extension) then
+                                                   [ body_params[mail.content_type_parameter_list],
+                                                     body_disposition[mail],
+                                                     body_language[mail],
+                                                     [ mail.header['Content-Location'] ]
+                                                   ]
+                                                 else
+                                                   []
+                                                 end
+                                               ))
             else
               Net::IMAP::BodyTypeBasic.new(mail.media_main_type_upcase,
                                            mail.media_sub_type_upcase,
-                                           Hash[mail.content_type_parameters.map{|n, v| [ n.upcase, v ] }],
+                                           body_params[mail.content_type_parameter_list],
                                            mail.header['Content-Id'],
                                            mail.header['Content-Description'],
                                            mail.header.fetch_upcase('Content-Transfer-Encoding'),
-                                           mail.raw_source.bytesize)
+                                           mail.raw_source.bytesize,
+                                           *(
+                                             if (extension) then
+                                               [ mail.header['Content-MD5'],
+                                                 body_disposition[mail],
+                                                 body_language[mail],
+                                                 [ mail.header['Content-Location'] ]
+                                               ]
+                                             else
+                                               []
+                                             end
+                                           ))
             end
           }
 
@@ -1406,9 +1518,9 @@ Hello world.
                        imap_fetch.call(msg_set[1..-1], 'BODY'))
 
           assert_equal(fetch_data[
-                         [ 1, { 'BODYSTRUCTURE' => body_type[@simple_mail] } ],
-                         [ 2, { 'BODYSTRUCTURE' => body_type[@mpart_mail] } ],
-                         [ 3, { 'BODYSTRUCTURE' => body_type[@mime_subject_mail] } ]
+                         [ 1, { 'BODYSTRUCTURE' => body_type[@simple_mail, true] } ],
+                         [ 2, { 'BODYSTRUCTURE' => body_type[@mpart_mail, true] } ],
+                         [ 3, { 'BODYSTRUCTURE' => body_type[@mime_subject_mail, true] } ]
                        ],
                        imap_fetch.call(msg_set[1..-1], 'BODYSTRUCTURE'))
 

data/test/test_channel.rb

@@ -55,7 +55,8 @@ module RIMS::Test
       pub1.publish('msg1')
       pub2.publish('msg2')
 
-      error = assert_raise(RuntimeError) { pub3.publish('msg3') }
+      error = assert_raise(RIMS::ServerResponseChannelPublishError) { pub3.publish('msg3') }
+      pp error, error.optional_data if $DEBUG
       assert_match(/detached/, error.message)
 
       assert_equal(%w[ msg2 ], sub1.enum_for(:fetch).to_a)

data/test/test_error.rb

@@ -4,7 +4,19 @@ require 'rims'
 require 'test/unit'
 
 module RIMS::Test
-  class TestError < Test::Unit::TestCase
+  class ErrorTest < Test::Unit::TestCase
+    def test_optional_data
+      error = RIMS::Error.new('test', foo: 1, bar: '2')
+      assert_equal('test', error.message)
+      assert_equal({ foo: 1, bar: '2' }, error.optional_data)
+    end
+
+    def test_no_optional_data
+      error = RIMS::Error.new('test')
+      assert_equal('test', error.message)
+      assert_predicate(error.optional_data, :empty?)
+    end
+
     def test_trace_error_chain
       exception = assert_raise(RuntimeError) {
         begin
@@ -32,6 +44,26 @@ module RIMS::Test
                      'error level 0'
                    ], errors.map(&:message))
     end
+
+    def test_optional_data_block
+      count = 0
+      error = RIMS::Error.new('test', foo: 1, bar: '2')
+      RIMS::Error.optional_data(error) do |e, data|
+        count += 1
+        assert_equal(error, e)
+        assert_equal({ foo: 1, bar: '2' }, data)
+      end
+      assert_equal(1, count)
+    end
+
+    data('not a RIMS::Error' => StandardError.new('test'),
+         'no optional data'  => RIMS::Error.new('test'))
+    def test_no_optional_data_block(data)
+      error = data
+      RIMS::Error.optional_data(error) do |e, data|
+        flunk
+      end
+    end
   end
 end
 

data/test/test_lock.rb

@@ -51,7 +51,7 @@ module RIMS::Test
       assert_equal('write-lock wait timeout', error.message)
     end
 
-    def calculate_threa_work_seconds
+    def calculate_thread_work_seconds
       t0 = Time.now
       1000.times{|i| i.succ }
       t1 = Time.now
@@ -60,10 +60,10 @@ module RIMS::Test
 
       wait_seconds
     end
-    private :calculate_threa_work_seconds
+    private :calculate_thread_work_seconds
 
     def test_read_write_lock_multithread
-      lock_wait_seconds = calculate_threa_work_seconds
+      lock_wait_seconds = calculate_thread_work_seconds
 
       count = 0
       read_thread_num = 10
@@ -116,7 +116,7 @@ module RIMS::Test
     def test_write_lock_timeout_detach
       logger = Logger.new(STDOUT)
       logger.level = ($DEBUG) ? Logger::DEBUG : Logger::FATAL
-      wait_seconds = calculate_threa_work_seconds
+      wait_seconds = calculate_thread_work_seconds
 
       t_list = []
       assert_nil(RIMS::ReadWriteLock.write_lock_timeout_detach(wait_seconds, wait_seconds * 2, logger: logger ) {|timeout_seconds|

data/test/test_passwd.rb

@@ -61,7 +61,7 @@ module RIMS::Test
     end
   end
 
-  class PasswordHashSourceEntry < Test::Unit::TestCase
+  class PasswordHashSourceEntryTest < Test::Unit::TestCase
     def setup
       @digest_factory = Digest::SHA256
       @hash_type = 'SHA256'

data/test/test_protocol_decoder.rb

@@ -127,6 +127,7 @@ module RIMS::Test
         cmd_name, cmd_args, cmd_client_output = parse_imap_command(tag, imap_command_message)
         normalized_cmd_name = RIMS::Protocol::Decoder.imap_command_normalize(cmd_name)
         cmd_id = RIMS::Protocol::Decoder::IMAP_CMDs[normalized_cmd_name] or flunk("not a imap command: #{cmd_name}")
+        cmd_kw_args = {}
 
         input = nil
         output = nil
@@ -135,8 +136,10 @@ module RIMS::Test
           output = StringIO.new('', 'w')
           input_gets = input.method(:gets)
           output_write = lambda{|res|
-            for line in res
-              output << line
+            for data in res
+              if (data != :flush) then
+                output << data
+              end
             end
           }
           inout_args = [ input_gets, output_write ]
@@ -144,30 +147,29 @@ module RIMS::Test
           cmd_args = inout_args + cmd_args
         end
         unless (uid.nil?) then
-          cmd_args += [ { uid: uid } ]
+          cmd_kw_args[:uid] = uid
         end
 
         block_call = 0
         ret_val = nil
 
+        response_message = cmd_client_output.b
         pp [ :debug_imap_command, imap_command_message, cmd_id, cmd_args ] if $DEBUG
-        @decoder.__send__(cmd_id, tag, *cmd_args) {|responses|
+        @decoder.__send__(cmd_id, tag, *cmd_args, **cmd_kw_args) {|response|
           block_call += 1
-          response_message = cmd_client_output.b
-          if (output) then
+          if (block_call == 1 && output) then
             response_message << output.string
           end
-          for response in responses
+          if (response != :flush) then
             response_message << response
           end
-          response_lines = StringIO.new(response_message, 'r').each_line
-          ret_val = yield(response_lines)
-          assert_raise(StopIteration) { response_lines.next }
         }
+        response_lines = StringIO.new(response_message, 'r').each_line
+        ret_val = yield(response_lines)
+        assert_raise(StopIteration) { response_lines.next }
         if (client_input_text) then
           pp input.string, output.string if $DEBUG
         end
-        assert_equal(1, block_call, 'IMAP command block should be called only once.')
 
         @decoder = @decoder.next_decoder
 
@@ -242,7 +244,7 @@ module RIMS::Test
     extend Forwardable
 
     def open_mail_store
-      @services.call_service(:engine, @unique_user_id) {|engine|
+      @drb_services.call_service(:engine, @unique_user_id) {|engine|
         begin
           @mail_store = engine.mail_store
           @mail_store.write_synchronize{
@@ -255,8 +257,15 @@ module RIMS::Test
     end
     private :open_mail_store
 
+    LINE_LENGTH_LIMIT  = 128
+    LITERAL_SIZE_LIMIT = 1024**2
+    COMMAND_SIZE_LIMIT = LITERAL_SIZE_LIMIT + LINE_LENGTH_LIMIT
+
     def make_decoder
-      RIMS::Protocol::Decoder.new_decoder(@services, @auth, @logger)
+      RIMS::Protocol::Decoder.new_decoder(@drb_services, @auth, @logger,
+                                          line_length_limit: LINE_LENGTH_LIMIT,
+                                          literal_size_limit: LITERAL_SIZE_LIMIT,
+                                          command_size_limit: COMMAND_SIZE_LIMIT)
     end
     private :make_decoder
 
@@ -288,20 +297,26 @@ module RIMS::Test
       }
       @unique_user_id = RIMS::Authentication.unique_user_id('foo')
 
-      @services = Riser::DRbServices.new(0)
-      @services.add_sticky_process_service(:engine,
-                                           Riser::ResourceSet.build{|builder|
-                                             builder.at_create{|unique_user_id|
-                                               mail_store = RIMS::MailStore.build(unique_user_id, @kvs_open, @kvs_open)
-                                               RIMS::Protocol::Decoder::Engine.new(unique_user_id, mail_store, @logger)
-                                             }
-                                             builder.at_destroy{|engine|
-                                               engine.destroy
-                                             }
-                                             builder.alias_unref(:destroy)
-                                           })
-      @services.start_server
-      @services.start_client
+      @bulk_response_count = 10
+      @charset_aliases = RIMS::RFC822::CharsetAliases.new
+      @charset_convert_options = {}
+      @drb_services = Riser::DRbServices.new(0)
+      @drb_services.add_sticky_process_service(:engine,
+                                               Riser::ResourceSet.build{|builder|
+                                                 builder.at_create{|unique_user_id|
+                                                   mail_store = RIMS::MailStore.build(unique_user_id, @kvs_open, @kvs_open)
+                                                   RIMS::Protocol::Decoder::Engine.new(unique_user_id, mail_store, @logger,
+                                                                                       bulk_response_count: @bulk_response_count,
+                                                                                       charset_aliases: @charset_aliases,
+                                                                                       charset_convert_options: @charset_convert_options)
+                                                 }
+                                                 builder.at_destroy{|engine|
+                                                   engine.destroy
+                                                 }
+                                                 builder.alias_unref(:destroy)
+                                               })
+      @drb_services.start_server
+      @drb_services.start_client
 
       open_mail_store{
         @inbox_id = @mail_store.mbox_id('INBOX')
@@ -328,8 +343,8 @@ module RIMS::Test
     end
 
     def teardown
-      assert_equal(0, @services.get_service(:engine, @unique_user_id).proxy_count)
-      @services.stop_server
+      assert_equal(0, @drb_services.get_service(:engine, @unique_user_id).proxy_count)
+      @drb_services.stop_server
       pp @kvs if $DEBUG
     end
 
@@ -372,6 +387,17 @@ module RIMS::Test
     end
     private :assert_imap_command
 
+    def assert_imap_closed
+      if (stream_test?) then
+        assert_raise(Errno::EPIPE, StopIteration) {
+          assert_imap_command('NOOP') {|assert|
+            assert.equal("#{tag} OK NOOP completed")
+          }
+        }
+      end
+    end
+    private :assert_imap_closed
+
     def client_plain_response_base64(authentication_id, plain_password)
       response_txt = [ authentication_id, authentication_id, plain_password ].join("\0")
       RIMS::Protocol.encode_base64(response_txt)
@@ -554,6 +580,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -599,6 +627,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -650,6 +680,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -705,6 +737,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -747,6 +781,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -828,6 +864,8 @@ module RIMS::Test
           assert_equal(false, @decoder.selected?)
         end
 
+        assert_imap_closed
+
         open_mail_store{
           assert_msg_uid(                      2, 3)
           assert_flag_enabled_msgs('answered',     )
@@ -878,6 +916,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -959,6 +999,8 @@ module RIMS::Test
           assert_equal(false, @decoder.selected?)
         end
 
+        assert_imap_closed
+
         open_mail_store{
           assert_msg_uid(                      1, 2, 3)
           assert_flag_enabled_msgs('answered',        )
@@ -1009,6 +1051,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1058,6 +1102,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1094,6 +1140,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1166,6 +1214,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1206,6 +1256,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1285,6 +1337,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1332,6 +1386,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1401,6 +1457,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1511,6 +1569,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1549,6 +1609,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1655,6 +1717,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1686,6 +1750,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1753,6 +1819,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1873,6 +1941,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1912,6 +1982,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1920,6 +1992,69 @@ module RIMS::Test
       test_append_utf7_mbox_name
     end
 
+    def test_append_literal_stream
+      make_mail_simple
+      make_mail_multipart
+      make_mail_mime_subject
+
+      use_imap_stream_decode_engine # always run in stream
+      imap_decode_engine_evaluate{
+        if (stream_test?) then
+          assert_untagged_response{|assert|
+            assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+          }
+        end
+
+        assert_imap_command('LOGIN foo open_sesame') {|assert|
+          assert.equal("#{tag} OK LOGIN completed")
+        }
+
+        open_mail_store{
+          assert_msg_uid()
+        }
+
+        assert_imap_command("APPEND INBOX #{literal(@simple_mail.raw_source)}") {|assert|
+          assert.match(/^\+ /)
+          assert.match(/^#{tag} OK \[APPENDUID \d+ \d+\] APPEND completed/)
+        }
+
+        open_mail_store{
+          assert_msg_uid(1)
+          assert_equal(@simple_mail.raw_source, get_msg_text(1))
+          assert_msg_flags(1, recent: true)
+        }
+
+        assert_imap_command("APPEND INBOX #{literal(@mpart_mail.raw_source)}") {|assert|
+          assert.match(/^\+ /)
+          assert.match(/^#{tag} OK \[APPENDUID \d+ \d+\] APPEND completed/)
+        }
+
+        open_mail_store{
+          assert_msg_uid(1, 2)
+          assert_equal(@mpart_mail.raw_source, get_msg_text(2))
+          assert_msg_flags(2, recent: true)
+        }
+
+        assert_imap_command("APPEND INBOX #{literal(@mime_subject_mail.raw_source)}") {|assert|
+          assert.match(/^\+ /)
+          assert.match(/^#{tag} OK \[APPENDUID \d+ \d+\] APPEND completed/)
+        }
+
+        open_mail_store{
+          assert_msg_uid(1, 2, 3)
+          assert_equal(@mime_subject_mail.raw_source, get_msg_text(3))
+          assert_msg_flags(3, recent: true)
+        }
+
+        assert_imap_command('LOGOUT') {|assert|
+          assert.match(/^\* BYE /)
+          assert.equal("#{tag} OK LOGOUT completed")
+        }
+
+        assert_imap_closed
+      }
+    end
+
     def test_check
       imap_decode_engine_evaluate{
         if (stream_test?) then
@@ -1956,7 +2091,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -1973,6 +2108,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2084,6 +2221,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -2188,6 +2327,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -2338,6 +2479,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2414,6 +2557,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2439,11 +2584,6 @@ module RIMS::Test
           assert.match(/^#{tag} NO /, peek_next_line: true).match(/not auth/)
         }
 
-        if (command_test?) then
-          assert_equal(false, @decoder.auth?)
-          assert_equal(false, @decoder.selected?)
-        end
-
         assert_imap_command('LOGIN foo open_sesame') {|assert|
           assert.equal("#{tag} OK LOGIN completed")
         }
@@ -2548,6 +2688,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2591,15 +2733,10 @@ module RIMS::Test
           assert_equal(false, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH CHARSET utf-8 ALL') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii ALL') {|assert|
           assert.match(/^#{tag} NO /, peek_next_line: true).match(/not auth/)
         }
 
-        if (command_test?) then
-          assert_equal(false, @decoder.auth?)
-          assert_equal(false, @decoder.selected?)
-        end
-
         assert_imap_command('LOGIN foo open_sesame') {|assert|
           assert.equal("#{tag} OK LOGIN completed")
         }
@@ -2609,7 +2746,7 @@ module RIMS::Test
           assert_equal(false, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH CHARSET utf-8 ALL') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii ALL') {|assert|
           assert.match(/^#{tag} NO /, peek_next_line: true).match(/not selected/)
         }
 
@@ -2623,28 +2760,37 @@ module RIMS::Test
           assert_equal(true, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH CHARSET utf-8 ALL') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii ALL') {|assert|
           assert.equal("* SEARCH 1 2 3 4 5\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
-        assert_imap_command('SEARCH CHARSET utf-8 BODY foo') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii BODY foo') {|assert|
           assert.equal("* SEARCH 1 2 3\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
-        assert_imap_command('SEARCH CHARSET utf-8 BODY bar') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii BODY bar') {|assert|
           assert.equal("* SEARCH\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
         utf8_msg = "\u306F\u306B\u307B"
-        assert_imap_command("SEARCH CHARSET utf-8 BODY {#{utf8_msg.bytesize}}\r\n#{utf8_msg}".b) {|assert|
+        assert_imap_command("SEARCH CHARSET utf-8 BODY #{literal(utf8_msg)}".b) {|assert|
           assert.match(/^\+ /)
           assert.equal("* SEARCH 4 5\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
+        assert_imap_command("SEARCH CHARSET euc-jp BODY #{literal(utf8_msg)}".b) {|assert|
+          assert.match(/^\+ /)
+          assert.match(/^#{tag} BAD /, peek_next_line: true).match(/syntax error/)
+        }
+
+        assert_imap_command('SEARCH CHARSET x-nothing BODY foo') {|assert|
+          assert.match(/^#{tag} NO \[BADCHARSET \(\S+( \S+)*\)\] unknown charset/)
+        }
+
         assert_imap_command('SEARCH CHARSET') {|assert|
           assert.match(/^#{tag} BAD /, peek_next_line: true).match(/syntax error/)
         }
@@ -2661,6 +2807,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2679,6 +2827,7 @@ module RIMS::Test
 
         open_mail_store{
           add_msg("Content-Type: text/plain\r\n" +
+                  "\r\n" +
                   "foo")
           add_msg("Content-Type: text/plain; charset=utf-8\r\n" +
                   "X-foo: dummy\r\n" +
@@ -2705,15 +2854,10 @@ module RIMS::Test
           assert_equal(false, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH CHARSET utf-8 ALL') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii ALL') {|assert|
           assert.match(/^#{tag} NO /, peek_next_line: true).match(/not auth/)
         }
 
-        if (command_test?) then
-          assert_equal(false, @decoder.auth?)
-          assert_equal(false, @decoder.selected?)
-        end
-
         assert_imap_command('LOGIN foo open_sesame') {|assert|
           assert.equal("#{tag} OK LOGIN completed")
         }
@@ -2723,7 +2867,7 @@ module RIMS::Test
           assert_equal(false, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH CHARSET utf-8 ALL') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii ALL') {|assert|
           assert.match(/^#{tag} NO /, peek_next_line: true).match(/not selected/)
         }
 
@@ -2737,12 +2881,12 @@ module RIMS::Test
           assert_equal(true, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH CHARSET utf-8 ALL') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii ALL') {|assert|
           assert.equal("* SEARCH 1 2 3 4 5\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
-        assert_imap_command('SEARCH CHARSET utf-8 TEXT foo') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii TEXT foo') {|assert|
           assert.equal("* SEARCH 1 2 3\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
@@ -2752,18 +2896,27 @@ module RIMS::Test
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
-        assert_imap_command('SEARCH CHARSET utf-8 TEXT baz') {|assert|
+        assert_imap_command('SEARCH CHARSET us-ascii TEXT baz') {|assert|
           assert.equal("* SEARCH\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
         utf8_msg = "\u306F\u306B\u307B"
-        assert_imap_command("SEARCH CHARSET utf-8 TEXT {#{utf8_msg.bytesize}}\r\n#{utf8_msg}".b) {|assert|
+        assert_imap_command("SEARCH CHARSET utf-8 TEXT #{literal(utf8_msg)}".b) {|assert|
           assert.match(/^\+ /)
           assert.equal("* SEARCH 4 5\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
         }
 
+        assert_imap_command("SEARCH CHARSET euc-jp TEXT #{literal(utf8_msg)}".b) {|assert|
+          assert.match(/^\+ /)
+          assert.match(/^#{tag} BAD /, peek_next_line: true).match(/syntax error/)
+        }
+
+        assert_imap_command('SEARCH CHARSET x-nothing TEXT foo') {|assert|
+          assert.match(/^#{tag} NO \[BADCHARSET \(\S+( \S+)*\)\] unknown charset/)
+        }
+
         assert_imap_command('SEARCH CHARSET') {|assert|
           assert.match(/^#{tag} BAD /, peek_next_line: true).match(/syntax error/)
         }
@@ -2780,6 +2933,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2788,6 +2943,146 @@ module RIMS::Test
       test_search_charset_text
     end
 
+    def test_search_charset_skip_encoding_error
+      imap_decode_engine_evaluate{
+        if (stream_test?) then
+          assert_untagged_response{|assert|
+            assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+          }
+        end
+
+        open_mail_store{
+          add_msg("Content-Type: text/plain\r\n" +
+                  "\r\n" +
+                  "foo")
+          add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                  "\r\n" +
+                  # utf-8
+                  "\u3053\u3093\u306B\u3061\u306F\r\n" +
+                  "\u3044\u308D\u306F\u306B\u307B\u3078\u3068\r\n" +
+                  "\u3042\u3044\u3046\u3048\u304A\r\n" +
+                  "foo\r\n")
+
+          assert_msg_uid(1, 2)
+        }
+
+        if (command_test?) then
+          assert_equal(false, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('LOGIN foo open_sesame') {|assert|
+          assert.equal("#{tag} OK LOGIN completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('SELECT INBOX') {|assert|
+          assert.skip_while{|line| line =~ /^\* / }
+          assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(true, @decoder.selected?)
+        end
+
+        assert_imap_command('SEARCH CHARSET us-ascii BODY foo') {|assert|
+          assert.equal("* SEARCH 1\r\n")
+          assert.equal("#{tag} OK SEARCH completed\r\n")
+        }
+
+        utf8_msg = "\u306F\u306B\u307B"
+        assert_imap_command("SEARCH CHARSET utf-8 TEXT #{literal(utf8_msg)}".b) {|assert|
+          assert.match(/^\+ /)
+          assert.equal("* SEARCH\r\n")
+          assert.equal("#{tag} OK SEARCH completed\r\n")
+        }
+
+        assert_imap_command('LOGOUT') {|assert|
+          assert.match(/^\* BYE /)
+          assert.equal("#{tag} OK LOGOUT completed")
+        }
+
+        assert_imap_closed
+      }
+    end
+
+    def test_search_charset_skip_encoding_error_stream
+      use_imap_stream_decode_engine
+      test_search_charset_skip_encoding_error
+    end
+
+    # skip this test because `EncodingError' is ignored.
+    def _test_search_interrupt_by_bad_response
+      imap_decode_engine_evaluate{
+        if (stream_test?) then
+          assert_untagged_response{|assert|
+            assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+          }
+        end
+
+        open_mail_store{
+          @bulk_response_count.times do
+            add_msg("Content-Type: text/plain\r\n" +
+                    "\r\n" +
+                    "foo")
+          end
+
+          add_msg("Content-Type: text/plain; charset=x-nothing\r\n" +
+                  "\r\n" +
+                  "foo")
+
+          assert_msg_uid(*(1..(@bulk_response_count.succ)).to_a)
+        }
+
+        if (command_test?) then
+          assert_equal(false, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('LOGIN foo open_sesame') {|assert|
+          assert.equal("#{tag} OK LOGIN completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('SELECT INBOX') {|assert|
+          assert.skip_while{|line| line =~ /^\* / }
+          assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(true, @decoder.selected?)
+        end
+
+        assert_imap_command('SEARCH CHARSET utf-8 TEXT foo') {|assert|
+          assert.match(/\A\* SEARCH( \d+)+\r\n\z/, peek_next_line: true).no_match(/ #{@bulk_response_count.succ}/)
+          assert.equal("#{tag} BAD internal server error\r\n")
+        }
+
+        assert_imap_command('LOGOUT') {|assert|
+          assert.match(/^\* BYE /)
+          assert.equal("#{tag} OK LOGOUT completed")
+        }
+
+        assert_imap_closed
+      }
+    end
+
+    # skip this test because `EncodingError' is ignored.
+    def _test_search_interrupt_by_bad_response_stream
+      use_imap_stream_decode_engine
+      test_search_interrupt_by_bad_response
+    end
+
     def test_fetch
       imap_decode_engine_evaluate{
         if (stream_test?) then
@@ -2932,6 +3227,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -3084,6 +3381,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -3436,6 +3735,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -3738,6 +4039,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4090,6 +4393,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4392,6 +4697,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4561,6 +4868,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4765,6 +5074,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4969,6 +5280,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -5022,6 +5335,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -5065,7 +5380,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5092,7 +5407,7 @@ module RIMS::Test
         }
 
         assert_imap_command('EXAMINE INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-ONLY] EXAMINE completed")
         }
 
@@ -5114,6 +5429,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -5153,7 +5470,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5199,7 +5516,7 @@ module RIMS::Test
         }
 
         assert_imap_command('EXAMINE INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-ONLY] EXAMINE completed")
         }
 
@@ -5222,6 +5539,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -5231,11 +5550,11 @@ module RIMS::Test
     end
 
     def test_error_handling_stream
-      use_imap_stream_decode_engine
+      use_imap_stream_decode_engine # always run in stream
       imap_decode_engine_evaluate{
         assert_imap_command('') {|assert|
           assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
-          assert.equal('* BAD client command syntax error')
+          assert.equal("#{tag} BAD client command syntax error")
         }
 
         assert_imap_command('no_command') {|assert|
@@ -5253,6 +5572,30 @@ module RIMS::Test
         assert_imap_command('noop detarame') {|assert|
           assert.equal("#{tag} BAD invalid command parameter")
         }
+
+        assert_imap_command("APPEND INBOX {#{LITERAL_SIZE_LIMIT + 1}}") {|assert|
+          assert.equal("#{tag} BAD literal size too large")
+        }
+
+        assert_imap_command("APPEND #{literal('x' * LITERAL_SIZE_LIMIT)} #{'y' * (LINE_LENGTH_LIMIT - 3)}") {|assert|
+          assert.match(/^\+ /)
+          assert.equal("#{tag} BAD command size too large") # by last line
+        }
+
+        assert_imap_command("APPEND #{literal('x' * LITERAL_SIZE_LIMIT)} {#{LITERAL_SIZE_LIMIT}}") {|assert|
+          assert.match(/^\+ /)
+          assert.equal("#{tag} BAD command size too large") # by last literal
+        }
+
+        @tag = '*T000'
+        assert_imap_command('noop') {|assert|
+          assert.equal('* BAD client command syntax error')
+        }
+
+        @tag = '+T000'
+        assert_imap_command('noop') {|assert|
+          assert.equal('* BAD client command syntax error')
+        }
       }
     end
 
@@ -5284,6 +5627,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -5440,6 +5785,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -5498,6 +5845,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -5580,7 +5929,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5604,7 +5953,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5628,7 +5977,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5656,7 +6005,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5689,10 +6038,8 @@ module RIMS::Test
         }
 
         another_decoder = make_decoder
-        another_writer = proc{|res|
-          for line in res
-            p line if $DEBUG
-          end
+        another_writer = proc{|response|
+          p response if $DEBUG
         }
 
         another_decoder.login('tag', 'foo', 'open_sesame', &another_writer)
@@ -5967,10 +6314,8 @@ module RIMS::Test
         }
 
         another_decoder = make_decoder
-        another_writer = proc{|res|
-          for line in res
-            p line if $DEBUG
-          end
+        another_writer = proc{|response|
+          p response if $DEBUG
         }
 
         another_decoder.login('tag', 'foo', 'open_sesame', &another_writer)
@@ -6031,6 +6376,232 @@ module RIMS::Test
       use_imap_stream_decode_engine
       test_idle_untagged_server_response
     end
+
+    def test_charset_aliases
+      imap_decode_engine_evaluate{
+        if (stream_test?) then
+          assert_untagged_response{|assert|
+            assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+          }
+        end
+
+        platform_dependent_character = "\u2460"
+        open_mail_store{
+          add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                  "\r\n" +
+                  "#{platform_dependent_character.encode(Encoding::CP50221).b}")
+        }
+
+        if (command_test?) then
+          assert_equal(false, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('LOGIN foo open_sesame') {|assert|
+          assert.equal("#{tag} OK LOGIN completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('SELECT INBOX') {|assert|
+          assert.skip_while{|line| line =~ /^\* / }
+          assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(true, @decoder.selected?)
+        end
+
+        assert_imap_command("SEARCH CHARSET utf-8 TEXT #{literal(platform_dependent_character)}") {|assert|
+          assert.match(/^\+ /)
+          assert.equal("* SEARCH\r\n") # skip by `EncodingError'
+          assert.equal("#{tag} OK SEARCH completed\r\n")
+        }
+
+        # not recommend changing charset aliases after passing them to the decoder.
+        # here, the charset aliases are reluctantly changed for testing.
+        @charset_aliases.add_alias('iso-2022-jp', Encoding::CP50221)
+
+        assert_imap_command("SEARCH CHARSET utf-8 TEXT #{literal(platform_dependent_character)}") {|assert|
+          assert.match(/^\+ /)
+          assert.equal("* SEARCH 1\r\n") # matched!
+          assert.equal("#{tag} OK SEARCH completed\r\n")
+        }
+
+        assert_imap_command('CLOSE') {|assert|
+          assert.equal("#{tag} OK CLOSE completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('LOGOUT') {|assert|
+          assert.match(/^\* BYE /)
+          assert.equal("#{tag} OK LOGOUT completed")
+        }
+
+        if (command_test?) then
+          assert_equal(false, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_closed
+      }
+    end
+
+    def test_charset_aliases_stream
+      use_imap_stream_decode_engine
+      test_charset_aliases
+    end
+
+    def test_charset_convert_options
+      imap_decode_engine_evaluate{
+        if (stream_test?) then
+          assert_untagged_response{|assert|
+            assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+          }
+        end
+
+        platform_dependent_character = "\u2460"
+        open_mail_store{
+          add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                  "\r\n" +
+                  "#{platform_dependent_character.encode(Encoding::CP50221).b}")
+        }
+
+        if (command_test?) then
+          assert_equal(false, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('LOGIN foo open_sesame') {|assert|
+          assert.equal("#{tag} OK LOGIN completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('SELECT INBOX') {|assert|
+          assert.skip_while{|line| line =~ /^\* / }
+          assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(true, @decoder.selected?)
+        end
+
+        assert_imap_command(%Q'SEARCH CHARSET utf-8 TEXT #{literal("\uFFFD")}') {|assert|
+          assert.match(/^\+ /)
+          assert.equal("* SEARCH\r\n") # skip by `EncodingError'
+          assert.equal("#{tag} OK SEARCH completed\r\n")
+        }
+
+        # not recommend changing charset convert options after passing them to the decoder.
+        # here, the options are reluctantly changed for testing.
+        @charset_convert_options[:undef] = :replace
+
+        assert_imap_command("SEARCH CHARSET utf-8 TEXT #{literal("\uFFFD")}") {|assert|
+          assert.match(/^\+ /)
+          assert.equal("* SEARCH 1\r\n") # matched!
+          assert.equal("#{tag} OK SEARCH completed\r\n")
+        }
+
+        assert_imap_command('CLOSE') {|assert|
+          assert.equal("#{tag} OK CLOSE completed")
+        }
+
+        if (command_test?) then
+          assert_equal(true, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_command('LOGOUT') {|assert|
+          assert.match(/^\* BYE /)
+          assert.equal("#{tag} OK LOGOUT completed")
+        }
+
+        if (command_test?) then
+          assert_equal(false, @decoder.auth?)
+          assert_equal(false, @decoder.selected?)
+        end
+
+        assert_imap_closed
+      }
+    end
+
+    def test_charset_convert_options_stream
+      use_imap_stream_decode_engine
+      test_charset_convert_options
+    end
+
+    def test_command_line_too_long_error_stream
+      use_imap_stream_decode_engine # always run in stream
+      imap_decode_engine_evaluate{
+        assert_untagged_response{|assert|
+          assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+        }
+
+        assert_imap_command('APPEND INBOX ' + 'x' * LINE_LENGTH_LIMIT) {|assert|
+          assert.equal('* BAD line too long')
+          assert.equal('* BYE server autologout: connection terminated')
+        }
+
+        assert_imap_closed
+      }
+    end
+
+    def test_authenticate_line_too_long_error_stream
+      use_imap_stream_decode_engine # always run in stream
+      imap_decode_engine_evaluate{
+        assert_untagged_response{|assert|
+          assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+        }
+
+        assert_imap_command('AUTHENTICATE plain',
+                            client_input_text: 'x' * LINE_LENGTH_LIMIT + "\r\n") {|assert|
+          assert.equal('+ ')
+          assert.equal('* BAD line too long')
+          assert.equal('* BYE server autologout: connection terminated')
+        }
+
+        assert_imap_closed
+      }
+    end
+
+    def test_idle_line_too_long_error_stream
+      use_imap_stream_decode_engine # always run in stream
+      imap_decode_engine_evaluate{
+        assert_untagged_response{|assert|
+          assert.equal("* OK RIMS v#{RIMS::VERSION} IMAP4rev1 service ready.")
+        }
+
+        assert_imap_command('LOGIN foo open_sesame') {|assert|
+          assert.equal("#{tag} OK LOGIN completed")
+        }
+
+        assert_imap_command('SELECT INBOX') {|assert|
+          assert.skip_while{|line| line =~ /^\* / }
+          assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
+        }
+
+        assert_imap_command('IDLE', client_input_text: 'DONE' + ' ' * LINE_LENGTH_LIMIT +  "\r\n") {|assert|
+          assert.match(/^\+ /)
+          assert.equal('* BAD line too long')
+          assert.equal('* BYE server autologout: connection terminated')
+        }
+
+        assert_imap_closed
+      }
+    end
   end
 
   class ProtocolMailDeliveryDecoderTest < Test::Unit::TestCase
@@ -6053,6 +6624,93 @@ module RIMS::Test
       assert_equal(%w[ foo INBOX ], RIMS::Protocol::Decoder.decode_delivery_target_mailbox(encoded_mbox_name))
     end
   end
+
+  class ProtocolDecoderBulkResponseTest < Test::Unit::TestCase
+    def setup
+      limit_count = 10
+      limit_size = 100
+      @res = RIMS::Protocol::Decoder::BulkResponse.new(limit_count, limit_size)
+    end
+
+    data('empty' => [ 0, 0,  [] ],
+         '1'     => [ 1, 3,  %w[ foo ] ],
+         '2'     => [ 2, 6,  %w[ foo bar ] ],
+         '3'     => [ 3, 11, %w[ foo bar baaaz ] ])
+    def test_add(data)
+      expected_count, expected_size, response_list = data
+
+      assert_equal(0, @res.count)
+      assert_equal(0, @res.size)
+
+      for response in response_list
+        @res << response
+      end
+
+      assert_equal(expected_count, @res.count)
+      assert_equal(expected_size, @res.size)
+    end
+
+    def test_emtpy?
+      assert_true(@res.empty?)
+    end
+
+    def test_not_empty?
+      @res << 'foo'
+      assert_false(@res.empty?)
+    end
+
+    data('count: boundary'      => %w[ 1 2 3 4 5 6 7 8 9 0 ],
+         'count: over'          => %w[ 1 2 3 4 5 6 7 8 9 0 a ],
+         'size: boundary'       => [ 'x' * 50, 'y' * 50 ],
+         'size: over'           => [ 'x' * 50, 'y' * 50, 'z' ],
+         'count,size: boundary' => %w[ 1 2 3 4 5 6 7 8 9 0 ].map{|s| s * 10 },
+         'count,size: over'     => %w[ 1 2 3 4 5 6 7 8 9 0 ].map{|s| s * 10 } + %w[ a ])
+    def test_full?(data)
+      response_list = data
+      for response in response_list
+        @res << response
+      end
+      assert_true(@res.full?)
+    end
+
+    data('empty'           => [],
+         'under'           => %w[ foo bar baz ],
+         'count: boundary' => %w[ 1 2 3 4 5 6 7 8 9 ],
+         'size: boundary'  => [ 'x' * 50, 'y' * 49 ])
+    def test_not_full?(data)
+      response_list = data
+      for response in response_list
+        @res << response
+      end
+      assert_false(@res.full?)
+    end
+
+    def test_flush
+      @res << 'foo'
+      @res << 'bar'
+      r1 = @res.flush
+      assert_equal('foo' + 'bar', r1.join(''), 'responses may be joined.')
+      assert_true(@res.empty?)
+      assert_false(@res.full?)
+
+      @res << 'baz'
+      r2 = @res.flush
+      assert_equal('baz', r2.join(''), 'responses may be joined.')
+      assert_true(@res.empty?)
+      assert_false(@res.full?)
+
+      assert_not_equal(r1, r2)
+    end
+
+    def test_flush_joined
+      for c in ('a'..).first(10)
+        @res << c
+      end
+      assert_equal([ ('a'..).first(10).join('') ], @res.flush)
+      assert_true(@res.empty?)
+      assert_false(@res.full?)
+    end
+  end
 end
 
 # Local Variables: