cpuinfo 1.0.0 → 1.0.1

data/lib/sys-cpu.rb

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

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,15 +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.7.2', Sys::CPU::VERSION)
-  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