sicl 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,8 @@
+= 0.2.0 2007-05-12
+
+* add build rules for bcc32 with ruby-mswin32.
+* refactor testcases in test/test_sicl.rb.
+
 = 0.1.0 2007-05-12
 
 * Birthday!

data/Manifest.txt

@@ -5,4 +5,5 @@ Rakefile
 
 ext/sicl.c
 ext/extconf.rb
+ext/Makefile.bcc
 test/test_sicl.rb

data/README.txt

@@ -62,7 +62,15 @@ Agilent Technologies
 
 == INSTALL:
 
-* sudo gem install sicl
+  $ export http_proxy='http://web-proxy:8088' # if you need
+  $ gem install sicl
+
+or
+
+  $ tar jvxf sicl.tar.bz2
+  $ cd sicl
+  $ ruby extconf.rb
+  $ make
 
 == LICENSE:
 

data/Rakefile

@@ -30,8 +30,8 @@ task :default => :package
 
 spec = Gem::Specification.new do |s|
   s.name = "sicl"
-  s.version = "0.1.0"
-  s.summary = "Agilent SICL API module for Ruby."
+  s.version = "0.2.0"
+  s.summary = "Agilent SICL API wrapper class for Ruby."
   s.autorequire = "sicl"
   s.files = PKG_FILES
   s.default_executable = "ext/extconf.rb"
@@ -45,3 +45,11 @@ Rake::GemPackageTask.new(spec) do |pkg|
     pkg.need_tar_bz2 = true
     pkg.need_tar_gz = true
 end
+
+task :test do
+  ruby "-Iext test/test_sicl.rb"
+end
+
+task :html do
+  sh "rd2 -r rd/rd2html-lib.rb --with-css=style.css doc/sicl.ja.rd > html/sicl.ja.html"
+end

data/ext/Makefile.bcc

@@ -0,0 +1,79 @@
+################################################################################
+#
+#   Copyright (c) 2007 Satoshi Nihonyanagi
+#   Copyright (c) 2007 Naoki Kobayashi
+#
+#   $Header: $
+#
+#   Description: 
+#
+#        You need to export three environment variables for path of header
+#      files and libraries if you wish to build this library.
+#
+#          - SICL_DIR is path of Agilent IO Libraries Suite.
+#          - BCC_DIR is path of Borland C/C++ compiler.
+#          - RUBY_DIR is path of Ruby mswin32 verion.
+#
+#        Please, make like this:)
+#
+#        $ SICL_DIR='C:\Program Files\Agilent\IO Libraries Suite' \
+#        > BCC_DIR='C:\borland\bcc55' RUBY_DIR='C:\ruby-mswin32' \
+#        > PATH=/cygdrive/c/borland/bcc55/Bin:$PATH make -f Makefile.bcc
+#
+################################################################################
+
+################################################################################
+# Path definitions
+################################################################################
+
+#SICL_DIR     = C:\Program Files\Agilent\IO Libraries Suite
+SICL_INC_DIR = $(SICL_DIR)\include
+SICL_LIB_DIR = $(SICL_DIR)\lib
+
+#BCC_DIR      = C:\borland\bcc55
+BCC_INC_DIR  = $(BCC_DIR)\include
+BCC_LIB_DIR  = $(BCC_DIR)\lib
+
+#RUBY_DIR     = C:\ruby-mswin32
+RUBY_BIN_DIR = $(RUBY_DIR)\bin
+RUBY_INC_DIR = $(RUBY_DIR)\lib\ruby\1.8\i386-mswin32
+RUBYDLL      = msvcrt-ruby18.dll
+RUBYLIB      = $(RUBYDLL:.dll=.lib)
+
+################################################################################
+# Compiler and linker settings
+################################################################################
+
+CC       = bcc32
+CFLAGS   = -O2 -w-8070 -w-8004 -w-8057 \
+           -I"$(SICL_INC_DIR)" -I"$(RUBY_INC_DIR)" -I"$(BCC_INC_DIR)" \
+           -L"$(BCC_LIB_DIR)"
+
+LD       = ilink32
+LDFLAGS  = -L"$(BCC_LIB_DIR)" -L"$(SICL_LIB_DIR)"
+
+################################################################################
+# List of target files
+################################################################################
+
+SRCS     = sicl.c
+OBJS     = $(SRCS:.c=.obj)
+LIBS     = bcsicl32.lib import32.lib cw32mt.lib $(RUBYLIB)
+SICLDLL  = sicl.dll
+
+################################################################################
+# Build rules
+################################################################################
+
+.PHONY: all
+all: $(SICLDLL)
+
+$(RUBYLIB): $(RUBY_BIN_DIR)\$(RUBYDLL)
+	implib -a $@ $?
+
+$(SICLDLL): $(OBJS) $(RUBYLIB)
+	$(LD) $(LDFLAGS) -Tpd $? c0d32.obj, $(DLL), , $(LIBS),
+
+.PHONY: clean
+clean:
+	rm -f *~ *.obj *.lib *.tds *.map *.ilc *.ild *.ilf *.ils 

data/ext/sicl.c

@@ -8,7 +8,18 @@
  *
  */
 
-#define _REENT_ONLY
+#if defined(__BORLANDC__)
+#   define _MSC_VER 1200
+#   include <windows.h>
+#endif /* __BORLANDC__ */
+
+#if defined(__CYGWIN__)
+#   define _REENT_ONLY
+#endif /* __CYGWIN__ */
+
+#if defined(__BORLANDC__)
+__declspec(dllexport) BOOL __stdcall DllMain(HANDLE h, DWORD w, LPVOID p) { return TRUE; }
+#endif  /* __BORLANDC__ */
 
 #include <ruby.h>
 #include "sicl.h"
@@ -37,6 +48,7 @@ static ID s_call;
 static ID s_buf_mode;
 
 static const VALUE READ_ALL_DATA = INT2FIX(-1);
+static const char EOL[] = "\r\n";
 
 /* -----------------------------------------------------------------------
                        struct cparse_params
@@ -123,25 +135,29 @@ static void SICLCALLBACK intr_handler ( INST id, long reason, long secval )
         rb_funcall ( hdlr, s_call, 2, INT2FIX(reason), INT2FIX(secval) );
 }
 
-VALUE sicl_igeterrstr ( int argc, VALUE * argv, VALUE self )
+VALUE sicl_s_igeterrstr ( VALUE self, VALUE code )
 {
-    VALUE code = 0;
+    Check_Type ( code, T_FIXNUM );
 
-    rb_scan_args ( argc, argv, "01", & code );
+    return rb_str_new2 ( igeterrstr ( FIX2INT ( code ) ) );
+}
 
-    if ( TYPE(code)!=T_FIXNUM ) {
-        struct instrument * inst = NULL;
+VALUE sicl_igeterrstr ( VALUE self )
+{
+    struct instrument * inst = NULL;
 
-        Data_Get_Struct ( self, struct instrument, inst );
+    Data_Get_Struct ( self, struct instrument, inst );
 
-        if ( ! inst->errno ) return Qnil;
+    return rb_str_new2 ( igeterrstr ( inst->errno ) );
+}
 
-        code = INT2FIX ( inst->errno );
-    }
+VALUE sicl_igeterrno ( VALUE self )
+{
+    struct instrument * inst = NULL;
 
-    if ( NIL_P(code) ) return code;
+    Data_Get_Struct ( self, struct instrument, inst );
 
-    return rb_str_new2 ( igeterrstr ( FIX2INT ( code ) ) );
+    return INT2FIX(inst->errno);
 }
 
 VALUE sicl_ionerror ( VALUE self, VALUE proc )
@@ -366,7 +382,7 @@ VALUE sicl_iwrite ( VALUE self, VALUE cmd, VALUE eoi )
     char * ptr               = NULL;
     long len                 = 0;
 
-    int ( * write )( INST, char *, unsigned long, int, unsigned long * ) = iwrite;
+    int ( * write_func )( INST, char *, unsigned long, int, unsigned long * ) = iwrite;
 
     Check_Type ( cmd, T_STRING );
 
@@ -377,10 +393,10 @@ VALUE sicl_iwrite ( VALUE self, VALUE cmd, VALUE eoi )
     ptr = RSTRING(cmd)->ptr;
     len = RSTRING(cmd)->len;
 
-    if ( rb_ivar_get( self, s_buf_mode )==Qtrue ) write = ifwrite;
+    if ( rb_ivar_get( self, s_buf_mode )==Qtrue ) write_func = ifwrite;
 
     while ( len>0 ) {
-        err = write ( inst->id, ptr, len, endi, & actualcnt );
+        err = write_func ( inst->id, ptr, len, endi, & actualcnt );
 
         if ( err ) break;
 
@@ -391,6 +407,20 @@ VALUE sicl_iwrite ( VALUE self, VALUE cmd, VALUE eoi )
     return sicl_return ( self, inst, err );
 }
 
+VALUE sicl_iwrite_op ( VALUE self, VALUE cmd )
+{
+    VALUE eoi = Qfalse;
+    char ch = 0;
+
+    Check_Type ( cmd, T_STRING );
+
+    ch = RSTRING(cmd)->ptr[RSTRING(cmd)->len-1];
+
+    if ( ch == '\r' || ch == '\n' ) eoi = Qtrue;
+
+    return sicl_iwrite ( self, cmd, eoi );
+}
+
 VALUE sicl_iwrite_arg ( int argc, VALUE * argv, VALUE self )
 {
     VALUE cmd = 0;
@@ -411,7 +441,7 @@ VALUE sicl_iread ( VALUE self, VALUE max )
     int reason               = 0;
     unsigned long actualcnt  = 0;
 
-    int ( * read )( INST, char *, unsigned long, int *, unsigned long *) = iread;
+    int ( * read_func )( INST, char *, unsigned long, int *, unsigned long *) = iread;
 
     VALUE str = rb_str_new2 ("");
 
@@ -421,14 +451,14 @@ VALUE sicl_iread ( VALUE self, VALUE max )
 
     Data_Get_Struct ( self, struct instrument, inst );
 
-    if ( rb_ivar_get( self, s_buf_mode )==Qtrue ) read = ifread;
+    if ( rb_ivar_get( self, s_buf_mode )==Qtrue ) read_func = ifread;
 
     for (;;) {
         if ( len==0 ) break;
 
         if ( 0<len && len<size ) size = len;
 
-        err = read ( inst->id, buf, size, & reason, & actualcnt );
+        err = read_func( inst->id, buf, size, & reason, & actualcnt );
 
         if ( err && err!=I_ERR_TIMEOUT ) break;
 
@@ -474,7 +504,7 @@ VALUE sicl_output ( VALUE self, VALUE cmd )
     tmp = rb_funcall ( cmd, s_gsub, 2, reg1, blnk );
     cmd = rb_funcall ( tmp, s_gsub, 2, reg2, blnk );
 
-    rb_str_cat2 ( cmd, "\r\n" );
+    rb_str_cat2 ( cmd, EOL );
 
     self = sicl_iwrite ( self, cmd, eoi );
 
@@ -636,12 +666,16 @@ VALUE sicl_itrigger ( VALUE self ) { sicl_func ( self, itrigger ); }
 /* -----------------------------------------------------------------------
                           Ruby Interface
 ----------------------------------------------------------------------- */
-
-void Init_sicl ()
+#if defined(__BORLANDC__)
+__declspec(dllexport) void __stdcall Init_sicl()
+#else  /* __BORLANDC__ */
+void Init_sicl()
+#endif /* __BORLANDC__ */
 {
     mSicl = rb_define_module ( "SICL" );
 
     rb_define_module_function( mSicl, "open", sicl_s_iopen, 1 );
+    rb_define_module_function( mSicl, "errstr", sicl_s_igeterrstr, 1 );
 
     rb_define_const ( mSicl, "BUF_READ"         , INT2FIX(I_BUF_READ)          );
     rb_define_const ( mSicl, "BUF_WRITE"        , INT2FIX(I_BUF_WRITE)         );
@@ -649,6 +683,8 @@ void Init_sicl ()
     rb_define_const ( mSicl, "BUF_DISCARD_READ" , INT2FIX(I_BUF_DISCARD_READ)  );
     rb_define_const ( mSicl, "BUF_DISCARD_WRITE", INT2FIX(I_BUF_DISCARD_WRITE) );
 
+    rb_define_const ( mSicl, "EOL", rb_str_new2(EOL) );
+
     eSicl = rb_define_class_under ( mSicl, "Error", rb_eStandardError );
 
     ionerror ( err_handler );
@@ -671,23 +707,24 @@ void Init_sicl ()
     rb_define_method ( cInstrument, "initialize" , sicl_initialize, 1 );
     rb_define_method ( cInstrument, "close" , sicl_iclose    ,  0 );
     rb_define_method ( cInstrument, "write" , sicl_iwrite_arg, -1 );
+    rb_define_method ( cInstrument, "<<"    , sicl_iwrite_op, 1 );
     rb_define_method ( cInstrument, "read"  , sicl_iread_arg , -1 );
+    rb_define_method ( cInstrument, "readstb" , sicl_ireadstb  ,  0 );
     rb_define_method ( cInstrument, "spoll" , sicl_ireadstb  ,  0 );
     rb_define_method ( cInstrument, "flush" , sicl_iflush    ,  -1 );
 
-    rb_define_method ( cInstrument, "timeout=", sicl_itimeout   ,  1 );
-    rb_define_method ( cInstrument, "timeout" , sicl_igettimeout,  0 );
-    rb_define_method ( cInstrument, "termchr=", sicl_itermchr   ,  1 );
-    rb_define_method ( cInstrument, "termchr" , sicl_igettermchr,  0 );
-    rb_define_method ( cInstrument, "addr"    , sicl_igetaddr   ,  0 );
-    rb_define_method ( cInstrument, "address" , sicl_igetaddr   ,  0 );
-    rb_define_method ( cInstrument, "errstr"  , sicl_igeterrstr , -1 );
+    rb_define_method ( cInstrument, "timeout=", sicl_itimeout   , 1 );
+    rb_define_method ( cInstrument, "timeout" , sicl_igettimeout, 0 );
+    rb_define_method ( cInstrument, "termchr=", sicl_itermchr   , 1 );
+    rb_define_method ( cInstrument, "termchr" , sicl_igettermchr, 0 );
+    rb_define_method ( cInstrument, "addr"    , sicl_igetaddr   , 0 );
+    rb_define_method ( cInstrument, "address" , sicl_igetaddr   , 0 );
+    rb_define_method ( cInstrument, "errstr"  , sicl_igeterrstr , 0 );
+    rb_define_method ( cInstrument, "errno"   , sicl_igeterrno , 0 );
 
     rb_define_method ( cInstrument, "output" , sicl_output, 1 );
     rb_define_method ( cInstrument, "enter"  , sicl_enter , 0 );
     rb_define_method ( cInstrument, "query"  , sicl_query , 1 );
-    rb_define_method ( cInstrument, "<<"     , sicl_output, 1 );
-    rb_define_method ( cInstrument, ">>"     , sicl_enter2, 1 );
 
     rb_define_method ( cInstrument, "abort"  , sicl_iabort  , 0 );
     rb_define_method ( cInstrument, "clear"  , sicl_iclear  , 0 );
@@ -701,8 +738,10 @@ void Init_sicl ()
     rb_define_method ( cInstrument, "on_error" , sicl_igetonerror, 0 );
     rb_define_method ( cInstrument, "on_srq="  , sicl_ionsrq     , 1 );
     rb_define_method ( cInstrument, "on_srq"   , sicl_igetonsrq  , 0 );
-    rb_define_method ( cInstrument, "on_intrrupt=" , sicl_ionintr    , 1 );
-    rb_define_method ( cInstrument, "on_intrrupt"  , sicl_igetonintr , 0 );
+    rb_define_method ( cInstrument, "on_intr=" , sicl_ionintr    , 1 );
+    rb_define_method ( cInstrument, "on_intr"  , sicl_igetonintr , 0 );
+    rb_define_method ( cInstrument, "on_interrupt=" , sicl_ionintr    , 1 );
+    rb_define_method ( cInstrument, "on_interrupt"  , sicl_igetonintr , 0 );
 
     /* accessor for @buf_mode */
     rb_define_method ( cInstrument, "buf_mode=", sicl_set_buf_mode, 1 );

data/test/test_sicl.rb

@@ -10,6 +10,8 @@
 #
 ################################################################################
 
+Signal.trap(:USR2) {} if RUBY_PLATFORM =~ /hpux/ # workaround ...;|
+
 ################################################################################
 # OPTION SETTINGS
 ################################################################################
@@ -19,6 +21,7 @@ require "optparse"
 Settings = Hash.new
 opts = OptionParser.new
 opts.on( "-a", "--address ADDRESS", String ) { |v| Settings[:address] = v }
+opts.on( "-d", "--debug", String ) { |v| Settings[:debug] = true }
 opts.parse!( ARGV )
 
 ################################################################################
@@ -40,7 +43,8 @@ class TestSicl < RUNIT::TestCase
 
   def TestSicl.suite(address)
     @@address = address
-    @@idn_str = SICL.open(@@address).query("*idn?")
+    SICL.open(@@address) { |io| @@name = io.query("*IDN?") }
+    puts "#{@@address} : #{@@name}" if Settings[:debug]
     super()
   end
 
@@ -50,18 +54,22 @@ class TestSicl < RUNIT::TestCase
       super(addr)
 
       reset
-      enable_srq_detection
     end
 
     def reset
-      output "*cls"
-      output "*rst"
-      query "*esr?"
+      output "*CLS"
+      output "*RST"
+      query "*ESR?"
     end
 
     def enable_srq_detection
-      output "*sre #{0x20}"
-      output "*ese #{0x3c}"
+      output "*SRE #{0x20}"
+      output "*ESE #{0x3c}"
+    end
+
+    def disable_srq_detection
+      output "*SRE #{0x00}"
+      output "*ESE #{0x00}"
     end
 
     def raise_timeout(timeout=1000)
@@ -85,19 +93,23 @@ class TestSicl < RUNIT::TestCase
   RQS_BIT = 6 # ReQuest Service
 
   def setup
-    @exp = {}
-    @exp[:str] = @@idn_str
-    @exp[:chr] = @exp[:str][0].chr
-    @exp[:rgx] = /^#{@exp[:str]}/
-
-    @inst = MyInstrument.new @@address
+    @io = MyInstrument.new @@address
+    @name = @@name
   end
 
   def teardown
 
     begin
-      @inst.on_error = nil
-      @inst.on_srq = nil
+      if Settings[:debug] then
+        @io.on_error { |err| puts "[ERR: #{err}]" }
+        @io.on_srq { puts "[SRQ]" }
+        @io.on_intr { |reason, secval| puts "[INTR: #{reason}, #{secval}]" }
+      else
+        @io.on_error = nil
+        @io.on_srq   = nil
+        @io.on_intr  = nil
+      end
+      @io.disable_srq_detection
     rescue
       # do nothing...
     end
@@ -107,14 +119,14 @@ class TestSicl < RUNIT::TestCase
   def test_open0
     ret = SICL.open(@@address) { |io|
 
-      res = io.write("*idn?\n").read
-      assert_match @exp[:rgx], res
+      res = io.write("*IDN?\n").read.chomp
+      assert_equal @name, res
 
-      res = io.output("*idn?").enter
-      assert_match @exp[:rgx], res
+      res = io.output("*IDN?").enter
+      assert_equal @name, res
 
-      res = io.query("*idn?")
-      assert_match @exp[:rgx], res
+      res = io.query("*IDN?")
+      assert_equal @name, res
 
       io.address
     }
@@ -129,53 +141,73 @@ class TestSicl < RUNIT::TestCase
   end
 
   def test_stb0
-    @inst.output("*sre #{0x00}")
-    @inst.output("*ese #{0x00}")
+    @io.output("*SRE #{0x00}")
+    @io.output("*ESE #{0x00}")
 
-    rqs = @inst.query("*stb?").to_i[RQS_BIT]
+    rqs = @io.query("*STB?").to_i[RQS_BIT]
     assert_equal 0, rqs
   end
 
   def test_stb1
-    @inst.output("xxx")
+    @io.enable_srq_detection
+
+    @io.output("xxx")
 
     sleep 0.1
 
-    stb = @inst.query("*stb?").to_i
+    stb = @io.query("*STB?").to_i
 
     assert_equal 1, stb[ESR_BIT]
     assert_equal 1, stb[RQS_BIT]
   end
 
   def test_stb2
-    @inst.output("xxx")
+    @io.enable_srq_detection
+
+    @io.output("xxx")
 
     sleep 1
 
-    stb = @inst.spoll
+    stb = @io.spoll
 
     assert_equal 1, stb[ESR_BIT]
     assert_equal 1, stb[RQS_BIT]
   end
 
+  def test_typerr_error
+    assert_exception(TypeError) { @io.on_error = "xxx" }
+  end
+
+  def test_typerr_srq
+    assert_exception(TypeError) { @io.on_srq = "xxx" }
+  end
+
+  def test_typerr_intr
+    assert_exception(TypeError) { @io.on_intr = "xxx" }
+  end
+
   def test_srq0
+    @io.enable_srq_detection
+
     srq_occured = false
 
-    @inst.on_srq { srq_occured = true }
+    @io.on_srq { srq_occured = true }
 
-    @inst.output("xxx")
+    @io.output("xxx")
 
-    10.times { sleep 0.1 until srq_occured }
+    10.times { sleep 0.1 unless srq_occured }
 
     assert_equal true, srq_occured
   end
 
   def test_srq1
+    @io.enable_srq_detection
+
     stb = 0
 
-    @inst.on_srq { sleep 1; stb = @inst.spoll }
+    @io.on_srq { sleep 1; stb = @io.spoll }
 
-    @inst.output("xxx")
+    @io.output("xxx")
 
     10.times { sleep 0.1 if stb == 0 }
 
@@ -183,68 +215,92 @@ class TestSicl < RUNIT::TestCase
     assert_equal 1, stb[RQS_BIT]
   end
 
+  def test_typerr_write
+    assert_exception(TypeError) { @io.write(10) }
+  end
+
+  def test_typerr_write_op
+    assert_exception(TypeError) { @io << 10 }
+  end
+
+  def test_typerr_read
+    assert_exception(TypeError) { @io.read("xxx") }
+  end
+
+  def test_typerr_output
+    assert_exception(TypeError) { @io.output(10) }
+  end
+
   def test_write_and_read0
-    res = @inst.write("*idn?\n")
+    res = @io.write("*IDN?\n")
     assert res
 
-    res = @inst.read 1
-    assert_equal @exp[:chr], res
+    res = @io.read 1
+    assert_equal @name[0].chr, res
   end
+
   def test_write_and_read1
-    res = @inst.write("*idn?\n").read 1
-    assert_equal @exp[:chr], res
+    res = @io.write("*IDN?\n").read 1
+    assert_equal @name[0].chr, res
   end
+
   def test_write_and_read2
-    res = @inst.write("*idn?\n").read 7
-    assert_equal @exp[:str][0...7], res
+    res = @io.write("*IDN?\n").read 7
+    assert_equal @name[0...7], res
   end
+
   def test_write_and_read3
-    res = @inst.write("*i").write("dn").write("?\n").read 1
-    assert_equal @exp[:chr], res
+    res = @io.write("*I").write("DN").write("?\n").read 1
+    assert_equal @name[0].chr, res
+  end
+
+  def test_write_and_read4
+    @io << "*I" << "DN" << "?" << SICL::EOL
+    res = @io.read 1
+    assert_equal @name[0].chr, res
+  end
+
+  def test_write_and_read5
+    @io << "*RST" << SICL::EOL << "*IDN?" << SICL::EOL
+    res = @io.read 1
+    assert_equal @name[0].chr, res
   end
 
   def test_output_and_enter0
-    res = @inst.output("*idn?")
+    res = @io.output("*IDN?")
     assert res
-    res = @inst.enter
-    assert_match @exp[:rgx], res
+    res = @io.enter
+    assert_equal @name, res
   end
 
   def test_output_and_enter1
-    res = @inst.output("*idn?").enter
-    assert_match @exp[:rgx], res
+    res = @io.output("*IDN?").enter
+    assert_equal @name, res
   end
 
   def test_output_and_enter2
-    res = @inst.output("*idn?\r\n \r\r\r\r;;\n;;\r\n\n").enter
-    assert_match @exp[:rgx], res
-  end
-
-  def test_output_and_enter3
-    @inst << "*idn?"
-    res = "" # @inst.enter
-    @inst >> res
-    assert_match @exp[:rgx], res
+    res = @io.output("*IDN?\r\n \r\r\r\r;;\n;;\r\n\n").enter
+    assert_equal @name, res
   end
 
   def test_error_message0
-    assert_equal NO_ERROR, @inst.errstr(0)
+    assert_equal NO_ERROR, SICL.errstr(0)
   end
 
   def test_error_message1
-    assert @inst.errstr(15)
+    assert SICL.errstr(15)
   end
 
   def test_error_message2
-    assert_equal nil, @inst.errstr
+    assert_equal NO_ERROR, @io.errstr
   end
 
   def test_error_message3
     error_message = ''
 
-    @inst.on_error { |err| error_message = err[1] }
+    @io.on_error { |err| error_message = err[1] }
 
-    @inst.raise_timeout
+    @io.raise_timeout
 
     assert_equal TIMEOUT_OCCURRED, error_message
   end
@@ -252,23 +308,33 @@ class TestSicl < RUNIT::TestCase
   def test_error_message4
     error_message = ''
 
-    @inst.on_error { |num, msg| error_message = msg }
+    @io.on_error {}
 
-    @inst.raise_timeout
+    @io.raise_timeout
+
+    assert_equal TIMEOUT_OCCURRED, @io.errstr
+  end
+
+  def test_error_message5
+    error_message = ''
+
+    @io.on_error { |num, msg| error_message = msg }
+
+    @io.raise_timeout
 
     assert_equal TIMEOUT_OCCURRED, error_message
   end
 
   def test_error_close0
-    @inst.close
-    err = assert_exception(SICL::Error) { @inst.close }
+    @io.close
+    err = assert_exception(SICL::Error) { @io.close }
 
     assert_equal INVALID_INST, err.message
   end
 
   def test_error_close1
-    @inst.close
-    err = assert_exception(SICL::Error) { @inst.close }
+    @io.close
+    err = assert_exception(SICL::Error) { @io.close }
 
     assert_equal INVALID_INST, err.message
   end
@@ -276,90 +342,102 @@ class TestSicl < RUNIT::TestCase
   def test_error_timeout0
     time_limit = 10000
 
-    @inst.timeout = time_limit
+    @io.timeout = time_limit
 
-    assert_equal time_limit, @inst.timeout
+    assert_equal time_limit, @io.timeout
   end
 
   def test_error_timeout1
     err = assert_exception(SICL::Error) {
-      @inst.raise_timeout
+      @io.raise_timeout
     }
 
     assert_equal TIMEOUT_OCCURRED, err.message
   end
 
   def test_error_timeout2
-    @inst.on_error = lambda {}
+    @io.on_error = lambda {}
 
-    @inst.raise_timeout
+    @io.raise_timeout
 
     assert true
   end
 
   def test_error_timeout3
-    @inst.on_error = lambda {}
-    @inst.on_error = nil
+    @io.on_error = lambda {}
+    @io.on_error = nil
 
     err = assert_exception(SICL::Error) {
-      @inst.raise_timeout
+      @io.raise_timeout
     }
 
     assert_equal TIMEOUT_OCCURRED, err.message
   end
 
   def test_error_timeout4
-    @inst.on_error {}
+    @io.on_error {}
 
-    @inst.raise_timeout
+    @io.raise_timeout
 
     assert true
   end
 
+  def test_close
+    assert @io.close
+  end
+
   def test_abort
-    assert @inst.abort if @@address =~ /^[gh]pib/ # gpib only
+    assert @io.abort.instance_of?(@io.class) if @@address =~ /^[gh]pib/
   end
 
   def test_clear
-    assert @inst.clear
+    assert @io.clear.instance_of?(@io.class)
   end
 
   def test_spoll
-    assert @inst.spoll
+    assert @io.spoll.instance_of?(Fixnum)
+  end
+
+  def test_readstb
+    assert @io.readstb.instance_of?(Fixnum)
   end
 
   def test_local
-    assert @inst.local
+    assert @io.local.instance_of?(@io.class)
   end
 
   def test_remote
-    assert @inst.remote
+    assert @io.remote.instance_of?(@io.class)
   end
 
   def test_flush0
-    assert @inst.flush
+    assert @io.flush.instance_of?(@io.class)
   end
 
   def test_flush1
-    assert @inst.flush(SICL::BUF_DISCARD_READ | SICL::BUF_DISCARD_WRITE)
+    assert @io.flush(SICL::BUF_DISCARD_READ | SICL::BUF_DISCARD_WRITE)
   end
 
   def test_addr
-    assert_equal @inst.addr, @@address
+    assert_equal @io.addr, @@address
   end
 
   def test_addr
-    assert_equal @inst.address, @@address
+    assert_equal @io.address, @@address
+  end
+
+  def test_typerr_termchr
+    assert_exception(TypeError) { @io.termchr = " " }
   end
 
   def test_termchr0
-    assert @inst.termchr = 0x20
-    assert_equal @inst.termchr, 0x20
+    assert @io.termchr = 0x20
+    assert_equal @io.termchr, 0x20
   end
 
   def test_termchr1
-    assert @inst.termchr = " "[0]
-    assert_equal @inst.termchr, 0x20
+    assert @io.termchr = " "[0]
+    assert_equal @io.termchr, 0x20
   end
 
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.3
 specification_version: 1
 name: sicl
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-05-13 00:00:00 +09:00
-summary: Agilent SICL API module for Ruby.
+  version: 0.2.0
+date: 2007-05-18 00:00:00 +09:00
+summary: Agilent SICL API wrapper class for Ruby.
 require_paths: 
 - lib
 email: 
@@ -35,6 +35,7 @@ files:
 - Rakefile
 - ext/sicl.c
 - ext/extconf.rb
+- ext/Makefile.bcc
 - test/test_sicl.rb
 test_files: []