sicl 0.2.0 → 1.0.0

data/test/test_sicl.rb

@@ -1,451 +1,465 @@
-#!/usr/bin/ruby
-################################################################################
-#
-#   Copyright (c) 2005-2006 Naoki Kobayashi
-#
-#   This library is free software.
-#   You can distribute/modify this script under the same terms of ruby.
-#
-#   $Header: $
-#
-################################################################################
-
-Signal.trap(:USR2) {} if RUBY_PLATFORM =~ /hpux/ # workaround ...;|
-
-################################################################################
-# OPTION SETTINGS
-################################################################################
-
-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 )
-
-################################################################################
-# PARAMETER VALIDATION
-################################################################################
-
-address = Settings[:address]
-address = "gpib0,17" unless address
-
-################################################################################
-# CLASS DECLARATION
-################################################################################
-
-require "runit/testcase"
-require "runit/cui/testrunner"
-require "sicl"
-
-class TestSicl < RUNIT::TestCase
-
-  def TestSicl.suite(address)
-    @@address = address
-    SICL.open(@@address) { |io| @@name = io.query("*IDN?") }
-    puts "#{@@address} : #{@@name}" if Settings[:debug]
-    super()
-  end
-
-  class MyInstrument < SICL::Instrument
-
-    def initialize(addr)
-      super(addr)
-
-      reset
-    end
-
-    def reset
-      output "*CLS"
-      output "*RST"
-      query "*ESR?"
-    end
-
-    def enable_srq_detection
-      output "*SRE #{0x20}"
-      output "*ESE #{0x3c}"
-    end
-
-    def disable_srq_detection
-      output "*SRE #{0x00}"
-      output "*ESE #{0x00}"
-    end
-
-    def raise_timeout(timeout=1000)
-      self.timeout = timeout
-      loop { break unless self.read }
-    end
-
-    def raise_srq(timeout=10)
-      self.output "xxx"
-      sleep timeout
-    end
-
-  end
-
-  NO_ERROR         = "No error"
-  BAD_ADDRESS      = "Bad address"
-  TIMEOUT_OCCURRED = "Timeout occurred"
-  INVALID_INST     = "Invalid INST"
-
-  ESR_BIT = 5 # Standard Event Register
-  RQS_BIT = 6 # ReQuest Service
-
-  def setup
-    @io = MyInstrument.new @@address
-    @name = @@name
-  end
-
-  def teardown
-
-    begin
-      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
-
-  end
-
-  def test_open0
-    ret = SICL.open(@@address) { |io|
-
-      res = io.write("*IDN?\n").read.chomp
-      assert_equal @name, res
-
-      res = io.output("*IDN?").enter
-      assert_equal @name, res
-
-      res = io.query("*IDN?")
-      assert_equal @name, res
-
-      io.address
-    }
-
-    assert_equal @@address, ret
-  end
-
-  def test_open1
-    err = assert_exception(SICL::Error) { SICL.open("xxx") }
-
-    assert_equal BAD_ADDRESS, err.message
-  end
-
-  def test_stb0
-    @io.output("*SRE #{0x00}")
-    @io.output("*ESE #{0x00}")
-
-    rqs = @io.query("*STB?").to_i[RQS_BIT]
-    assert_equal 0, rqs
-  end
-
-  def test_stb1
-    @io.enable_srq_detection
-
-    @io.output("xxx")
-
-    sleep 0.1
-
-    stb = @io.query("*STB?").to_i
-
-    assert_equal 1, stb[ESR_BIT]
-    assert_equal 1, stb[RQS_BIT]
-  end
-
-  def test_stb2
-    @io.enable_srq_detection
-
-    @io.output("xxx")
-
-    sleep 1
-
-    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
-
-    @io.on_srq { srq_occured = true }
-
-    @io.output("xxx")
-
-    10.times { sleep 0.1 unless srq_occured }
-
-    assert_equal true, srq_occured
-  end
-
-  def test_srq1
-    @io.enable_srq_detection
-
-    stb = 0
-
-    @io.on_srq { sleep 1; stb = @io.spoll }
-
-    @io.output("xxx")
-
-    10.times { sleep 0.1 if stb == 0 }
-
-    assert_equal 1, stb[ESR_BIT]
-    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 = @io.write("*IDN?\n")
-    assert res
-
-    res = @io.read 1
-    assert_equal @name[0].chr, res
-  end
-
-  def test_write_and_read1
-    res = @io.write("*IDN?\n").read 1
-    assert_equal @name[0].chr, res
-  end
-
-  def test_write_and_read2
-    res = @io.write("*IDN?\n").read 7
-    assert_equal @name[0...7], res
-  end
-
-  def test_write_and_read3
-    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 = @io.output("*IDN?")
-    assert res
-    res = @io.enter
-    assert_equal @name, res
-  end
-
-  def test_output_and_enter1
-    res = @io.output("*IDN?").enter
-    assert_equal @name, res
-  end
-
-  def test_output_and_enter2
-    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, SICL.errstr(0)
-  end
-
-  def test_error_message1
-    assert SICL.errstr(15)
-  end
-
-  def test_error_message2
-    assert_equal NO_ERROR, @io.errstr
-  end
-
-  def test_error_message3
-    error_message = ''
-
-    @io.on_error { |err| error_message = err[1] }
-
-    @io.raise_timeout
-
-    assert_equal TIMEOUT_OCCURRED, error_message
-  end
-
-  def test_error_message4
-    error_message = ''
-
-    @io.on_error {}
-
-    @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
-    @io.close
-    err = assert_exception(SICL::Error) { @io.close }
-
-    assert_equal INVALID_INST, err.message
-  end
-
-  def test_error_close1
-    @io.close
-    err = assert_exception(SICL::Error) { @io.close }
-
-    assert_equal INVALID_INST, err.message
-  end
-
-  def test_error_timeout0
-    time_limit = 10000
-
-    @io.timeout = time_limit
-
-    assert_equal time_limit, @io.timeout
-  end
-
-  def test_error_timeout1
-    err = assert_exception(SICL::Error) {
-      @io.raise_timeout
-    }
-
-    assert_equal TIMEOUT_OCCURRED, err.message
-  end
-
-  def test_error_timeout2
-    @io.on_error = lambda {}
-
-    @io.raise_timeout
-
-    assert true
-  end
-
-  def test_error_timeout3
-    @io.on_error = lambda {}
-    @io.on_error = nil
-
-    err = assert_exception(SICL::Error) {
-      @io.raise_timeout
-    }
-
-    assert_equal TIMEOUT_OCCURRED, err.message
-  end
-
-  def test_error_timeout4
-    @io.on_error {}
-
-    @io.raise_timeout
-
-    assert true
-  end
-
-  def test_close
-    assert @io.close
-  end
-
-  def test_abort
-    assert @io.abort.instance_of?(@io.class) if @@address =~ /^[gh]pib/
-  end
-
-  def test_clear
-    assert @io.clear.instance_of?(@io.class)
-  end
-
-  def test_spoll
-    assert @io.spoll.instance_of?(Fixnum)
-  end
-
-  def test_readstb
-    assert @io.readstb.instance_of?(Fixnum)
-  end
-
-  def test_local
-    assert @io.local.instance_of?(@io.class)
-  end
-
-  def test_remote
-    assert @io.remote.instance_of?(@io.class)
-  end
-
-  def test_flush0
-    assert @io.flush.instance_of?(@io.class)
-  end
-
-  def test_flush1
-    assert @io.flush(SICL::BUF_DISCARD_READ | SICL::BUF_DISCARD_WRITE)
-  end
-
-  def test_addr
-    assert_equal @io.addr, @@address
-  end
-
-  def test_addr
-    assert_equal @io.address, @@address
-  end
-
-  def test_typerr_termchr
-    assert_exception(TypeError) { @io.termchr = " " }
-  end
-
-  def test_termchr0
-    assert @io.termchr = 0x20
-    assert_equal @io.termchr, 0x20
-  end
-
-  def test_termchr1
-    assert @io.termchr = " "[0]
-    assert_equal @io.termchr, 0x20
-  end
-
-end
-
-################################################################################
-# MAIN ROUTINE
-################################################################################
-
-if $0 == __FILE__ then
-  RUNIT::CUI::TestRunner.run(TestSicl.suite(address))
-end
+#!/usr/bin/ruby
+################################################################################
+#
+#   Copyright (c) 2005-2006 Naoki Kobayashi
+#
+#   This library is free software.
+#   You can distribute/modify this script under the same terms of ruby.
+#
+#   $LastChangedDate$
+#   $Revision$
+#   $Author$
+#
+################################################################################
+
+Signal.trap(:USR2) {} if RUBY_PLATFORM =~ /hpux/ # workaround ...;|
+
+################################################################################
+# OPTION SETTINGS
+################################################################################
+
+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 )
+
+################################################################################
+# PARAMETER VALIDATION
+################################################################################
+
+address = Settings[:address]
+address = "gpib0,17" unless address
+
+################################################################################
+# CLASS DECLARATION
+################################################################################
+
+require "runit/testcase"
+require "runit/cui/testrunner"
+require "sicl"
+
+class TestSicl < RUNIT::TestCase
+
+  def TestSicl.suite(address)
+    @@address = address
+    SICL.open(@@address) { |io| @@name = io.query("*IDN?") }
+    puts "#{@@address} : #{@@name}" if Settings[:debug]
+    super()
+  end
+
+  class MyInstrument < SICL::Instrument
+
+    def initialize(addr)
+      super(addr)
+
+      reset
+    end
+
+    def reset
+      output "*CLS"
+      output "*RST"
+      query "*ESR?"
+    end
+
+    def enable_srq_detection
+      output "*SRE #{0x20}"
+      output "*ESE #{0x3c}"
+    end
+
+    def disable_srq_detection
+      output "*SRE #{0x00}"
+      output "*ESE #{0x00}"
+    end
+
+    def raise_timeout(timeout=1000)
+      self.timeout = timeout
+      loop { break unless self.read }
+    end
+
+    def raise_srq(timeout=10)
+      self.output "xxx"
+      sleep timeout
+    end
+
+  end
+
+  NO_ERROR         = "No error"
+  BAD_ADDRESS      = "Bad address"
+  TIMEOUT_OCCURRED = "Timeout occurred"
+  INVALID_INST     = "Invalid INST"
+
+  ESR_BIT = 5 # Standard Event Register
+  RQS_BIT = 6 # ReQuest Service
+
+  def setup
+    @io = MyInstrument.new @@address
+    @name = @@name
+  end
+
+  def teardown
+
+    begin
+      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
+
+  end
+
+  def test_open0
+    ret = SICL.open(@@address) { |io|
+
+      res = io.query("*IDN?")
+      assert_equal @name, res
+
+      io.address
+    }
+
+    assert_equal @@address, ret
+  end
+
+  def test_open1
+    err = assert_exception(SICL::Error) { SICL.open("xxx") }
+
+    assert_equal BAD_ADDRESS, err.message
+  end
+
+  def test_open2
+    ret = SICL::Instrument.open(@@address) { |io|
+
+      res = io.query("*IDN?")
+      assert_equal @name, res
+
+      io.address
+    }
+
+    assert_equal @@address, ret
+  end
+
+  def test_open3
+    err = assert_exception(SICL::Error) { SICL::Instrument.open("xxx") }
+
+    assert_equal BAD_ADDRESS, err.message
+  end
+
+  def test_stb0
+    @io.output("*SRE #{0x00}")
+    @io.output("*ESE #{0x00}")
+
+    rqs = @io.query("*STB?").to_i[RQS_BIT]
+    assert_equal 0, rqs
+  end
+
+  def test_stb1
+    @io.enable_srq_detection
+
+    @io.output("xxx")
+
+    sleep 0.1
+
+    stb = @io.query("*STB?").to_i
+
+    assert_equal 1, stb[ESR_BIT]
+    assert_equal 1, stb[RQS_BIT]
+  end
+
+  def test_stb2
+    @io.enable_srq_detection
+
+    @io.output("xxx")
+
+    sleep 1
+
+    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
+
+    @io.on_srq { srq_occured = true }
+
+    @io.output("xxx")
+
+    10.times { sleep 0.1 unless srq_occured }
+
+    assert_equal true, srq_occured
+  end
+
+  def test_srq1
+    @io.enable_srq_detection
+
+    stb = 0
+
+    @io.on_srq { sleep 1; stb = @io.spoll }
+
+    @io.output("xxx")
+
+    10.times { sleep 0.1 if stb == 0 }
+
+    assert_equal 1, stb[ESR_BIT]
+    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 = @io.write("*IDN?\n")
+    assert res
+
+    res = @io.read 1
+    assert_equal @name[0].chr, res
+  end
+
+  def test_write_and_read1
+    res = @io.write("*IDN?\n").read 1
+    assert_equal @name[0].chr, res
+  end
+
+  def test_write_and_read2
+    res = @io.write("*IDN?\n").read 7
+    assert_equal @name[0...7], res
+  end
+
+  def test_write_and_read3
+    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 = @io.output("*IDN?")
+    assert res
+    res = @io.enter
+    assert_equal @name, res
+  end
+
+  def test_output_and_enter1
+    res = @io.output("*IDN?").enter
+    assert_equal @name, res
+  end
+
+  def test_output_and_enter2
+    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, SICL::Error.errstr(0)
+  end
+
+  def test_error_message1
+    assert SICL::Error.errstr(15)
+  end
+
+  def test_error_message2
+    assert_equal NO_ERROR, @io.errstr
+  end
+
+  def test_error_message3
+    error_message = ''
+
+    @io.on_error { |err| error_message = err[1] }
+
+    @io.raise_timeout
+
+    assert_equal TIMEOUT_OCCURRED, error_message
+  end
+
+  def test_error_message4
+    error_message = ''
+
+    @io.on_error {}
+
+    @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
+    @io.close
+    err = assert_exception(SICL::Error) { @io.close }
+
+    assert_equal INVALID_INST, err.message
+  end
+
+  def test_error_close1
+    @io.close
+    err = assert_exception(SICL::Error) { @io.close }
+
+    assert_equal INVALID_INST, err.message
+  end
+
+  def test_error_timeout0
+    time_limit = 10000
+
+    @io.timeout = time_limit
+
+    assert_equal time_limit, @io.timeout
+  end
+
+  def test_error_timeout1
+    err = assert_exception(SICL::Error) {
+      @io.raise_timeout
+    }
+
+    assert_equal TIMEOUT_OCCURRED, err.message
+  end
+
+  def test_error_timeout2
+    @io.on_error = lambda {}
+
+    @io.raise_timeout
+
+    assert true
+  end
+
+  def test_error_timeout3
+    @io.on_error = lambda {}
+    @io.on_error = nil
+
+    err = assert_exception(SICL::Error) {
+      @io.raise_timeout
+    }
+
+    assert_equal TIMEOUT_OCCURRED, err.message
+  end
+
+  def test_error_timeout4
+    @io.on_error {}
+
+    @io.raise_timeout
+
+    assert true
+  end
+
+  def test_close
+    assert @io.close
+  end
+
+  def test_abort
+    assert @io.abort.instance_of?(@io.class) if @@address =~ /^[gh]pib/
+  end
+
+  def test_clear
+    assert @io.clear.instance_of?(@io.class)
+  end
+
+  def test_spoll
+    assert @io.spoll.instance_of?(Fixnum)
+  end
+
+  def test_readstb
+    assert @io.readstb.instance_of?(Fixnum)
+  end
+
+  def test_local
+    assert @io.local.instance_of?(@io.class)
+  end
+
+  def test_remote
+    assert @io.remote.instance_of?(@io.class)
+  end
+
+  def test_flush0
+    assert @io.flush.instance_of?(@io.class)
+  end
+
+  def test_flush1
+    assert @io.flush(SICL::BUF_DISCARD_READ | SICL::BUF_DISCARD_WRITE)
+  end
+
+  def test_addr
+    assert_equal @io.addr, @@address
+  end
+
+  def test_addr
+    assert_equal @io.address, @@address
+  end
+
+  def test_typerr_termchr
+    assert_exception(TypeError) { @io.termchr = " " }
+  end
+
+  def test_termchr0
+    assert @io.termchr = 0x20
+    assert_equal @io.termchr, 0x20
+  end
+
+  def test_termchr1
+    assert @io.termchr = " "[0]
+    assert_equal @io.termchr, 0x20
+  end
+
+end
+
+################################################################################
+# MAIN ROUTINE
+################################################################################
+
+if $0 == __FILE__ then
+  RUNIT::CUI::TestRunner.run(TestSicl.suite(address))
+end