sys-cpu 0.5.5-i586-linux

data/CHANGES

@@ -0,0 +1,113 @@
+== 0.5.5 - 17-Nov-2006
+* Fixed a bug in the Linux version where there could be a key but no
+   associated value, causing a String#strip! call to fail.  Now the value is
+   simply left at nil.
+* Refactored the CPU.processors method on Linux, including the removal of '?'
+  from the CPUStruct members for the boolean methods (Ruby doesn't like them).
+* Minor tweaks and updates to the documentation, including the README.
+* Modified the gemspec so that it sets the platform properly for Linux
+  and Windows.
+
+== 0.5.4 - 12-Jul-2006
+* Added a gemspec (and a gem on RubyForge).
+* The CPU.architecture method on HP-UX now returns nil if it cannot be
+  determined instead of "Unknown" for consistency with the other
+  platforms.
+* Inlined the RDoc and made some minor cosmetic source code changes.
+
+== 0.5.3 - 4-May-2006
+* Fixed in a bug in the Solaris version where CPU.load_avg returned bad values
+  when compiled in 64 bit mode.  Thanks go to James Hranicky for the spot and
+  both James Hranicky and Peter Tribble (via comp.unix.solaris) for patches.
+* Made some modifications to the test suite.  You know longer need to know
+  which test suite to run.  All platforms now use 'ts_all.rb', which will run
+  the appropriate test case behind the scenes.
+
+== 0.5.2 - 24-Jun-2005
+* Bug fixed on Linux where empty lines could cause problems.  This affected
+  both the install.rb and linux.rb files, though it only seems to have been
+  an issue on the 2.6+ kernel.
+* Altered the behavior of the CPU.cpu_stats method on Linux.  Now, only the
+  numbered cpu entries return associated data, unless the numberless entry
+  is the only entry.
+* Added a sample program for Linux under the 'examples' directory.
+
+== 0.5.1 - 5-May-2005
+* Fixed a potential bug in the FreeBSD version of CPU.model.
+* Eliminated some warnings in the FreeBSD version.
+* Moved examples directory to the toplevel package directory.
+* Renamed and updated the sample scripts.
+* Added a sample script for FreeBSD.
+* Removed the INSTALL file.  That information is now included in the README.
+* Made the CHANGES, README, and .txt files rdoc friendly.
+* The dynamic documentation generation for Linux has been altered.  Anything
+  relating to rd2 has been removed.  The doc file generated is now
+  doc/linux.txt.
+* Some $LOAD_PATH setup changes in the unit tests.
+
+== 0.5.0 - 26-Jun-2004
+* Now requires Ruby 1.8.0 or later.
+* FreeBSD support added.
+* Replaced 'CPUException' with 'CPUError'
+* The MS Windows version has been completely revamped to use WMI instead of
+  the C API.  Some method names have changed and some methods have been
+  dropped entirely.  Please see the documentation for details.
+* Corresponding documentation updates and test suite changes.
+* Sample programs have been moved to doc/examples.
+* Installation procedure somewhat revamped.
+* No longer autogenerates test file.
+* The .html files have been removed.  You can generate the html on your own
+  if you like.
+
+== 0.4.0 - 18-Sep-2003
+* Added MS Windows support
+* Changed some method names.  The "cpu" has been dropped from most method
+  names.  See documentation for details.
+* The state() and freq() methods (where supported) now assume a default 
+  value of zero.
+* More unit tests added.
+* Fixed minor issue with test.rb for those without TestUnit installed.
+* Fixed issue with linux.rb file being auto-installed on non-Linux platforms.
+* Minor API change for the load_avg() method on HP-UX.  It now accepts a
+  CPU number as an argument.
+
+== 0.3.1 - 16-Jul-2003
+* Fixed a bug in the Solaris version that was using up and not
+  freeing file descriptors.
+* Added html doc for Solaris under doc directory.
+* Minor changes to test_hpux.rb and test_sunos.rb
+* Minor README changes.
+
+== 0.3.0 - 30-Jun-2003
+* Added HP-UX support
+* Removed the VERSION class method.  Use the constant instead
+* Changed license to "Artistic"
+* Moved version info into its own file for convenience
+* Some minor mods to the test suites
+* Modified extconf.rb, moving some of the dynamic test generation
+  into separate files
+
+== 0.2.2 - 25-Mar-2003
+* fpu_type and cpu_type now return nil if not found (Solaris)
+* CPUException is now a direct subclass of StandardError
+* Modified extconf.rb script
+* Minor doc updates
+* Added another test to the solaris test suite
+* Important note added to INSTALL file
+
+== 0.2.1 - 12-Mar-2003
+* Added the cpu_stats() class method for Linux, which contains the
+  data from the 'cpu' lines of /proc/stat
+* Minor fix for extconf.rb (thanks Michael Granger)
+* Some tests added to Linux test suite
+* MANIFEST correction
+
+== 0.2.0 - 13-Feb-2003
+* Linux support added (pure Ruby only)
+* Many changes to extconf.rb to support Linux version
+* sys-uname prerequisite dropped
+* rd2 documentation now kept separate from source
+
+== 0.1.0 - 3-Feb-2003
+* Initial release
+* Currently supports Solaris (only)

data/README

@@ -0,0 +1,78 @@
+= Description
+   A Ruby interface for getting cpu information.
+
+= Installation
+=== Linux and Windows:
+   ruby test/ts_all.rb (optional)
+   ruby install.rb
+
+=== All other platforms:
+   ruby extconf.rb
+   make
+   ruby test/ts_all.rb (optional)
+   make site-install
+
+= Notes
+=== All Platforms
+   As of version 0.5.0 Ruby 1.8.0 or later is required.  It may work with
+   earlier versions, but I will not support it.  In addition, a test file is
+   no longer auto-generated for you.  If wish to run the test suite, cd to the
+   'test' directory and run the test suite appropriate for your platform.
+
+=== Solaris
+   Currently there is no 'processors()' iterative method for multi-cpu systems.
+   I plan to add it this in a future release.
+
+=== Linux
+   This is pure Ruby.  This version reads information out of /proc/cpuinfo and
+   /proc/loadavg, so if /proc isn't mounted it won't work.
+
+   The key-value information in /proc/cpuinfo is stored internally (i.e. in
+   memory) as an array of hashes when you first 'require' this package.  This
+   overhead is exceptionally minimal, given that your average cpuinfo file
+   contains less than 1k of text (and I don't store whitespace or newlines).
+
+   The text documentation for Linux is dynamically generated during the
+   build process because the fields vary depending on your setup.  So, don't
+   look at it until *after* you've installed it.  You will see a doc/linux.txt
+   file after you run install.rb.
+
+=== HP-UX
+   Unlike other platforms, you can get load averages for an individual cpu (in
+   multi-cpu systems).  See documentation for more details.
+
+=== Win32
+   This is a pure Ruby implementation using the win32ole package + WMI.  The C
+   version has been scrapped. 
+
+   As of version 0.5.0, the CPU.usage method has been removed in favor of the
+   CPU.load_avg method.  This does not (currently) use a perf counter, so there
+   is no longer any delay.  Also, the 'processors' method has been
+   added and the 'supported' method has been dropped.  See the documentation
+   for other changes.
+
+= Known Bugs
+   None that I'm aware of.  Please report bugs on the project page at
+   http://www.rubyforge.org/projects/sysutils.
+
+= Future Plans
+=== Solaris
+   Add iterative CPU.processors method.
+   Add more information in general, such as what 'prtdiag' shows.
+
+= License
+   Ruby's.
+
+= Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+= Author
+   Daniel J. Berger
+   djberg96 at gmail dot com
+   imperator on IRC (irc.freenode.net)

data/doc/freebsd.txt

@@ -0,0 +1,65 @@
+= Description
+   Sys::CPU - An interface for various cpu statistics
+   
+= Synopsis
+   require "sys/cpu"
+   include Sys
+
+   # FreeBSD
+   puts "Architecture: " + CPU.architecture
+   puts "Machine: " + CPU.machine
+   puts "Mhz: " + CPU.cpu_freq.to_s
+   puts "Number of cpu's on this system: " + CPU.num_cpu.to_s
+   puts "CPU model: " + CPU.model
+   puts "Load averages: " + CPU.load_avg.join(", ")
+   
+= Constants
+VERSION
+   Returns the current version number for this package.
+    
+= Class Methods
+CPU.architecture
+   Returns the cpu's architecture.
+
+CPU.freq
+   Returns an integer indicating the speed (i.e. frequency in Mhz) of
+   the cpu.
+    
+CPU.load_avg
+   Returns an array of three floats indicating the 1, 5 and 15 minute load
+   average.
+    
+CPU.machine
+   Returns the class of cpu (probably identical to the architecture).
+
+CPU.model
+   Returns a string indicating the cpu model.
+    
+CPU.num_cpu
+   Returns an integer indicating the number of cpu's on the system.
+    
+= Error Classes
+CPUError < StandardError
+   Raised is response to internal function errors, usually relating to an
+   invalid cpu number.
+    
+= Known Bugs
+   None known.  Please post bug reports to the SourceForge home page at
+   http://www.rubyforge.org/projects/sysutils
+    
+= Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+= License
+   Ruby's
+    
+= Author
+   Daniel J. Berger
+   djberg96 at yahoo dot com
+   imperator/rubyhacker1 on IRC (Freenode)

data/doc/hpux.txt

@@ -0,0 +1,75 @@
+= Description
+   Sys::CPU - An interface for various cpu statistics
+   
+= Synopsis
+   require "sys/cpu"
+   include Sys
+
+   puts "Mhz: " + CPU.cpu_freq.to_s
+   puts "State: " + CPU.state(0)
+   puts "Number of cpu's on this system: " + CPU.num_cpu.to_s
+   puts "Number of active cpu's: " + CPU.num_active_cpu.to_s
+   puts "Load averages: " + CPU.load_avg.join(", ")
+   
+= Constants
+VERSION
+   Returns the current version number for this package.
+    
+= Class Methods
+CPU.architecture
+   Returns the cpu architecture, e.g. PA RISC 1.2, etc.
+    
+CPU.freq(cpu_num=0)
+   Returns an integer indicating the speed (i.e. frequency in Mhz) of
+   the cpu.
+    
+CPU.load_avg
+CPU.load_avg(cpu_num)
+CPU.load_avg{ |cpu| ... }
+
+   In non-block form returns an array of three floats indicating the 1, 5
+   and 15 minute overall load average.
+
+   In block form, it returns an array of three floats indicating the 1, 5
+   and 15 minute load average for each cpu.  Only useful on multi-cpu
+   systems.
+
+   If 'cpu_num' is provided, returns the load average (as a 3-element
+   array) for that cpu only.
+
+   You cannot provide a cpu number and use block form at the same time.
+    
+CPU.num_cpu
+   Returns an integer indicating the number of cpu's on the system.
+    
+CPU.num_active_cpu
+   Returns an integer indicating the number of active cpu's on the system.
+    
+= Error Classes
+CPUError < StandardError
+   Raised is response to internal function errors, usually relating to an
+   invalid cpu number.
+    
+= Known Bugs
+   No bugs known.  Please log any bugs at
+   http://www.rubyforge.org/projects/sysutils
+    
+= Future Plans
+   Add cpu model and type
+   
+= Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+    
+= License
+   Ruby's
+    
+= Author
+   Daniel J. Berger
+   djberg96 at yahoo dot com
+   imperator/rubyhacker1 on IRC (Freenode)

data/doc/linux.txt

@@ -0,0 +1,41 @@
+== Description
+    Sys::CPU - An interface for various cpu statistics
+
+== Synopsis
+    require "sys/cpu"
+    include Sys
+
+    CPU.processors{ |cs|
+       cs.members.each{ |m|
+          puts "#{m}: " + cs[m].to_s
+       }
+    }
+
+    CPU.bogomips(1) # -> returns bogomips for cpu #2
+
+== Notes
+   Portions of this documentation built dynamically
+
+== Constants
+VERSION
+   Returns the current version number for this package as a String.
+
+== Class Methods
+CPU.load_avg
+    Returns an array of three floats indicating the 1, 5 and 15 minute load
+    average.
+
+CPU.cpu_stats
+    Returns a hash, with the cpu number as the key and an array as the value.
+    The array contains the number of seconds that the system spent in
+    user mode, user mode with low priority (nice), system mode, and the
+    idle task, respectively, for that cpu.
+
+CPU.processors{ |cpu struct| block }
+    Calls the block for each processor on your system, passing a CPUStruct as the
+    parameter.
+
+    The exact members of the CPUStruct are the same as the class method names, except
+    for CPU.processors (although you may optionally omit the "?" when referring to a
+    struct member).  These were determined when you installed this package because they
+    vary from one chip architecture to another.

data/doc/sunos.txt

@@ -0,0 +1,76 @@
+= Description
+   Sys::CPU - An interface for various cpu statistics
+   
+= Synopsis
+   require "sys/cpu"
+   include Sys
+
+   # Solaris
+   puts "Mhz: " + CPU.cpu_freq(0).to_s
+   puts "State: " + CPU.state(0)
+   puts "Number of cpu's on this system: " + CPU.num_cpu.to_s
+   puts "CPU type: " + CPU.type
+   puts "FPU type: " + CPU.fpu_type
+   puts "CPU model: " + CPU.model
+   puts "Load averages: " + CPU.load_avg.join(", ")
+   
+= Constants
+VERSION
+   Returns the current version number for this package.
+    
+= Class Methods
+CPU.freq(cpu_num=0)
+   Returns an integer indicating the speed (i.e. frequency in Mhz) of
+   'cpu_num', or CPU 0 if no number is provided.
+    
+CPU.type
+   Returns a string indicating the type of processor.  This is the
+   architecture (e.g. sparcv9), not the exact model (e.g. Ultra-IIe).
+   Returns nil if not found.
+    
+CPU.fpu_type
+   Returns a string indicating the type of floating point unit, or nil if
+   not found.
+    
+CPU.load_avg
+   Returns an array of three floats indicating the 1, 5 and 15 minute load
+   average.
+    
+CPU.model
+   Returns a string indicating the cpu model.  For now, this is the
+   architecture type, rather than the exact model.  However, see the
+   'Future Plans' section below.
+    
+CPU.num_cpu
+   Returns an integer indicating the number of cpu's on the system.
+    
+CPU.state(cpu_num)
+   Returns a string indicating the cpu state of 'cpu_num'.
+    
+= Error Classes
+CPUError < StandardError
+   Raised is response to internal function errors, usually relating to an
+   invalid cpu number.
+    
+= Known Bugs
+   None known.  Please post bug reports to the SourceForge home page at
+   http://www.rubyforge.org/projects/sysutils
+    
+= Future Plans
+   Add more information, such as what prtdiag shows.
+   Get the model() method to display more specific information.
+    
+= Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+    
+= License
+   Ruby's
+    
+= Author
+   Daniel J. Berger

data/doc/windows.txt

@@ -0,0 +1,152 @@
+= Description
+   Sys::CPU - An interface for various cpu statistics
+    
+= Synopsis
+   require "sys/cpu"
+   include Sys
+
+   CPU.processors{ |cs|
+      cs.members.each{ |m|
+         puts "#{m}: " + cs[m].to_s
+      }
+   }
+
+   puts "CPU Speed (Frequency): " + CPU.freq(0).to_s
+   puts "Load avg: " + CPU.load_avg.to_s
+   puts "Num CPU: " + CPU.num_cpu.to_s
+   puts "Type: " + CPU.type
+   puts "Model: " + CPU.model
+   puts "Architecture: " + CPU.architecture
+    
+= Constants
+VERSION
+   Returns the current version number for this package.
+    
+= Class Methods
+CPU.architecture(host=localhost)
+   Returns the architecture of the cpu, e.g. x86 Family 15 Model 2
+    
+CPU.freq(cpu_num=0, host=localhost)
+   Returns an integer indicating the speed (i.e. frequency in Mhz) of
+   'cpu_num'.  If cpu_num+1 is greater than the number of cpu's on
+   your system, or this call fails for any other reason, a CPUError
+   is raised.
+    
+CPU.load_avg(host=localhost)
+   Returns the load capacity of each processor, averaged to the last second.
+   Processor loading refers to the total computing burden for each
+   processor at one time.
+	
+   Note that this attribute is actually the LoadPercentage.  I may use
+   one of the Win32_Perf* classes in the future.
+	
+CPU.model(host=localhost)
+   Returns a string indicating the cpu model, e.g. Intel Pentium 4
+    
+CPU.num_cpu(host=localhost)
+   Returns an integer indicating the number of cpu's on the system.
+    
+CPU.processors(host=localhost){ |cpu| ... }
+   Returns a CPUStruct for each CPU on the system containing the following
+   members:
+	
+   * address_width
+   * architecture
+   * availability
+   * caption
+   * config_manager_error_code
+   * config_manager_user_config
+   * cpu_status
+   * creation_class_name
+   * freq
+   * voltage
+   * data_width
+   * description
+   * device_id
+   * error_cleared?
+   * error_description
+   * ext_clock
+   * family
+   * install_date
+   * l2_cache_size
+   * l2_cache_speed
+   * last_error_code
+   * level
+   * load_avg
+   * manufacturer
+   * max_clock_speed
+   * name
+   * other_family_description
+   * pnp_device_id
+   * power_management_supported?
+   * power_management_capabilities
+   * processor_id
+   * processor_type
+   * revision
+   * role
+   * socket_designation
+   * status
+   * status_info
+   * stepping
+   * system_creation_class_name
+   * system_name
+   * unique_id
+   * upgrade_method
+   * version
+   * voltage_caps
+   
+   Note that not all of these members will necessarily be defined.  See the
+   NOTES section below.
+    
+CPU.type(host=localhost)
+    Returns a string indicating the type of processor, e.g. GenuineIntel.
+    
+= Exception Classes
+CPUError < StandardError
+   Raised is response to internal function errors, most likely to be raised
+   in the event that in invalid cpu number is provided for the 'freq'
+   method.
+    
+= Notes
+   Some of the CPUStruct members may be nil.  As far as I can tell, this
+   means that Windows is unable to determine the value for the attribute due
+   to your BIOS and/or BIOS settings.  There is nothing clear in the
+   documentation I could find for this, however.
+	
+   The 'family' attribute may contain the trademark symbol.
+	
+   The 'status_info' attribute was not converted to a string because the
+   'status' attribute already is a string.  I'm not even sure why MS has both
+   versions.
+	
+   The 'system_name' attribute appears to be the hostname.  I have no idea
+   why this is included as part of the CPU information, but there you go.
+	
+   See http://tinyurl.com/2mros (and click on 'Win32_Processor' in the left
+   frame) for a list of attributes and their meaning.  Link courtesy of
+   tinyurl.com.	
+
+= Known Bugs
+   No bugs known.  Please log any bugs at
+   http://www.rubyforge.org/projects/sysutils
+
+= Future Plans
+   Add more detailed CPU usage information via the
+   Win32_PerfFormattedData_PerfOS_Processor class.
+    
+= Copyright
+   (C) 2003-2006 Daniel J. Berger
+   All Rights Reserved
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+= License
+   Ruby's
+    
+= Author
+   Daniel J. Berger
+   djberg96 at yahoo dot com
+   imperator/rubyhacker1 on IRC (Freenode)

data/lib/sys/cpu.rb

@@ -0,0 +1,105 @@
+##########################################################
+# linux.rb (sys-cpu) - pure Ruby version for Linux
+##########################################################
+module Sys
+   cpu_file     = "/proc/cpuinfo"
+   cpu_hash     = {}
+   $cpu_array   = []
+
+   # Parse the info out of the /proc/cpuinfo file
+   IO.foreach(cpu_file){ |line|
+      line.strip!
+      next if line.empty?
+
+      key, val = line.split(":")
+      key.strip!
+      key.gsub!(/\s+/,"_")
+      key.downcase!
+      val.strip! if val
+
+      if cpu_hash.has_key?(key)
+         $cpu_array.push(cpu_hash.dup)
+         cpu_hash.clear
+      end
+      
+      # Turn yes/no attributes into booleans
+      if val == 'yes'
+         val = true
+      elsif val == 'no'
+         val = false
+      end
+      cpu_hash[key] = val
+   }
+
+   $cpu_array.push(cpu_hash)
+
+   class CPU
+
+      VERSION = '0.5.5'
+      CPUStruct = Struct.new("CPUStruct", *$cpu_array.first.keys)
+
+      # In block form, yields a CPUStruct for each CPU on the system.  In
+      # non-block form, returns an Array of CPUStruct's.
+      #
+      # The exact members of the struct vary on Linux systems.
+      #
+      def self.processors
+         array = []
+         $cpu_array.each{ |hash|
+            struct = CPUStruct.new
+            struct.members.each{ |m| struct.send("#{m}=", hash[m]) }
+            if block_given?
+               yield struct
+            else
+               array << struct
+            end
+         }
+         array unless block_given?
+      end
+
+      #--
+      # Create singleton methods for each of the attributes
+      #
+      def self.method_missing(id,arg=0)
+         rv = $cpu_array[arg][id.to_s]
+         if rv.nil?
+            id = id.to_s + "?"
+            rv = $cpu_array[arg][id]
+         end
+         rv
+      end
+
+      # Returns a 3 element Array corresponding to the 1, 5 and 15 minute
+      # load average for the system.
+      #
+      def self.load_avg
+         load_avg_file = "/proc/loadavg"
+         IO.readlines(load_avg_file).first.split[0..2].map{|e| e.to_f}
+      end
+
+      # Returns a hash of arrays that contain the number of seconds that the
+      # system spent in user mode, user mode with low priority (nice), system
+      # mode, and the idle task, respectively.
+      #
+      def self.cpu_stats
+         cpu_stat_file = "/proc/stat"
+         hash = {} # Hash needed for multi-cpu systems
+
+         lines = IO.readlines(cpu_stat_file)
+         lines.each_with_index{ |line, i|
+            array = line.split
+            break unless array[0] =~ /cpu/   # 'cpu' entries always on top
+            
+            # Some machines list a 'cpu' and a 'cpu0'.  In this case, only
+            # return values for the numbered cpu entry.
+            if lines[i].split[0] == "cpu" && lines[i+1].split[0] =~ /cpu\d/
+               next
+            end
+
+            vals = array[1..-1].map{ |e| e = e.to_i / 100 } # 100 jiffies/sec.
+            hash[array[0]] = vals
+         }
+         hash
+      end
+   end
+end

data/test/tc_freebsd.rb

@@ -0,0 +1,71 @@
+###########################################################
+# tc_freebsd.rb
+#
+# Test suite for sys-cpu on FreeBSD.  This should only be
+# run *after* the make process.
+###########################################################
+base = File.basename(Dir.pwd)
+if base == "test" || base =~ /sys-cpu/
+   require "ftools"
+   Dir.chdir ".." if base == "test"
+   
+   Dir.mkdir("sys") unless File.exist?("sys")
+
+   if File.exist?("cpu.so")
+      File.copy("cpu.so","sys")
+   else
+      puts "No cpu.so file found.  Please run extconf.rb and make first"
+      exit
+   end
+
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "sys/cpu"
+require "test/unit"
+include Sys
+
+class TC_FreeBSD < Test::Unit::TestCase
+   def test_architecture
+      assert_respond_to(CPU, :architecture)
+      assert_nothing_raised{ CPU.architecture }
+      assert_kind_of(String,CPU.architecture)
+      assert_raises(ArgumentError){ CPU.architecture(0) }
+   end
+
+   def test_cpu_freq
+      assert_respond_to(CPU, :freq)
+      assert_nothing_raised{ CPU.freq }
+      assert_kind_of(Integer,CPU.freq)
+      assert_raises(ArgumentError){ CPU.freq(0) }
+   end
+
+   def test_load_avg
+      assert_respond_to(CPU, :load_avg)
+      assert_nothing_raised{ CPU.load_avg }
+      assert_kind_of(Array,CPU.load_avg)
+      assert_equal(3,CPU.load_avg.length)
+      assert_raises(ArgumentError){ CPU.load_avg(0) }
+   end
+   
+   def test_machine
+      assert_respond_to(CPU, :machine)
+      assert_nothing_raised{ CPU.machine }
+      assert_kind_of(String,CPU.machine)
+      assert_raises(ArgumentError){ CPU.machine(0) }
+   end
+
+   def test_model
+      assert_respond_to(CPU, :model)
+      assert_nothing_raised{ CPU.model }
+      assert_kind_of(String,CPU.model)
+      assert_raises(ArgumentError){ CPU.model(0) }
+   end
+
+   def test_num_cpu
+      assert_respond_to(CPU, :num_cpu)
+      assert_nothing_raised{ CPU.num_cpu }
+      assert_kind_of(Integer,CPU.num_cpu)
+      assert_raises(ArgumentError){ CPU.num_cpu(0) }
+   end
+end

data/test/tc_hpux.rb

@@ -0,0 +1,63 @@
+####################################################
+# tc_hpux.rb
+#
+# Test suite for the HP-UX platform.  Note that this should only
+# be run *after* the make process.
+####################################################
+base = File.basename(Dir.pwd)
+if base == "test" || base =~ /sys-cpu/
+   require "ftools"
+   Dir.chdir ".." if base == "test"
+   
+   Dir.mkdir("sys") unless File.exists?("sys")
+   if File.exist?("cpu.sl")
+      File.copy("cpu.sl","sys")
+   else
+      puts "No cpu.sl file found.  Please run extconf.rb and make first"
+      exit
+   end
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "sys/cpu"
+require "test/unit"
+include Sys
+
+class TC_HPUX < Test::Unit::TestCase
+   def test_cpu_freq
+      assert_respond_to(CPU, :freq)
+      assert_nothing_raised{ CPU.freq }
+      assert_nothing_raised{ CPU.freq(0) }
+      assert_kind_of(Integer,CPU.freq,"Invalid Type")
+   end
+
+   def test_num_cpu
+      assert_respond_to(CPU, :num_cpu)
+      assert_nothing_raised{ CPU.num_cpu }
+      assert_kind_of(Integer,CPU.num_cpu,"Invalid Type")
+   end
+
+   def test_num_active_cpu
+      assert_respond_to(CPU, :num_active_cpu)
+      assert_nothing_raised{ CPU.num_active_cpu }
+      assert_kind_of(Integer,CPU.num_active_cpu,"Invalid Type")
+   end
+
+   def test_cpu_architecture
+      assert_respond_to(CPU, :architecture)
+      assert_nothing_raised{ CPU.architecture }
+      assert_kind_of(String,CPU.architecture,"Invalid Type")
+   end
+
+   def test_load_avg
+      assert_respond_to(CPU, :load_avg)
+      assert_nothing_raised{ CPU.load_avg }
+      assert_nothing_raised{ CPU.load_avg(0) }
+      assert_nothing_raised{ CPU.load_avg{ |e| } }
+      assert_raises(ArgumentError){ CPU.load_avg(0){ } }
+      assert_kind_of(Array,CPU.load_avg,"Invalid Type")
+      assert_kind_of(Array,CPU.load_avg(0),"Invalid Type")
+      assert_equal(3,CPU.load_avg.length,"Bad number of elements") 
+      assert_equal(3,CPU.load_avg(0).length,"Bad number of elements")
+   end
+end

data/test/tc_linux.rb

@@ -0,0 +1,41 @@
+########################################
+# tc_linux.rb
+#
+# Test Suite for sys-cpu for Linux
+########################################
+base = File.basename(Dir.pwd)
+if base == "test" || base =~ /sys-cpu/
+   require "ftools"
+   Dir.chdir ".." if base == "test"
+   Dir.mkdir("sys") unless File.exists?("sys")
+   File.copy("lib/sys/linux.rb","sys/cpu.rb")
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "sys/cpu"
+require "test/unit"
+include Sys
+
+class TC_Linux < Test::Unit::TestCase
+   def test_all_dynamic_methods
+      assert_nothing_raised{
+         CPU.processors{ |cs|
+            cs.members.each{ |m|
+               puts "#{m}: " + cs[m].to_s
+            }
+         }
+      }
+   end
+
+   def test_load_avg
+      assert_nothing_raised{ CPU.load_avg }
+      assert_equal(3, CPU.load_avg.length)
+   end
+
+   def test_cpu_stats
+      assert_nothing_raised{ CPU.cpu_stats }
+      assert_kind_of(Hash, CPU.cpu_stats)
+      assert_equal(true, CPU.cpu_stats["cpu0"].length >= 4)
+   end
+end
+  

data/test/tc_sunos.rb

@@ -0,0 +1,82 @@
+###########################################################
+# tc_sunos.rb
+#
+# Test suite for sys-cpu on Solaris.  This should only be
+# run *after* the make process.
+###########################################################
+base = File.basename(Dir.pwd)
+if base == "test" || base =~ /sys-cpu/
+   require "ftools"
+   Dir.chdir ".." if base == "test"
+   
+   Dir.mkdir("sys") unless File.exist?("sys")
+
+   if File.exist?("cpu.so")
+      File.copy("cpu.so","sys")
+   else
+      puts "No cpu.so file found.  Please run extconf.rb and make first"
+      exit
+   end
+
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "sys/cpu"
+require "test/unit"
+include Sys
+
+# I could really use a mock object here
+class TC_SunOS < Test::Unit::TestCase
+   def test_cpu_freq
+      assert_respond_to(CPU, :freq)
+      assert_nothing_raised{ CPU.freq }
+      assert_nothing_raised{ CPU.freq(0) }
+      assert_kind_of(Integer, CPU.freq(0))
+   end
+
+   def test_cpu_type
+      assert_respond_to(CPU, :type)
+      assert_nothing_raised{ CPU.type }
+      assert_kind_of(String, CPU.type)
+   end
+
+   def test_fpu_type
+      assert_respond_to(CPU, :fpu_type)
+      assert_nothing_raised{ CPU.fpu_type }
+      assert_kind_of(String, CPU.fpu_type)
+   end
+
+   def test_load_avg
+      assert_respond_to(CPU, :load_avg)
+      assert_nothing_raised{ CPU.load_avg }
+      assert_kind_of(Array, CPU.load_avg)
+      assert_equal(3, CPU.load_avg.length)
+      assert_kind_of(Float, CPU.load_avg.first)
+   end
+
+   def test_cpu_model
+      assert_respond_to(CPU, :model)
+      assert_nothing_raised{ CPU.model }
+      assert_kind_of(String, CPU.model)
+   end
+
+   def test_num_cpu
+      assert_respond_to(CPU, :num_cpu)
+      assert_nothing_raised{ CPU.num_cpu }
+      assert_kind_of(Integer, CPU.num_cpu)
+   end
+
+   def test_state
+      assert_respond_to(CPU, :state)
+      assert_nothing_raised{ CPU.state }
+      assert_nothing_raised{ CPU.state(0) }
+      assert_kind_of(String, CPU.state(0))
+   end
+
+   def test_exceptions
+      assert_raises(Sys::CPUError){ CPU.state(55) }
+      assert_raises(TypeError){ CPU.state("yo") }
+      assert_raises(Sys::CPUError){ CPU.freq(999) }
+      assert_raises(TypeError){ CPU.freq("yo") }
+   end
+end

data/test/tc_version.rb

@@ -0,0 +1,44 @@
+###########################################################
+# tc_version.rb
+#
+# The sole purpose of this test case is to verify the
+# version.  This reduces the pain of having separate tests
+# for the VERSION constant in every single test case.
+###########################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /sys-cpu/
+   require "ftools"
+
+   Dir.chdir("..") if base == "test"
+   Dir.mkdir("sys") unless File.exist?("sys")
+
+   case RUBY_PLATFORM
+      when /mswin|dos|cygwin|mingw/i
+         file = 'lib/sys/windows.rb'
+      when /linux/i
+         file = 'lib/sys/linux.rb'
+      else
+         require "rbconfig"
+         file = "cpu." << Config::CONFIG["DLEXT"]
+   end
+
+   if File.exist?(file)
+      File.copy(file, "sys/cpu.rb")
+   else
+      puts "No '#{file}' file found.  Please run extconf.rb and make first"
+      exit
+   end
+
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "sys/cpu"
+require "test/unit"
+include Sys
+
+class TC_Sys_CPU_VERSION < Test::Unit::TestCase
+   def test_version
+      assert_equal('0.5.5', CPU::VERSION)
+   end
+end

data/test/tc_windows.rb

@@ -0,0 +1,76 @@
+######################################################################
+# tc_windows.rb
+#
+# Test suite for Win32 systems.
+######################################################################
+base =  File.basename(Dir.pwd)
+if base == "test" || base =~ /sys-cpu/
+   require "ftools" if base == "test"
+   Dir.chdir '..'
+   Dir.mkdir("sys") unless File.exists?("sys")
+   File.copy("lib/sys/windows.rb","sys/cpu.rb")
+   $LOAD_PATH.unshift Dir.pwd
+end
+
+require "test/unit"
+require "sys/cpu"
+require "socket"
+include Sys
+
+class TC_Windows_CPU < Test::Unit::TestCase
+   def setup
+      @host = Socket.gethostname
+   end
+   
+   def test_architecture
+      assert_respond_to(CPU, :architecture)
+      assert_nothing_raised{ CPU.architecture }
+      assert_nothing_raised{ CPU.architecture(@host) }
+      assert_kind_of(String,CPU.architecture,"Invalid Type")
+   end
+   
+   def test_freq
+      assert_respond_to(CPU, :freq)
+      assert_nothing_raised{ CPU.freq }
+      assert_nothing_raised{ CPU.freq(0) }
+      assert_nothing_raised{ CPU.freq(0,@host) }
+      assert_kind_of(Integer,CPU.freq,"Invalid Type")
+   end
+    
+   def test_model
+      assert_respond_to(CPU, :model)
+      assert_nothing_raised{ CPU.model }
+      assert_nothing_raised{ CPU.model(@host) }
+      assert_kind_of(String,CPU.model,"Invalid Type")
+   end
+   
+   def test_num_cpu
+      assert_respond_to(CPU, :num_cpu)
+      assert_nothing_raised{ CPU.num_cpu }
+      assert_nothing_raised{ CPU.num_cpu(@host) }
+      assert_kind_of(Integer,CPU.num_cpu,"Invalid Type")
+   end
+   
+   def test_type
+      assert_respond_to(CPU, :type)
+      assert_nothing_raised{ CPU.type }
+      assert_nothing_raised{ CPU.type(@host) }
+      assert_kind_of(String,CPU.type,"Invalid Type")
+   end
+   
+   def test_load_avg
+      assert_respond_to(CPU, :load_avg)
+      assert_nothing_raised{ CPU.load_avg }
+      assert_nothing_raised{ CPU.load_avg(0,@host) }
+      assert_kind_of(Integer,CPU.load_avg,"Invalid Type")
+   end
+   
+   def test_processors
+      assert_respond_to(CPU, :processors)
+      assert_nothing_raised{ CPU.processors{} }
+   end
+
+   def teardown
+      @host = nil
+   end  
+end

data/test/ts_all.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/test'
+
+require 'tc_version'
+
+case RUBY_PLATFORM
+   when /sunos|solaris/i
+      require 'tc_sunos'
+   when /linux/i
+      require 'tc_linux'
+   when /mswin|cygwin|mingw/i
+      require 'tc_windows'
+   when /hpux/i
+      require 'tc_hpux'
+   when /bsd/i
+      require 'tc_freebsd'
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: sys-cpu
+version: !ruby/object:Gem::Version 
+  version: 0.5.5
+date: 2006-11-18 00:00:00 -07:00
+summary: A Ruby interface for providing CPU information
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/sysutils
+rubyforge_project: sysutils
+description: A Ruby interface for providing CPU information
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: i586-linux
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- doc/freebsd.txt
+- doc/sunos.txt
+- doc/windows.txt
+- doc/hpux.txt
+- doc/linux.txt
+- test/tc_linux.rb
+- test/tc_sunos.rb
+- test/ts_all.rb
+- test/tc_hpux.rb
+- test/tc_windows.rb
+- test/tc_version.rb
+- test/tc_freebsd.rb
+- CHANGES
+- README
+- lib/sys/cpu.rb
+test_files: 
+- test/ts_all.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+