sys-cpu 0.8.0 → 1.0.0

data/README

@@ -1,72 +0,0 @@
-= Description
-   A Ruby interface for getting cpu information.
-
-= Installation
-  gem install sys-cpu
-
-= Notes
-== Solaris
-  Currently there is no 'processors()' iterative method for multi-cpu systems.
-  I plan to add it this in a future release.
-   
-== OS X
-  The CPU.model method returns very limited information. I do not yet know
-  how to get more detailed information.
-
-== 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 'rake install' (via 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.
-
-  Note that version 0.7.x and later will not work on HP-UX because of the
-  switch to FFI and the lack of a testing platform. However, version 0.6.x
-  will work just fine.
-
-== MS Windows
-  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.
-   
-= Acknowledgements
-  Thanks go to the MPlayer team for some source code that helped me on
-  certain versions of FreeBSD in the original C version.
-
-= Known Bugs
-  None that I'm aware of. Please report bugs on the project page at
-  https://github.com/djberg96/sys-cpu
-
-= Future Plans
-  Add iterative CPU.processors method.
-  Add more information in general, such as what 'prtdiag' shows.
-
-= License
-  Artistic 2.0
-
-= Copyright
-  (C) 2003-2015 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

data/test/test_sys_cpu.rb

@@ -1,23 +0,0 @@
-#######################################################################
-# test_sys_cpu.rb
-#
-# This isn't a test file, just a file that require's the appropriate
-# test file base on the platform you're on.
-#######################################################################
-require 'rbconfig'
-require 'test_sys_cpu_version'
-
-case RbConfig::CONFIG['host_os']
-  when /bsd|darwin|mach|osx/i
-    require 'test_sys_cpu_bsd'
-  when /hpux/i
-    require 'test_sys_cpu_hpux'
-  when /linux/i
-    require 'test_sys_cpu_linux'
-  when /sunos|solaris/i
-    require 'test_sys_cpu_sunos'
-  when /mswin|win32|dos|mingw|cygwin/i
-    require 'test_sys_cpu_windows'
-  else
-    raise "Platform not supported"
-end

data/test/test_sys_cpu_bsd.rb

@@ -1,97 +0,0 @@
-#############################################################
-# test_sys_cpu_bsd.rb
-#
-# The test case for sys-cpu on BSD flavors, including OS X.
-#############################################################
-require 'sys/cpu'
-require 'rbconfig'
-require 'test-unit'
-require 'test_sys_cpu_version'
-include Sys
-
-class TC_Sys_CPU_BSD < Test::Unit::TestCase
-  test "architecture method basic functionality" do
-    assert_respond_to(CPU, :architecture)
-    assert_nothing_raised{ CPU.architecture }
-  end
-
-  test "architecture method returns a sane value" do
-    assert_kind_of(String, CPU.architecture)
-    assert_true(CPU.architecture.size > 0)
-  end
-
-  test "architecture method does not accept any arguments" do
-    assert_raises(ArgumentError){ CPU.architecture(0) }
-  end
-
-  test "freq method basic functionality" do
-    assert_respond_to(CPU, :freq)
-    assert_nothing_raised{ CPU.freq }
-  end
-
-  test "freq method returns expected value" do
-    assert_kind_of(Integer, CPU.freq)
-    assert_true(CPU.freq > 0)
-  end
-
-  test "freq method does not accept any arguments" do
-    assert_raises(ArgumentError){ CPU.freq(0) }
-  end
-
-  test "load_avg method basic functionality" do
-    assert_respond_to(CPU, :load_avg)
-    assert_nothing_raised{ CPU.load_avg }
-  end
-
-  test "load_avg returns the expected results" do
-    assert_kind_of(Array, CPU.load_avg)
-    assert_equal(3, CPU.load_avg.length)
-    assert_kind_of(Float, CPU.load_avg[0])
-  end
-
-  test "load_avg does not accept any arguments" do
-    assert_raises(ArgumentError){ CPU.load_avg(0) }
-  end
-
-  test "machine method basic functionality" do
-    assert_respond_to(CPU, :machine)
-    assert_nothing_raised{ CPU.machine }
-  end
-
-  test "machine method returns sane value" do
-    assert_kind_of(String, CPU.machine)
-    assert_true(CPU.machine.size > 0)
-  end
-
-  test "machine method does not accept any arguments" do
-    assert_raises(ArgumentError){ CPU.machine(0) }
-  end
-
-  test "model method basic functionality" do
-    assert_respond_to(CPU, :model)
-    assert_nothing_raised{ CPU.model }
-  end
-
-  test "model method returns sane value" do
-    assert_kind_of(String, CPU.model)
-    assert_true(CPU.model.length > 0)
-  end
-
-  test "model method does not accept any arguments" do
-    assert_raises(ArgumentError){ CPU.model(0) }
-  end
-
-  test "num_cpu method basic functionality" do
-    assert_respond_to(CPU, :num_cpu)
-    assert_nothing_raised{ CPU.num_cpu }
-  end
-
-  test "num_cpu method returns expected value" do
-    assert_kind_of(Integer, CPU.num_cpu)
-    assert_true(CPU.num_cpu > 0)
-  end
-
-  test "num_cpu method does not accept any arguments" do
-    assert_raises(ArgumentError){ CPU.num_cpu(0) }
-  end
-end

data/test/test_sys_cpu_hpux.rb

@@ -1,49 +0,0 @@
-#####################################################################
-# test_sys_cpu_hpux.rb
-#
-# Test suite for the HP-UX platform. This should be run via the
-# 'rake test' task.
-#####################################################################
-require 'sys/cpu'
-require 'test-unit'
-require 'test_sys_cpu_version'
-include Sys
-
-class TC_Sys_CPU_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/test_sys_cpu_linux.rb

@@ -1,31 +0,0 @@
-###########################################################
-# test_sys_cpu_linux.rb
-#
-# Test Suite for sys-cpu for Linux. This should be run via
-# the 'rake test' task.
-###########################################################
-require 'sys/cpu'
-require 'test-unit'
-require 'test_sys_cpu_version'
-include Sys
-
-class TC_Sys_CPU_Linux < Test::Unit::TestCase
-  def test_all_dynamic_methods
-    assert_nothing_raised{
-      CPU.processors{ |cs|
-        cs.members.each{ |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/test_sys_cpu_sunos.rb

@@ -1,81 +0,0 @@
-###########################################################
-# test_sys_cpu_sunos.rb
-#
-# Test suite for sys-cpu on Solaris. This should be run
-# via the 'rake test' task.
-###########################################################
-require 'sys/cpu'
-require 'test-unit'
-include Sys
-
-class TC_Sys_CPU_SunOS < Test::Unit::TestCase
-  test "freq method basic functionality" do
-    assert_respond_to(CPU, :freq)
-    assert_nothing_raised{ CPU.freq }
-  end
-
-  test "freq method does not accept any arguments" do
-    assert_raise(ArgumentError){ CPU.freq(0) }
-  end
-
-  test "freq method returns a sane value" do
-    assert_kind_of(Integer, CPU.freq)
-    assert_true(CPU.freq > 100)
-  end
-
-  test "fpu_type basic functionality" do
-    assert_respond_to(CPU, :fpu_type)
-    assert_nothing_raised{ CPU.fpu_type }
-  end
-
-  test "fpu_type returns a sane value" do
-    assert_kind_of(String, CPU.fpu_type)
-    assert_false(CPU.fpu_type.empty?)
-  end
-
-  test "load_avg basic functionality" do
-    assert_respond_to(CPU, :load_avg)
-    assert_nothing_raised{ CPU.load_avg }
-  end
-
-  test "load_avg method returns the expected values" do
-    assert_kind_of(Array, CPU.load_avg)
-    assert_equal(3, CPU.load_avg.length)
-    assert_kind_of(Float, CPU.load_avg.first)
-  end
-
-  test "model method basic functionality" do
-    assert_respond_to(CPU, :model)
-    assert_nothing_raised{ CPU.model }
-  end
-
-  test "model method returns a sane value" do
-    assert_kind_of(String, CPU.model)
-    assert_false(CPU.model.empty?)
-  end
-
-  test "num_cpu method basic functionalty" do
-    assert_respond_to(CPU, :num_cpu)
-    assert_nothing_raised{ CPU.num_cpu }
-  end
-
-  test "num_cpu method returns a sane value" do
-    assert_kind_of(Integer, CPU.num_cpu)
-    assert_true(CPU.num_cpu > 0)
-  end
-
-  test "state basic functionality" do
-    assert_respond_to(CPU, :state)
-    assert_nothing_raised{ CPU.state }
-  end
-
-  test "state method accepts one optional argument" do
-    assert_nothing_raised{ CPU.state(0) }
-    assert_raise(ArgumentError){ CPU.state(0,0) }
-  end
-
-  test "state method returns a sane value" do
-    assert_kind_of(String, CPU.state(0))
-    assert_false(CPU.state.empty?)
-  end
-end

data/test/test_sys_cpu_version.rb

@@ -1,19 +0,0 @@
-#######################################################################
-# test_sys_cpu_version.rb
-#
-# The sole purpose of this test case is to verify the version number.
-# This reduces the pain of having separate tests for the VERSION
-# constant in every single test case.
-#######################################################################
-require 'sys/cpu'
-require 'test-unit'
-
-class TC_Sys_CPU_VERSION < Test::Unit::TestCase
-  test "version number is set to the expected value" do
-    assert_equal('0.8.0', Sys::CPU::VERSION)
-  end
-
-  test "version number is frozen" do
-    assert_true(Sys::CPU::VERSION.frozen?)
-  end
-end

data/test/test_sys_cpu_windows.rb

@@ -1,72 +0,0 @@
-######################################################################
-# test_sys_cpu_windows.rb
-#
-# Test suite for MS Windows systems. This should be run via the
-# 'rake test' task.
-######################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'sys/cpu'
-require 'test_sys_cpu_version'
-require 'socket'
-include Sys
-
-class TC_Sys_CPU_Windows < Test::Unit::TestCase
-  def self.startup
-    @@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_cpu_type
-    assert_respond_to(CPU, :cpu_type)
-    assert_nothing_raised{ CPU.cpu_type }
-    assert_nothing_raised{ CPU.cpu_type(@@host) }
-    assert_kind_of(String, CPU.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 self.shutdown
-    @@host = nil
-  end
-end