rstyx 0.2.0 → 0.3.0

data/tests/tc_message.rb

@@ -1,6 +1,6 @@
  #!/usr/bin/ruby
 #
-# Copyright (C) 2005 Rafael Sevilla
+# Copyright (C) 2005,2006 Rafael Sevilla
 # This file is part of RStyx
 #
 # RStyx is free software; you can redistribute it and/or modify
@@ -15,50 +15,18 @@
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with RStyx; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-# 02111-1307 USA.
+# Foundation, Inc., 51 Franklin St., Fifth Floor, Boston, MA
+# 02110-1301 USA.
 #
 # Unit tests for Styx messages
 #
-# $Id: tc_message.rb,v 1.25 2005/11/01 11:44:06 dido Exp $
+# $Id: tc_message.rb 177 2007-05-31 08:23:25Z dido $
 #
 require 'test/unit'
+require 'rstyx/common'
 require 'rstyx/messages'
 
 class MessageTest < Test::Unit::TestCase
-  ##
-  # Test the utility functions provided
-  #
-  def test_utils
-    # Basic test
-    pstr = RStyx::Message::Util.strpack("foo")
-    assert(pstr == "\003\000foo")
-    # Add trailing garbage to the string
-    pstr += "some trailing garbage"
-    upstr = RStyx::Message::Util.strextract(pstr, 0)
-    assert(upstr[0] == "foo")
-    # Try packing several strings together
-    packstr = RStyx::Message::Util.strpack("foo") +
-      RStyx::Message::Util.strpack("bar") +
-      RStyx::Message::Util.strpack("baz")
-    str, offset = RStyx::Message::Util.strextract(packstr, 0)
-    assert(str == "foo")
-    str, offset = RStyx::Message::Util.strextract(packstr, offset)
-    assert(str == "bar")
-    str, offset = RStyx::Message::Util.strextract(packstr, offset)
-    assert(str == "baz")
-    # Try a long string
-    longstr = "alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mama nancy oscar papa quebec romeo sierra tango uniform victor whiskey x-ray yankee zulu"
-    pstr = RStyx::Message::Util.strpack(longstr)
-    assert(RStyx::Message::Util.strextract(pstr, 0)[0] == longstr)
-
-    # Test decoding of invalid strings
-    invstr ="\003\000fo"
-    assert_raise(RStyx::StyxException) { RStyx::Message::Util.strextract(invstr, 0) }
-    invstr = "\003"
-    assert_raise(RStyx::StyxException) { RStyx::Message::Util.strextract(invstr, 0) }
-  end
-
   ##
   # Test the Qid class
   #
@@ -70,31 +38,40 @@ class MessageTest < Test::Unit::TestCase
     assert(bytes == "\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe")
 
     # Try to deserialize and check whether the output is as expected
-    qqid = RStyx::Message::Qid.decode(bytes)
+    qqid = RStyx::Message::Qid.from_bytes(bytes)
     assert(qqid.qtype == 0x01)
     assert(qqid.version == 0xdeadbeef)
     assert(qqid.path == 0xfeedfacec0ffeeee)
 
     # Test decoding short values
-    assert_raise(RStyx::StyxException) { RStyx::Message::Qid.decode("") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::Qid.decode("     ") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Qid.from_bytes("") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Qid.from_bytes("     ") }
 
     # Test decoding 13 bytes and with trailing garbage
-    assert_nothing_raised { RStyx::Message::Qid.decode("             ") }
-    assert_nothing_raised { qqid = RStyx::Message::Qid.decode("\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfesome trailing garbage") }
+    assert_nothing_raised { RStyx::Message::Qid.from_bytes("             ") }
+    assert_nothing_raised { qqid = RStyx::Message::Qid.from_bytes("\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfesome trailing garbage") }
 
     # test if the decoding still works even in the face of trailing garbage
-    assert(qqid.qtype == 0x01)
-    assert(qqid.version == 0xdeadbeef)
-    assert(qqid.path == 0xfeedfacec0ffeeee)
+    assert_equal(0x01, qqid.qtype)
+    assert(0xdeadbeef, qqid.version)
+    assert(0xfeedfacec0ffeeee, qqid.path)
+
+    # test equality
+    qid = RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee)
+    qid2 = RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeef)
+    assert_not_equal(qid, qid2)
+
+    qid2 = RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee)
+    assert_equal(qid, qid2)
+
   end
 
   ##
-  # Test the DirEntry class
+  # Test the Stat class
   #
-  def test_direntry
-    # generate a dummy DirEntry for testing
-    de = RStyx::Message::DirEntry.new
+  def test_stat
+    # generate a dummy Stat for testing
+    de = RStyx::Message::Stat.new
     de.dtype = 0x1234
     de.dev = 0x567890ab
     de.qid = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
@@ -111,7 +88,7 @@ class MessageTest < Test::Unit::TestCase
     assert(bytes == expect)
 
     # Generate a new direntry based on the above string
-    de2 = RStyx::Message::DirEntry.decode(expect)
+    de2 = RStyx::Message::Stat.from_bytes(expect)
     assert(de2.dtype == 0x1234)
     assert(de2.dev == 0x567890ab)
     assert(de2.qid.qtype == 0x01)
@@ -127,14 +104,14 @@ class MessageTest < Test::Unit::TestCase
     assert(de2.muid == "quux")
 
     # Test decoding truncated strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::DirEntry.decode("") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::DirEntry.decode("\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::DirEntry.decode("\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00qu") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Stat.from_bytes("") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Stat.from_bytes("\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Stat.from_bytes("\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00qu") }
 
     # Test decoding strings with garbage at the end
     # Generate a new direntry based on the above string
     assert_nothing_raised do
-      de2 = RStyx::Message::DirEntry.decode(expect + "trailing garbage")
+      de2 = RStyx::Message::Stat.from_bytes(expect + "trailing garbage")
     end
     assert(de2.dtype == 0x1234)
     assert(de2.dev == 0x567890ab)
@@ -156,28 +133,24 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tversion class
   #
   def test_tversion
-    tv = RStyx::Message::Tversion.new(0xdeadbeef, "9P2000")
-    bytes = tv.to_bytes(0x1234)
+    tv = RStyx::Message::Tversion.new(:msize => 0xdeadbeef, :version => "9P2000", :tag => 0x1234)
+    bytes = tv.to_bytes
     expect = "\x13\x00\x00\x00\x64\x34\x12\xef\xbe\xad\xde\x06\x009P2000"
     assert(expect == bytes)
     # Try to decode the expect string
-    tvm = RStyx::Message::StyxMessage.decode(expect)
+    tvm = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tvm.class == RStyx::Message::Tversion)
-    assert(tvm.length == 0x13)
-    assert(tvm.mtype == RStyx::Message::StyxMessage::TVERSION)
     assert(tvm.tag == 0x1234)
     assert(tvm.msize == 0xdeadbeef)
     assert(tvm.version == "9P2000")
 
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x13\x00\x00\x00\x64\x34\x12\xef\xbe\xad\xde\x06\x009P200") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x13\x00\x00\x00\x64\x34\x12\xef\xbe\xad") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x13\x00\x00\x00\x64\x34\x12\xef\xbe\xad\xde\x06\x009P200") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x13\x00\x00\x00\x64\x34\x12\xef\xbe\xad") }
 
     # Try to decode the expect string with trailing garbage
-    tvm = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+    tvm = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     assert(tvm.class == RStyx::Message::Tversion)
-    assert(tvm.length == 0x13)
-    assert(tvm.mtype == RStyx::Message::StyxMessage::TVERSION)
     assert(tvm.tag == 0x1234)
     assert(tvm.msize == 0xdeadbeef)
     assert(tvm.version == "9P2000")
@@ -188,30 +161,26 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rversion class
   #
   def test_rversion
-    rv = RStyx::Message::Rversion.new(0xdeadbeef, "9P2000")
-    bytes = rv.to_bytes(0x1234)
+    rv = RStyx::Message::Rversion.new(:msize => 0xdeadbeef, :version => "9P2000", :tag => 0x1234)
+    bytes = rv.to_bytes
     expect = "\x13\x00\x00\x00\x65\x34\x12\xef\xbe\xad\xde\x06\x009P2000"
     assert(expect == bytes)
     # Try to decode the expect string
-    rvm = RStyx::Message::StyxMessage.decode(expect)
+    rvm = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rvm.class == RStyx::Message::Rversion)
-    assert(rvm.length == 0x13)
-    assert(rvm.mtype == RStyx::Message::StyxMessage::RVERSION)
     assert(rvm.tag == 0x1234)
     assert(rvm.msize == 0xdeadbeef)
     assert(rvm.version == "9P2000")
 
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x13\x00\x00\x00\x65\x34\x12\xef\xbe\xad\xde\x06\x009P200") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x13\x00\x00\x00\x65\x34\x12\xef\xbe") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x13\x00\x00\x00\x65\x34\x12\xef\xbe\xad\xde\x06\x009P200") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x13\x00\x00\x00\x65\x34\x12\xef\xbe") }
 
     # Try to decode with trailing garbage
     assert_nothing_raised do
-      rvm = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rvm = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rvm.class == RStyx::Message::Rversion)
-    assert(rvm.length == 0x13)
-    assert(rvm.mtype == RStyx::Message::StyxMessage::RVERSION)
     assert(rvm.tag == 0x1234)
     assert(rvm.msize == 0xdeadbeef)
     assert(rvm.version == "9P2000")
@@ -221,33 +190,30 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tauth class.
   #
   def test_tauth
-    ta = RStyx::Message::Tauth.new("foo", 0x9abcdef0, "bar")
-    bytes = ta.to_bytes(0x1234)
+    ta = RStyx::Message::Tauth.new(:uname => "foo", :afid => 0x9abcdef0, :aname => "bar", :tag => 0x1234)
+    bytes = ta.to_bytes
     expect = "\x66\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00bar"
     len = expect.length + 4
     expect = [len].pack("V") + expect
     assert(bytes == expect)
-    ta2 = RStyx::Message::StyxMessage.decode(expect)
+    ta2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(ta2.class == RStyx::Message::Tauth)
-    assert(ta2.length == len)
-    assert(ta2.mtype == RStyx::Message::StyxMessage::TAUTH)
     assert(ta2.tag == 0x1234)
     assert(ta2.afid == 0x9abcdef0)
     assert(ta2.uname == "foo")
     assert(ta2.aname == "bar")
 
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x66\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00b") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x66\x34\x12\xf0\xde\xbc") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x66\x34") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Tauth.from_bytes("1234567890") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x66\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00b") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x66\x34\x12\xf0\xde\xbc") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x66\x34") }
 
     # decode with trailing garbage
     assert_nothing_raised do
-      ta2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      ta2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(ta2.class == RStyx::Message::Tauth)
-    assert(ta2.length == len)
-    assert(ta2.mtype == RStyx::Message::StyxMessage::TAUTH)
     assert(ta2.tag == 0x1234)
     assert(ta2.afid == 0x9abcdef0)
     assert(ta2.uname == "foo")
@@ -258,30 +224,26 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rauth class.
   #
   def test_rauth
-    ra = RStyx::Message::Rauth.new(RStyx::Message::Qid.new(0x01, 0xdeadbeef, 0xfeedfacec0ffeeee))
-    bytes = ra.to_bytes(0x1234)
+    ra = RStyx::Message::Rauth.new(:aqid => RStyx::Message::Qid.new(0x01, 0xdeadbeef, 0xfeedfacec0ffeeee), :tag => 0x1234)
+    bytes = ra.to_bytes
     expect = "\x67\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe"
     len = expect.length + 4
     expect = [len].pack("V") + expect
     assert(expect == bytes)
-    ra2 = RStyx::Message::StyxMessage.decode(expect)
+    ra2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(ra2.class == RStyx::Message::Rauth)
-    assert(ra2.length == len)
-    assert(ra2.mtype == RStyx::Message::StyxMessage::RAUTH)
     assert(ra2.tag == 0x1234)
     assert(ra2.aqid.qtype == 0x01)
     assert(ra2.aqid.version == 0xdeadbeef)
     assert(ra2.aqid.path == 0xfeedfacec0ffeeee)
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x67\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x67\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
 
     # Decode with trailing garbage
     assert_nothing_raised do
-      ra2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      ra2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(ra2.class == RStyx::Message::Rauth)
-    assert(ra2.length == len)
-    assert(ra2.mtype == RStyx::Message::StyxMessage::RAUTH)
     assert(ra2.tag == 0x1234)
     assert(ra2.aqid.qtype == 0x01)
     assert(ra2.aqid.version == 0xdeadbeef)
@@ -292,45 +254,39 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rerror class
   #
   def test_rerror
-    rerr = RStyx::Message::Rerror.new("error")
-    bytes = rerr.to_bytes(0x1234)
+    rerr = RStyx::Message::Rerror.new(:ename => "error", :tag => 0x1234)
+    bytes = rerr.to_bytes
     expect = "\x0e\x00\x00\x00\x6b\x34\x12\x05\x00error"
     assert(bytes == expect)
 
     # Try to decode the expect string
-    emsg = RStyx::Message::StyxMessage.decode(expect)
+    emsg = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(emsg.class == RStyx::Message::Rerror)
-    assert(emsg.length == 0x0e)
-    assert(emsg.mtype == RStyx::Message::StyxMessage::RERROR)
     assert(emsg.tag == 0x1234)
     assert(emsg.ename == "error")
-    assert(emsg.messagebody == "\x05\x00error")
 
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x0e\x00\x00") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x0e\x00\x00\x00\x6b\x34\x12\x05\x00erro") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x0e\x00\x00\x00\x6b\x34\x12\x05\x00erro") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode("\x0e\x00\x00\x00\x6b\x34\x12") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x0e\x00\x00") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x0e\x00\x00\x00\x6b\x34\x12\x05\x00erro") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x0e\x00\x00\x00\x6b\x34\x12\x05\x00erro") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes("\x0e\x00\x00\x00\x6b\x34\x12") }
 
     # Try to decode strings with trailing garbage
     assert_nothing_raised do
-      emsg = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      emsg = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(emsg.class == RStyx::Message::Rerror)
-    assert(emsg.length == 0x0e)
-    assert(emsg.mtype == RStyx::Message::StyxMessage::RERROR)
     assert(emsg.tag == 0x1234)
     assert(emsg.ename == "error")
-    assert(emsg.messagebody == "\x05\x00error")
   end
 
   ##
   # Test the Tflush class.
   #
   def test_tflush
-    tf = RStyx::Message::Tflush.new(0x5678)
-    bytes = tf.to_bytes(0x1234)
+    tf = RStyx::Message::Tflush.new(:oldtag => 0x5678, :tag => 0x1234)
+    bytes = tf.to_bytes
     expect = "\x6c\x34\x12\x78\x56"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -338,25 +294,21 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    tf2 = RStyx::Message::StyxMessage.decode(expect)
+    tf2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tf2.class == RStyx::Message::Tflush)
-    assert(tf2.length == len)
-    assert(tf2.mtype == RStyx::Message::StyxMessage::TFLUSH)
     assert(tf2.tag == 0x1234)
     assert(tf2.oldtag == 0x5678)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6c\x34\x12\x78") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6c\x34\x12") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6c\x34\x12\x78") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6c\x34\x12") }
 
     # decode with trailing garbage
     tf2 = nil
     assert_nothing_raised do
-      tf2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tf2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tf2.class == RStyx::Message::Tflush)
-    assert(tf2.length == len)
-    assert(tf2.mtype == RStyx::Message::StyxMessage::TFLUSH)
     assert(tf2.tag == 0x1234)
     assert(tf2.oldtag == 0x5678)
   end
@@ -365,8 +317,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rflush class.
   #
   def test_rflush
-    tf = RStyx::Message::Rflush.new
-    bytes = tf.to_bytes(0x1234)
+    tf = RStyx::Message::Rflush.new(:tag => 0x1234)
+    bytes = tf.to_bytes
     expect = "\x6d\x34\x12"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -374,23 +326,19 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    rf2 = RStyx::Message::StyxMessage.decode(expect)
+    rf2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rf2.class == RStyx::Message::Rflush)
-    assert(rf2.length == len)
-    assert(rf2.mtype == RStyx::Message::StyxMessage::RFLUSH)
     assert(rf2.tag == 0x1234)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6d\x34") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6d\x34") }
 
     # decode with trailing garbage
     rf2 = nil
     assert_nothing_raised do
-      rf2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rf2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rf2.class == RStyx::Message::Rflush)
-    assert(rf2.length == len)
-    assert(rf2.mtype == RStyx::Message::StyxMessage::RFLUSH)
     assert(rf2.tag == 0x1234)
 
   end
@@ -399,8 +347,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tattach class.
   #
   def test_tattach
-    ta = RStyx::Message::Tattach.new(0x12345678, "foo", 0x9abcdef0, "bar")
-    bytes = ta.to_bytes(0x1234)
+    ta = RStyx::Message::Tattach.new(:fid=> 0x12345678, :uname => "foo", :afid => 0x9abcdef0, :aname => "bar", :tag => 0x1234)
+    bytes = ta.to_bytes
     expect = "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00bar"
     len = expect.length + 4
     packlen = [len].pack("V") 
@@ -408,10 +356,8 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # Decode expect string
-    ta2 = RStyx::Message::StyxMessage.decode(expect)
+    ta2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(ta2.class == RStyx::Message::Tattach)
-    assert(ta2.length == len)
-    assert(ta2.mtype == RStyx::Message::StyxMessage::TATTACH)
     assert(ta2.tag == 0x1234)
     assert(ta2.fid == 0x12345678)
     assert(ta2.afid == 0x9abcdef0)
@@ -419,18 +365,16 @@ class MessageTest < Test::Unit::TestCase
     assert(ta2.aname == "bar")
 
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00ba") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x03\x00fo") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00ba") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x03\x00fo") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x68\x34\x12\x78\x56\x34\x12\xf0") }
 
     # Decode expect string with trailing garbage
     assert_nothing_raised do
-      ta2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      ta2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(ta2.class == RStyx::Message::Tattach)
-    assert(ta2.length == len)
-    assert(ta2.mtype == RStyx::Message::StyxMessage::TATTACH)
     assert(ta2.tag == 0x1234)
     assert(ta2.fid == 0x12345678)
     assert(ta2.afid == 0x9abcdef0)
@@ -442,32 +386,29 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rattach class.
   #
   def test_rattach
-    ra = RStyx::Message::Rattach.new(RStyx::Message::Qid.new(0x01, 0xdeadbeef, 0xfeedfacec0ffeeee))
-    bytes = ra.to_bytes(0x1234)
+    ra = RStyx::Message::Rattach.new(:qid => RStyx::Message::Qid.new(0x01, 0xdeadbeef, 0xfeedfacec0ffeeee), :tag => 0x1234)
+    bytes = ra.to_bytes
     expect = "\x69\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe"
     len = expect.length + 4
     packlen = [len].pack("V") 
     expect = packlen + expect
     assert(expect == bytes)
-    ra2 = RStyx::Message::StyxMessage.decode(expect)
+
+    ra2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(ra2.class == RStyx::Message::Rattach)
-    assert(ra2.length == len)
-    assert(ra2.mtype == RStyx::Message::StyxMessage::RATTACH)
     assert(ra2.tag == 0x1234)
     assert(ra2.qid.qtype == 0x01)
     assert(ra2.qid.version == 0xdeadbeef)
     assert(ra2.qid.path == 0xfeedfacec0ffeeee)
 
     # Try to decode short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x69\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x69\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
 
     # Decode with trailing garbage
     assert_nothing_raised do
-      ra2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      ra2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(ra2.class == RStyx::Message::Rattach)
-    assert(ra2.length == len)
-    assert(ra2.mtype == RStyx::Message::StyxMessage::RATTACH)
     assert(ra2.tag == 0x1234)
     assert(ra2.qid.qtype == 0x01)
     assert(ra2.qid.version == 0xdeadbeef)
@@ -478,48 +419,34 @@ class MessageTest < Test::Unit::TestCase
   # Test the Twalk class.
   #
   def test_twalk
-    tw = RStyx::Message::Twalk.new(0x12345678, 0x9abcdef0,
-                                   "foo/bar/baz/quux/blargle")
-    bytes = tw.to_bytes(0x1234)
-    expect = "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x05\x00\03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux\x07\x00blargle"
+    tw = RStyx::Message::Twalk.new(:fid => 0x12345678, :newfid => 0x9abcdef0,
+                                   :wnames => ["foo", "bar", "baz",
+                                               "quux", "blargle"],
+                                   :tag => 0x1234)
+    bytes = tw.to_bytes
+    expect = "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x05\x00\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux\x07\x00blargle"
     len = expect.length + 4
     packlen = [len].pack("V") 
     expect = packlen + expect
     assert(expect == bytes)
-    tw2 = RStyx::Message::StyxMessage.decode(expect)
+    tw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tw2.class == RStyx::Message::Twalk)
-    assert(tw2.length == len)
-    assert(tw2.mtype == RStyx::Message::StyxMessage::TWALK)
     assert(tw2.tag == 0x1234)
     assert(tw2.fid == 0x12345678)
     assert(tw2.newfid == 0x9abcdef0)
     assert(tw2.path = "foo/bar/baz/quux/blargle")
 
-    # Test a long path
-    assert_raise(RStyx::StyxException) do
-      RStyx::Message::Twalk.new(0x12345678, 0x9abcdef0,
-                                "1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17")
-    end
-
-    # Test a path not quite so long
-    assert_nothing_raised(RStyx::StyxException) do
-      RStyx::Message::Twalk.new(0x12345678, 0x9abcdef0,
-                                "1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16")
-    end
-
     # Test short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x05\x00\03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x05\x00\03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0\xde") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6e\x34\x12\x78\x56\x34\x12\xf0") }
 
     # trailing garbage test
     assert_nothing_raised do
-      tw2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tw2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tw2.class == RStyx::Message::Twalk)
-    assert(tw2.length == len)
-    assert(tw2.mtype == RStyx::Message::StyxMessage::TWALK)
     assert(tw2.tag == 0x1234)
     assert(tw2.fid == 0x12345678)
     assert(tw2.newfid == 0x9abcdef0)
@@ -535,17 +462,16 @@ class MessageTest < Test::Unit::TestCase
       RStyx::Message::Qid.new(0x02,0x12345678,0xfedcba9876543210),
       RStyx::Message::Qid.new(0x03,0x87654321,0x0123456789abcdef)
     ]
-    rw = RStyx::Message::Rwalk.new(qidlist)
-    bytes = rw.to_bytes(0x1234)
+    rw = RStyx::Message::Rwalk.new(:qids => qidlist, :tag => 0x1234)
+    bytes = rw.to_bytes
     expect = "\x6f\x34\x12\x03\x00\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x02\x78\x56\x34\x12\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x21\x43\x65\x87\xef\xcd\xab\x89\x67\x45\x23\x01"
     len = expect.length + 4
     packlen = [len].pack("V") 
     expect = packlen + expect
     assert(expect == bytes)
-    rw2 = RStyx::Message::StyxMessage.decode(expect)
+
+    rw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rw2.class == RStyx::Message::Rwalk)
-    assert(rw2.length == len)
-    assert(rw2.mtype == RStyx::Message::StyxMessage::RWALK)
     assert(rw2.tag == 0x1234)
     assert(rw2.qids.length == 3)
     qid = rw2.qids[0]
@@ -562,17 +488,15 @@ class MessageTest < Test::Unit::TestCase
     assert(qid.path == 0x0123456789abcdef)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6f\x34\x12\x03\x00\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x02\x78\x56\x34\x12\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x21\x43\x65\x87") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6f\x34\x12\x03\x00") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x6f\x34\x12\x03") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6f\x34\x12\x03\x00\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x02\x78\x56\x34\x12\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x21\x43\x65\x87") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6f\x34\x12\x03\x00") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x6f\x34\x12\x03") }
 
     # Trailing garbage
     assert_nothing_raised do
-      rw2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rw2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rw2.class == RStyx::Message::Rwalk)
-    assert(rw2.length == len)
-    assert(rw2.mtype == RStyx::Message::StyxMessage::RWALK)
     assert(rw2.tag == 0x1234)
     assert(rw2.qids.length == 3)
     qid = rw2.qids[0]
@@ -593,63 +517,31 @@ class MessageTest < Test::Unit::TestCase
   # Test the Topen class.
   #
   def test_topen
-    # make sure OTRUNC can only be used with mode OWRITE or ORDWR
-    assert_raise(RStyx::StyxException) do
-      to = RStyx::Message::Topen.new(0x12345678,
-                                     RStyx::Message::Topen::OREAD |
-                                       RStyx::Message::Topen::OTRUNC)
-    end
-
-    assert_raise(RStyx::StyxException) do
-      to = RStyx::Message::Topen.new(0x12345678,
-                                     RStyx::Message::Topen::OEXEC |
-                                       RStyx::Message::Topen::OTRUNC)
-    end
-
-    assert_raise(RStyx::StyxException) do
-      to = RStyx::Message::Topen.new(0x12345678, 4)
-    end
-
-    assert_raise(RStyx::StyxException) do
-      to = RStyx::Message::Topen.new(0x12345678, 0xff)
-    end
-
-    to = RStyx::Message::Topen.new(0x12345678,
-                                   RStyx::Message::Topen::OWRITE |
-                                     RStyx::Message::Topen::OTRUNC |
-                                     RStyx::Message::Topen::ORCLOSE)
-    bytes = to.to_bytes(0x1234)
+    to = RStyx::Message::Topen.new(:fid => 0x12345678,
+                                   :mode => RStyx::OWRITE | RStyx::OTRUNC | RStyx::ORCLOSE,
+                                   :tag => 0x1234)
+    bytes = to.to_bytes
     expect = "\x70\x34\x12\x78\x56\x34\x12\x51"
     len = expect.length + 4
     packlen = [len].pack("V")
     expect = packlen + expect
     assert(expect == bytes)
 
-    to2 = RStyx::Message::StyxMessage.decode(expect)
+    to2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(to2.class == RStyx::Message::Topen)
-    assert(to2.length == len)
-    assert(to2.mtype == RStyx::Message::StyxMessage::TOPEN)
     assert(to2.tag == 0x1234)
     assert(to2.mode == 0x51)
     assert(to2.fid == 0x12345678)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x70\x34\x12\x78\x56\x34\x12") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x70\x34\x12\x78\x56") }
-
-    # Try decoding invalid values
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x70\x34\x12\x78\x56\x34\x12\x50") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x70\x34\x12\x78\x56\x34\x12\x53") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x70\x34\x12\x78\x56\x34\x12\xff") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x70\x34\x12\x78\x56\x34\x12\x04") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x70\x34\x12\x78\x56\x34\x12") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x70\x34\x12\x78\x56") }
 
     # Try decoding with trailing garbage
     assert_nothing_raised do
-      to2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      to2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(to2.class == RStyx::Message::Topen)
-    assert(to2.length == len)
-    assert(to2.mtype == RStyx::Message::StyxMessage::TOPEN)
     assert(to2.tag == 0x1234)
     assert(to2.mode == 0x51)
     assert(to2.fid == 0x12345678)
@@ -659,8 +551,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Ropen class.
   #
   def test_ropen
-    ro = RStyx::Message::Ropen.new(RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee), 0xfedcba98)
-    bytes = ro.to_bytes(0x1234)
+    ro = RStyx::Message::Ropen.new(:qid => RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee), :iounit => 0xfedcba98, :tag => 0x1234)
+    bytes = ro.to_bytes
     expect = "\x71\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x98\xba\xdc\xfe"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -668,10 +560,8 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # Decode expect
-    ro2 = RStyx::Message::StyxMessage.decode(expect)
+    ro2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(ro2.class == RStyx::Message::Ropen)
-    assert(ro2.length == len)
-    assert(ro2.mtype == RStyx::Message::StyxMessage::ROPEN)
     assert(ro2.tag == 0x1234)
     assert(ro2.qid.qtype == 0x01)
     assert(ro2.qid.version == 0xdeadbeef)
@@ -679,16 +569,14 @@ class MessageTest < Test::Unit::TestCase
     assert(ro2.iounit == 0xfedcba98)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x71\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x98\xba") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x71\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x71\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x98\xba") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x71\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
 
     # Decode with trailing garbage
     assert_nothing_raised do
-      ro2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      ro2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(ro2.class == RStyx::Message::Ropen)
-    assert(ro2.length == len)
-    assert(ro2.mtype == RStyx::Message::StyxMessage::ROPEN)
     assert(ro2.tag == 0x1234)
     assert(ro2.qid.qtype == 0x01)
     assert(ro2.qid.version == 0xdeadbeef)
@@ -700,12 +588,12 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tcreate class
   #
   def test_tcreate
-    tc = RStyx::Message::Tcreate.new(0x12345678, "foo",
-                                     RStyx::Message::Topen::OWRITE |
-                                       RStyx::Message::Topen::OTRUNC |
-                                       RStyx::Message::Topen::ORCLOSE,
-                                     0xfedcba98)
-    bytes = tc.to_bytes(0x1234)
+    tc = RStyx::Message::Tcreate.new(:fid => 0x12345678, :name => "foo",
+                                     :mode => RStyx::OWRITE | RStyx::OTRUNC |
+                                     RStyx::ORCLOSE,
+                                     :perm => 0xfedcba98,
+                                     :tag => 0x1234)
+    bytes = tc.to_bytes
     expect = "\x72\x34\x12\x78\x56\x34\x12\x03\x00foo\x98\xba\xdc\xfe\x51"
     len = expect.length + 4
     packlen = [len].pack("V") 
@@ -713,10 +601,8 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # Decode expect
-    tc2 = RStyx::Message::StyxMessage.decode(expect)
+    tc2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tc2.class == RStyx::Message::Tcreate)
-    assert(tc2.length == len)
-    assert(tc2.mtype == RStyx::Message::StyxMessage::TCREATE)
     assert(tc2.tag == 0x1234)
     assert(tc2.fid == 0x12345678)
     assert(tc2.name == "foo")
@@ -724,18 +610,16 @@ class MessageTest < Test::Unit::TestCase
     assert(tc2.mode == 0x51)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x72\x34\x12\x78\x56\x34\x12\x03\x00foo\x98\xba\xdc\xfe") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x72\x34\x12\x78\x56\x34\x12\x03\x00foo\x98\xba") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x72\x34\x12\x78\x56\x34\x12\x03\x00f") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x72\x34\x12\x78\x56\x34") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x72\x34\x12\x78\x56\x34\x12\x03\x00foo\x98\xba\xdc\xfe") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x72\x34\x12\x78\x56\x34\x12\x03\x00foo\x98\xba") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x72\x34\x12\x78\x56\x34\x12\x03\x00f") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x72\x34\x12\x78\x56\x34") }
     # Decode with trailing garbage
     tc2 = nil
     assert_nothing_raised do
-      tc2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tc2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tc2.class == RStyx::Message::Tcreate)
-    assert(tc2.length == len)
-    assert(tc2.mtype == RStyx::Message::StyxMessage::TCREATE)
     assert(tc2.tag == 0x1234)
     assert(tc2.fid == 0x12345678)
     assert(tc2.name == "foo")
@@ -747,8 +631,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rcreate class.
   #
   def test_rcreate
-    rc = RStyx::Message::Rcreate.new(RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee), 0xfedcba98)
-    bytes = rc.to_bytes(0x1234)
+    rc = RStyx::Message::Rcreate.new(:qid => RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee), :iounit => 0xfedcba98, :tag => 0x1234)
+    bytes = rc.to_bytes
     expect = "\x73\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x98\xba\xdc\xfe"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -756,10 +640,8 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # Decode expect
-    rc2 = RStyx::Message::StyxMessage.decode(expect)
+    rc2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rc2.class == RStyx::Message::Rcreate)
-    assert(rc2.length == len)
-    assert(rc2.mtype == RStyx::Message::StyxMessage::RCREATE)
     assert(rc2.tag == 0x1234)
     assert(rc2.qid.qtype == 0x01)
     assert(rc2.qid.version == 0xdeadbeef)
@@ -767,17 +649,15 @@ class MessageTest < Test::Unit::TestCase
     assert(rc2.iounit == 0xfedcba98)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x73\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x98\xba") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x73\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x73\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\x98\xba") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x73\x34\x12\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
 
     # Decode with trailing garbage
     rc2 = nil
     assert_nothing_raised do
-      rc2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rc2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rc2.class == RStyx::Message::Rcreate)
-    assert(rc2.length == len)
-    assert(rc2.mtype == RStyx::Message::StyxMessage::RCREATE)
     assert(rc2.tag == 0x1234)
     assert(rc2.qid.qtype == 0x01)
     assert(rc2.qid.version == 0xdeadbeef)
@@ -789,8 +669,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tread class.
   #
   def test_tread
-    tr = RStyx::Message::Tread.new(0xdeadbeef, 0xfeedfacec0ffeeee, 0xcafebabe)
-    bytes = tr.to_bytes(0x1234)
+    tr = RStyx::Message::Tread.new(:fid => 0xdeadbeef, :offset => 0xfeedfacec0ffeeee, :count => 0xcafebabe, :tag => 0x1234)
+    bytes = tr.to_bytes
     expect = "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xbe\xba\xfe\xca"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -798,31 +678,27 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # Decode expect
-    tr2 = RStyx::Message::StyxMessage.decode(expect)
+    tr2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tr2.class == RStyx::Message::Tread)
-    assert(tr2.length == len)
-    assert(tr2.mtype == RStyx::Message::StyxMessage::TREAD)
     assert(tr2.tag == 0x1234)
     assert(tr2.fid == 0xdeadbeef)
     assert(tr2.offset == 0xfeedfacec0ffeeee)
     assert(tr2.count == 0xcafebabe)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xbe\xba\xfe") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x74\x34\x12\xef\xbe\xad") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xbe\xba\xfe") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee\xee\xff\xc0\xce") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x74\x34\x12\xef\xbe\xad\xde\xee") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x74\x34\x12\xef\xbe\xad") }
 
     # Decode with trailing garbage
     tr2 = nil
     assert_nothing_raised do
-      tr2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tr2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tr2.class == RStyx::Message::Tread)
-    assert(tr2.length == len)
-    assert(tr2.mtype == RStyx::Message::StyxMessage::TREAD)
     assert(tr2.tag == 0x1234)
     assert(tr2.fid == 0xdeadbeef)
     assert(tr2.offset == 0xfeedfacec0ffeeee)
@@ -833,9 +709,9 @@ class MessageTest < Test::Unit::TestCase
   # test cases for Rread class
   #
   def test_rread
-    data = "alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mama nancy oscar papa quebec romeo sierra tango uniform victor whiskey xray yankee zulu"
-    rr = RStyx::Message::Rread.new(data)
-    bytes = rr.to_bytes(0x1234)
+    data = "alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mama nancy oscar papa quebec romeo sierra tango uniform victor whiskey xray yankee \xff\xfe\xfd\xfc"
+    rr = RStyx::Message::Rread.new(:data => data, :tag => 0x1234)
+    bytes = rr.to_bytes
     expect = "\x75\x34\x12\xa0\x00\x00\x00" + data
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -843,28 +719,24 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # Decode expect
-    rr2 = RStyx::Message::StyxMessage.decode(expect)
+    rr2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rr2.class == RStyx::Message::Rread)
-    assert(rr2.length == len)
-    assert(rr2.mtype == RStyx::Message::StyxMessage::RREAD)
     assert(rr2.tag == 0x1234)
     assert(rr2.count == data.length)
     assert(rr2.data == data)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x75\x34\x12\xa0\x00\x00") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(expect.chop) }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x75\x34\x12\xa0\x00\x00") }
     # Try decoding empty
-    assert_nothing_raised { RStyx::Message::StyxMessage.decode("\x0b\x00\x00\x00\x75\x34\x12\x00\x00\x00\x00") }
+    assert_nothing_raised { RStyx::Message::StyxMessage.from_bytes("\x0b\x00\x00\x00\x75\x34\x12\x00\x00\x00\x00") }
 
     # Decode with trailing garbage
     rr2 = nil
     assert_nothing_raised do
-      rr2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rr2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rr2.class == RStyx::Message::Rread)
-    assert(rr2.length == len)
-    assert(rr2.mtype == RStyx::Message::StyxMessage::RREAD)
     assert(rr2.tag == 0x1234)
     assert(rr2.count == data.length)
     assert(rr2.data == data)
@@ -875,49 +747,45 @@ class MessageTest < Test::Unit::TestCase
   #
   def test_twrite
     data = "alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mama nancy oscar papa quebec romeo sierra tango uniform victor whiskey xray yankee zulu"
-    tw = RStyx::Message::Twrite.new(0x12345678, 0xfeedfacec0ffeeee, data)
-    bytes = tw.to_bytes(0x1234)
+    tw = RStyx::Message::Twrite.new(:fid => 0x12345678, :offset => 0xfeedfacec0ffeeee, :data => data, :tag => 0x1234)
     expect = "\x76\x34\x12\x78\x56\x34\x12\xee\xee\xff\xc0\xce\xfa\xed\xfe\xa0\x00\x00\x00" + data
     len = expect.length + 4
     packlen = [len].pack("V")
     expect = packlen + expect
+    bytes = tw.to_bytes
     assert(expect == bytes)
 
     # Decode expect
-    tw2 = RStyx::Message::StyxMessage.decode(expect)
+    tw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tw2.class == RStyx::Message::Twrite)
-    assert(tw2.length == len)
-    assert(tw2.mtype == RStyx::Message::StyxMessage::TWRITE)
     assert(tw2.tag == 0x1234)
     assert(tw2.fid == 0x12345678)
     assert(tw2.offset == 0xfeedfacec0ffeeee)
-    assert(tw2.count == data.length)
     assert(tw2.data == data)
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(expect.chop) }
 
     # Try decoding empty
-    assert_nothing_raised { RStyx::Message::StyxMessage.decode("\x17\x00\x00\x00\x75\x34\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::Twrite.from_bytes("1234567890123456789012") }
+
+    assert_nothing_raised { RStyx::Message::StyxMessage.from_bytes("\x17\x00\x00\x00\x75\x34\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") }
     # Decode with trailing garbage
     tw2 = nil
     assert_nothing_raised do
-      tw2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tw2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tw2.class == RStyx::Message::Twrite)
-    assert(tw2.length == len)
-    assert(tw2.mtype == RStyx::Message::StyxMessage::TWRITE)
     assert(tw2.tag == 0x1234)
     assert(tw2.fid == 0x12345678)
     assert(tw2.offset == 0xfeedfacec0ffeeee)
-    assert(tw2.count == data.length)
     assert(tw2.data == data)
   end
 
   ##
   # Tests for Rwrite class
   def test_rwrite
-    rw = RStyx::Message::Rwrite.new(0x12345678)
-    bytes = rw.to_bytes(0x1234)
+    rw = RStyx::Message::Rwrite.new(:count => 0x12345678, :tag => 0x1234)
+    bytes = rw.to_bytes
     expect = "\x77\x34\x12\x78\x56\x34\x12"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -925,23 +793,19 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    rw2 = RStyx::Message::StyxMessage.decode(expect)
+    rw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rw2.class == RStyx::Message::Rwrite)
-    assert(rw2.length == len)
-    assert(rw2.mtype == RStyx::Message::StyxMessage::RWRITE)
     assert(rw2.tag == 0x1234)
     assert(rw2.count == 0x12345678)
 
     # Try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(expect.chop) }
     # Decode with trailing garbage
     rw2 = nil
     assert_nothing_raised do
-      rw2 = RStyx::Message::StyxMessage.decode(expect)
+      rw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     end
     assert(rw2.class == RStyx::Message::Rwrite)
-    assert(rw2.length == len)
-    assert(rw2.mtype == RStyx::Message::StyxMessage::RWRITE)
     assert(rw2.tag == 0x1234)
     assert(rw2.count == 0x12345678)
   end
@@ -950,34 +814,29 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tclunk class.
   #
   def test_tclunk
-    tc = RStyx::Message::Tclunk.new(0xdeadbeef)
-    bytes = tc.to_bytes(0x1234)
+    tc = RStyx::Message::Tclunk.new(:fid => 0xdeadbeef, :tag => 0x1234)
     expect = "\x78\x34\x12\xef\xbe\xad\xde"
     len = expect.length + 4
     packlen = [len].pack("V")
     expect = packlen + expect
-    assert(expect == bytes)
+    assert(expect == tc.to_bytes)
 
     # decode expect
-    tc2 = RStyx::Message::StyxMessage.decode(expect)
+    tc2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tc2.class == RStyx::Message::Tclunk)
-    assert(tc2.length == len)
-    assert(tc2.mtype == RStyx::Message::StyxMessage::TCLUNK)
     assert(tc2.tag == 0x1234)
     assert(tc2.fid == 0xdeadbeef)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x78\x34\x12\xef\xbe\xad") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x78\x34\x12") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x78\x34\x12\xef\xbe\xad") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x78\x34\x12") }
 
     # decode with trailing garbage
     tc2 = nil
     assert_nothing_raised do
-      tc2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tc2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tc2.class == RStyx::Message::Tclunk)
-    assert(tc2.length == len)
-    assert(tc2.mtype == RStyx::Message::StyxMessage::TCLUNK)
     assert(tc2.tag == 0x1234)
     assert(tc2.fid == 0xdeadbeef)
   end
@@ -986,8 +845,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rclunk class.
   #
   def test_rclunk
-    rc = RStyx::Message::Rclunk.new
-    bytes = rc.to_bytes(0x1234)
+    rc = RStyx::Message::Rclunk.new(:tag => 0x1234)
+    bytes = rc.to_bytes
     expect = "\x79\x34\x12"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -995,23 +854,19 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    rc2 = RStyx::Message::StyxMessage.decode(expect)
+    rc2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rc2.class == RStyx::Message::Rclunk)
-    assert(rc2.length == len)
-    assert(rc2.mtype == RStyx::Message::StyxMessage::RCLUNK)
     assert(rc2.tag == 0x1234)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x79\x34") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x79\x34") }
 
     # decode with trailing garbage
     rc2 = nil
     assert_nothing_raised do
-      rc2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rc2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rc2.class == RStyx::Message::Rclunk)
-    assert(rc2.length == len)
-    assert(rc2.mtype == RStyx::Message::StyxMessage::RCLUNK)
     assert(rc2.tag == 0x1234)
   end
 
@@ -1019,8 +874,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tremove class.
   #
   def test_tremove
-    tr = RStyx::Message::Tremove.new(0xdeadbeef)
-    bytes = tr.to_bytes(0x1234)
+    tr = RStyx::Message::Tremove.new(:fid => 0xdeadbeef, :tag => 0x1234)
+    bytes = tr.to_bytes
     expect = "\x7a\x34\x12\xef\xbe\xad\xde"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -1028,25 +883,21 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    tr2 = RStyx::Message::StyxMessage.decode(expect)
+    tr2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tr2.class == RStyx::Message::Tremove)
-    assert(tr2.length == len)
-    assert(tr2.mtype == RStyx::Message::StyxMessage::TREMOVE)
     assert(tr2.tag == 0x1234)
     assert(tr2.fid == 0xdeadbeef)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x7a\x34\x12\xef\xbe\xad") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x7a\x34\x12") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x7a\x34\x12\xef\xbe\xad") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x7a\x34\x12") }
 
     # decode with trailing garbage
     tr2 = nil
     assert_nothing_raised do
-      tr2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      tr2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(tr2.class == RStyx::Message::Tremove)
-    assert(tr2.length == len)
-    assert(tr2.mtype == RStyx::Message::StyxMessage::TREMOVE)
     assert(tr2.tag == 0x1234)
     assert(tr2.fid == 0xdeadbeef)
   end
@@ -1055,8 +906,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rremove class.
   #
   def test_rremove
-    rr = RStyx::Message::Rremove.new
-    bytes = rr.to_bytes(0x1234)
+    rr = RStyx::Message::Rremove.new(:tag => 0x1234)
+    bytes = rr.to_bytes
     expect = "\x7b\x34\x12"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -1064,23 +915,19 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    rr2 = RStyx::Message::StyxMessage.decode(expect)
+    rr2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rr2.class == RStyx::Message::Rremove)
-    assert(rr2.length == len)
-    assert(rr2.mtype == RStyx::Message::StyxMessage::RREMOVE)
     assert(rr2.tag == 0x1234)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x7b\x34") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x7b\x34") }
 
     # decode with trailing garbage
     rr2 = nil
     assert_nothing_raised do
-      rr2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      rr2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(rr2.class == RStyx::Message::Rremove)
-    assert(rr2.length == len)
-    assert(rr2.mtype == RStyx::Message::StyxMessage::RREMOVE)
     assert(rr2.tag == 0x1234)
   end
 
@@ -1088,8 +935,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Tstat class.
   #
   def test_tstat
-    ts = RStyx::Message::Tstat.new(0xdeadbeef)
-    bytes = ts.to_bytes(0x1234)
+    ts = RStyx::Message::Tstat.new(:fid => 0xdeadbeef, :tag => 0x1234)
+    bytes = ts.to_bytes
     expect = "\x7c\x34\x12\xef\xbe\xad\xde"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -1097,25 +944,21 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    ts2 = RStyx::Message::StyxMessage.decode(expect)
+    ts2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(ts2.class == RStyx::Message::Tstat)
-    assert(ts2.length == len)
-    assert(ts2.mtype == RStyx::Message::StyxMessage::TSTAT)
     assert(ts2.tag == 0x1234)
     assert(ts2.fid == 0xdeadbeef)
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x7c\x34\x12\xef\xbe\xad") }
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(packlen + "\x7c\x34\x12") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x7c\x34\x12\xef\xbe\xad") }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(packlen + "\x7c\x34\x12") }
 
     # decode with trailing garbage
     ts2 = nil
     assert_nothing_raised do
-      ts2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage")
+      ts2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage")
     end
     assert(ts2.class == RStyx::Message::Tstat)
-    assert(ts2.length == len)
-    assert(ts2.mtype == RStyx::Message::StyxMessage::TSTAT)
     assert(ts2.tag == 0x1234)
     assert(ts2.fid == 0xdeadbeef)
   end
@@ -1124,7 +967,7 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rstat class.
   #
   def test_rstat
-    de = RStyx::Message::DirEntry.new
+    de = RStyx::Message::Stat.new
     de.dtype = 0x1234
     de.dev = 0x567890ab
     de.qid = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
@@ -1136,20 +979,17 @@ class MessageTest < Test::Unit::TestCase
     de.uid = "bar"
     de.gid = "baz"
     de.muid = "quux"
-    rs = RStyx::Message::Rstat.new(de)
-    bytes = rs.to_bytes(0x1234)
+    rs = RStyx::Message::Rstat.new(:stat => de, :tag => 0x1234)
+    bytes = rs.to_bytes
     expect = "\x7d\x34\x12\x3e\x00\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux"
     len = expect.length + 4
     packlen = [len].pack("V")
     expect = packlen + expect
-    puts ""
     assert(expect == bytes)
 
     # decode expect
-    rs2 = RStyx::Message::StyxMessage.decode(expect)
+    rs2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rs2.class == RStyx::Message::Rstat)
-    assert(rs2.length == len)
-    assert(rs2.mtype == RStyx::Message::StyxMessage::RSTAT)
     assert(rs2.tag == 0x1234)
     assert(rs2.stat.dtype == 0x1234)
     assert(rs2.stat.dev == 0x567890ab)
@@ -1166,14 +1006,12 @@ class MessageTest < Test::Unit::TestCase
     assert(rs2.stat.muid == "quux")
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(expect.chop) }
 
     # Trailing garbage test
     rs2 = nil
-    assert_nothing_raised { rs2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage") }
+    assert_nothing_raised { rs2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage") }
     assert(rs2.class == RStyx::Message::Rstat)
-    assert(rs2.length == len)
-    assert(rs2.mtype == RStyx::Message::StyxMessage::RSTAT)
     assert(rs2.tag == 0x1234)
     assert(rs2.stat.dtype == 0x1234)
     assert(rs2.stat.dev == 0x567890ab)
@@ -1194,7 +1032,7 @@ class MessageTest < Test::Unit::TestCase
   # Test the Twstat class.
   #
   def test_twstat
-    de = RStyx::Message::DirEntry.new
+    de = RStyx::Message::Stat.new
     de.dtype = 0x1234
     de.dev = 0x567890ab
     de.qid = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
@@ -1206,8 +1044,8 @@ class MessageTest < Test::Unit::TestCase
     de.uid = "bar"
     de.gid = "baz"
     de.muid = "quux"
-    tw = RStyx::Message::Twstat.new(0x12345678, de)
-    bytes = tw.to_bytes(0x1234)
+    tw = RStyx::Message::Twstat.new(:fid => 0x12345678, :stat => de, :tag => 0x1234)
+    bytes = tw.to_bytes
     expect = "\x7e\x34\x12\x78\x56\x34\x12\x3e\x00\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -1215,10 +1053,8 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    tw2 = RStyx::Message::StyxMessage.decode(expect)
+    tw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(tw2.class == RStyx::Message::Twstat)
-    assert(tw2.length == len)
-    assert(tw2.mtype == RStyx::Message::StyxMessage::TWSTAT)
     assert(tw2.tag == 0x1234)
     assert(tw2.stat.dtype == 0x1234)
     assert(tw2.stat.dev == 0x567890ab)
@@ -1235,13 +1071,11 @@ class MessageTest < Test::Unit::TestCase
     assert(tw2.stat.muid == "quux")
 
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(expect.chop) }
     # Trailing garbage test
     tw2 = nil
-    assert_nothing_raised { tw2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage") }
+    assert_nothing_raised { tw2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage") }
     assert(tw2.class == RStyx::Message::Twstat)
-    assert(tw2.length == len)
-    assert(tw2.mtype == RStyx::Message::StyxMessage::TWSTAT)
     assert(tw2.tag == 0x1234)
     assert(tw2.stat.dtype == 0x1234)
     assert(tw2.stat.dev == 0x567890ab)
@@ -1262,8 +1096,8 @@ class MessageTest < Test::Unit::TestCase
   # Test the Rwstat class.
   #
   def test_rwstat
-    rw = RStyx::Message::Rwstat.new
-    bytes = rw.to_bytes(0x1234)
+    rw = RStyx::Message::Rwstat.new(:tag => 0x1234)
+    bytes = rw.to_bytes
     expect = "\x7f\x34\x12"
     len = expect.length + 4
     packlen = [len].pack("V")
@@ -1271,19 +1105,42 @@ class MessageTest < Test::Unit::TestCase
     assert(expect == bytes)
 
     # decode expect
-    rw2 = RStyx::Message::StyxMessage.decode(expect)
+    rw2 = RStyx::Message::StyxMessage.from_bytes(expect)
     assert(rw2.class == RStyx::Message::Rwstat)
-    assert(rw2.length == len)
-    assert(rw2.mtype == RStyx::Message::StyxMessage::RWSTAT)
     assert(rw2.tag == 0x1234)
     # try decoding short strings
-    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.from_bytes(expect.chop) }
     # trailing garbage test
-    assert_nothing_raised { rw2 = RStyx::Message::StyxMessage.decode(expect + "trailing garbage") }
+    assert_nothing_raised { rw2 = RStyx::Message::StyxMessage.from_bytes(expect + "trailing garbage") }
     assert(rw2.class == RStyx::Message::Rwstat)
-    assert(rw2.length == len)
-    assert(rw2.mtype == RStyx::Message::StyxMessage::RWSTAT)
     assert(rw2.tag == 0x1234)
   end
 
+  # Decode live Styx messages received from actual Styx server
+  # implementations.
+  def test_decode
+    # Rversion from Inferno
+    str = "\023\000\000\000eA\271\030 \000\000\006\0009P2000"
+    m = RStyx::Message::StyxMessage.from_bytes(str)
+    assert_equal(RStyx::Message::Rversion, m.class)
+    assert_equal(47425, m.tag)
+    assert_equal(8216, m.msize)
+    assert_equal("9P2000", m.version)
+
+    # Rattach from Inferno
+    str = "\024\000\000\000i.w\200\240q^F\240\307\006\000\000\000\000\000"
+    m = RStyx::Message::StyxMessage.from_bytes(str)
+    assert_equal(RStyx::Message::Rattach, m.class)
+    assert_equal(30510, m.tag)
+    assert_equal(1180594592, m.qid.version)
+    assert_equal(128, m.qid.qtype)
+    assert_equal(444320, m.qid.path)
+
+    # Rclunk from Inferno
+    str = "\a\000\000\000y7\372"
+    m = RStyx::Message::StyxMessage.from_bytes(str)
+    assert_equal(RStyx::Message::Rclunk, m.class)
+    assert_equal(64055, m.tag)
+  end
+
 end