sys-proctable 0.9.1-universal-solaris

data/lib/sys/top.rb

@@ -0,0 +1,32 @@
+require 'sys/proctable'
+require 'rbconfig'
+
+# The Sys module serves as a namespace only
+module Sys
+
+  # The Top class serves as a toplevel name for the 'top' method.
+  class Top
+
+    # The version of the sys-top library
+    VERSION = '1.0.3'
+
+    # Returns an array of Struct::ProcTableStruct elements containing up
+    # to +num+ elements, sorted by +field+. The default number of elements
+    # is 10, while the default field is 'pctcpu'.
+    #
+    # Exception: the default sort field is 'pid' on Linux and Windows.
+    #
+    def self.top(num=10, field='pctcpu')
+      field = field.to_s if field.is_a?(Symbol)
+
+      windows = /mswin|win32|windows|dos|cygwin|mingw/i
+
+      # Sort by pid on Windows by default
+      if Config::CONFIG['host_os'].match(windows) && field == 'pctcpu'
+        field = 'pid'
+      end
+
+      Sys::ProcTable.ps.sort_by{ |obj| obj.send(field) || '' }[0..num-1]
+    end
+  end
+end

data/sys-proctable.gemspec

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'sys-proctable'
+  spec.version    = '0.9.1'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Artistic 2.0' 
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://www.rubyforge.org/projects/sysutils'
+  spec.platform   = Gem::Platform::CURRENT # Probably altered by Rake task
+  spec.summary    = 'An interface for providing process table information'
+  spec.test_files = ['test/test_sys_proctable_all.rb']
+   
+  # Additional files for your platform are added by the 'rake gem' task.
+  spec.files = [
+    'benchmarks/bench_ps.rb',
+    'examples/example_ps.rb',
+    'lib/sys/top.rb',
+    'CHANGES',
+    'MANIFEST',
+    'Rakefile',
+    'README',
+    'sys-proctable.gemspec'
+  ]
+
+  spec.rubyforge_project = 'sysutils'
+  spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST', 'doc/top.txt']
+
+  spec.add_development_dependency('test-unit', '>= 2.1.2')
+
+  spec.description = <<-EOF
+    The sys-proctable library provides an interface for gathering information
+    about processes on your system, i.e. the process table. Most major
+    platforms are supported and, while different platforms may return
+    different information, the external interface is identical across
+    platforms.
+  EOF
+end

data/test/test_sys_proctable_all.rb

@@ -0,0 +1,85 @@
+#######################################################################
+# test_sys_proctable_all.rb
+#
+# Test suite for methods common to all platforms. Generally speaking
+# you should run this test case using the 'rake test' task.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/proctable'
+require 'rbconfig'
+require 'test/test_sys_top'
+include Sys
+
+class TC_ProcTable_All < Test::Unit::TestCase
+  def self.startup
+    @@windows = Config::CONFIG['host_os'] =~ /windows|win32|msdos|mswin32|mingw|cygwin/i
+  end
+
+  def setup
+    @pid = @@windows ? 0 : 1
+  end
+
+  def test_version
+    assert_equal('0.9.1', ProcTable::VERSION)
+  end
+
+  def test_fields
+    assert_respond_to(ProcTable, :fields)
+    assert_nothing_raised{ ProcTable.fields }
+    assert_kind_of(Array, ProcTable.fields)
+    assert_kind_of(String, ProcTable.fields.first)
+  end
+
+  def test_ps
+    assert_respond_to(ProcTable, :ps)
+    assert_nothing_raised{ ProcTable.ps }
+    assert_nothing_raised{ ProcTable.ps{} }
+  end
+
+  def test_ps_with_pid
+    assert_nothing_raised{ ProcTable.ps(0) }
+  end
+
+  def test_ps_with_explicit_nil
+    assert_nothing_raised{ ProcTable.ps(nil) }
+    assert_kind_of(Array, ProcTable.ps(nil))
+  end
+
+  def test_ps_return_value
+    assert_kind_of(Array, ProcTable.ps)
+    assert_kind_of(Struct::ProcTableStruct, ProcTable.ps(@pid))
+    assert_equal(nil, ProcTable.ps(999999999))
+    assert_equal(nil, ProcTable.ps(999999999){})
+    assert_equal(nil, ProcTable.ps{})
+  end
+
+  def test_ps_returned_struct_is_frozen
+    assert_true(ProcTable.ps.first.frozen?)
+  end
+
+  def test_ps_expected_errors
+    assert_raises(TypeError){ ProcTable.ps('vim') }
+    omit_if(@@windows, 'ArgumentError check skipped on MS Windows')
+    assert_raises(ArgumentError){ ProcTable.ps(0, 'localhost') }
+  end
+
+  def test_new_not_allowed
+    assert_raise(NoMethodError){ Sys::ProcTable.new }
+  end
+
+  def test_error_class_defined
+    assert_not_nil(Sys::ProcTable::Error)
+    assert_kind_of(StandardError, Sys::ProcTable::Error.new)
+  end
+
+  def teardown
+    @pid  = nil
+  end
+
+  def self.teardown
+    @@windows = nil
+  end
+end

data/test/test_sys_proctable_sunos.rb

@@ -0,0 +1,308 @@
+#######################################################################
+# tc_sunos.rb
+#
+# Test suite for sys-proctable for SunOS/Solaris. This should be run
+# run via the 'rake test' task.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'sys/proctable'
+require 'test/test_sys_proctable_all'
+include Sys
+
+class TC_ProcTable_SunOS < Test::Unit::TestCase
+   def self.startup
+      @@fields = %w//
+   end
+
+   def setup
+      @ptable = ProcTable.ps.first
+   end
+
+   # PSINFO
+
+   def test_flag
+      assert_respond_to(@ptable, :flag)
+      assert_kind_of(Integer, @ptable.flag)
+   end
+
+   def test_nlwp
+      assert_respond_to(@ptable, :nlwp)
+      assert_kind_of(Integer, @ptable.nlwp)
+      assert_true(@ptable.nlwp >= 0)
+   end
+
+   def test_pid
+      assert_respond_to(@ptable, :pid)
+      assert_kind_of(Integer, @ptable.pid)
+      assert_true(@ptable.pid >= 0)
+   end
+
+   def test_ppid
+      assert_respond_to(@ptable, :ppid)
+      assert_kind_of(Integer, @ptable.ppid)
+      assert_true(@ptable.ppid >= 0)
+   end
+
+   def test_pgid
+      assert_respond_to(@ptable, :pgid)
+      assert_kind_of(Integer, @ptable.pgid)
+      assert_true(@ptable.pgid >= 0)
+   end
+
+   def test_sid
+      assert_respond_to(@ptable, :sid)
+      assert_kind_of(Integer, @ptable.sid)
+      assert_true(@ptable.sid >= 0)
+   end
+
+   def test_uid
+      assert_respond_to(@ptable, :uid)
+      assert_kind_of(Integer, @ptable.uid)
+      assert_true(@ptable.uid >= 0)
+   end
+
+   def test_euid
+      assert_respond_to(@ptable, :euid)
+      assert_kind_of(Integer, @ptable.euid)
+      assert_true(@ptable.euid >= 0)
+   end
+
+   def test_gid
+      assert_respond_to(@ptable, :gid)
+      assert_kind_of(Integer, @ptable.gid)
+      assert_true(@ptable.gid >= 0)
+   end
+
+   def test_egid
+      assert_respond_to(@ptable, :egid)
+      assert_kind_of(Integer, @ptable.egid)
+      assert_true(@ptable.egid >= 0)
+   end
+
+   def test_addr
+      assert_respond_to(@ptable, :addr)
+      assert_kind_of(Integer, @ptable.addr)
+      assert_true(@ptable.addr >= 0)
+   end
+
+   def test_size
+      assert_respond_to(@ptable, :size)
+      assert_kind_of(Integer, @ptable.size)
+      assert_true(@ptable.size >= 0)
+   end
+
+   def test_rssize
+      assert_respond_to(@ptable, :rssize)
+      assert_kind_of(Integer, @ptable.rssize)
+      assert_true(@ptable.rssize >= 0)
+   end
+
+   def test_ttydev
+      assert_respond_to(@ptable, :ttydev)
+      assert_kind_of(Integer, @ptable.ttydev)
+      assert_true(@ptable.ttydev >= 0 || @ptable.ttydev == -1)
+   end
+
+   def test_pctcpu
+      assert_respond_to(@ptable, :pctcpu)
+      assert_kind_of(Float, @ptable.pctcpu)
+      assert_true(@ptable.pctcpu >= 0)
+   end
+
+   def test_pctmem
+      assert_respond_to(@ptable, :pctmem)
+      assert_kind_of(Float, @ptable.pctmem)
+      assert_true(@ptable.pctmem >= 0)
+   end
+
+   def test_start
+      assert_respond_to(@ptable, :start)
+      assert_kind_of(Time, @ptable.start)
+   end
+
+   def test_time
+      assert_respond_to(@ptable, :time)
+      assert_kind_of(Integer, @ptable.time)
+      assert_true(@ptable.time >= 0)
+   end
+
+   def test_ctime
+      assert_respond_to(@ptable, :ctime)
+      assert_kind_of(Integer, @ptable.ctime)
+      assert_true(@ptable.ctime >= 0)
+   end
+
+   def test_fname
+      assert_respond_to(@ptable, :fname)
+      assert_kind_of(String, @ptable.fname)
+      assert_true(@ptable.fname.size > 0)
+   end
+
+   def test_comm_alias
+      assert_respond_to(@ptable, :comm)
+      assert_kind_of(String, @ptable.comm)
+      assert_true(@ptable.comm.size > 0)
+   end
+
+   def test_psargs
+      assert_respond_to(@ptable, :psargs)
+      assert_kind_of(String, @ptable.psargs)
+      assert_true(@ptable.psargs.size > 0)
+   end
+
+   def test_wstat
+      assert_respond_to(@ptable, :wstat)
+      assert_kind_of(Integer, @ptable.wstat)
+      assert_true(@ptable.wstat >= 0)
+   end
+
+   def test_argc
+      assert_respond_to(@ptable, :argc)
+      assert_kind_of(Integer, @ptable.argc)
+      assert_true(@ptable.argc >= 0)
+   end
+
+   def test_argv
+      assert_respond_to(@ptable, :argv)
+      assert_kind_of(Integer, @ptable.argv)
+      assert_true(@ptable.argv >= 0)
+   end
+
+   def test_envp
+      assert_respond_to(@ptable, :envp)
+      assert_kind_of(Integer, @ptable.envp)
+      assert_true(@ptable.envp >= 0)
+   end
+
+   def test_dmodel
+      assert_respond_to(@ptable, :dmodel)
+      assert_kind_of(Integer, @ptable.dmodel)
+      assert_true(@ptable.dmodel >= 0)
+   end
+
+   def test_taskid
+      assert_respond_to(@ptable, :taskid)
+      assert_kind_of(Integer, @ptable.taskid)
+      assert_true(@ptable.taskid >= 0)
+   end
+
+   def test_projid
+      assert_respond_to(@ptable, :projid)
+      assert_kind_of(Integer, @ptable.projid)
+      assert_true(@ptable.projid >= 0)
+   end
+
+   def test_nzomb
+      assert_respond_to(@ptable, :nzomb)
+      assert_kind_of(Integer, @ptable.nzomb)
+      assert_true(@ptable.nzomb >= 0)
+   end
+
+   def test_poolid
+      assert_respond_to(@ptable, :poolid)
+      assert_kind_of(Integer, @ptable.poolid)
+      assert_true(@ptable.poolid >= 0)
+   end
+
+   def test_zoneid
+      assert_respond_to(@ptable, :zoneid)
+      assert_kind_of(Integer, @ptable.zoneid)
+      assert_true(@ptable.zoneid >= 0)
+   end
+
+   def test_contract
+      assert_respond_to(@ptable, :contract)
+      assert_kind_of(Integer, @ptable.contract)
+      assert_true(@ptable.contract >= 0 || @ptable.contract == -1)
+   end
+
+   # LWPSINFO
+ 
+   def test_lwpid
+      assert_respond_to(@ptable, :lwpid)
+      assert_kind_of(Integer, @ptable.lwpid)
+      assert_true(@ptable.lwpid >= 0)
+   end
+
+   def test_wchan
+      assert_respond_to(@ptable, :wchan)
+      assert_kind_of(Integer, @ptable.wchan)
+      assert_true(@ptable.wchan >= 0)
+   end
+
+   def test_stype
+      assert_respond_to(@ptable, :stype)
+      assert_kind_of(Fixnum, @ptable.stype)
+      assert_true(@ptable.stype >= 0)
+   end
+
+   def test_state
+      assert_respond_to(@ptable, :state)
+      assert_kind_of(Fixnum, @ptable.state)
+      assert_true(@ptable.state >= 0)
+   end
+
+   def test_sname
+      assert_respond_to(@ptable, :sname)
+      assert_kind_of(String, @ptable.sname)
+      assert_true(['S', 'R', 'Z', 'T', 'I', 'O'].include?(@ptable.sname))
+   end
+
+   def test_nice
+      assert_respond_to(@ptable, :nice)
+      assert_kind_of(Fixnum, @ptable.nice)
+      assert_true(@ptable.nice >= 0)
+   end
+
+   def test_syscall
+      assert_respond_to(@ptable, :syscall)
+      assert_kind_of(Fixnum, @ptable.syscall)
+      assert_true(@ptable.syscall >= 0)
+   end
+
+   def test_pri
+      assert_respond_to(@ptable, :pri)
+      assert_kind_of(Fixnum, @ptable.pri)
+      assert_true(@ptable.pri >= 0)
+   end
+
+   def test_clname
+      assert_respond_to(@ptable, :clname)
+      assert_kind_of(String, @ptable.clname)
+      assert_true(@ptable.clname.length >= 0 && @ptable.clname.length <= 8)
+   end
+
+   def test_name
+      assert_respond_to(@ptable, :name)
+      assert_kind_of(String, @ptable.name)
+      assert_true(@ptable.name.length >= 0 && @ptable.name.length <= 16)
+   end
+
+   def test_onpro
+      assert_respond_to(@ptable, :onpro)
+      assert_kind_of(Fixnum, @ptable.onpro)
+      assert_true(@ptable.onpro >= 0)
+   end
+
+   def test_bindpro
+      assert_respond_to(@ptable, :bindpro)
+      assert_kind_of(Fixnum, @ptable.bindpro)
+      assert_true(@ptable.bindpro >= 0 || @ptable.bindpro == -1)
+   end
+
+   def test_bindpset
+      assert_respond_to(@ptable, :bindpset)
+      assert_kind_of(Fixnum, @ptable.bindpset)
+      assert_true(@ptable.bindpset >= 0 || @ptable.bindpset == -1)
+   end
+
+   def teardown
+      @ptable = nil
+   end
+
+   def self.shutdown
+      @@fields = nil
+   end
+end