rims 0.2.6 → 0.3.1

data/lib/rims/test.rb

@@ -38,8 +38,7 @@ module RIMS
       module_function :message_data_list
 
       def make_body(description)
-        reader = RIMS::Protocol::RequestReader.new(StringIO.new('', 'r'), StringIO.new('', 'w'), Logger.new(STDOUT))
-        reader.parse(reader.scan_line(description))[0]
+        RIMS::Protocol::RequestReader.parse(RIMS::Protocol::RequestReader.scan(description))[0]
       end
       private :make_body
 
@@ -68,29 +67,30 @@ module RIMS
     end
 
     module ProtocolFetchMailSample
-      def make_mail_simple
-        @simple_mail_body = <<-'EOF'
+      simple_mail_body = <<-'EOF'.freeze
 Hello world.
-        EOF
+      EOF
 
-        md5_digest = Digest::MD5.digest(@simple_mail_body)
-        @simple_mail = RIMS::RFC822::Message.new(<<-"EOF" + @simple_mail_body)
+      MAIL_SIMPLE_TEXT = (<<-"EOF" + simple_mail_body).freeze
 To: foo@nonet.org
 From: bar@nonet.org
 Subject: test
 MIME-Version: 1.0
 Content-Type: text/plain; charset=us-ascii
 Content-Transfer-Encoding: 7bit
-Content-MD5: #{[ md5_digest ].pack('m').strip}
+Content-MD5: #{[ Digest::MD5.digest(simple_mail_body) ].pack('m').strip}
 Content-Language: en-US, en
 Date: Fri,  8 Nov 2013 06:47:50 +0900 (JST)
 
-        EOF
+      EOF
+
+      def make_mail_simple
+        @simple_mail = RIMS::RFC822::Message.new(MAIL_SIMPLE_TEXT)
+        @simple_mail_body = @simple_mail.body.raw_source
       end
       private :make_mail_simple
 
-      def make_mail_multipart
-        @mpart_mail = RIMS::RFC822::Message.new(<<-'EOF')
+      MPART_MAIL_TEXT = <<-'EOF'.freeze
 To: bar@nonet.com
 From: foo@nonet.com
 Subject: multipart test
@@ -173,12 +173,14 @@ Content-Location: baz
 --1383.905529.351300--
 --1383.905529.351299--
 --1383.905529.351297--
-        EOF
+      EOF
+
+      def make_mail_multipart
+        @mpart_mail = RIMS::RFC822::Message.new(MPART_MAIL_TEXT)
       end
       private :make_mail_multipart
 
-      def make_mail_mime_subject
-        @mime_subject_mail = RIMS::RFC822::Message.new(<<-'EOF')
+      MAIL_MIME_SUBJECT_TEXT = <<-'EOF'.freeze
 Date: Fri, 8 Nov 2013 19:31:03 +0900
 Subject: =?ISO-2022-JP?B?GyRCJEYkOSRIGyhC?=
 From: foo@nonet.com, bar <bar@nonet.com>
@@ -194,22 +196,28 @@ In-Reply-To: <20131106081723.5KJU1774292@smtp.test.com>
 Message-Id: <20131107214750.445A1255B9F@smtp.nonet.com>
 
 Hello world.
-        EOF
+      EOF
+
+      def make_mail_mime_subject
+        @mime_subject_mail = RIMS::RFC822::Message.new(MAIL_MIME_SUBJECT_TEXT)
       end
       private :make_mail_mime_subject
 
+      MAIL_EMPTY_TEXT = ''.freeze
+
       def make_mail_empty
-        @empty_mail = RIMS::RFC822::Message.new('')
+        @empty_mail = RIMS::RFC822::Message.new(MAIL_EMPTY_TEXT)
       end
       private :make_mail_empty
 
+      MAIL_NO_BODY_TEXT = "Subject: foo\r\n\r\n".freeze
+
       def make_mail_no_body
-        @no_body_mail = RIMS::RFC822::Message.new("Subject: foo\r\n\r\n")
+        @no_body_mail = RIMS::RFC822::Message.new(MAIL_NO_BODY_TEXT)
       end
       private :make_mail_no_body
 
-      def make_mail_address_header_pattern
-        @address_header_pattern_mail = RIMS::RFC822::Message.new(<<-'EOF')
+      MAIL_ADDRESS_HEADER_PATTERN_TEXT = <<-'EOF'.freeze
 To: "foo@nonet.org" <foo@nonet.org>
 From: bar@nonet.org
 Subject: test
@@ -219,7 +227,10 @@ Content-Transfer-Encoding: 7bit
 Date: Fri,  8 Nov 2013 06:47:50 +0900 (JST)
 
 Hello world.
-EOF
+      EOF
+
+      def make_mail_address_header_pattern
+        @address_header_pattern_mail = RIMS::RFC822::Message.new(MAIL_ADDRESS_HEADER_PATTERN_TEXT)
       end
       private :make_mail_address_header_pattern
     end

data/lib/rims/version.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 module RIMS
-  VERSION = '0.2.6'
+  VERSION = '0.3.1'
   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,23 +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 "rims-rfc822", '>= 0.2.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 ] ],
@@ -1232,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' ]))

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
@@ -146,32 +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
+          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
 
@@ -259,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(@drb_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
 
@@ -293,13 +298,17 @@ module RIMS::Test
       @unique_user_id = RIMS::Authentication.unique_user_id('foo')
 
       @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)
+                                                                                       bulk_response_count: @bulk_response_count,
+                                                                                       charset_aliases: @charset_aliases,
+                                                                                       charset_convert_options: @charset_convert_options)
                                                  }
                                                  builder.at_destroy{|engine|
                                                    engine.destroy
@@ -378,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)
@@ -560,6 +580,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -605,6 +627,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -656,6 +680,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -711,6 +737,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -753,6 +781,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -834,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',     )
@@ -884,6 +916,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -965,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',        )
@@ -1015,6 +1051,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1064,6 +1102,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1100,6 +1140,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1172,6 +1214,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1212,6 +1256,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1291,6 +1337,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1338,6 +1386,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1407,6 +1457,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1517,6 +1569,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1555,6 +1609,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1661,6 +1717,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1692,6 +1750,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1759,6 +1819,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1879,6 +1941,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1918,6 +1982,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -1926,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
@@ -1962,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")
         }
 
@@ -1979,6 +2108,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2090,6 +2221,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -2194,6 +2327,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -2344,6 +2479,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2420,6 +2557,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2549,6 +2688,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2635,13 +2776,13 @@ module RIMS::Test
         }
 
         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 {#{utf8_msg.bytesize}}\r\n#{utf8_msg}".b) {|assert|
+        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/)
         }
@@ -2666,6 +2807,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2759,13 +2902,13 @@ module RIMS::Test
         }
 
         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 {#{utf8_msg.bytesize}}\r\n#{utf8_msg}".b) {|assert|
+        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/)
         }
@@ -2790,6 +2933,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2851,7 +2996,7 @@ module RIMS::Test
         }
 
         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\r\n")
           assert.equal("#{tag} OK SEARCH completed\r\n")
@@ -2861,6 +3006,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -2869,7 +3016,8 @@ module RIMS::Test
       test_search_charset_skip_encoding_error
     end
 
-    def test_search_interrupt_by_bad_response
+    # 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|
@@ -2915,7 +3063,7 @@ module RIMS::Test
           assert_equal(true, @decoder.selected?)
         end
 
-        assert_imap_command('SEARCH TEXT foo') {|assert|
+        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")
         }
@@ -2924,10 +3072,13 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
-    def test_search_interrupt_by_bad_response_stream
+    # 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
@@ -3076,6 +3227,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -3228,6 +3381,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -3580,6 +3735,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -3882,6 +4039,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4234,6 +4393,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4536,6 +4697,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4705,6 +4868,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -4909,6 +5074,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -5113,6 +5280,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -5166,6 +5335,8 @@ module RIMS::Test
           assert.match(/^\* BYE /)
           assert.equal("#{tag} OK LOGOUT completed")
         }
+
+        assert_imap_closed
       }
     end
 
@@ -5209,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")
         }
 
@@ -5236,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")
         }
 
@@ -5258,6 +5429,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -5297,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")
         }
 
@@ -5343,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")
         }
 
@@ -5366,6 +5539,8 @@ module RIMS::Test
           assert_equal(false, @decoder.auth?)
           assert_equal(false, @decoder.selected?)
         end
+
+        assert_imap_closed
       }
     end
 
@@ -5375,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|
@@ -5397,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
 
@@ -5428,6 +5627,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -5584,6 +5785,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -5642,6 +5845,8 @@ module RIMS::Test
         }
 
         assert_equal(false, @decoder.auth?) if command_test?
+
+        assert_imap_closed
       }
     end
 
@@ -5724,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")
         }
 
@@ -5748,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")
         }
 
@@ -5772,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")
         }
 
@@ -5800,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")
         }
 
@@ -5833,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)
@@ -6111,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)
@@ -6175,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
@@ -6197,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: