cpuinfo 1.0.0

data/lib/sys-cpu.rb

@@ -0,0 +1 @@
+require_relative 'sys/cpu'

data/test/test_sys_cpu_bsd.rb

@@ -0,0 +1,97 @@
+#############################################################
+# 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

@@ -0,0 +1,49 @@
+#####################################################################
+# 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

@@ -0,0 +1,31 @@
+###########################################################
+# 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

@@ -0,0 +1,81 @@
+###########################################################
+# 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

@@ -0,0 +1,15 @@
+#######################################################################
+# 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.7.2', Sys::CPU::VERSION)
+  end
+end

data/test/test_sys_cpu_windows.rb

@@ -0,0 +1,72 @@
+######################################################################
+# 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

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: cpuinfo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matthias Winkelmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: "    Very basic parsing of /proc/cpuinfo for now.\n"
+email: m@matthi.coffee
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- cpuinfo/LICENSE
+- cpuinfo/README.md
+- cpuinfo/Rakefile
+- cpuinfo/cpuinfo.gemspec
+- cpuinfo/lib/cpuinfo.rb
+- cpuinfo/test/fixtures/cpuinfo
+- cpuinfo/test/test.rb
+- lib/cp/cpu.rb
+- lib/cp/unix/sys/cpu.rb
+- lib/cp/windows/sys/cpu.rb
+- lib/sys-cpu.rb
+- test/test_sys_cpu_bsd.rb
+- test/test_sys_cpu_hpux.rb
+- test/test_sys_cpu_linux.rb
+- test/test_sys_cpu_sunos.rb
+- test/test_sys_cpu_version.rb
+- test/test_sys_cpu_windows.rb
+homepage: https://github.com/MatthiasWinkelmann/cpuinfo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A Ruby interface to system CPU info
+test_files: []