rims 0.2.1

data/test/test_protocol_request.rb

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*-
+
+require 'logger'
+require 'rims'
+require 'test/unit'
+
+module RIMS::Test
+  class ProtocolRequestReaderTest < Test::Unit::TestCase
+    def setup
+      @input = StringIO.new('', 'r')
+      @output = StringIO.new('', 'w')
+      @logger = Logger.new(STDOUT)
+      @logger.level = ($DEBUG) ? Logger::DEBUG : Logger::FATAL
+      @reader = RIMS::Protocol::RequestReader.new(@input, @output, @logger)
+    end
+
+    def test_scan_line
+      assert_equal([], @reader.scan_line(''))
+      assert_equal(%w[ abcd CAPABILITY ], @reader.scan_line('abcd CAPABILITY'))
+      assert_equal(%w[ abcd OK CAPABILITY completed ], @reader.scan_line('abcd OK CAPABILITY completed'))
+      assert_equal(%w[ * CAPABILITY IMAP4rev1 AUTH=KERBEROS_V4 ], @reader.scan_line('* CAPABILITY IMAP4rev1 AUTH=KERBEROS_V4'))
+      assert_equal(%w[ * 172 EXISTS ], @reader.scan_line('* 172 EXISTS'))
+      assert_equal([ '*', 'OK', '['.intern, 'UNSEEN', '12', ']'.intern, 'Message', '12', 'is', 'first', 'unseen' ],
+                   @reader.scan_line('* OK [UNSEEN 12] Message 12 is first unseen'))
+      assert_equal([ '*', 'FLAGS', '('.intern, '\Answered', '\Flagged', '\Deleted', '\Seen', '\Draft', ')'.intern ],
+                   @reader.scan_line('* FLAGS (\Answered \Flagged \Deleted \Seen \Draft)'))
+      assert_equal([ '*', 'OK', '['.intern, 'PERMANENTFLAGS', '('.intern, '\Deleted', '\Seen', '\*', ')'.intern, ']'.intern, 'Limited' ],
+                   @reader.scan_line('* OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited'))
+      assert_equal([ 'A82', 'LIST', '', '*' ], @reader.scan_line('A82 LIST "" *'))
+      assert_equal([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, '/', 'foo' ], @reader.scan_line('* LIST (\Noselect) "/" foo',))
+      assert_equal([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, '/', 'foo [bar] (baz)' ],
+                   @reader.scan_line('* LIST (\Noselect) "/" "foo [bar] (baz)"'))
+      assert_equal([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, :NIL, '' ], @reader.scan_line('* LIST (\Noselect) NIL ""'))
+      assert_equal([ 'A654', 'FETCH', '2:4',
+                     '('.intern,
+                     [ :body, RIMS::Protocol.body(symbol: 'BODY', section: '') ],
+                     ')'.intern
+                   ],
+                   @reader.scan_line('A654 FETCH 2:4 (BODY[])'))
+
+      assert_equal('', @output.string)
+    end
+
+    def test_scan_line_string_literal
+      literal = <<-'EOF'
+Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
+From: Fred Foobar <foobar@Blurdybloop.COM>
+Subject: afternoon meeting
+To: mooch@owatagu.siam.edu
+Message-Id: <B27397-0100000@Blurdybloop.COM>
+MIME-Version: 1.0
+Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
+
+Hello Joe, do you think we can meet at 3:30 tomorrow?
+      EOF
+
+      line = 'A003 APPEND saved-messages (\Seen) ' + "{#{literal.bytesize}}"
+      @input.string = literal + "\r\n"
+
+      assert_equal([ 'A003', 'APPEND', 'saved-messages', '('.intern, '\Seen', ')'.intern, literal ], @reader.scan_line(line))
+      assert_equal('', @input.read)
+
+      cmd_cont_req = @output.string.each_line
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_raise(StopIteration) { cmd_cont_req.next }
+    end
+
+    def test_read_line
+      assert_nil(@reader.read_line)
+
+      @input.string = "\n"
+      assert_equal([], @reader.read_line)
+
+      @input.string = "abcd CAPABILITY\n"
+      assert_equal(%w[ abcd CAPABILITY ], @reader.read_line)
+
+      @input.string = "abcd OK CAPABILITY completed\n"
+      assert_equal(%w[ abcd OK CAPABILITY completed ], @reader.read_line)
+
+      @input.string = "* CAPABILITY IMAP4rev1 AUTH=KERBEROS_V4\n"
+      assert_equal(%w[ * CAPABILITY IMAP4rev1 AUTH=KERBEROS_V4 ], @reader.read_line)
+
+      @input.string = "* 172 EXISTS\n"
+      assert_equal(%w[ * 172 EXISTS ], @reader.read_line)
+
+      @input.string = "* OK [UNSEEN 12] Message 12 is first unseen\n"
+      assert_equal([ '*', 'OK', '['.intern, 'UNSEEN', '12', ']'.intern, 'Message', '12', 'is', 'first', 'unseen', ], @reader.read_line)
+
+      @input.string = "* FLAGS (\\Answered \\Flagged \\Deleted \\Seen \\Draft)\n"
+      assert_equal([ '*', 'FLAGS', '('.intern, '\Answered', '\Flagged', '\Deleted', '\Seen', '\Draft', ')'.intern ], @reader.read_line)
+
+      @input.string = "* OK [PERMANENTFLAGS (\\Deleted \\Seen \\*)] Limited\n"
+      assert_equal([ '*', 'OK',
+                     '['.intern, 'PERMANENTFLAGS', '('.intern, '\Deleted', '\Seen', '\*', ')'.intern, ']'.intern,
+                     'Limited'
+                   ], @reader.read_line)
+
+      @input.string = "A82 LIST \"\" *\n"
+      assert_equal([ 'A82', 'LIST', '', '*' ], @reader.read_line)
+
+      @input.string = "* LIST (\\Noselect) \"/\" foo\n"
+      assert_equal([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, '/', 'foo' ], @reader.read_line)
+
+      @input.string = "* LIST (\\Noselect) \"/\" \"foo [bar] (baz)\""
+      assert_equal([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, '/', 'foo [bar] (baz)' ], @reader.read_line)
+
+      @input.string = '* LIST (\Noselect) NIL ""'
+      assert_equal([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, :NIL, '' ], @reader.read_line)
+
+      @input.string = "A654 FETCH 2:4 (BODY[])\n"
+      assert_equal([ 'A654', 'FETCH', '2:4',
+                     '('.intern,
+                     [ :body, RIMS::Protocol.body(symbol: 'BODY', section: '') ],
+                     ')'.intern
+                   ],
+                   @reader.read_line)
+
+      assert_equal('', @output.string)
+    end
+
+    def test_read_line_string_literal
+      literal = <<-'EOF'
+Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
+From: Fred Foobar <foobar@Blurdybloop.COM>
+Subject: afternoon meeting
+To: mooch@owatagu.siam.edu
+Message-Id: <B27397-0100000@Blurdybloop.COM>
+MIME-Version: 1.0
+Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
+
+Hello Joe, do you think we can meet at 3:30 tomorrow?
+      EOF
+
+      @input.string = "A003 APPEND saved-messages (\\Seen) {#{literal.bytesize}}\n" + literal + "\n"
+      assert_equal([ 'A003', 'APPEND', 'saved-messages', '('.intern, '\Seen', ')'.intern, literal ], @reader.read_line)
+      assert_equal('', @input.read)
+
+      cmd_cont_req = @output.string.each_line
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_raise(StopIteration) { cmd_cont_req.next }
+    end
+
+    def test_read_line_string_literal_multi
+      literal1 = <<-'EOF'
+Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
+From: Fred Foobar <foobar@Blurdybloop.COM>
+Subject: afternoon meeting
+To: mooch@owatagu.siam.edu
+Message-Id: <B27397-0100000@Blurdybloop.COM>
+MIME-Version: 1.0
+Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
+      EOF
+
+      literal2 = <<-'EOF'
+Hello Joe, do you think we can meet at 3:30 tomorrow?
+      EOF
+
+      @input.string = "* ({#{literal1.bytesize}}\n" + literal1 + " {#{literal2.bytesize}}\n" + literal2 + ")\n"
+      assert_equal([ '*', '('.intern, literal1, literal2, ')'.intern ], @reader.read_line)
+      assert_equal('', @input.read)
+
+      cmd_cont_req = @output.string.each_line
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_raise(StopIteration) { cmd_cont_req.next }
+    end
+
+    def test_parse
+      assert_equal([], @reader.parse([]))
+      assert_equal(%w[ abcd CAPABILITY ], @reader.parse(%w[ abcd CAPABILITY ]))
+      assert_equal(%w[ abcd OK CAPABILITY completed ], @reader.parse(%w[ abcd OK CAPABILITY completed ]))
+      assert_equal([ '*', 'OK', [ :block, 'UNSEEN', '12' ], 'Message', '12', 'is', 'first', 'unseen' ],
+                   @reader.parse([ '*', 'OK', '['.intern, 'UNSEEN', '12', ']'.intern, 'Message', '12', 'is', 'first', 'unseen' ]))
+      assert_equal([ '*', 'FLAGS', [ :group,  '\Answered', '\Flagged', '\Deleted', '\Seen', '\Draft' ] ],
+                   @reader.parse([ '*', 'FLAGS', '('.intern, '\Answered', '\Flagged', '\Deleted', '\Seen', '\Draft', ')'.intern ]))
+      assert_equal([ '*', 'OK', [ :block, 'PERMANENTFLAGS', [ :group, '\Deleted', '\Seen', '\*' ] ], 'Limited' ],
+                   @reader.parse([ '*', 'OK', '['.intern, 'PERMANENTFLAGS', '('.intern, '\Deleted', '\Seen', '\*', ')'.intern, ']'.intern, 'Limited' ]))
+      assert_equal([ '*', 'LIST', [ :group, '\Noselect' ], :NIL, '' ],
+                   @reader.parse([ '*', 'LIST', '('.intern, '\Noselect', ')'.intern, :NIL, '' ]))
+      assert_equal([ 'A654', 'FETCH', '2:4',
+                     [ :group,
+                       [ :body,
+                         RIMS::Protocol.body(symbol: 'BODY',
+                                             section: '',
+                                             section_list: [])
+                       ]
+                     ]
+                   ],
+                   @reader.parse([ 'A654', 'FETCH', '2:4',
+                                   '('.intern,
+                                   [ :body, RIMS::Protocol.body(symbol: 'BODY', section: '') ],
+                                   ')'.intern
+                                 ]))
+      assert_equal([ 'A003', 'APPEND', 'saved-messages', "foo\nbody[]\nbar\n" ],
+                   @reader.parse([ 'A003', 'APPEND', 'saved-messages', "foo\nbody[]\nbar\n" ]))
+
+      assert_equal('', @output.string)
+    end
+
+    def test_read_command
+      assert_nil(@reader.read_command)
+
+      @input.string = "\n"
+      assert_nil(@reader.read_command)
+
+      @input.string = " \t\n"
+      assert_nil(@reader.read_command)
+
+      @input.string = "abcd CAPABILITY\n"
+      assert_equal(%w[ abcd CAPABILITY ], @reader.read_command)
+
+      @input.string = "\n \n\t\nabcd CAPABILITY\n"
+      assert_equal(%w[ abcd CAPABILITY ], @reader.read_command)
+
+      @input.string = "abcd OK CAPABILITY completed\n"
+      assert_equal(%w[ abcd OK CAPABILITY completed ], @reader.read_command)
+
+      @input.string = "A003 STORE 2:4 +FLAGS (\\Deleted)\n"
+      assert_equal([ 'A003', 'STORE', '2:4', '+FLAGS', [ :group, '\Deleted' ] ], @reader.read_command)
+
+      @input.string = "abcd SEARCH (OR (FROM foo) (FROM bar))\n"
+      assert_equal([ 'abcd', 'SEARCH',
+                     [ :group,
+                       'OR',
+                       [ :group, 'FROM', 'foo' ],
+                       [ :group, 'FROM', 'bar' ]
+                     ]
+                   ],
+                   @reader.read_command)
+
+      @input.string = "abcd SEARCH SUBJECT \"NIL\"\n"
+      assert_equal([ 'abcd', 'SEARCH', 'SUBJECT', 'NIL'  ], @reader.read_command)
+
+      @input.string = "abcd SEARCH SUBJECT \"(\"\n"
+      assert_equal([ 'abcd', 'SEARCH', 'SUBJECT', '('  ], @reader.read_command)
+
+      @input.string = "abcd SEARCH SUBJECT \")\"\n"
+      assert_equal([ 'abcd', 'SEARCH', 'SUBJECT', ')'  ], @reader.read_command)
+
+      @input.string = "abcd SEARCH SUBJECT \"[\"\n"
+      assert_equal([ 'abcd', 'SEARCH', 'SUBJECT', '['  ], @reader.read_command)
+
+      @input.string = "abcd SEARCH SUBJECT \"]\"\n"
+      assert_equal([ 'abcd', 'SEARCH', 'SUBJECT', ']'  ], @reader.read_command)
+
+      @input.string = "A654 FETCH 2:4 (BODY)\n"
+      assert_equal([ 'A654', 'FETCH', '2:4', [ :group, 'BODY' ] ], @reader.read_command)
+
+      @input.string = "A654 FETCH 2:4 (BODY[])\n"
+      assert_equal([ 'A654', 'FETCH', '2:4', [
+                       :group, [
+                         :body,
+                         RIMS::Protocol.body(symbol: 'BODY',
+                                             section: '',
+                                             section_list: [])
+                       ]
+                     ]
+                   ], @reader.read_command)
+
+      @input.string = "A654 FETCH 2:4 (FLAGS BODY.PEEK[HEADER.FIELDS (DATE FROM)]<0.1500>)\n"
+      assert_equal([ 'A654', 'FETCH', '2:4',
+                     [ :group,
+                       'FLAGS',
+                       [ :body,
+                         RIMS::Protocol.body(symbol: 'BODY',
+                                             option: 'PEEK',
+                                             section: 'HEADER.FIELDS (DATE FROM)',
+                                             section_list: [ 'HEADER.FIELDS', [ :group, 'DATE', 'FROM' ] ],
+                                             partial_origin: 0,
+                                             partial_size: 1500)
+                       ]
+                     ]
+                   ],
+                   @reader.read_command)
+
+      @input.string = "A654 APPEND saved-messages \"body[]\"\n"
+      assert_equal([ 'A654', 'APPEND', 'saved-messages', 'body[]' ], @reader.read_command)
+
+      assert_equal('', @output.string)
+
+      literal = <<-'EOF'
+Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
+From: Fred Foobar <foobar@Blurdybloop.COM>
+Subject: afternoon meeting
+To: mooch@owatagu.siam.edu
+Message-Id: <B27397-0100000@Blurdybloop.COM>
+MIME-Version: 1.0
+Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
+
+Hello Joe, do you think we can meet at 3:30 tomorrow?
+      EOF
+
+      @input.string = "A003 APPEND saved-messages (\\Seen) {#{literal.bytesize}}\n" + literal + "\n"
+      @output.string = ''
+      assert_equal([ 'A003', 'APPEND', 'saved-messages', [ :group, '\Seen' ], literal ], @reader.read_command)
+
+      cmd_cont_req = @output.string.each_line
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_raise(StopIteration) { cmd_cont_req.next }
+
+
+      literal2 = <<-'EOF'
+Subject: parse test
+
+body[]
+      EOF
+
+      @input.string = "A004 APPEND saved-messages {#{literal2.bytesize}}\n" + literal2 + "\n"
+      @output.string = ''
+      assert_equal([ 'A004', 'APPEND', 'saved-messages', literal2 ], @reader.read_command)
+
+      cmd_cont_req = @output.string.each_line
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_raise(StopIteration) { cmd_cont_req.next }
+
+      literal3 = 'body[]'
+
+      @input.string = "A005 APPEND saved-messages {#{literal3.bytesize}}\n" + literal3 + "\n"
+      @output.string = ''
+      assert_equal([ 'A005', 'APPEND', 'saved-messages', literal3 ], @reader.read_command)
+
+      cmd_cont_req = @output.string.each_line
+      assert_match(/^\+ /, cmd_cont_req.next)
+      assert_raise(StopIteration) { cmd_cont_req.next }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_protocol_search.rb

@@ -0,0 +1,974 @@
+# -*- coding: utf-8 -*-
+
+require 'rims'
+require 'test/unit'
+require 'time'
+
+module RIMS::Test
+  class ProtocolSearchParserTest < Test::Unit::TestCase
+    def setup
+      @kv_store = {}
+      @kvs_open = proc{|path| RIMS::Hash_KeyValueStore.new(@kv_store[path] = {}) }
+      @mail_store = RIMS::MailStore.new(RIMS::DB::Meta.new(@kvs_open.call('meta')),
+                                        RIMS::DB::Message.new(@kvs_open.call('msg'))) {|mbox_id|
+        RIMS::DB::Mailbox.new(@kvs_open.call("mbox_#{mbox_id}"))
+      }
+      @inbox_id = @mail_store.add_mbox('INBOX')
+    end
+
+    def add_msg(msg_txt, *optional_args)
+      @mail_store.add_msg(@inbox_id, msg_txt, *optional_args)
+    end
+    private :add_msg
+
+    def get_msg_flag(uid, flag_name)
+      @mail_store.msg_flag(@inbox_id, uid, flag_name)
+    end
+    private :get_msg_flag
+
+    def set_msg_flag(uid, flag_name, flag_value)
+      @mail_store.set_msg_flag(@inbox_id, uid, flag_name, flag_value)
+      nil
+    end
+    private :set_msg_flag
+
+    def expunge(*uid_list)
+      for uid in uid_list
+        set_msg_flag(uid, 'deleted', true)
+      end
+      @mail_store.expunge_mbox(@inbox_id)
+      nil
+    end
+    private :expunge
+
+    def assert_msg_uid(*uid_list)
+      assert_equal(uid_list, @mail_store.each_msg_uid(@inbox_id).to_a)
+    end
+    private :assert_msg_uid
+
+    def assert_msg_flag(flag_name, *flag_value_list)
+      uid_list = @mail_store.each_msg_uid(@inbox_id).to_a
+      assert_equal(uid_list.map{|uid| get_msg_flag(uid, flag_name) }, flag_value_list)
+    end
+    private :assert_msg_flag
+
+    def make_search_parser(charset: nil)
+      yield
+      @folder = @mail_store.select_mbox(@inbox_id).reload
+      @parser = RIMS::Protocol::SearchParser.new(@mail_store, @folder)
+      @parser.charset = charset if charset
+      nil
+    end
+    private :make_search_parser
+
+    def parse_search_key(search_key_list)
+      @cond = @parser.parse(search_key_list)
+      begin
+        yield
+      ensure
+        @cond = nil
+      end
+    end
+    private :parse_search_key
+
+    def assert_search_cond(msg_idx, expected_found_flag)
+      assert_equal(expected_found_flag, @cond.call(@folder[msg_idx]))
+    end
+    private :assert_search_cond
+
+    def assert_search_syntax_error(search_key_list)
+      assert_raise(RIMS::SyntaxError) {
+        @parser.parse(search_key_list)
+      }
+    end
+    private :assert_search_syntax_error
+
+    def test_parse_all
+      make_search_parser{
+        add_msg('foo')
+        assert_msg_uid(1)
+      }
+
+      parse_search_key([ 'ALL' ]) {
+        assert_search_cond(0, true)
+      }
+    end
+
+    def test_parse_answered
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'answered', true)
+        assert_msg_flag('answered', true, false)
+      }
+
+      parse_search_key([ 'ANSWERED' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+      }
+    end
+
+    def test_parse_bcc
+      make_search_parser{
+        add_msg("Bcc: foo\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Bcc: bar\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'BCC', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'BCC' ])
+      assert_search_syntax_error([ 'BCC', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_before
+      make_search_parser{
+        add_msg('foo', Time.parse('2013-11-07 12:34:56'))
+        add_msg('foo', Time.parse('2013-11-08 12:34:56'))
+        add_msg('foo', Time.parse('2013-11-09 12:34:56'))
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'BEFORE', '08-Nov-2013' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'BEFORE' ])
+      assert_search_syntax_error([ 'BEFORE', '99-Nov-2013' ])
+      assert_search_syntax_error([ 'BEFORE', [ :group, '08-Nov-2013'] ])
+    end
+
+    def test_parse_body
+      make_search_parser{
+        add_msg("Content-Type: text/plain\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Content-Type: text/plain\r\n" +
+                "\r\n" +
+                "bar")
+        add_msg("Content-Type: message/rfc822\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg(<<-'EOF')
+Content-Type: multipart/alternative; boundary="1383.905529.351297"
+
+--1383.905529.351297
+Content-Type: text/plain
+
+foo
+--1383.905529.351297
+Content-Type: text/html
+
+<html><body><p>foo</p></body></html>
+--1383.905529.351297--
+        EOF
+
+        assert_msg_uid(1, 2, 3, 4)
+      }
+
+      parse_search_key([ 'BODY', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, true)
+        assert_search_cond(3, false) # ignored text part of multipart message.
+      }
+
+      assert_search_syntax_error([ 'BODY' ])
+      assert_search_syntax_error([ 'BODY', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_cc
+      make_search_parser{
+        add_msg("Cc: foo\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Cc: bar\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'CC', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'CC' ])
+      assert_search_syntax_error([ 'CC', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_deleted
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'deleted', true)
+        assert_msg_flag('deleted', true, false)
+      }
+
+      parse_search_key([ 'DELETED' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+      }
+    end
+
+    def test_parse_draft
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'draft', true)
+        assert_msg_flag('draft', true, false)
+      }
+
+      parse_search_key([ 'DRAFT' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+      }
+    end
+
+    def test_parse_flagged
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'flagged', true)
+        assert_msg_flag('flagged', true, false)
+      }
+
+      parse_search_key([ 'FLAGGED' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+      }
+    end
+
+    def test_parse_from
+      make_search_parser{
+        add_msg("From: foo\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("From: bar\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'FROM', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'FROM' ])
+      assert_search_syntax_error([ 'FROM', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_header
+      make_search_parser{
+        add_msg("X-Foo: alice\r\n" +
+                "X-Bar: bob\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("X-Foo: bob\r\n" +
+                "X-Bar: alice\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'HEADER', 'x-foo', 'alice' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      parse_search_key([ 'HEADER', 'x-foo', 'bob' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, false)
+      }
+
+      parse_search_key([ 'HEADER', 'x-bar', 'alice' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, false)
+      }
+
+      parse_search_key([ 'HEADER', 'x-bar', 'bob' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'HEADER' ])
+      assert_search_syntax_error([ 'HEADER', 'Received' ])
+      assert_search_syntax_error([ 'HEADER', 'Received', [ :group, 'foo' ] ])
+      assert_search_syntax_error([ 'HEADER', [ :group, 'Received' ], 'foo' ])
+    end
+
+    def test_parse_keyword
+      make_search_parser{
+        add_msg('')
+        assert_msg_uid(1)
+      }
+
+      parse_search_key([ 'KEYWORD', 'foo' ]) {
+        assert_search_cond(0, false) # always false
+      }
+
+      assert_search_syntax_error([ 'KEYWORD' ])
+      assert_search_syntax_error([ 'KEYWORD', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_larger
+      make_search_parser{
+        add_msg('foo')
+        add_msg('1234')
+        add_msg('bar')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'LARGER', '3' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'LARGER' ])
+      assert_search_syntax_error([ 'LARGER', [ :group, '3' ] ])
+      assert_search_syntax_error([ 'LARGER', 'nonum' ])
+    end
+
+    def test_parse_new
+      make_search_parser{
+        add_msg('foo')
+        add_msg('bar')
+        add_msg('baz')
+        assert_msg_uid(1, 2, 3)
+
+        set_msg_flag(3, 'recent', false)
+        set_msg_flag(2, 'seen', true)
+        assert_msg_flag('recent', true,  true, false)
+        assert_msg_flag('seen',   false, true, false)
+      }
+
+      parse_search_key([ 'NEW' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+    end
+
+    def test_parse_not
+      make_search_parser{
+        add_msg('foo')
+        add_msg('1234')
+        add_msg('bar')
+        assert_msg_uid(1, 2, 3)
+
+        set_msg_flag(1, 'answered', true)
+        assert_msg_flag('answered', true, false, false)
+      }
+
+      parse_search_key([ 'NOT', 'LARGER', '3' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, true)
+      }
+
+      parse_search_key([ 'NOT', 'ANSWERED' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, true)
+      }
+
+      assert_search_syntax_error([ 'NOT' ])
+    end
+
+    def test_parse_old
+      make_search_parser{
+        add_msg('foo')
+        add_msg('bar')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'recent', false)
+        assert_msg_flag('recent', false, true)
+      }
+
+      parse_search_key([ 'OLD' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+      }
+    end
+
+    def test_parse_on
+      make_search_parser{
+        add_msg('foo', Time.parse('2013-11-07 12:34:56'))
+        add_msg('foo', Time.parse('2013-11-08 12:34:56'))
+        add_msg('foo', Time.parse('2013-11-09 12:34:56'))
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'ON', '08-Nov-2013' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'ON' ])
+      assert_search_syntax_error([ 'ON', '99-Nov-2013' ])
+      assert_search_syntax_error([ 'ON', [ :group, '08-Nov-2013'] ])
+    end
+
+    def test_parse_or
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3, 4)
+
+        set_msg_flag(1, 'answered', true)
+        set_msg_flag(2, 'answered', true)
+        set_msg_flag(1, 'flagged', true)
+        set_msg_flag(3, 'flagged', true)
+        assert_msg_flag('answered', true, true,  false, false)
+        assert_msg_flag('flagged',  true, false, true,  false)
+      }
+
+      parse_search_key([ 'OR', 'ANSWERED', 'FLAGGED' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, true)
+        assert_search_cond(2, true)
+        assert_search_cond(3, false)
+
+      }
+
+      assert_search_syntax_error([ 'OR' ])
+      assert_search_syntax_error([ 'OR', 'ANSWERED' ])
+    end
+
+    def test_parse_recent
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'recent', false)
+        assert_msg_flag('recent', false, true)
+      }
+
+      parse_search_key([ 'RECENT' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+      }
+    end
+
+    def test_parse_seen
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'seen', true)
+        assert_msg_flag('seen', true, false)
+      }
+
+      parse_search_key([ 'SEEN' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+      }
+    end
+
+    def test_parse_sentbefore
+      make_search_parser{
+        add_msg("Date: Thu, 07 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Date: Fri, 08 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Date: Sat, 09 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3, 4)
+      }
+
+      parse_search_key([ 'SENTBEFORE', '08-Nov-2013' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, false)
+      }
+
+      assert_search_syntax_error([ 'SENTBEFORE' ])
+      assert_search_syntax_error([ 'SENTBEFORE', '99-Nov-2013' ])
+      assert_search_syntax_error([ 'SENTBEFORE', [ :group, '08-Nov-2013'] ])
+    end
+
+    def test_parse_senton
+      make_search_parser{
+        add_msg("Date: Thu, 07 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Date: Fri, 08 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Date: Sat, 09 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3, 4)
+      }
+
+      parse_search_key([ 'SENTON', '08-Nov-2013' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, false)
+        assert_search_cond(3, false)
+      }
+
+      assert_search_syntax_error([ 'SENTON' ])
+      assert_search_syntax_error([ 'SENTON', '99-Nov-2013' ])
+      assert_search_syntax_error([ 'SENTON', [ :group, '08-Nov-2013'] ])
+    end
+
+    def test_parse_sentsince
+      make_search_parser{
+        add_msg("Date: Thu, 07 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Date: Fri, 08 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Date: Sat, 09 Nov 2013 12:34:56 +0900\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3, 4)
+      }
+
+      parse_search_key([ 'SENTSINCE', '08-Nov-2013' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, false)
+        assert_search_cond(2, true)
+        assert_search_cond(3, false)
+      }
+
+      assert_search_syntax_error([ 'SENTSINCE' ])
+      assert_search_syntax_error([ 'SENTSINCE', '99-Nov-2013' ])
+      assert_search_syntax_error([ 'SENTSINCE', [ :group, '08-Nov-2013'] ])
+    end
+
+    def test_parse_since
+      make_search_parser{
+        add_msg('foo', Time.parse('2013-11-07 12:34:56'))
+        add_msg('foo', Time.parse('2013-11-08 12:34:56'))
+        add_msg('foo', Time.parse('2013-11-09 12:34:56'))
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'SINCE', '08-Nov-2013' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, false)
+        assert_search_cond(2, true)
+      }
+
+      assert_search_syntax_error([ 'SINCE' ])
+      assert_search_syntax_error([ 'SINCE', '99-Nov-2013' ])
+      assert_search_syntax_error([ 'SINCE', [ :group, '08-Nov-2013'] ])
+    end
+
+    def test_parse_smaller
+      make_search_parser{
+        add_msg('foo')
+        add_msg('12')
+        add_msg('bar')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'SMALLER', '3' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'SMALLER' ])
+      assert_search_syntax_error([ 'SMALLER', [ :group, '3' ] ])
+      assert_search_syntax_error([ 'SMALLER', 'nonum' ])
+    end
+
+    def test_parse_subject
+      make_search_parser{
+        add_msg("Subject: foo\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Subject: bar\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'SUBJECT', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'SUBJECT' ])
+      assert_search_syntax_error([ 'SUBJECT', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_text
+      make_search_parser{
+        add_msg("Content-Type: text/plain\r\n" +
+                "Subject: foo\r\n" +
+                "\r\n" +
+                "bar")
+        assert_msg_uid(1)
+      }
+
+      parse_search_key([ 'TEXT', 'jec' ]) {
+        assert_search_cond(0, true)
+      }
+      parse_search_key([ 'TEXT', 'foo' ]) {
+        assert_search_cond(0, true)
+      }
+      parse_search_key([ 'TEXT', 'bar' ]) {
+        assert_search_cond(0, true)
+      }
+      parse_search_key([ 'TEXT', 'baz' ]) {
+        assert_search_cond(0, false)
+      }
+
+      assert_search_syntax_error([ 'TEXT' ])
+      assert_search_syntax_error([ 'TEXT', [ :group, 'foo'] ])
+    end
+
+    def test_parse_to
+      make_search_parser{
+        add_msg("To: foo\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("To: bar\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3)
+      }
+
+      parse_search_key([ 'TO', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+      }
+
+      assert_search_syntax_error([ 'TO' ])
+      assert_search_syntax_error([ 'TO', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_uid
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        expunge(1, 3, 5)
+        assert_msg_uid(2, 4, 6)
+      }
+
+      parse_search_key([ 'UID', '2,*' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, true)
+      }
+
+      begin
+        @parser.parse([ 'UID', 'detarame' ])
+      rescue
+        error = $!
+      end
+      assert_kind_of(RIMS::SyntaxError, error)
+    end
+
+    def test_parse_unanswered
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'answered', true)
+        assert_msg_flag('answered', true, false)
+      }
+
+      parse_search_key([ 'UNANSWERED' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+      }
+    end
+
+    def test_parse_undeleted
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'deleted', true)
+        assert_msg_flag('deleted', true, false)
+      }
+
+      parse_search_key([ 'UNDELETED' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+      }
+    end
+
+    def test_parse_undraft
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'draft', true)
+        assert_msg_flag('draft', true, false)
+      }
+
+      parse_search_key([ 'UNDRAFT' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+      }
+    end
+
+    def test_parse_unflagged
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'flagged', true)
+        assert_msg_flag('flagged', true, false)
+      }
+
+      parse_search_key([ 'UNFLAGGED' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+      }
+    end
+
+    def test_parse_unkeyword
+      make_search_parser{
+        add_msg('')
+        assert_msg_uid(1)
+      }
+
+      parse_search_key([ 'UNKEYWORD', 'foo' ]) {
+        assert_search_cond(0, true) # always true
+      }
+
+      assert_search_syntax_error([ 'UNKEYWORD' ])
+      assert_search_syntax_error([ 'UNKEYWORD', [ :group, 'foo' ] ])
+    end
+
+    def test_parse_unseen
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2)
+
+        set_msg_flag(1, 'seen', true)
+        assert_msg_flag('seen', true, false)
+      }
+
+      parse_search_key([ 'UNSEEN' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+      }
+    end
+
+    def test_parse_msg_set
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        expunge(1, 3, 5)
+        assert_msg_uid(2, 4, 6)
+      }
+
+      parse_search_key([ '1,*' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, true)
+      }
+
+      assert_search_syntax_error([ 'detarame' ])
+    end
+
+    def test_parse_group
+      make_search_parser{
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        add_msg('foo')
+        assert_msg_uid(1, 2, 3, 4)
+
+        set_msg_flag(1, 'answered', true)
+        set_msg_flag(2, 'answered', true)
+        set_msg_flag(1, 'flagged', true)
+        set_msg_flag(3, 'flagged', true)
+        assert_msg_flag('answered', true, true,  false, false)
+        assert_msg_flag('flagged',  true, false, true,  false)
+      }
+
+      parse_search_key([ 'ANSWERED', 'FLAGGED' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, false)
+      }
+
+      parse_search_key([ [ :group, 'ANSWERED', 'FLAGGED' ] ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, false)
+      }
+
+      assert_search_syntax_error([ [ :block, 'ANSWERED', 'FLAGGED' ] ])
+    end
+
+    def test_parse_charset_body
+      make_search_parser(charset: 'utf-8') {
+        add_msg("Content-Type: text/plain\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Content-Type: text/plain; charset=utf-8\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                "\r\n" +
+                "foo")
+        add_msg("Content-Type: text/plain; charset=utf-8\r\n" +
+                "\r\n" +
+                "\u3053\u3093\u306B\u3061\u306F\r\n" +
+                "\u3044\u308D\u306F\u306B\u307B\u3078\u3068\r\n" +
+                "\u3042\u3044\u3046\u3048\u304A\r\n")
+        add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                "\r\n" +
+                "\e$B$3$s$K$A$O\e(B\r\n\e$B$$$m$O$K$[$X$H\e(B\r\n\e$B$\"$$$&$($*\e(B\r\n")
+        assert_msg_uid(1, 2, 3, 4, 5)
+      }
+
+      parse_search_key([ 'BODY', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, true)
+        assert_search_cond(2, true)
+        assert_search_cond(3, false)
+        assert_search_cond(4, false)
+      }
+
+      parse_search_key([ 'BODY', 'bar' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, false)
+        assert_search_cond(4, false)
+      }
+
+      parse_search_key([ 'BODY', "\u306F\u306B\u307B".b ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, true)
+        assert_search_cond(4, true)
+      }
+    end
+
+    def test_parse_charset_text
+      make_search_parser(charset: 'utf-8') {
+        add_msg("Content-Type: text/plain\r\n" +
+                "foo")
+        add_msg("Content-Type: text/plain; charset=utf-8\r\n" +
+                "X-foo: dummy\r\n" +
+                "\r\n" +
+                "bar")
+        add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                "X-dummy: foo\r\n" +
+                "\r\n" +
+                "bar")
+        add_msg("Content-Type: text/plain; charset=utf-8\r\n" +
+                "\r\n" +
+                "\u3053\u3093\u306B\u3061\u306F\r\n" +
+                "\u3044\u308D\u306F\u306B\u307B\u3078\u3068\r\n" +
+                "\u3042\u3044\u3046\u3048\u304A\r\n")
+        add_msg("Content-Type: text/plain; charset=iso-2022-jp\r\n" +
+                "\r\n" +
+                "\e$B$3$s$K$A$O\e(B\r\n\e$B$$$m$O$K$[$X$H\e(B\r\n\e$B$\"$$$&$($*\e(B\r\n")
+        assert_msg_uid(1, 2, 3, 4, 5)
+      }
+
+      parse_search_key([ 'TEXT', 'foo' ]) {
+        assert_search_cond(0, true)
+        assert_search_cond(1, true)
+        assert_search_cond(2, true)
+        assert_search_cond(3, false)
+        assert_search_cond(4, false)
+      }
+
+      parse_search_key([ 'TEXT', 'bar' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, true)
+        assert_search_cond(2, true)
+        assert_search_cond(3, false)
+        assert_search_cond(4, false)
+      }
+
+      parse_search_key([ 'TEXT', 'baz' ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, false)
+        assert_search_cond(4, false)
+      }
+
+      parse_search_key([ 'TEXT', "\u306F\u306B\u307B".b ]) {
+        assert_search_cond(0, false)
+        assert_search_cond(1, false)
+        assert_search_cond(2, false)
+        assert_search_cond(3, true)
+        assert_search_cond(4, true)
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: