test/test_misc.rb

   1 # $Id: test_misc.rb 1 2005-03-26 01:45:38Z tilman $
   2
   3 require "eet"
   4 require "test/unit"
   5 require "ftools"
   6
   7 class Foo
   8         def initialize
   9                 @foo = "foo"
  10                 @bar = true
  11                 @baz = 512
  12         end
  13 end
  14
  15 class MiscTest < Test::Unit::TestCase
  16         def setup
  17                 @keys = ["key_foo", "key_bar", "key_baz"].sort
  18                 @dest = __FILE__.sub(/\.rb$/, ".eet")
  19                 @foo_data = Foo.new.to_eet
  20
  21                 assert_not_nil(@foo_data)
  22
  23                 File.rm_f(@dest)
  24
  25                 Eet::File.open(@dest, "w") do |ef|
  26                         @keys.each do |k|
  27                                 assert(ef.write(k, @foo_data) > 0)
  28                         end
  29                 end
  30         end
  31
  32         def test_stream_chunks
  33                 stream = nil
  34
  35                 assert_nothing_raised do
  36                         stream = Eet::Stream.deserialize(@foo_data)
  37                 end
  38
  39                 assert_equal(1, stream.length)
  40                 assert_equal("Foo", stream.first.tag)
  41
  42                 assert_nothing_raised do
  43                         stream = Eet::Stream.deserialize(stream.first.data)
  44                 end
  45
  46                 assert_equal(3, stream.length)
  47                 ["foo", "bar", "baz"].each do |tag|
  48                         found = stream.find { |c| c.tag == tag }
  49                         assert_not_nil(found)
  50                 end
  51         end
  52
  53         def test_create_new
  54                 assert_raise(RuntimeError) do
  55                         Eet::File.open("/foo/bar/baz/xyzzy", "w") { |ef| }
  56                 end
  57         end
  58
  59         def test_catch_invalid_open_mode
  60                 assert_raise(ArgumentError) do
  61                         Eet::File.open(@dest, @keys[0]) { |ef| }
  62                 end
  63         end
  64
  65         def test_zero_write
  66                 assert_raise(IOError) do
  67                         Eet::File.open(@dest, "w") do |ef|
  68                                 ef.write("empty", "")
  69                         end
  70                 end
  71         end
  72
  73         def test_open_existing_ro
  74                 # if mode isn't specified, the file must be opened read-only.
  75                 # assert that we cannot write in read-only mode.
  76                 Eet::File.open(@dest) do |ef|
  77                         assert_raise(IOError) do
  78                                 ef.write("xyzzy", "data")
  79                         end
  80                 end
  81         end
  82
  83         def test_open_existing_w
  84                 # if the file is opened in write-only or read-write mode,
  85                 # we must be able to write to it.
  86                 ["w", "r+"].each do |mode|
  87                         Eet::File.open(@dest, mode) do |ef|
  88                                 assert_equal(4, ef.write("xyzzy", "data"))
  89                         end
  90                 end
  91         end
  92
  93         def test_accessing_closed_file
  94                 ef = Eet::File.open(@dest, "r")
  95                 ef.close
  96
  97                 assert_raise(IOError) do
  98                         ef.read(@keys[0])
  99                 end
 100         end
 101
 102         def test_delete_entry_ro
 103                 assert_raise(IOError) do
 104                         Eet::File.open(@dest, "r") do |ef|
 105                                 ef.delete(@keys[0])
 106                         end
 107                 end
 108         end
 109
 110         def test_delete_nonexisting_entry
 111                 assert_raise(IOError) do
 112                         Eet::File.open(@dest, "w") do |ef|
 113                                 ef.delete("nonexistingkey")
 114                         end
 115                 end
 116         end
 117
 118         def test_read
 119                 Eet::File.open(@dest, "r") do |ef|
 120                         @keys.each do |k|
 121                                 assert_equal(@foo_data, ef.read(k))
 122                         end
 123                 end
 124
 125                 assert_raise(IOError) do
 126                         Eet::File.open(@dest, "w") do |ef|
 127                                 ef.read(@keys[0])
 128                         end
 129                 end
 130         end
 131
 132         def test_list
 133                 ["r", "r+"].each do |mode|
 134                         Eet::File.open(@dest, mode) do |ef|
 135                                 assert_equal(@keys, ef.list.sort)
 136                                 assert_equal(@keys, ef.list("*").sort, @keys)
 137                                 assert_equal([@keys[0]], ef.list(@keys[0]))
 138                         end
 139                 end
 140
 141                 assert_raise(IOError) do
 142                         Eet::File.open(@dest, "w") do |ef|
 143                                 ef.list
 144                         end
 145                 end
 146         end
 147
 148         def test_delete
 149                 assert_nothing_raised do
 150                         Eet::File.open(@dest, "r+") do |ef|
 151                                 ef.delete(@keys[0])
 152                         end
 153                 end
 154
 155                 Eet::File.open(@dest) do |ef|
 156                         tmp = @keys.shift
 157                         assert_equal(@keys, ef.list.sort)
 158                         @keys.unshift(tmp)
 159                 end
 160         end
 161
 162         def test_invalid_key
 163                 Eet::File.open(@dest, "r+") do |ef|
 164                         assert_raise(ArgumentError) do
 165                                 ef.read("key_\0foo")
 166                         end
 167
 168                         assert_raise(ArgumentError) do
 169                                 ef.write("key_\0foo", "data")
 170                         end
 171
 172                         assert_raise(ArgumentError) do
 173                                 ef.delete("key_\0foo")
 174                         end
 175                 end
 176         end
 177 end