tb 0.9 → 1.0

data/test/test_headercsv.rb

@@ -0,0 +1,43 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbHeaderCSV < Test::Unit::TestCase
+  def test_reader
+    csv = <<-'End'.gsub(/^\s*/, '')
+      A,B,C
+      a,b,c
+      d,e,f
+    End
+    reader = Tb::HeaderCSVReader.new(StringIO.new(csv))
+    assert_equal({"A"=>"a", "B"=>"b", "C"=>"c"}, reader.get_hash)
+    assert_equal({"A"=>"d", "B"=>"e", "C"=>"f"}, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+  end
+
+  def test_writer
+    arys = []
+    writer = Tb::HeaderCSVWriter.new(arys)
+    assert_equal([], arys)
+    writer.put_hash({"A"=>"a", "B"=>"b", "C"=>"c"})
+    assert_equal([], arys)
+    writer.put_hash({"A"=>"d", "B"=>"e", "C"=>"f"})
+    assert_equal([], arys)
+    writer.finish
+    assert_equal(["A,B,C\n", "a,b,c\n", "d,e,f\n"], arys)
+  end
+
+  def test_writer_known_header
+    arys = []
+    writer = Tb::HeaderCSVWriter.new(arys)
+    writer.header_generator = lambda { %w[A B C] }
+    assert_equal([], arys)
+    writer.put_hash({"A"=>"a", "B"=>"b", "C"=>"c"})
+    assert_equal(["A,B,C\n", "a,b,c\n"], arys)
+    writer.put_hash({"A"=>"d", "B"=>"e", "C"=>"f"})
+    assert_equal(["A,B,C\n", "a,b,c\n", "d,e,f\n"], arys)
+    writer.finish
+    assert_equal(["A,B,C\n", "a,b,c\n", "d,e,f\n"], arys)
+  end
+
+end

data/test/test_json.rb

@@ -3,13 +3,13 @@ require 'test/unit'
 
 class TestTbJSON < Test::Unit::TestCase
   def test_parse
-    r = Tb::JSONReader.new('[{"a":1, "b":2}, {"a":3, "b":4}]')
+    r = Tb::JSONReader.new(StringIO.new('[{"a":1, "b":2}, {"a":3, "b":4}]'))
     result = []
     r.with_header {|header|
       result << header
     }.each {|obj|
       result << obj
     }
-    assert_equal([nil, {"a"=>1, "b"=>2}, {"a"=>3, "b"=>4}], result)
+    assert_equal([%w[a b], {"a"=>1, "b"=>2}, {"a"=>3, "b"=>4}], result)
   end
 end

data/test/test_ltsv.rb

@@ -2,6 +2,17 @@ require 'tb'
 require 'test/unit'
 
 class TestTbLTSV < Test::Unit::TestCase
+  def parse_ltsv(ltsv)
+    Tb::LTSVReader.new(StringIO.new(ltsv)).to_a
+  end
+
+  def generate_ltsv(ary)
+    writer = Tb::LTSVWriter.new(out = '')
+    ary.each {|h| writer.put_hash h }
+    writer.finish
+    out
+  end
+
   def test_escape_and_unescape
     0x00.upto(0x7f) {|c|
       s = [c].pack("C")
@@ -11,38 +22,32 @@ class TestTbLTSV < Test::Unit::TestCase
   end
 
   def test_parse
-    r = Tb::LTSVReader.new("a:1\tb:2\na:3\tb:4\n")
+    r = Tb::LTSVReader.new(StringIO.new("a:1\tb:2\na:3\tb:4\n"))
     result = []
     r.with_header {|header|
       result << header
     }.each {|obj|
       result << obj
     }
-    assert_equal([nil, {"a"=>"1", "b"=>"2"}, {"a"=>"3", "b"=>"4"}], result)
+    assert_equal([%w[a b], {"a"=>"1", "b"=>"2"}, {"a"=>"3", "b"=>"4"}], result)
   end
 
   def test_parse2
-    ltsv = "a:1\tb:2\n"
-    t = Tb.parse_ltsv(ltsv)
-    records = []
-    t.each_record {|record|
-      records << record.to_h_with_reserved
-    }
+    t = parse_ltsv("a:1\tb:2\n")
     assert_equal(
-      [{"_recordid"=>0, "a"=>"1", "b"=>"2"}],
-      records)
+      [{"a"=>"1", "b"=>"2"}],
+      t)
   end
 
   def test_generate_ltsv
-    tbl = Tb.new %w[a b], %w[foo bar]
-    tbl.generate_ltsv(out="")
-    assert_equal("a:foo\tb:bar\n", out)
+    t = [{'a' => 'foo', 'b' => 'bar'}]
+    assert_equal("a:foo\tb:bar\n", generate_ltsv(t))
   end
 
-  def test_generate_ltsv_with_block
-    tbl = Tb.new %w[a b], %w[foo bar], %w[q w]
-    tbl.generate_ltsv(out="") {|recids| recids.reverse }
-    assert_equal("a:q\tb:w\na:foo\tb:bar\n", out)
+  def test_generate_ltsv2
+    t = [{'a' => 'foo', 'b' => 'bar'},
+         {'a' => 'q', 'b' => 'w'}]
+    assert_equal("a:foo\tb:bar\na:q\tb:w\n", generate_ltsv(t))
   end
 
 end

data/test/test_ndjson.rb

@@ -0,0 +1,62 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbNDJSON < Test::Unit::TestCase
+  def parse_ndjson(ndjson)
+    Tb::NDJSONReader.new(StringIO.new(ndjson)).to_a
+  end
+
+  def generate_ndjson(ary)
+    writer = Tb::NDJSONWriter.new(out = '')
+    ary.each {|h| writer.put_hash h }
+    writer.finish
+    out
+  end
+
+  def test_reader
+    ndjson = <<-'End'
+      {"A":"a","B":"b","C":"c"}
+      {"A":"d","B":"e","C":"f"}
+    End
+    reader = Tb::NDJSONReader.new(StringIO.new(ndjson))
+    assert_equal({"A"=>"a", "B"=>"b", "C"=>"c"}, reader.get_hash)
+    assert_equal({"A"=>"d", "B"=>"e", "C"=>"f"}, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+  end
+
+  def test_reader_header
+    ndjson = <<-'End'
+      {"A":"a"}
+      {"A":"d","B":"e","C":"f"}
+    End
+    reader = Tb::NDJSONReader.new(StringIO.new(ndjson))
+    assert_equal(%w[A B C], reader.get_named_header)
+    assert_equal({"A"=>"a"}, reader.get_hash)
+    assert_equal({"A"=>"d", "B"=>"e", "C"=>"f"}, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+  end
+
+  def test_writer
+    arys = []
+    writer = Tb::NDJSONWriter.new(arys)
+    writer.header_generator = lambda { flunk }
+    assert_equal([], arys)
+    writer.put_hash({"A"=>"a", "B"=>"b", "C"=>"c"})
+    assert_equal(['{"A":"a","B":"b","C":"c"}'+"\n"], arys)
+    writer.put_hash({"A"=>"d", "B"=>"e", "C"=>"f"})
+    assert_equal(['{"A":"a","B":"b","C":"c"}'+"\n", '{"A":"d","B":"e","C":"f"}'+"\n"], arys)
+    writer.finish
+    assert_equal(['{"A":"a","B":"b","C":"c"}'+"\n", '{"A":"d","B":"e","C":"f"}'+"\n"], arys)
+  end
+
+  def test_newline_in_string
+    assert_equal('{"r":"\r","n":"\n"}'+"\n", generate_ndjson([{"r"=>"\r", "n"=>"\n"}]))
+  end
+
+  def test_empty_line
+    assert_equal([{"a"=>"1"}, {"a"=>"2"}], parse_ndjson('{"a":"1"}'+"\n\n" + '{"a":"2"}'+"\n"))
+  end
+
+end

data/test/test_numericcsv.rb

@@ -0,0 +1,36 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbNumericCSV < Test::Unit::TestCase
+  def test_reader
+    csv = <<-'End'.gsub(/^\s*/, '')
+      A,B,C
+      a,b,c
+      d,e,f
+    End
+    reader = Tb::NumericCSVReader.new(StringIO.new(csv))
+    assert_equal({"1"=>"A", "2"=>"B", "3"=>"C"}, reader.get_hash)
+    assert_equal({"1"=>"a", "2"=>"b", "3"=>"c"}, reader.get_hash)
+    assert_equal({"1"=>"d", "2"=>"e", "3"=>"f"}, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+    assert_equal(nil, reader.get_hash)
+  end
+
+  def test_writer
+    arys = []
+    writer = Tb::NumericCSVWriter.new(arys)
+    writer.put_hash({"1"=>"A", "2"=>"B", "3"=>"C"})
+    assert_equal(["A,B,C\n"], arys)
+    writer.put_hash({"1"=>"a", "2"=>"b", "3"=>"c"})
+    assert_equal(["A,B,C\n", "a,b,c\n"], arys)
+    writer.put_hash({"1"=>"d", "2"=>"e", "3"=>"f"})
+    assert_equal(["A,B,C\n", "a,b,c\n", "d,e,f\n"], arys)
+  end
+
+  def test_writer_invalid_field
+    arys = []
+    writer = Tb::NumericCSVWriter.new(arys)
+    assert_raise(ArgumentError) { writer.put_hash({"A"=>"1"}) }
+  end
+
+end

data/test/test_pnm.rb

@@ -5,9 +5,20 @@ require 'tmpdir'
 require 'test/unit'
 
 class TestTbPNM < Test::Unit::TestCase
+  def parse_pnm(pnm)
+    Tb::PNMReader.new(StringIO.new(pnm)).to_a
+  end
+
+  def generate_pnm(ary)
+    writer = Tb::PNMWriter.new(out = '')
+    ary.each {|h| writer.put_hash h }
+    writer.finish
+    out
+  end
+
   def test_parse_pbm_ascii
     pbm = "P1\n2 3\n101101\n"
-    t = Tb.parse_pnm(pbm)
+    t = parse_pnm(pbm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P1"},
@@ -20,13 +31,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>1, "component"=>"V", "value"=>0.0},
         {"type"=>"pixel", "x"=>0, "y"=>2, "component"=>"V", "value"=>1.0},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"V", "value"=>0.0}
-      ], t.map {|rec| rec.to_h })
-    assert_equal("P1\n2 3\n10\n11\n01\n", t.generate_pnm)
+      ], t)
+    assert_equal("P1\n2 3\n10\n11\n01\n", generate_pnm(t))
   end
 
   def test_parse_pbm_binary
     pbm = "P4\n2 3\n\x80\xc0\x40"
-    t = Tb.parse_pnm(pbm)
+    t = parse_pnm(pbm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P4"},
@@ -39,13 +50,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>1, "component"=>"V", "value"=>0.0},
         {"type"=>"pixel", "x"=>0, "y"=>2, "component"=>"V", "value"=>1.0},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"V", "value"=>0.0}
-      ], t.map {|rec| rec.to_h })
-    assert_equal(pbm, t.generate_pnm)
+      ], t)
+    assert_equal(pbm, generate_pnm(t))
   end
 
   def test_parse_pgm_ascii
     pgm = "P2\n2 3\n255\n0 1\n100 101\n254 255\n"
-    t = Tb.parse_pnm(pgm)
+    t = parse_pnm(pgm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P2"},
@@ -58,13 +69,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>1, "component"=>"V", "value"=>101.0/255},
         {"type"=>"pixel", "x"=>0, "y"=>2, "component"=>"V", "value"=>254.0/255},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"V", "value"=>255.0/255}
-      ], t.map {|rec| rec.to_h })
-    assert_equal(pgm, t.generate_pnm)
+      ], t)
+    assert_equal(pgm, generate_pnm(t))
   end
 
   def test_parse_pgm_binary
     pgm = "P5\n2 3\n255\n\x00\x01\x64\x65\xfe\xff"
-    t = Tb.parse_pnm(pgm)
+    t = parse_pnm(pgm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P5"},
@@ -77,13 +88,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>1, "component"=>"V", "value"=>101.0/255},
         {"type"=>"pixel", "x"=>0, "y"=>2, "component"=>"V", "value"=>254.0/255},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"V", "value"=>255.0/255}
-      ], t.map {|rec| rec.to_h })
-    assert_equal(pgm, t.generate_pnm)
+      ], t)
+    assert_equal(pgm, generate_pnm(t))
   end
 
   def test_parse_ppm_ascii
     ppm = "P3\n2 3\n255\n0 1 2 3 4 5\n100 101 102 103 104 105\n250 251 252 253 254 255\n"
-    t = Tb.parse_pnm(ppm)
+    t = parse_pnm(ppm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P3"},
@@ -108,13 +119,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"R", "value"=>253.0/255},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"G", "value"=>254.0/255},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"B", "value"=>255.0/255}
-      ], t.map {|rec| rec.to_h })
-    assert_equal(ppm, t.generate_pnm)
+      ], t)
+    assert_equal(ppm, generate_pnm(t))
   end
 
   def test_parse_ppm_binary
     ppm = "P6\n2 3\n255\n\x00\x01\x02\x03\x04\x05\x64\x65\x66\x67\x68\x69\xfa\xfb\xfc\xfd\xfe\xff"
-    t = Tb.parse_pnm(ppm)
+    t = parse_pnm(ppm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P6"},
@@ -139,13 +150,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"R", "value"=>253.0/255},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"G", "value"=>254.0/255},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"B", "value"=>255.0/255}
-      ], t.map {|rec| rec.to_h })
-    assert_equal(ppm, t.generate_pnm)
+      ], t)
+    assert_equal(ppm, generate_pnm(t))
   end
 
   def test_parse_ppm_binary2
     ppm = "P6\n2 3\n65535\n\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff"
-    t = Tb.parse_pnm(ppm)
+    t = parse_pnm(ppm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P6"},
@@ -170,13 +181,13 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"R", "value"=>253.0/65535},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"G", "value"=>254.0/65535},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"B", "value"=>255.0/65535}
-      ], t.map {|rec| rec.to_h })
-    assert_equal(ppm, t.generate_pnm)
+      ], t)
+    assert_equal(ppm, generate_pnm(t))
   end
 
   def test_parse_pbm_comment
     pbm = "P1\n\#foo\n2 3\n101101\n"
-    t = Tb.parse_pnm(pbm)
+    t = parse_pnm(pbm)
     assert_equal(
       [
         {"type"=>"meta", "component"=>"pnm_type", "value"=>"P1"},
@@ -190,124 +201,112 @@ class TestTbPNM < Test::Unit::TestCase
         {"type"=>"pixel", "x"=>1, "y"=>1, "component"=>"V", "value"=>0.0},
         {"type"=>"pixel", "x"=>0, "y"=>2, "component"=>"V", "value"=>1.0},
         {"type"=>"pixel", "x"=>1, "y"=>2, "component"=>"V", "value"=>0.0}
-      ], t.map {|rec| rec.to_h })
-    assert_equal("P1\n\#foo\n2 3\n10\n11\n01\n", t.generate_pnm)
+      ], t)
+    assert_equal("P1\n\#foo\n2 3\n10\n11\n01\n", generate_pnm(t))
   end
 
   def test_parse_pbm_ascii_wide
     pbm = "P1\n71 3\n" + "0" * (71 * 3)
-    t = Tb.parse_pnm(pbm)
-    assert_equal("P1\n71 3\n" + ("0"*70+"\n0\n")*3, t.generate_pnm)
+    t = parse_pnm(pbm)
+    assert_equal("P1\n71 3\n" + ("0"*70+"\n0\n")*3, generate_pnm(t))
   end
 
   def test_parse_pgm_ascii_wide
     pgm = "P2\n40 3\n255\n" + "0 " * (40*3)
-    t = Tb.parse_pnm(pgm)
-    assert_equal("P2\n40 3\n255\n" + ("0 "*34 + "0\n" + "0 "*4 + "0\n")*3, t.generate_pnm)
+    t = parse_pnm(pgm)
+    assert_equal("P2\n40 3\n255\n" + ("0 "*34 + "0\n" + "0 "*4 + "0\n")*3, generate_pnm(t))
   end
 
   def test_parse_invalid
     invalid = "foo"
-    assert_raise(ArgumentError) { Tb.parse_pnm(invalid) }
+    assert_raise(ArgumentError) { parse_pnm(invalid) }
   end
 
   def test_parse_too_short
     too_short = "P1\n2 3\n10110\n"
-    assert_raise(ArgumentError) { Tb.parse_pnm(too_short) }
+    assert_raise(ArgumentError) { parse_pnm(too_short) }
   end
 
   def test_generate_invalid_fields
-    t = Tb.new %w[foo], [1]
-    assert_raise(ArgumentError) { t.generate_pnm }
+    t = [{ "foo" => 1 }]
+    assert_raise(ArgumentError) { generate_pnm(t) }
   end
 
   def test_generate_inconsistent_color_component
-    t = Tb.new %w[x y component value], [nil, nil, 'V', 1.0], [nil, nil, 'R', 1.0]
-    assert_raise(ArgumentError) { t.generate_pnm }
+    t = [{'component' => 'V', 'value' => 1.0}, {'component' => 'R'}]
+    assert_raise(ArgumentError) { generate_pnm(t) }
   end
 
   def test_generate_complement
-    t = Tb.new %w[x y component value]
-    [
+    t = [
       {"x"=>0, "y"=>0, "component"=>"V", "value"=>0.0},
       {"x"=>1, "y"=>0, "component"=>"V", "value"=>1.0},
       {"x"=>0, "y"=>1, "component"=>"V", "value"=>0.0},
       {"x"=>1, "y"=>1, "component"=>"V", "value"=>0.0},
       {"x"=>0, "y"=>2, "component"=>"V", "value"=>1.0},
       {"x"=>1, "y"=>2, "component"=>"V", "value"=>0.0}
-    ].each {|h| t.insert h }
-    assert_equal("P4\n2 3\n\x80\xc0\x40", t.generate_pnm)
+    ]
+    assert_equal("P4\n2 3\n\x80\xc0\x40", generate_pnm(t))
   end
 
   def test_generate_complement2
-    t = Tb.new %w[x y component value]
-    [
+    t = [
       {"x"=>0, "y"=>0, "component"=>"V", "value"=>1.0/65535},
       {"x"=>1, "y"=>0, "component"=>"V", "value"=>1.0},
       {"x"=>0, "y"=>1, "component"=>"V", "value"=>0.0},
       {"x"=>1, "y"=>1, "component"=>"V", "value"=>0.0},
       {"x"=>0, "y"=>2, "component"=>"V", "value"=>1.0},
       {"x"=>1, "y"=>2, "component"=>"V", "value"=>0.0}
-    ].each {|h| t.insert h }
-    assert_equal("P5\n2 3\n65535\n\x00\x01\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00", t.generate_pnm)
+    ]
+    assert_equal("P5\n2 3\n65535\n\x00\x01\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00", generate_pnm(t))
   end
 
   def test_generate_complement1
-    t = Tb.new %w[x y component value]
-    [
+    t = [
       {"x"=>0, "y"=>0, "component"=>"V", "value"=>1.0/255},
       {"x"=>1, "y"=>0, "component"=>"V", "value"=>1.0},
       {"x"=>0, "y"=>1, "component"=>"V", "value"=>0.0},
       {"x"=>1, "y"=>1, "component"=>"V", "value"=>0.0},
       {"x"=>0, "y"=>2, "component"=>"V", "value"=>1.0},
       {"x"=>1, "y"=>2, "component"=>"V", "value"=>0.0}
-    ].each {|h| t.insert h }
-    assert_equal("P5\n2 3\n255\n\x01\xff\x00\x00\xff\x00", t.generate_pnm)
+    ]
+    assert_equal("P5\n2 3\n255\n\x01\xff\x00\x00\xff\x00", generate_pnm(t))
   end
 
   def test_generate_complement_ppm
-    t = Tb.new %w[x y component value]
-    [
+    t = [
       {"x"=>0, "y"=>0, "component"=>"R", "value"=>0.0},
       {"x"=>0, "y"=>0, "component"=>"G", "value"=>1.0},
       {"x"=>0, "y"=>0, "component"=>"B", "value"=>1.0},
-    ].each {|h| t.insert h }
-    assert_equal("P6\n1 1\n255\n\x00\xff\xff", t.generate_pnm)
+    ]
+    assert_equal("P6\n1 1\n255\n\x00\xff\xff", generate_pnm(t))
   end
 
   def test_generate_overrange
-    t = Tb.new %w[x y component value]
-    [
+    t = [
       {"x"=>0, "y"=>0, "component"=>"V", "value"=>-0.5},
       {"x"=>0, "y"=>1, "component"=>"V", "value"=>1.5},
-    ].each {|h| t.insert h }
-    assert_equal("P5\n1 2\n255\n\x00\xff", t.generate_pnm)
+    ]
+    assert_equal("P5\n1 2\n255\n\x00\xff", generate_pnm(t))
   end
 
   def test_invalid_pnm_type
-    t = Tb.new %w[x y component value], [nil, nil, 'pnm_type', "foo"]
-    assert_raise(ArgumentError) { t.generate_pnm }
+    t = [{'component' => 'pnm_type', 'value' => "foo"}]
+    assert_raise(ArgumentError) { generate_pnm(t) }
   end
 
   def test_invalid_comment
-    t = Tb.new %w[x y component value], [nil, nil, 'comment', "\n"]
-    assert_raise(ArgumentError) { t.generate_pnm }
-  end
-
-  def test_load_pnm
-    Dir.mktmpdir {|d|
-      File.open(fn="#{d}/foo.pbm", "w") {|f| f << "P4\n1 1\n\0" }
-      t = Tb.load_pnm(fn)
-      assert_equal({"type"=>"meta", "component"=>"pnm_type", "value"=>"P4"}, t.get_record(0).to_h)
-    }
+    t = [{'component' => 'comment', 'value' => "\n"}]
+    assert_raise(ArgumentError) { generate_pnm(t) }
   end
 
   def test_pnmreader_to_a
     pbm = "P1\n2 3\n101101\n"
-    r = Tb::PNMReader.new(pbm)
+    r = Tb::PNMReader.new(StringIO.new(pbm))
+    header = r.get_named_header
+    assert_equal(["type", "x", "y", "component", "value"], header)
     assert_equal(
-      [["type", "x", "y", "component", "value"],
-       ["meta", nil, nil, "pnm_type", "P1"],
+      [["meta", nil, nil, "pnm_type", "P1"],
        ["meta", nil, nil, "width", 2],
        ["meta", nil, nil, "height", 3],
        ["meta", nil, nil, "max", 1],
@@ -317,7 +316,7 @@ class TestTbPNM < Test::Unit::TestCase
        ["pixel", 1, 1, "V", 0.0],
        ["pixel", 0, 2, "V", 1.0],
        ["pixel", 1, 2, "V", 0.0]],
-       r.to_a)
+       r.to_a.map {|h| h.values_at(*header) })
   end
 
   def test_reader_open