sys-cpu 0.6.4-universal-linux → 0.7.0-universal-linux

data/lib/windows/sys/cpu.rb

@@ -9,7 +9,7 @@ module Sys
     class Error < StandardError; end
 
     # The version of the sys-cpu library
-    VERSION = '0.6.4'
+    VERSION = '0.7.0'
 
     private
 
@@ -17,7 +17,7 @@ module Sys
     BASE_CS = "winmgmts:{impersonationLevel=impersonate}" # :nodoc:
 
     # Fields used in the CPUStruct
-    fields = %w/
+    fields = %w[
       address_width
       architecture
       availability
@@ -62,7 +62,7 @@ module Sys
       upgrade_method
       version
       voltage_caps
-    /
+    ]
 
     # The struct returned by the CPU.processors method
     CPUStruct = Struct.new("CPUStruct", *fields) # :nodoc:
@@ -255,7 +255,7 @@ module Sys
 
     # Returns a string indicating the type of processor, e.g. GenuineIntel.
     #
-    def self.type(host = Socket.gethostname)
+    def self.cpu_type(host = Socket.gethostname)
       cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"
       begin
         wmi = WIN32OLE.connect(cs)

data/sys-cpu.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'sys-cpu'
-  spec.version   = '0.6.4'
+  spec.version   = '0.7.0'
   spec.author    = 'Daniel J. Berger'
   spec.email     = 'djberg96 at nospam at gmail dot com'
   spec.homepage  = 'http://www.rubyforge.org/projects/sysutils'
@@ -14,6 +14,7 @@ Gem::Specification.new do |spec|
   spec.rubyforge_project = 'sysutils'
   spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
 
+  spec.add_dependency('ffi', '>= 1.0.0')
   spec.add_development_dependency('test-unit', '>= 2.1.2')
 
   spec.description = <<-EOF
@@ -22,15 +23,6 @@ Gem::Specification.new do |spec|
     and load average.
   EOF
 
-  case Config::CONFIG['host_os']
-    when /hpux/i
-      spec.extra_rdoc_files += ['ext/hpux/hpux.c']
-    when /sunos|solaris/i
-      spec.extra_rdoc_files += ['ext/sunos/sunos.c']
-    when /bsd|darwin|mach|osx/i
-      spec.extra_rdoc_files += ['ext/bsd/bsd.c']
-  end
-   
   case Config::CONFIG['host_os']
     when /mswin|dos|windows|win32|mingw|cygwin/i
       spec.require_paths = ['lib', 'lib/windows']
@@ -45,6 +37,7 @@ Gem::Specification.new do |spec|
       spec.platform = Gem::Platform.new('universal-linux')
       spec.original_platform = spec.platform
     else
-      spec.extensions = ['ext/extconf.rb']
+      spec.require_paths = ['lib', 'lib/unix']
+      spec.extra_rdoc_files << 'lib/unix/sys/cpu.rb'
    end
 end

data/test/test_sys_cpu.rb

@@ -8,16 +8,16 @@ require 'rbconfig'
 require 'test_sys_cpu_version'
 
 case Config::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"
+  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

@@ -13,64 +13,88 @@ require 'test_sys_cpu_version'
 include Sys
 
 class TC_Sys_CPU_BSD < Test::Unit::TestCase
-   def test_architecture
-      assert_respond_to(CPU, :architecture)
-      assert_nothing_raised{ CPU.architecture }
-      assert_kind_of(String, CPU.architecture)
-   end
-
-   def test_architecture_expected_errors
-      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)
-   end
-
-   def test_cpu_freq_expected_errors
-      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)
-   end
-
-   def test_load_avg_expected_errors
-      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)
-   end
-
-   def test_machine_expected_errors
-      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)
-   end
-
-   def test_model_expected_errors
-      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)
-   end
-
-   def test_num_cpu_expected_errors
-      assert_raises(ArgumentError){ CPU.num_cpu(0) }
-   end
+  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_sunos.rb

@@ -6,62 +6,78 @@
 ###########################################################
 require 'rubygems'
 gem 'test-unit'
-
 require 'sys/cpu'
 require 'test/unit'
 include Sys
 
 class TC_Sys_CPU_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
+  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
 
-   def test_cpu_type
-      assert_respond_to(CPU, :cpu_type)
-      assert_nothing_raised{ CPU.cpu_type }
-      assert_kind_of(String, CPU.cpu_type)
-   end
+  test "model method basic functionality" do
+    assert_respond_to(CPU, :model)
+    assert_nothing_raised{ CPU.model }
+  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
+  test "model method returns a sane value" do
+    assert_kind_of(String, CPU.model)
+    assert_false(CPU.model.empty?)
+  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
+  test "num_cpu method basic functionalty" do
+    assert_respond_to(CPU, :num_cpu)
+    assert_nothing_raised{ CPU.num_cpu }
+  end
 
-   def test_cpu_model
-      assert_respond_to(CPU, :model)
-      assert_nothing_raised{ CPU.model }
-      assert_kind_of(String, CPU.model)
-   end
+  test "num_cpu method returns a sane value" do
+    assert_kind_of(Integer, CPU.num_cpu)
+    assert_true(CPU.num_cpu > 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)
-   end
+  test "state basic functionality" do
+    assert_respond_to(CPU, :state)
+    assert_nothing_raised{ CPU.state }
+  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
+  test "state method accepts one optional argument" do
+    assert_nothing_raised{ CPU.state(0) }
+    assert_raise(ArgumentError){ CPU.state(0,0) }
+  end
 
-   def test_expected_errors
-      assert_raises(Sys::CPU::Error){ CPU.state(55) }
-      assert_raises(TypeError){ CPU.state('yo') }
-      assert_raises(Sys::CPU::Error){ CPU.freq(999) }
-      assert_raises(TypeError){ CPU.freq('yo') }
-   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

@@ -12,7 +12,7 @@ require 'sys/cpu'
 require 'test/unit'
 
 class TC_Sys_CPU_VERSION < Test::Unit::TestCase
-  def test_version
-    assert_equal('0.6.4', Sys::CPU::VERSION)
+  test "version number is set to the expected value" do
+    assert_equal('0.7.0', Sys::CPU::VERSION)
   end
 end

data/test/test_sys_cpu_windows.rb

@@ -17,14 +17,14 @@ 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 }
@@ -32,35 +32,35 @@ class TC_Sys_CPU_Windows < Test::Unit::TestCase
     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')
+
+  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{} }
@@ -68,5 +68,5 @@ class TC_Sys_CPU_Windows < Test::Unit::TestCase
 
   def self.shutdown
     @@host = nil
-  end  
+  end
 end