mumboe-vpim 0.7

data/test/test_agent_atomize.rb

@@ -0,0 +1,84 @@
+require 'test/common'
+
+require 'vpim/agent/atomize'
+require 'vpim/icalendar'
+require 'vpim/view'
+
+class TextAgentAtomize < Test::Unit::TestCase
+
+  def atomize(cal, feeduri, caluri, filter=nil)
+    ical = Vpim::Icalendar.decode(cal).first
+    if filter
+      ical = filter.call(ical)
+    end
+    feed = Vpim::Agent::Atomize.calendar(ical, feeduri, caluri)
+    return ical, feed
+  end
+
+  def test_minimal
+    ical, feed = atomize(<<'__', "http://example.com/feed", "http://example.com/calendar")
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:20090214T144503
+END:VEVENT
+END:VCALENDAR
+__
+
+  assert_equal(feed.entries.size, 1)
+  assert_equal("http://example.com/feed", feed.id)
+  assert_equal("http://example.com/calendar", feed.title)
+  assert(feed.to_xml.to_str)
+  assert_equal(nil, feed.entries.first.title)
+  assert_equal(nil, feed.entries.first.content)
+  #puts feed.to_xml
+  end
+
+  def test_small
+    ical, feed = atomize(<<'__', "http://example.com/feed", "http://example.com/calendar")
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:20090214T144503
+SUMMARY:I am summarized
+DESCRIPTION:And I am described
+UID:very, very, unique
+END:VEVENT
+END:VCALENDAR
+__
+
+  assert_equal(feed.entries.size, 1)
+  assert_equal("http://example.com/feed", feed.id)
+  assert_equal("http://example.com/calendar", feed.title)
+  assert_equal("I am summarized", feed.entries.first.title)
+  assert_equal("And I am described", feed.entries.first.content)
+  assert(feed.to_xml.to_str)
+  #puts feed.to_xml
+  end
+
+  def test_recurring
+    filter = proc do |cal|
+      Vpim::View.week(cal)
+    end
+    ical, feed = atomize(<<'__', "http://example.com/feed", "http://example.com/calendar", filter)
+BEGIN:VCALENDAR
+BEGIN:VEVENT
+DTSTART:20090214T144503
+RRULE:FREQ=weekly
+SUMMARY:I am summarized
+DESCRIPTION:And I am described
+UID:very, very, unique
+END:VEVENT
+END:VCALENDAR
+__
+
+  #puts feed.to_xml
+  assert_equal(1, feed.entries.size)
+  assert_equal("http://example.com/feed", feed.id)
+  assert_equal("http://example.com/calendar", feed.title)
+  assert_equal("I am summarized", feed.entries.first.title)
+  assert_equal("And I am described", feed.entries.first.content)
+  assert(feed.to_xml.to_str)
+  end
+
+end
+
+

data/test/test_agent_calendars.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+
+require 'vpim/repo'
+require 'vpim/agent/calendars'
+require 'test/common'
+
+class TestAgentCalendars < Test::Unit::TestCase
+  Apple3 = Vpim::Repo::Apple3
+  Directory = Vpim::Repo::Directory
+  Uri = Vpim::Repo::Uri
+  Agent = Vpim::Agent
+  Path = Agent::Path
+  NotFound = Agent::NotFound
+
+  def setup
+    @testdir = Dir.getwd + "/test" #File.dirname($0) doesn't work with rcov :-(
+    @caldir = @testdir + "/calendars"
+    @eventsz = Dir[@caldir + "/**/*.ics"].size
+    assert(@testdir)
+    assert(test(?d, @caldir), "no caldir "+@caldir)
+  end
+
+  def assert_is_text_calendar(text)
+    lines = text.split("\n")
+    lines = lines.first, lines.last
+    assert_equal("BEGIN:VCALENDAR", lines.first.upcase, lines)
+    assert_equal("END:VCALENDAR", lines.last.upcase, lines)
+  end
+
+  def test_agent_calendars
+    repo = Apple3.new(@caldir)
+    rest = Agent::Calendars.new(repo)
+
+    out1, form = rest.get(Path.new("http://host/here", "/here"))
+    assert_equal("text/html", form)
+    #puts(out1)
+
+    out1, form = rest.get(Path.new("http://host/here/weather%2fLeavenworth", "/here"))
+    assert_equal("text/html", form)
+    #puts(out1)
+
+    out2, form = rest.get(Path.new("http://host/here/weather%2fLeavenworth/calendar", "/here"))
+    assert_equal("text/calendar", form)
+    assert_is_text_calendar(out2)
+
+    #assert_equal(out1, out2)
+
+    assert_raise(Vpim::Agent::NotFound) do
+      rest.get(Path.new("http://host/here/weather%2fLeavenworth/an_unknown_protocol", "/here"))
+    end
+    assert_raise(Vpim::Agent::NotFound) do
+      rest.get(Path.new("http://host/here/no_such_calendar", "/here"))
+    end
+
+    assert_equal(["","/","/"], Vpim::Agent::Path.split_path("/%2F/%2F"))
+    assert_equal(["/","/"], Vpim::Agent::Path.split_path("%2F/%2F"))
+    assert_equal(["calendars", "weather/Leavenworth"],
+                 Vpim::Agent::Path.split_path("calendars/weather%2FLeavenworth"))
+  end
+
+  def test_agent_calendar_atom
+    repo = Apple3.new(@caldir)
+    rest = Agent::Calendars.new(repo)
+
+    out, form = rest.get(Path.new("http://host/here/weather%2fLeavenworth/atom", "/here"))
+    assert_equal("application/atom+xml", form)
+    #pp out
+    #assert_is_atom(out)
+  end
+
+  def _test_path_shift(url, shifts)
+    # last shift should be a nil
+    shifts << nil
+
+    # presence or absence of a trailing / should not affect shifting
+    ["", "/"].each do |trailer|
+      path = Path.new(url + trailer)
+      shifts.each do |_|
+        assert_equal(_, path.shift)
+      end
+    end
+  end
+
+  def test_path_shift
+    _test_path_shift("http://host.ex", [])
+    _test_path_shift("http://host.ex/a", ["a"])
+    _test_path_shift("http://host.ex/a/b", ["a", "b"])
+    _test_path_shift("http://host.ex/a/b/c", ["a", "b", "c"])
+  end
+
+  def _test_path_prefix(base, parts, shifts, prefix)
+    path = Path.new(base+parts.join("/"))
+    shifts.times{ path.shift }
+    assert_equal(prefix, path.prefix)
+  end
+
+  def test_path_prefix
+    _test_path_prefix("http://host.ex/", [], 0, "/")
+    _test_path_prefix("http://host.ex/", ["a"], 0, "/")
+    _test_path_prefix("http://host.ex/", ["a"], 1, "/")
+    _test_path_prefix("http://host.ex/", ["a"], 2, "/a/")
+    _test_path_prefix("http://host.ex/", ["a"], 3, "/a/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 0, "/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 1, "/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 2, "/a/")
+    _test_path_prefix("http://host.ex/", ["a", "b"], 3, "/a/b/")
+  end
+
+=begin
+  def test_atomize
+    repo = Apple3.new(@caldir)
+    cal = repo.find{true}
+    a = Vpim::Agent::Atomize.new(cal)
+    assert( a.get(Path.new("http://example.com/path")))
+  end
+
+  def x_test_uri_query
+    uri = "http://example.com/ics/atom?http://localhost:9876"
+
+    repo = Uri.new("http://localhost:9876")
+    rest = Agent::Calendars.new(repo)
+    out1, form = rest.get(Path.new("http://example.com/ics", "/ics/atom"))
+    p [out1, form]
+  end
+=end
+
+end
+

data/test/test_agent_ics.rb

@@ -0,0 +1,96 @@
+require 'test/common'
+require 'sinatra/test'
+require 'vpim/agent/ics'
+
+class TestIcsAgent < Test::Unit::TestCase
+  include Sinatra::Test
+
+  def to_str
+    @caldata
+  end
+
+  def setup
+    @thrd = data_on_port(self, 9876)
+    @app = Vpim::Agent::Ics
+  end
+  def teardown
+    @thrd.kill
+  end
+
+  def _test_ics_atom_query(scheme)
+    @caldata = open("test/weekly.ics").read
+
+    get "/atom?#{scheme}://127.0.0.1:9876"
+
+    assert_match(/<\?xml/, @response.body)
+    assert_equal(Vpim::Agent::Atomize::MIME, @response["Content-Type"])
+    assert_equal(200, @response.status)
+    assert_match(Regexp.new( Regexp.quote(
+        "<id>http://example.org/atom?#{scheme}://127.0.0.1:9876</id>"
+    )), @response.body)
+  end
+
+  def test_ics_atom_query_http
+    _test_ics_atom_query "http"
+  end
+
+  def test_ics_atom_query_webcal
+    _test_ics_atom_query "webcal"
+  end
+
+  def test_ics
+    get ""
+
+    assert_match(/<html/, @response.body)
+    assert_equal("text/html", @response["Content-Type"])
+    assert_equal(200, @response.status)
+    assert_match(Regexp.new(Regexp.quote("<title>Subscribe")), @response.body)
+  end
+
+  def test_ics_query
+    @caldata = open("test/calendars/weather.calendar/Events/1205042405-0-0.ics").read
+
+    get "?http://127.0.0.1:9876"
+
+    assert_match(/<html/, @response.body)
+    assert_equal("text/html", @response["Content-Type"])
+    assert_equal(200, @response.status)
+
+    assert_match(Regexp.new(Regexp.quote("Subscribe to")), @response.body)
+  end
+
+  def test_ics_post
+    post "/", :url => "http://example.com"
+    assert_equal(302, @response.status)
+    assert_equal("http://example.org?http://example.com", @response.headers["Location"])
+  end
+
+  def test_ics_atom
+    get "/atom"
+    assert_equal(302, @response.status)
+    assert_equal("http://example.org", @response.headers["Location"])
+  end
+
+  def test_ics_style
+    get "/style.css"
+    assert_match(/body \{/, @response.body)
+    assert_equal("text/css", @response["Content-Type"])
+    assert_equal(200, @response.status)
+  end
+
+  def test_ics_query_bad
+    get "/?url://example.com"
+    assert_equal(200, @response.status)
+    assert_match(/Sorry/, @response.body)
+  end
+
+  def test_ics_atom_query_bad
+    #Vpim::Agent::Ics.enable :raise_errors
+
+    get "/atom?url://example.com"
+    assert_equal(302, @response.status)
+    assert_equal("http://example.org?url://example.com", @response.headers["Location"])
+  end
+
+end
+

data/test/test_all.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+
+$-w = true
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+
+#pp [__LINE__, $:, $"]
+
+require 'test/unit'
+
+Dir[File.dirname(__FILE__) + "/test_*.rb"].each do |test|
+  require test unless test =~ /test_all/
+end
+

data/test/test_date.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+
+require 'vpim/date'
+require 'vpim/time'
+require 'test/unit'
+
+class TestVpimDate < Test::Unit::TestCase
+
+  def test_to_time
+    # Need to test with DateTime, but I don't have that with ruby 1.6.
+    assert_equal(Time.at(0), Date.new(1970, 1, 1).vpim_to_time)
+    assert_equal(Time.at(24 * 60 * 60), Date.new(1970, 1, 2).vpim_to_time)
+  end
+
+  def test_date_weekstart
+    assert_equal(Date.weekstart(2004, 01, 12, 'tu').to_s, Date.new(2004, 01,  6).to_s)
+    assert_equal(Date.weekstart(2004, 01, 12, 'we').to_s, Date.new(2004, 01,  7).to_s)
+    assert_equal(Date.weekstart(2004, 01, 12, 'th').to_s, Date.new(2004, 01,  8).to_s)
+    assert_equal(Date.weekstart(2004, 01, 12, 'fr').to_s, Date.new(2004, 01,  9).to_s)
+    assert_equal(Date.weekstart(2004, 01, 12, 'sa').to_s, Date.new(2004, 01, 10).to_s)
+    assert_equal(Date.weekstart(2004, 01, 12, 'su').to_s, Date.new(2004, 01, 11).to_s)
+    assert_equal(Date.weekstart(2004, 01, 12, 'mo').to_s, Date.new(2004, 01, 12).to_s)
+  end
+
+  def do_bywday(args, expect)
+    # Rewrite 'string' weekday specifications.
+    args = [ args[0], args[1], Date.str2wday(args[2]), args[3] ]
+    date  = Date.bywday(*args)
+    dates = DateGen.bywday(*args)
+    need  = Date.new(*expect)
+
+    assert_equal(date, need)
+
+    # Date.bywday always produces a single date, so should the generator, in
+    # this case.
+    assert_equal(dates[0], need)
+  end
+
+  def test_bywday
+
+    #                               2004                              
+    # 
+    #       January               February               March        
+    #  S  M Tu  W Th  F  S   S  M Tu  W Th  F  S   S  M Tu  W Th  F  S
+    #              1  2  3   1  2  3  4  5  6  7      1  2  3  4  5  6
+    #  4  5  6  7  8  9 10   8  9 10 11 12 13 14   7  8  9 10 11 12 13
+    # 11 12 13 14 15 16 17  15 16 17 18 19 20 21  14 15 16 17 18 19 20
+    # 18 19 20 21 22 23 24  22 23 24 25 26 27 28  21 22 23 24 25 26 27
+    # 25 26 27 28 29 30 31  29                    28 29 30 31
+    # 
+    do_bywday([2004,  1, 4,  1], [2004,  1,  1])
+    do_bywday([2004,  1, 4,  2], [2004,  1,  8])
+    do_bywday([2004,  1, 4, -1], [2004,  1, 29])
+    do_bywday([2004,  1, 4, -2], [2004,  1, 22])
+    do_bywday([2004,  1, 4, -5], [2004,  1,  1])
+    do_bywday([2004,nil, 4,  1], [2004,  1,  1])
+    do_bywday([2004,nil, 4,  2], [2004,  1,  8])
+    do_bywday([2004,-12, 4,  1], [2004,  1,  1])
+    do_bywday([2004,-12, 4,  2], [2004,  1,  8])
+    do_bywday([2004,-12, 4, -1], [2004,  1, 29])
+    do_bywday([2004,-12, 4, -2], [2004,  1, 22])
+    do_bywday([2004,-12, 4, -5], [2004,  1,  1])
+
+    do_bywday([2004,  1, "th",  1], [2004,  1,  1])
+    do_bywday([2004,  1, "th",  2], [2004,  1,  8])
+    do_bywday([2004,  1, "th", -1], [2004,  1, 29])
+    do_bywday([2004,  1, "th", -2], [2004,  1, 22])
+    do_bywday([2004,  1, "th", -5], [2004,  1,  1])
+    do_bywday([2004,nil, "th",  1], [2004,  1,  1])
+    do_bywday([2004,nil, "th",  2], [2004,  1,  8])
+    do_bywday([2004,-12, "th",  1], [2004,  1,  1])
+    do_bywday([2004,-12, "th",  2], [2004,  1,  8])
+    do_bywday([2004,-12, "th", -1], [2004,  1, 29])
+    do_bywday([2004,-12, "th", -2], [2004,  1, 22])
+    do_bywday([2004,-12, "th", -5], [2004,  1,  1])
+
+    #       October               November              December      
+    #  S  M Tu  W Th  F  S   S  M Tu  W Th  F  S   S  M Tu  W Th  F  S
+    #                 1  2      1  2  3  4  5  6            1  2  3  4
+    #  3  4  5  6  7  8  9   7  8  9 10 11 12 13   5  6  7  8  9 10 11
+    # 10 11 12 13 14 15 16  14 15 16 17 18 19 20  12 13 14 15 16 17 18
+    # 17 18 19 20 21 22 23  21 22 23 24 25 26 27  19 20 21 22 23 24 25
+    # 24 25 26 27 28 29 30  28 29 30              26 27 28 29 30 31
+    # 31
+
+    do_bywday([2004, -1, 4,  1], [2004, 12,  2])
+    do_bywday([2004, -1, 4, -1], [2004, 12, 30])
+    do_bywday([2004, -1, 4, -2], [2004, 12, 23])
+    do_bywday([2004, -1, 4, -5], [2004, 12,  2])
+    do_bywday([2004,nil, 4, -1], [2004, 12, 30])
+    do_bywday([2004,nil, 4, -2], [2004, 12, 23])
+    do_bywday([2004,nil, 4, -5], [2004, 12,  2])
+    do_bywday([2004,nil, 4, -7], [2004, 11, 18])
+
+  end
+
+  def do_gen(args)
+    assert_nothing_thrown do
+      dates = DateGen.bywday(*args)
+      dates.each do |d|
+        assert_equal(args[0], d.year)
+        if(args[1])
+          mon = args[1]
+          if mon < 0
+            mon = 13 + args[1]
+          end
+          assert_equal(mon, d.mon)
+        end
+        assert_equal(args[2], d.wday)
+      end
+    end
+  end
+
+  def test_gen
+    do_gen([2004,  12, 1])
+    do_gen([2004,  -1, 1])
+    do_gen([2004, nil, 1])
+  end
+end
+

data/test/test_dur.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'vpim/duration'
+require 'test/unit'
+
+include Vpim
+
+class TestVpimDate < Test::Unit::TestCase
+
+  def duration(d0, h0, m0, s0)
+    # 3 hours, 2 mins, 39 secs
+    d = Duration.secs(d0 * 24 * 60 * 60 + h0 * 60 * 60 + m0 * 60 + s0)
+
+    assert_equal(d.secs,  d0 * 24 * 60 * 60 + h0 * 60 * 60 + m0 * 60 + s0)
+    assert_equal(d.mins,  d0 * 24 * 60 + h0 * 60 + m0)
+    assert_equal(d.hours, d0 * 24 + h0)
+    assert_equal(d.days,  d0)
+    assert_equal(d.by_hours, [d0*24 + h0, m0, s0])
+    assert_equal(d.by_days,  [d0,     h0, m0, s0])
+
+    h, m, s = d.by_hours
+
+    assert_equal(h, h0 + d0*24)
+    assert_equal(m, m0)
+    assert_equal(s, s0)
+
+    d, h, m, s = d.by_days
+
+    assert_equal(d, d0)
+    assert_equal(h, h0)
+    assert_equal(m, m0)
+    assert_equal(s, s0)
+  end
+
+  def test_1
+    duration(0, 3, 2, 39)
+    duration(5, 23, 39, 1)
+  end
+
+end
+

data/test/test_field.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'pp'
+require 'vpim/field'
+
+Field=Vpim::DirectoryInfo::Field
+
+class TestField < Test::Unit::TestCase
+
+  def test_encode_decode_text()
+    enc_in = "+\\\\+\\n+\\N+\\,+\\;+\\a+\\b+\\c+"
+    dec = Vpim.decode_text(enc_in)
+    #puts("<#{enc_in}> => <#{dec}>")
+    assert_equal("+\\+\n+\n+,+;+a+b+c+", dec)
+    enc_out = Vpim.encode_text(dec)
+    should_be = "+\\\\+\\n+\\n+\\,+\\;+a+b+c+"
+    # Note a, b, and c are allowed to be escaped, but shouldn't be and 
+    # aren't in output
+    #puts("<#{dec}> => <#{enc_out}>")
+    assert_equal(should_be, enc_out)
+
+  end
+
+  def test_field4
+    line = 't;e=a,b: 4 '
+    part = Field.decode0(line)
+    assert_equal("4", part[ 3 ])
+  end
+
+  def test_field3
+    line = 't;e=a,b:4'
+    part = Field.decode0(line)
+    assert_equal("4", part[ 3 ])
+    assert_equal( {'E' => [ 'a','b' ] }, part[ 2 ])
+  end
+
+  def test_field2
+    line = 'tel;type=work,voice,msg:+1 313 747-4454'
+    part = Field.decode0(line)
+    assert_equal("+1 313 747-4454", part[ 3 ])
+    assert_equal( {'TYPE' => [ 'work','voice','msg' ] }, part[ 2 ])
+  end
+
+  def test_field1
+    line = 'ORGANIZER;CN="xxxx, xxxx [SC100:370:EXCH]":MAILTO:xxxx@americasm01.nt.com'
+    parts = Field.decode0(line)
+
+    assert_equal(nil, parts[0])
+    assert_equal('ORGANIZER', parts[1])
+    assert_equal({ 'CN' => [ "xxxx, xxxx [SC100:370:EXCH]" ] }, parts[2])
+    assert_equal('MAILTO:xxxx@americasm01.nt.com', parts[3])
+  end
+
+=begin this can not be done :-(
+  def test_case_equiv
+    line = 'ORGANIZER;CN="xxxx, xxxx [SC100:370:EXCH]":MAILTO:xxxx@americasm01.nt.com'
+    field = Field.decode(line)
+    assert_equal(true, field.name?('organIZER'))
+    assert_equal(true, field === 'organIZER')
+
+    b = nil
+    case field
+    when 'organIZER'
+      b = true
+    end
+
+    assert_equal(true, b)
+  end
+=end
+
+  def test_field0
+    assert_equal('name:', line = Field.encode0(nil, 'name'))
+    assert_equal([ nil, 'NAME', {}, ''], Field.decode0(line))
+
+    assert_equal('name:value', line = Field.encode0(nil, 'name', {}, 'value'))
+    assert_equal([ nil, 'NAME', {}, 'value'], Field.decode0(line))
+
+    assert_equal('name;encoding=B:dmFsdWU=', line = Field.encode0(nil, 'name', { 'encoding'=>:b64 }, 'value'))
+    assert_equal([ nil, 'NAME', { 'ENCODING'=>['B']}, ['value'].pack('m').chomp ], Field.decode0(line))
+
+    assert_equal('group.name:value', line = Field.encode0('group', 'name', {}, 'value'))
+    assert_equal([ 'GROUP', 'NAME', {}, 'value'], Field.decode0(line))
+  end
+
+  def tEst_invalid_fields
+    [
+      'g.:',
+      ':v',
+    ].each do |line|
+      assert_raises(Vpim::InvalidEncodingError) { Field.decode0(line) }
+    end
+  end
+
+  def test_date_encode
+    assert_equal("DTSTART:20040101\n", Field.create('DTSTART',  Date.new(2004, 1, 1) ).to_s)
+    assert_equal("DTSTART:20040101\n", Field.create('DTSTART', [Date.new(2004, 1, 1)]).to_s)
+  end
+
+  def test_field_modify
+    f = Field.create('name')
+
+    assert_equal('', f.value)
+    f.value = ''
+    assert_equal('', f.value)
+    f.value = 'z'
+    assert_equal('z', f.value)
+
+    f.group = 'z.b'
+    assert_equal('Z.B', f.group)
+    assert_equal("z.b.NAME:z\n", f.encode)
+
+    assert_raises(TypeError) { f.value = :group }
+
+    assert_equal('Z.B', f.group)
+
+    assert_equal("z.b.NAME:z\n", f.encode)
+
+    assert_raises(TypeError) { f.group = :group }
+
+    assert_equal("z.b.NAME:z\n", f.encode)
+    assert_equal('Z.B', f.group)
+
+    f['p0'] = "hi julie"
+
+    assert_equal("Z.B.NAME;P0=hi julie:z\n", f.encode)
+    assert_equal(['hi julie'], f.param('p0'))
+    assert_equal(['hi julie'], f['p0'])
+    assert_equal('NAME', f.name)
+    assert_equal('Z.B', f.group)
+
+    # FAIL   assert_raises(ArgumentError) { f.group = 'z.b:' }
+
+    assert_equal('Z.B', f.group)
+
+    f.value = 'some text'
+    
+    assert_equal('some text', f.value)
+    assert_equal('some text', f.value_raw)
+
+    f['encoding'] = :b64
+
+    assert_equal('some text', f.value)
+    assert_equal([ 'some text' ].pack('m*').chomp, f.value_raw)
+  end
+
+  def test_field_wrapping
+    assert_equal("0:x\n",             Vpim::DirectoryInfo::Field.create('0', 'x' * 1).encode(4))
+    assert_equal("0:xx\n",            Vpim::DirectoryInfo::Field.create('0', 'x' * 2).encode(4))
+    assert_equal("0:xx\n x\n",        Vpim::DirectoryInfo::Field.create('0', 'x' * 3).encode(4))
+    assert_equal("0:xx\n xx\n",       Vpim::DirectoryInfo::Field.create('0', 'x' * 4).encode(4))
+    assert_equal("0:xx\n xxxx\n",     Vpim::DirectoryInfo::Field.create('0', 'x' * 6).encode(4))
+    assert_equal("0:xx\n xxxx\n x\n", Vpim::DirectoryInfo::Field.create('0', 'x' * 7).encode(4))
+  end
+end
+