rstyx 0.1.0

data/tests/tc_message.rb

@@ -0,0 +1,1288 @@
+ #!/usr/bin/ruby
+#
+# Copyright (C) 2005 Rafael Sevilla
+# This file is part of RStyx
+#
+# RStyx is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1
+# of the License, or (at your option) any later version.
+#
+# RStyx is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# 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.
+#
+# Unit tests for Styx messages
+#
+# $Id: tc_message.rb,v 1.23 2005/09/28 17:56:58 dido Exp $
+#
+require 'test/unit'
+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
+  #
+  def test_qid
+    # Generate a distinctive Styx message
+    qid = RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee)
+    bytes = qid.to_bytes
+    # Test if the serialized version is as expected
+    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)
+    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("     ") }
+
+    # 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") }
+
+    # 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)
+  end
+
+  ##
+  # Test the DirEntry class
+  #
+  def test_direntry
+    # generate a dummy DirEntry for testing
+    de = RStyx::Message::DirEntry.new
+    de.dtype = 0x1234
+    de.dev = 0x567890ab
+    de.qid = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
+    de.mode = 0x9abcdef0
+    de.atime = 0xdeadbeef
+    de.mtime = 0xcafebabe
+    de.length = 0xfedcba9876543210
+    de.name = "foo"
+    de.uid = "bar"
+    de.gid = "baz"
+    de.muid = "quux"
+    bytes = de.to_bytes
+    expect = "\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"
+    assert(bytes == expect)
+
+    # Generate a new direntry based on the above string
+    de2 = RStyx::Message::DirEntry.decode(expect)
+    assert(de2.dtype == 0x1234)
+    assert(de2.dev == 0x567890ab)
+    assert(de2.qid.qtype == 0x01)
+    assert(de2.qid.version == 0xdeadbeef)
+    assert(de2.qid.path == 0xfeedfacec0ffeeee)
+    assert(de2.mode == 0x9abcdef0)
+    assert(de2.atime == 0xdeadbeef)
+    assert(de2.mtime == 0xcafebabe)
+    assert(de2.length == 0xfedcba9876543210)
+    assert(de2.name == "foo")
+    assert(de2.uid == "bar")
+    assert(de2.gid == "baz")
+    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") }
+
+    # 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")
+    end
+    assert(de2.dtype == 0x1234)
+    assert(de2.dev == 0x567890ab)
+    q = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
+    assert(de2.qid.qtype == 0x01)
+    assert(de2.qid.version == 0xdeadbeef)
+    assert(de2.qid.path == 0xfeedfacec0ffeeee)
+    assert(de2.mode == 0x9abcdef0)
+    assert(de2.atime == 0xdeadbeef)
+    assert(de2.mtime == 0xcafebabe)
+    assert(de2.length == 0xfedcba9876543210)
+    assert(de2.name == "foo")
+    assert(de2.uid == "bar")
+    assert(de2.gid == "baz")
+    assert(de2.muid == "quux")
+  end
+
+  ##
+  # Test the Tversion class
+  #
+  def test_tversion
+    tv = RStyx::Message::Tversion.new(0xdeadbeef, "9P2000")
+    bytes = tv.to_bytes(0x1234)
+    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)
+    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") }
+
+    # Try to decode the expect string with trailing garbage
+    tvm = RStyx::Message::StyxMessage.decode(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")
+
+  end
+
+  ##
+  # Test the Rversion class
+  #
+  def test_rversion
+    rv = RStyx::Message::Rversion.new(0xdeadbeef, "9P2000")
+    bytes = rv.to_bytes(0x1234)
+    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)
+    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") }
+
+    # Try to decode with trailing garbage
+    assert_nothing_raised do
+      rvm = RStyx::Message::StyxMessage.decode(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")
+  end
+
+  ##
+  # Test the Tauth class.
+  #
+  def test_tauth
+    ta = RStyx::Message::Tauth.new("foo", 0x9abcdef0, "bar")
+    bytes = ta.to_bytes(0x1234)
+    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)
+    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") }
+
+    # decode with trailing garbage
+    assert_nothing_raised do
+      ta2 = RStyx::Message::StyxMessage.decode(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")
+    assert(ta2.aname == "bar")
+  end
+
+  ##
+  # Test the Rauth class.
+  #
+  def test_rauth
+    ra = RStyx::Message::Rauth.new(RStyx::Message::Qid.new(0x01, 0xdeadbeef, 0xfeedfacec0ffeeee))
+    bytes = ra.to_bytes(0x1234)
+    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)
+    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") }
+
+    # Decode with trailing garbage
+    assert_nothing_raised do
+      ra2 = RStyx::Message::StyxMessage.decode(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)
+    assert(ra2.aqid.path == 0xfeedfacec0ffeeee)
+  end
+
+  ##
+  # Test the Rerror class
+  #
+  def test_rerror
+    rerr = RStyx::Message::Rerror.new("error")
+    bytes = rerr.to_bytes(0x1234)
+    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)
+    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") }
+
+    # Try to decode strings with trailing garbage
+    assert_nothing_raised do
+      emsg = RStyx::Message::StyxMessage.decode(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)
+    expect = "\x6c\x34\x12\x78\x56"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    tf2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    tf2 = nil
+    assert_nothing_raised do
+      tf2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Rflush class.
+  #
+  def test_rflush
+    tf = RStyx::Message::Rflush.new
+    bytes = tf.to_bytes(0x1234)
+    expect = "\x6d\x34\x12"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    rf2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    rf2 = nil
+    assert_nothing_raised do
+      rf2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Tattach class.
+  #
+  def test_tattach
+    ta = RStyx::Message::Tattach.new(0x12345678, "foo", 0x9abcdef0, "bar")
+    bytes = ta.to_bytes(0x1234)
+    expect = "\x68\x34\x12\x78\x56\x34\x12\xf0\xde\xbc\x9a\x03\x00foo\x03\x00bar"
+    len = expect.length + 4
+    packlen = [len].pack("V") 
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # Decode expect string
+    ta2 = RStyx::Message::StyxMessage.decode(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)
+    assert(ta2.uname == "foo")
+    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") }
+
+    # Decode expect string with trailing garbage
+    assert_nothing_raised do
+      ta2 = RStyx::Message::StyxMessage.decode(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)
+    assert(ta2.uname == "foo")
+    assert(ta2.aname == "bar")
+  end
+
+  ##
+  # Test the Rattach class.
+  #
+  def test_rattach
+    ra = RStyx::Message::Rattach.new(RStyx::Message::Qid.new(0x01, 0xdeadbeef, 0xfeedfacec0ffeeee))
+    bytes = ra.to_bytes(0x1234)
+    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)
+    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") }
+
+    # Decode with trailing garbage
+    assert_nothing_raised do
+      ra2 = RStyx::Message::StyxMessage.decode(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)
+    assert(ra2.qid.path == 0xfeedfacec0ffeeee)
+  end
+
+  ##
+  # 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"
+    len = expect.length + 4
+    packlen = [len].pack("V") 
+    expect = packlen + expect
+    assert(expect == bytes)
+    tw2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # trailing garbage test
+    assert_nothing_raised do
+      tw2 = RStyx::Message::StyxMessage.decode(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)
+    assert(tw2.path = "foo/bar/baz/quux/blargle")
+  end
+
+  ##
+  # Test the Rwalk class.
+  #
+  def test_rwalk
+    qidlist = [
+      RStyx::Message::Qid.new(0x01,0xdeadbeef,0xfeedfacec0ffeeee),
+      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)
+    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)
+    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]
+    assert(qid.qtype == 0x01)
+    assert(qid.version == 0xdeadbeef)
+    assert(qid.path == 0xfeedfacec0ffeeee)
+    qid = rw2.qids[1]
+    assert(qid.qtype == 0x02)
+    assert(qid.version == 0x12345678)
+    assert(qid.path == 0xfedcba9876543210)
+    qid = rw2.qids[2]
+    assert(qid.qtype == 0x03)
+    assert(qid.version == 0x87654321)
+    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") }
+
+    # Trailing garbage
+    assert_nothing_raised do
+      rw2 = RStyx::Message::StyxMessage.decode(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]
+    assert(qid.qtype == 0x01)
+    assert(qid.version == 0xdeadbeef)
+    assert(qid.path == 0xfeedfacec0ffeeee)
+    qid = rw2.qids[1]
+    assert(qid.qtype == 0x02)
+    assert(qid.version == 0x12345678)
+    assert(qid.path == 0xfedcba9876543210)
+    qid = rw2.qids[2]
+    assert(qid.qtype == 0x03)
+    assert(qid.version == 0x87654321)
+    assert(qid.path == 0x0123456789abcdef)
+  end
+
+  ##
+  # 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)
+    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)
+    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") }
+
+    # Try decoding with trailing garbage
+    assert_nothing_raised do
+      to2 = RStyx::Message::StyxMessage.decode(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)
+  end
+
+  ##
+  # 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)
+    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")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # Decode expect
+    ro2 = RStyx::Message::StyxMessage.decode(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)
+    assert(ro2.qid.path == 0xfeedfacec0ffeeee)
+    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") }
+
+    # Decode with trailing garbage
+    assert_nothing_raised do
+      ro2 = RStyx::Message::StyxMessage.decode(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)
+    assert(ro2.qid.path == 0xfeedfacec0ffeeee)
+    assert(ro2.iounit == 0xfedcba98)
+  end
+
+  ##
+  # 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)
+    expect = "\x72\x34\x12\x78\x56\x34\x12\x03\x00foo\x98\xba\xdc\xfe\x51"
+    len = expect.length + 4
+    packlen = [len].pack("V") 
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # Decode expect
+    tc2 = RStyx::Message::StyxMessage.decode(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")
+    assert(tc2.perm == 0xfedcba98)
+    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") }
+    # Decode with trailing garbage
+    tc2 = nil
+    assert_nothing_raised do
+      tc2 = RStyx::Message::StyxMessage.decode(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")
+    assert(tc2.perm == 0xfedcba98)
+    assert(tc2.mode == 0x51)
+  end
+
+  ##
+  # 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)
+    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")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # Decode expect
+    rc2 = RStyx::Message::StyxMessage.decode(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)
+    assert(rc2.qid.path == 0xfeedfacec0ffeeee)
+    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") }
+
+    # Decode with trailing garbage
+    rc2 = nil
+    assert_nothing_raised do
+      rc2 = RStyx::Message::StyxMessage.decode(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)
+    assert(rc2.qid.path == 0xfeedfacec0ffeeee)
+    assert(rc2.iounit == 0xfedcba98)
+  end
+
+  ##
+  # Test the Tread class.
+  #
+  def test_tread
+    tr = RStyx::Message::Tread.new(0xdeadbeef, 0xfeedfacec0ffeeee, 0xcafebabe)
+    bytes = tr.to_bytes(0x1234)
+    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")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # Decode expect
+    tr2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # Decode with trailing garbage
+    tr2 = nil
+    assert_nothing_raised do
+      tr2 = RStyx::Message::StyxMessage.decode(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)
+    assert(tr2.count == 0xcafebabe)
+  end
+
+  ##
+  # 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)
+    expect = "\x75\x34\x12\xa0\x00\x00\x00" + data
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # Decode expect
+    rr2 = RStyx::Message::StyxMessage.decode(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") }
+    # Try decoding empty
+    assert_nothing_raised { RStyx::Message::StyxMessage.decode("\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")
+    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)
+  end
+
+  ##
+  # Tests for Twrite class
+  #
+  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)
+    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
+    assert(expect == bytes)
+
+    # Decode expect
+    tw2 = RStyx::Message::StyxMessage.decode(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) }
+
+    # 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") }
+    # Decode with trailing garbage
+    tw2 = nil
+    assert_nothing_raised do
+      tw2 = RStyx::Message::StyxMessage.decode(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)
+    expect = "\x77\x34\x12\x78\x56\x34\x12"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    rw2 = RStyx::Message::StyxMessage.decode(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) }
+    # Decode with trailing garbage
+    rw2 = nil
+    assert_nothing_raised do
+      rw2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Tclunk class.
+  #
+  def test_tclunk
+    tc = RStyx::Message::Tclunk.new(0xdeadbeef)
+    bytes = tc.to_bytes(0x1234)
+    expect = "\x78\x34\x12\xef\xbe\xad\xde"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    tc2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    tc2 = nil
+    assert_nothing_raised do
+      tc2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Rclunk class.
+  #
+  def test_rclunk
+    rc = RStyx::Message::Rclunk.new
+    bytes = rc.to_bytes(0x1234)
+    expect = "\x79\x34\x12"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    rc2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    rc2 = nil
+    assert_nothing_raised do
+      rc2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Tremove class.
+  #
+  def test_tremove
+    tr = RStyx::Message::Tremove.new(0xdeadbeef)
+    bytes = tr.to_bytes(0x1234)
+    expect = "\x7a\x34\x12\xef\xbe\xad\xde"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    tr2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    tr2 = nil
+    assert_nothing_raised do
+      tr2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Rremove class.
+  #
+  def test_rremove
+    rr = RStyx::Message::Rremove.new
+    bytes = rr.to_bytes(0x1234)
+    expect = "\x7b\x34\x12"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    rr2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    rr2 = nil
+    assert_nothing_raised do
+      rr2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Tstat class.
+  #
+  def test_tstat
+    ts = RStyx::Message::Tstat.new(0xdeadbeef)
+    bytes = ts.to_bytes(0x1234)
+    expect = "\x7c\x34\x12\xef\xbe\xad\xde"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    ts2 = RStyx::Message::StyxMessage.decode(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") }
+
+    # decode with trailing garbage
+    ts2 = nil
+    assert_nothing_raised do
+      ts2 = RStyx::Message::StyxMessage.decode(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
+
+  ##
+  # Test the Rstat class.
+  #
+  def test_rstat
+    de = RStyx::Message::DirEntry.new
+    de.dtype = 0x1234
+    de.dev = 0x567890ab
+    de.qid = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
+    de.mode = 0x9abcdef0
+    de.atime = 0xdeadbeef
+    de.mtime = 0xcafebabe
+    de.length = 0xfedcba9876543210
+    de.name = "foo"
+    de.uid = "bar"
+    de.gid = "baz"
+    de.muid = "quux"
+    rs = RStyx::Message::Rstat.new(de)
+    bytes = rs.to_bytes(0x1234)
+    expect = "\x7d\x34\x12\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
+    assert(expect == bytes)
+
+    # decode expect
+    rs2 = RStyx::Message::StyxMessage.decode(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)
+    assert(rs2.stat.qid.qtype == 0x01)
+    assert(rs2.stat.qid.version == 0xdeadbeef)
+    assert(rs2.stat.qid.path == 0xfeedfacec0ffeeee)
+    assert(rs2.stat.mode == 0x9abcdef0)
+    assert(rs2.stat.atime == 0xdeadbeef)
+    assert(rs2.stat.mtime == 0xcafebabe)
+    assert(rs2.stat.length == 0xfedcba9876543210)
+    assert(rs2.stat.name == "foo")
+    assert(rs2.stat.uid == "bar")
+    assert(rs2.stat.gid == "baz")
+    assert(rs2.stat.muid == "quux")
+
+    # try decoding short strings
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+
+    # Trailing garbage test
+    rs2 = nil
+    assert_nothing_raised { rs2 = RStyx::Message::StyxMessage.decode(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)
+    assert(rs2.stat.qid.qtype == 0x01)
+    assert(rs2.stat.qid.version == 0xdeadbeef)
+    assert(rs2.stat.qid.path == 0xfeedfacec0ffeeee)
+    assert(rs2.stat.mode == 0x9abcdef0)
+    assert(rs2.stat.atime == 0xdeadbeef)
+    assert(rs2.stat.mtime == 0xcafebabe)
+    assert(rs2.stat.length == 0xfedcba9876543210)
+    assert(rs2.stat.name == "foo")
+    assert(rs2.stat.uid == "bar")
+    assert(rs2.stat.gid == "baz")
+    assert(rs2.stat.muid == "quux")
+  end
+
+  ##
+  # Test the Twstat class.
+  #
+  def test_twstat
+    de = RStyx::Message::DirEntry.new
+    de.dtype = 0x1234
+    de.dev = 0x567890ab
+    de.qid = RStyx::Message::Qid.new(0x01, 0xdeadbeef,0xfeedfacec0ffeeee)
+    de.mode = 0x9abcdef0
+    de.atime = 0xdeadbeef
+    de.mtime = 0xcafebabe
+    de.length = 0xfedcba9876543210
+    de.name = "foo"
+    de.uid = "bar"
+    de.gid = "baz"
+    de.muid = "quux"
+    tw = RStyx::Message::Twstat.new(0x12345678, de)
+    bytes = tw.to_bytes(0x1234)
+    expect = "\x7e\x34\x12\x78\x56\x34\x12\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
+    assert(expect == bytes)
+
+    # decode expect
+    tw2 = RStyx::Message::StyxMessage.decode(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)
+    assert(tw2.stat.qid.qtype == 0x01)
+    assert(tw2.stat.qid.version == 0xdeadbeef)
+    assert(tw2.stat.qid.path == 0xfeedfacec0ffeeee)
+    assert(tw2.stat.mode == 0x9abcdef0)
+    assert(tw2.stat.atime == 0xdeadbeef)
+    assert(tw2.stat.mtime == 0xcafebabe)
+    assert(tw2.stat.length == 0xfedcba9876543210)
+    assert(tw2.stat.name == "foo")
+    assert(tw2.stat.uid == "bar")
+    assert(tw2.stat.gid == "baz")
+    assert(tw2.stat.muid == "quux")
+
+    # try decoding short strings
+    assert_raise(RStyx::StyxException) { RStyx::Message::StyxMessage.decode(expect.chop) }
+    # Trailing garbage test
+    tw2 = nil
+    assert_nothing_raised { tw2 = RStyx::Message::StyxMessage.decode(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)
+    assert(tw2.stat.qid.qtype == 0x01)
+    assert(tw2.stat.qid.version == 0xdeadbeef)
+    assert(tw2.stat.qid.path == 0xfeedfacec0ffeeee)
+    assert(tw2.stat.mode == 0x9abcdef0)
+    assert(tw2.stat.atime == 0xdeadbeef)
+    assert(tw2.stat.mtime == 0xcafebabe)
+    assert(tw2.stat.length == 0xfedcba9876543210)
+    assert(tw2.stat.name == "foo")
+    assert(tw2.stat.uid == "bar")
+    assert(tw2.stat.gid == "baz")
+    assert(tw2.stat.muid == "quux")
+  end
+
+  ##
+  # Test the Rwstat class.
+  #
+  def test_rwstat
+    rw = RStyx::Message::Rwstat.new
+    bytes = rw.to_bytes(0x1234)
+    expect = "\x7f\x34\x12"
+    len = expect.length + 4
+    packlen = [len].pack("V")
+    expect = packlen + expect
+    assert(expect == bytes)
+
+    # decode expect
+    rw2 = RStyx::Message::StyxMessage.decode(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) }
+    # trailing garbage test
+    assert_nothing_raised { rw2 = RStyx::Message::StyxMessage.decode(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
+
+end