sys-cpu 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 465bd2540877db4c141949b95fb9c2d011497f532a9325d604da521ab98b878a
-  data.tar.gz: 27e1124d09070b074db611e9d392a32739f15554841ba0fe0b51c865414e592b
+  metadata.gz: ff79a5d15ea499890892863713cf8b78d1e827f8d78e9baa3e637cea4aa1e732
+  data.tar.gz: e6d43e161f5f990cf6b5e7a3270ee3037eb052496b8712d1bbe4fc3e06a19f38
 SHA512:
-  metadata.gz: aece81104122383014b5e396a499550d3da21dadfb06846881786eb0898f2402452fe90a2f9c30a86ce89dbd6fad4bc16dfa9b0beafe3aa80cb8c120c3fbab05
-  data.tar.gz: 33e149e2e2ba7723609dc89ebb095f6df6496f7c2f4ef17656e2373fd004c88d51c3d75b3fec74dcaabcdd663289c00757771bd759869122c6935a4c3b972f75
+  metadata.gz: f23ba676b4100b4c8f2c01413965d9ffb67ed19746cf017dab2ece8cc5fb31b460fc04d75180dc4c5da647ee8e48934777d05720023e03e2aeb93213543458fe
+  data.tar.gz: 5c0b800fb4a1097f775378120775987c7b86a05728d68882b08432cd1b443ffc36b717360f6486797c091959c0b9102316f3967ab62fd297db1af679d3b83e08

data.tar.gz.sig

@@ -1 +1 @@
-MVonL`����fo`dm;���`�n�
++:s�u��vu�HA;&�4�K�ж��xԭ�H��j8����g7u�z�,����C�+Q7&C\r��QW�\��i��FrR�uL=�N� \Hړ^��1���S�G���6���Ô�/AafG����>Ìe�Jg�S^9�=�4��N�a��݈�	��4!�U�xh�22��N

data/CHANGES.rdoc

@@ -1,3 +1,9 @@
+== 1.0.0 - 23-Oct-2020
+* Fixed a bug in the Windows version where the attempt to convert the ConfigManagerErrorCode
+  to a string was busted. Coincidentally, this also exposed a core bug in JRuby (see PR #6443).
+  Thanks go to G. Gibson for reporting the issue.
+* Switched the tests from test-unit to rspec.
+
 == 0.9.0 - 12-May-2020
 * Added explicit freq, architecture, num_cpu and model methods to the Linux
   version in an effort to create a common interface across platforms.

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org' do
+  gem 'ffi', '~> 1.1'
+  group 'test' do
+    gem 'rake'
+    gem 'rspec', '~> 3.9'
+  end
+end

data/MANIFEST.rdoc

@@ -20,9 +20,10 @@
 * lib/sys/linux/sys/cpu.rb
 * lib/sys/unix/sys/cpu.rb
 * lib/sys/windows/sys/cpu.rb
-* test/test_sys_cpu.rb
-* test/test_sys_cpu_bsd.rb
-* test/test_sys_cpu_hpux.rb
-* test/test_sys_cpu_sunos.rb
-* test/test_sys_cpu_linux.rb
-* test/test_sys_cpu_windows.rb
+* spec/spec_helper.rb
+* spec/sys_cpu_spec.rb
+* spec/sys_cpu_bsd_spec.rb
+* spec/sys_cpu_hpux_spec.rb
+* spec/sys_cpu_linux_spec.rb
+* spec/sys_cpu_sunos_spec.rb
+* spec/sys_cpu_windows_spec.rb

data/Rakefile

@@ -1,10 +1,10 @@
 require 'rake'
 require 'rake/clean'
-require 'rake/testtask'
 require 'rbconfig'
+require 'rspec/core/rake_task'
 include RbConfig
 
-CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx')
+CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx', '**/*.lock')
 
 namespace 'gem' do
   desc "Create the sys-cpu gem"
@@ -44,9 +44,7 @@ task :example => [:clean] do
 
 end
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/test_sys_cpu.rb']
-end
+desc "Run the test suite"
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
+task :default => :spec

data/lib/sys/cpu.rb

@@ -5,7 +5,7 @@ require 'rbconfig'
 module Sys
   class CPU
     # The version of the sys-cpu gem.
-    VERSION = '0.9.0'.freeze
+    VERSION = '1.0.0'.freeze
   end
 end
 

data/lib/sys/windows/sys/cpu.rb

@@ -278,7 +278,7 @@ module Sys
     # Note that this value returns nil on my system.
     #
     def self.get_cmec(num)
-      case
+      case num
         when 0
           str = "The device is working properly."
           return str

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+
+RSpec.configure do |config|
+  config.filter_run_excluding(:bsd) if RbConfig::CONFIG['host_os'] !~ /bsd|darwin|mach|osx/i
+  config.filter_run_excluding(:sunos) if RbConfig::CONFIG['host_os'] !~ /sunos|solaris/i
+  config.filter_run_excluding(:windows) if RbConfig::CONFIG['host_os'] !~ /mswin|win32|dos|mingw|cygwin/i
+  config.filter_run_excluding(:hpux) if RbConfig::CONFIG['host_os'] !~ /hpux/i
+  config.filter_run_excluding(:linux) if RbConfig::CONFIG['host_os'] !~ /linux/i
+end

data/spec/sys_cpu_bsd_spec.rb

@@ -0,0 +1,94 @@
+#############################################################
+# test_sys_cpu_bsd.rb
+#
+# The test case for sys-cpu on BSD flavors, including OS X.
+#############################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :bsd => true do
+  example "architecture method basic functionality" do
+    expect(Sys::CPU).to respond_to(:architecture)
+    expect{ Sys::CPU.architecture }.not_to raise_error
+  end
+
+  example "architecture method returns a sane value" do
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+    expect(Sys::CPU.architecture.size).to be > 0
+  end
+
+  example "architecture method does not accept any arguments" do
+    expect{ Sys::CPU.architecture(0) }.to raise_error(ArgumentError)
+  end
+
+  example "freq method basic functionality" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+  end
+
+  example "freq method returns expected value" do
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+    expect(Sys::CPU.freq).to be > 0
+  end
+
+  example "freq method does not accept any arguments" do
+    expect{ Sys::CPU.freq(0) }.to raise_error(ArgumentError)
+  end
+
+  example "load_avg method basic functionality" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+  end
+
+  example "load_avg returns the expected results" do
+    expect(Sys::CPU.load_avg).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg.length).to eq(3)
+    expect(Sys::CPU.load_avg[0]).to be_kind_of(Float)
+  end
+
+  example "load_avg does not accept any arguments" do
+    expect{ Sys::CPU.load_avg(0) }.to raise_error(ArgumentError)
+  end
+
+  example "machine method basic functionality" do
+    expect(Sys::CPU).to respond_to(:machine)
+    expect{ Sys::CPU.machine }.not_to raise_error
+  end
+
+  example "machine method returns sane value" do
+    expect(Sys::CPU.machine).to be_kind_of(String)
+    expect(Sys::CPU.machine.size).to be > 0
+  end
+
+  example "machine method does not accept any arguments" do
+    expect{ Sys::CPU.machine(0) }.to raise_error(ArgumentError)
+  end
+
+  example "model method basic functionality" do
+    expect(Sys::CPU).to respond_to(:model)
+    expect{ Sys::CPU.model }.not_to raise_error
+  end
+
+  example "model method returns sane value" do
+    expect(Sys::CPU.model).to be_kind_of(String)
+    expect(Sys::CPU.model.length).to be > 0
+  end
+
+  example "model method does not accept any arguments" do
+    expect{ Sys::CPU.model(0) }.to raise_error(ArgumentError)
+  end
+
+  example "num_cpu method basic functionality" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+  end
+
+  example "num_cpu method returns expected value" do
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+    expect(Sys::CPU.num_cpu).to be > 0
+  end
+
+  example "num_cpu method does not accept any arguments" do
+    expect{ Sys::CPU.num_cpu(0) }.to raise_error(ArgumentError)
+  end
+end

data/spec/sys_cpu_hpux_spec.rb

@@ -0,0 +1,50 @@
+#####################################################################
+# sys_cpu_hpux_spec.rb
+#
+# Test suite for the HP-UX platform. This should be run via the
+# 'rake test' task.
+#####################################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :hpux => true do
+  example "cpu_freq" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+    expect{ Sys::CPU.freq(0) }.not_to raise_error
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+  end
+
+  example "num_cpu" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+  end
+
+  example "num_active_cpu" do
+    expect(Sys::CPU).to respond_to(:num_active_cpu)
+    expect{ Sys::CPU.num_active_cpu }.not_to raise_error
+    expect(Sys::CPU.num_active_cpu).to be_kind_of(Integer)
+  end
+
+  example "cpu_architecture" do
+    expect(Sys::CPU).to respond_to(:architecture)
+    expect{ Sys::CPU.architecture }.not_to raise_error
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+  end
+
+  example "load_avg sanity check" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+    expect{ Sys::CPU.load_avg(0) }.not_to raise_error
+    expect{ Sys::CPU.load_avg{ |e| }.not_to raise_error }
+    expect{ Sys::CPU.load_avg(0){ }.to raise_error(ArgumentError) }
+  end
+
+  example "load_avg expected results" do
+    expect(Sys::CPU.load_avg).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg(0)).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg.length).to eq(3)
+    expect(Sys::CPU.load_avg(0).length).to eq(3)
+  end
+end

data/spec/sys_cpu_linux_spec.rb

@@ -0,0 +1,53 @@
+###########################################################
+# sys_cpu_linux_spec.rb
+#
+# Specs for sys-cpu for Linux. This should be run via
+# the 'rake spec' task.
+###########################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :linux => true do
+  example "dynamic methods are defined as expected" do
+    expect{
+      Sys::CPU.processors{ |cs|
+        cs.members.each{ |m| cs[m].to_s }
+      }
+    }.not_to raise_error
+  end
+
+  example "load average works as expected" do
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+    expect(Sys::CPU.load_avg.length).to eq(3)
+  end
+
+  example "cpu_stats works as expected" do
+    expect{ Sys::CPU.cpu_stats }.not_to raise_error
+    expect(Sys::CPU.cpu_stats).to be_kind_of(Hash)
+    expect(Sys::CPU.cpu_stats['cpu0'].length).to be >= 4
+  end
+
+  example "architecture works as expected" do
+    expect{ Sys::CPU.architecture }.not_to raise_error
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+  end
+
+  example "model works as expected" do
+    expect{ Sys::CPU.model }.not_to raise_error
+    expect(Sys::CPU.model).to be_kind_of(String)
+  end
+
+  example "freq works as expected" do
+    expect{ Sys::CPU.freq }.not_to raise_error
+    expect(Sys::CPU.freq).to be_kind_of(Numeric)
+  end
+
+  example "num_cpu works as expected" do
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+    expect(Sys::CPU.num_cpu).to be_kind_of(Numeric)
+  end
+
+  example "bogus methods are not picked up by method_missing" do
+    expect{Sys::CPU.bogus }.to raise_error(NoMethodError)
+  end
+end

data/spec/sys_cpu_spec.rb

@@ -0,0 +1,18 @@
+#######################################################################
+# sys_cpu_spec.rb
+#
+# Only shared specs go here. Everything else goes into its own tagged
+# spec file.
+#######################################################################
+require 'sys/cpu'
+require 'rspec'
+
+RSpec.describe Sys::CPU::VERSION do
+  example "version number is set to the expected value" do
+    expect(Sys::CPU::VERSION).to eq('1.0.0')
+  end
+
+  example "version number is frozen" do
+    expect(Sys::CPU::VERSION).to be_frozen
+  end
+end

data/spec/sys_cpu_sunos_spec.rb

@@ -0,0 +1,80 @@
+###########################################################
+# sys_cpu_sunos_spec.rb
+#
+# Test suite for sys-cpu on Solaris. This should be run
+# via the 'rake spec' task.
+###########################################################
+require 'sys/cpu'
+require 'spec_helper'
+
+RSpec.describe Sys::CPU, :sunos => true do
+  example "freq method basic functionality" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+  end
+
+  example "freq method does not accept any arguments" do
+    expect{ Sys::CPU.freq(0) }.to raise_error(ArgumentError)
+  end
+
+  example "freq method returns a sane value" do
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+    expect(Sys::CPU.freq).to be > 100
+  end
+
+  example "fpu_type basic functionality" do
+    expect(Sys::CPU).to respond_to(:fpu_type)
+    expect{ Sys::CPU.fpu_type }.not_to raise_error
+  end
+
+  example "fpu_type returns a sane value" do
+    expect(Sys::CPU.fpu_type).to be_kind_of(String)
+    expect(Sys::CPU.fpu_type).not_to be_empty
+  end
+
+  example "load_avg basic functionality" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+  end
+
+  example "load_avg method returns the expected values" do
+    expect(Sys::CPU.load_avg).to be_kind_of(Array)
+    expect(Sys::CPU.load_avg.length).to eq(3)
+    expect(Sys::CPU.load_avg.first).to be_kind_of(Float)
+  end
+
+  example "model method basic functionality" do
+    expect(Sys::CPU).to respond_to(:model)
+    expect{ Sys::CPU.model }.not_to raise_error
+  end
+
+  example "model method returns a sane value" do
+    expect(Sys::CPU.model).to be_kind_of(String)
+    expect(Sys::CPU.model).not_to be_empty
+  end
+
+  example "num_cpu method basic functionalty" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+  end
+
+  example "num_cpu method returns a sane value" do
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+    expect(Sys::CPU.num_cpu).to be > 0
+  end
+
+  example "state basic functionality" do
+    expect(Sys::CPU).to respond_to(:state)
+    expect{ Sys::CPU.state }.not_to raise_error
+  end
+
+  example "state method accepts one optional argument" do
+    expect{ Sys::CPU.state(0) }.not_to raise_error
+    expect{ Sys::CPU.state(0,0) }.to raise_error(ArgumentError)
+  end
+
+  example "state method returns a sane value" do
+    expect(Sys::CPU.state(0)).to be_kind_of(String)
+    expect(Sys::CPU.state.empty?).to be false
+  end
+end

data/spec/sys_cpu_windows_spec.rb

@@ -0,0 +1,61 @@
+######################################################################
+# sys_cpu_windows_spec.rb
+#
+# Test suite for MS Windows systems. This should be run via the
+# 'rake test' task.
+######################################################################
+require 'spec_helper'
+require 'sys/cpu'
+require 'socket'
+
+RSpec.describe Sys::CPU, :windows => true do
+  let(:host) { Socket.gethostname }
+
+  example "architecture" do
+    expect(Sys::CPU).to respond_to(:architecture)
+    expect{ Sys::CPU.architecture }.not_to raise_error
+    expect{ Sys::CPU.architecture(host) }.not_to raise_error
+    expect(Sys::CPU.architecture).to be_kind_of(String)
+  end
+
+  example "freq" do
+    expect(Sys::CPU).to respond_to(:freq)
+    expect{ Sys::CPU.freq }.not_to raise_error
+    expect{ Sys::CPU.freq(0) }.not_to raise_error
+    expect{ Sys::CPU.freq(0, host) }.not_to raise_error
+    expect(Sys::CPU.freq).to be_kind_of(Integer)
+  end
+
+  example "model" do
+    expect(Sys::CPU).to respond_to(:model)
+    expect{ Sys::CPU.model }.not_to raise_error
+    expect{ Sys::CPU.model(host) }.not_to raise_error
+    expect(Sys::CPU.model).to be_kind_of(String)
+  end
+
+  example "num_cpu" do
+    expect(Sys::CPU).to respond_to(:num_cpu)
+    expect{ Sys::CPU.num_cpu }.not_to raise_error
+    expect{ Sys::CPU.num_cpu(host) }.not_to raise_error
+    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+  end
+
+  example "cpu_type" do
+    expect(Sys::CPU).to respond_to(:cpu_type)
+    expect{ Sys::CPU.cpu_type }.not_to raise_error
+    expect{ Sys::CPU.cpu_type(host) }.not_to raise_error
+    expect(Sys::CPU.cpu_type).to be_kind_of(String)
+  end
+
+  example "load_avg" do
+    expect(Sys::CPU).to respond_to(:load_avg)
+    expect{ Sys::CPU.load_avg }.not_to raise_error
+    expect{ Sys::CPU.load_avg(0, host) }.not_to raise_error
+    expect(Sys::CPU.load_avg).to be_kind_of(Integer)
+  end
+
+  example "processors" do
+    expect(Sys::CPU).to respond_to(:processors)
+    expect{ Sys::CPU.processors{}.not_to raise_error }
+  end
+end

data/sys-cpu.gemspec

@@ -2,13 +2,13 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'sys-cpu'
-  spec.version    = '0.9.0'
+  spec.version    = '1.0.0'
   spec.author     = 'Daniel J. Berger'
   spec.email      = 'djberg96@gmail.com'
   spec.license    = 'Apache-2.0'
   spec.homepage   = 'https://github.com/djberg96/sys-cpu'
   spec.summary    = 'A Ruby interface for providing CPU information'
-  spec.test_file  = 'test/test_sys_cpu.rb'
+  spec.test_files = Dir['spec/*.rb']
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
   spec.cert_chain = ['certs/djberg96_pub.pem']
 
@@ -17,10 +17,10 @@ Gem::Specification.new do |spec|
   # The ffi dependency is only relevent for the Unix version. Given the
   # ubiquity of ffi these days, I felt a bogus dependency on ffi for Windows
   # and Linux was worth the tradeoff of not having to create 3 separate gems.
-  spec.add_dependency('ffi')
+  spec.add_dependency('ffi', '~> 1.1')
 
-  spec.add_development_dependency('test-unit')
   spec.add_development_dependency('rake')
+  spec.add_development_dependency('rspec', '~> 3.9')
 
   spec.metadata = {
     'homepage_uri'      => 'https://github.com/djberg96/sys-cpu',

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: sys-cpu
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel J. Berger
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain:
 - |
@@ -35,24 +35,24 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date: 
+date:
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,19 +66,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.9'
 description: |2
       The sys-cpu library provides an interface for gathering information
       about your system's processor(s). Information includes speed, type,
@@ -87,52 +87,53 @@ email: djberg96@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
-- MANIFEST.rdoc
 - CHANGES.rdoc
-files:
+- MANIFEST.rdoc
 - README.rdoc
+files:
+- install.rb
+- LICENSE
+- spec
+- spec/spec_helper.rb
+- spec/sys_cpu_bsd_spec.rb
+- spec/sys_cpu_sunos_spec.rb
+- spec/sys_cpu_hpux_spec.rb
+- spec/sys_cpu_linux_spec.rb
+- spec/sys_cpu_windows_spec.rb
+- spec/sys_cpu_spec.rb
+- Rakefile
+- certs
+- certs/djberg96_pub.pem
 - examples
-- examples/example_sys_cpu_sunos.rb
-- examples/example_sys_cpu_windows.rb
-- examples/example_sys_cpu_hpux.rb
 - examples/example_sys_cpu_linux.rb
+- examples/example_sys_cpu_hpux.rb
+- examples/example_sys_cpu_sunos.rb
 - examples/example_sys_cpu_bsd.rb
+- examples/example_sys_cpu_windows.rb
 - sys-cpu.gemspec
-- MANIFEST.rdoc
-- certs
-- certs/djberg96_pub.pem
-- test
-- test/test_sys_cpu_bsd.rb
-- test/test_sys_cpu_version.rb
-- test/test_sys_cpu.rb
-- test/test_sys_cpu_windows.rb
-- test/test_sys_cpu_sunos.rb
-- test/test_sys_cpu_hpux.rb
-- test/test_sys_cpu_linux.rb
-- doc
-- doc/linux.txt
-- doc/windows.txt
-- doc/sunos.txt
-- doc/hpux.txt
-- doc/bsd.txt
-- install.rb
-- LICENSE
 - lib
-- lib/sys-cpu.rb
 - lib/sys
-- lib/sys/cpu.rb
-- lib/sys/linux
-- lib/sys/linux/sys
-- lib/sys/linux/sys/cpu.rb
 - lib/sys/unix
 - lib/sys/unix/sys
 - lib/sys/unix/sys/cpu.rb
+- lib/sys/linux
+- lib/sys/linux/sys
+- lib/sys/linux/sys/cpu.rb
+- lib/sys/cpu.rb
 - lib/sys/windows
 - lib/sys/windows/sys
 - lib/sys/windows/sys/cpu.rb
-- Rakefile
+- lib/sys-cpu.rb
 - CHANGES.rdoc
+- Gemfile
+- doc
+- doc/linux.txt
+- doc/sunos.txt
+- doc/windows.txt
+- doc/bsd.txt
+- doc/hpux.txt
+- MANIFEST.rdoc
+- README.rdoc
 homepage: https://github.com/djberg96/sys-cpu
 licenses:
 - Apache-2.0
@@ -143,7 +144,7 @@ metadata:
   documentation_uri: https://github.com/djberg96/sys-cpu/wiki
   source_code_uri: https://github.com/djberg96/sys-cpu
   wiki_uri: https://github.com/djberg96/sys-cpu/wiki
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -158,9 +159,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: A Ruby interface for providing CPU information
 test_files:
-- test/test_sys_cpu.rb
+- spec/spec_helper.rb
+- spec/sys_cpu_bsd_spec.rb
+- spec/sys_cpu_sunos_spec.rb
+- spec/sys_cpu_hpux_spec.rb
+- spec/sys_cpu_linux_spec.rb
+- spec/sys_cpu_windows_spec.rb
+- spec/sys_cpu_spec.rb

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,54 +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'
-
-class TC_Sys_CPU_Linux < Test::Unit::TestCase
-  test "dynamic methods are defined as expected" do
-    assert_nothing_raised{
-      Sys::CPU.processors{ |cs|
-        cs.members.each{ |m| cs[m].to_s }
-      }
-    }
-  end
-
-  test "load average works as expected" do
-    assert_nothing_raised{ Sys::CPU.load_avg }
-    assert_equal(3, Sys::CPU.load_avg.length)
-  end
-
-  test "cpu_stats works as expected" do
-    assert_nothing_raised{ Sys::CPU.cpu_stats }
-    assert_kind_of(Hash, Sys::CPU.cpu_stats)
-    assert_true(Sys::CPU.cpu_stats['cpu0'].length >= 4)
-  end
-
-  test "architecture works as expected" do
-    assert_nothing_raised{ Sys::CPU.architecture }
-    assert_kind_of(String, Sys::CPU.architecture)
-  end
-
-  test "model works as expected" do
-    assert_nothing_raised{ Sys::CPU.model }
-    assert_kind_of(String, Sys::CPU.model)
-  end
-
-  test "freq works as expected" do
-    assert_nothing_raised{ Sys::CPU.freq }
-    assert_kind_of(Numeric, Sys::CPU.freq)
-  end
-
-  test "num_cpu works as expected" do
-    assert_nothing_raised{ Sys::CPU.num_cpu }
-    assert_kind_of(Numeric, Sys::CPU.num_cpu)
-  end
-
-  test "bogus methods are not picked up by method_missing" do
-    assert_raise(NoMethodError){ Sys::CPU.bogus }
-  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.9.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