sys-cpu 0.5.5 → 0.6.0

data/ext/hpux/hpux.c

@@ -0,0 +1,219 @@
+/*****************************************************************************
+ * hpux.c (cpu.c) - sys-cpu extension for HP-UX
+ *
+ * Author: Daniel J. Berger
+ *
+ * Interface to provide various types of cpu information.
+ * Based on the Unix::Processors Perl module (Wilson Snyder) with ideas from
+ * Sys::CPU (Matt Sanford) and Solaris::Kstat (Alan Burlison) as well.
+ *****************************************************************************/
+#include <ruby.h>
+#include "version.h"
+#include <unistd.h>
+#include <sys/pstat.h>
+
+#ifndef PST_MAX_PROCS
+#define PST_MAX_PROCS 32
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+VALUE cCPUError;
+
+/*
+ * call-seq:
+ *    CPU.load_avg
+ *    CPU.load_avg(cpu_num)
+ *    CPU.load_avg{ block }
+ *
+ * In non-block form returns an array of three floats indicating the 1, 5
+ * and 15 minute overall load average.
+ *
+ * In block form, it returns an array of three floats indicating the 1, 5
+ * and 15 minute load average for each cpu.  Only useful on multi-cpu
+ * systems.
+ *
+ * If 'cpu_num' is provided, returns the load average (as a 3-element
+ * array) for that cpu only.
+ *
+ * You cannot provide +cpu_num+ and use block form at the same time.
+ */
+static VALUE cpu_load_avg(int argc, VALUE *argv)
+{
+   struct pst_processor psp[PST_MAX_PROCS];
+   struct pst_dynamic psd;
+   int i, num_cpu;
+   VALUE ncpu = Qnil;
+   VALUE la_ary = rb_ary_new();
+
+   rb_scan_args(argc,argv,"01",&ncpu);
+
+   if( (ncpu != Qnil) && (rb_block_given_p()) )
+   {
+      rb_raise(rb_eArgError,"Can't use block form when CPU number is provided");
+   }
+
+   if( (ncpu != Qnil) || ((ncpu == Qnil) && (rb_block_given_p())) )
+   {
+      num_cpu = pstat_getprocessor(psp,sizeof(struct pst_processor),PST_MAX_PROCS,0);
+      if(num_cpu < 0)
+      {
+         rb_raise(cCPUError,"Call to pstat_getprocessor() failed.");
+      }
+      else
+      {
+         for(i = 0; i < num_cpu; i++)
+         {
+            if( (ncpu != Qnil) && (NUM2INT(ncpu)) != i){ continue; }
+
+            rb_ary_push(la_ary,rb_float_new(psp[i].psp_avg_1_min));
+            rb_ary_push(la_ary,rb_float_new(psp[i].psp_avg_5_min));
+            rb_ary_push(la_ary,rb_float_new(psp[i].psp_avg_15_min));
+            if(rb_block_given_p())
+            {
+               rb_yield(la_ary);
+            }
+            else
+            {
+               return la_ary;
+            }
+            rb_ary_clear(la_ary);
+         }
+      }
+   }
+   else
+   {
+      if(pstat_getdynamic(&psd,sizeof(psd), (size_t)1, 0) == -1)
+      {
+         rb_raise(cCPUError,"Call to pstat_getdynamic() failed.");
+      }
+      else
+      {
+         rb_ary_push(la_ary,rb_float_new(psd.psd_avg_1_min));
+         rb_ary_push(la_ary,rb_float_new(psd.psd_avg_5_min));
+         rb_ary_push(la_ary,rb_float_new(psd.psd_avg_15_min));
+         return la_ary;
+      }
+   }
+
+   return Qnil;
+}
+
+/*
+ * call-seq:
+ *    CPU.num_cpu
+ *
+ * Returns the number of CPU's on the system.
+ */
+static VALUE cpu_num()
+{
+   struct pst_dynamic dyn;
+   pstat_getdynamic(&dyn, sizeof(dyn), 0, 0);
+   return INT2NUM(dyn.psd_max_proc_cnt);
+}
+
+/* call-seq:
+ *    CPU.num_active_cpu
+ *
+ * Returns the number of active CPU's on the system.
+ */
+static VALUE cpu_num_active()
+{
+   struct pst_dynamic dyn;
+   pstat_getdynamic(&dyn, sizeof(dyn), 0, 0);
+   return INT2NUM(dyn.psd_proc_cnt);
+}
+
+/*
+ * call-seq:
+ *    CPU.architecture
+ *
+ * Returns the cpu architecture, e.g. PA RISC 1.2, etc, or nil if it
+ * cannot be determined.
+ */
+static VALUE cpu_architecture()
+{
+   long cpu_ver = sysconf(_SC_CPU_VERSION);
+
+   if(cpu_ver == CPU_HP_MC68020){ return rb_str_new2("Motorola MC68020"); }
+   if(cpu_ver == CPU_HP_MC68030){ return rb_str_new2("Motorola MC68030"); }
+   if(cpu_ver == CPU_HP_MC68040){ return rb_str_new2("Motorola MC68040"); }
+   if(cpu_ver == CPU_PA_RISC1_0){ return rb_str_new2("HP PA-RISC 1.0"); }
+   if(cpu_ver == CPU_PA_RISC1_1){ return rb_str_new2("HP PA-RISC 1.1"); }
+   if(cpu_ver == CPU_PA_RISC1_2){ return rb_str_new2("HP PA-RISC 1.2"); }
+   if(cpu_ver == CPU_PA_RISC2_0){ return rb_str_new2("HP PA-RISC 2.0"); }
+
+   return Qnil;
+}
+
+/*
+ * call-seq:
+ *    CPU.freq(cpu_num=0)
+ *
+ * Returns an integer indicating the speed (i.e. frequency in Mhz) of
+ * +cpu_num+, or CPU 0 if no +cpu_num+ is specified.
+ */
+static VALUE cpu_freq(int argc, VALUE *argv)
+{
+   int cpu_num = 0; /* default value */
+   struct pst_processor psp;
+   unsigned long int clock_speed, scclktick;
+   VALUE ncpu = Qnil;
+
+   rb_scan_args(argc, argv, "01", &ncpu);
+
+   if(ncpu != Qnil)
+   {
+      Check_Type(ncpu,T_FIXNUM);
+      cpu_num = NUM2INT(ncpu);
+   }
+
+   if((pstat_getprocessor(&psp,sizeof(psp),(size_t)1,cpu_num)) == -1)
+      rb_raise(cCPUError, "Invalid CPU number?");
+
+   scclktick=sysconf(_SC_CLK_TCK);
+   clock_speed = (psp.psp_iticksperclktick * scclktick) / 1000000;
+
+   /************************************************************************/
+   /* It appears that pstat_getprocessor does not return a failure code    */
+   /* for an invalid processor number.  So, we'll assume that if the clock */
+   /* speed is 0 that an invalid number was provided.                      */
+   /************************************************************************/
+   if(clock_speed <= 0)
+      rb_raise(cCPUError, "Invalid CPU number?");
+
+   return UINT2NUM(clock_speed);
+}
+
+void Init_cpu()
+{
+   VALUE mSys, cCPU;
+
+   /* The Sys module serves as a toplevel namespace only */
+   mSys = rb_define_module("Sys");
+   
+   /* The CPU class provides class methods for obtaining CPU information */
+   cCPU = rb_define_class_under(mSys, "CPU", rb_cObject);
+   
+   /* The CPU::Error Exception class is raised whenever any of the CPU class
+    * methods fail.
+    */
+   cCPUError = rb_define_class_under(cCPU, "Error", rb_eStandardError);
+   
+   /* 0.6.0: The version of this package, returned as a String */
+   rb_define_const(cCPU, "VERSION", rb_str_new2(SYS_CPU_VERSION));
+
+   /* Class Methods */
+   rb_define_singleton_method(cCPU, "freq", cpu_freq, -1);
+   rb_define_singleton_method(cCPU, "num_cpu", cpu_num, 0);
+   rb_define_singleton_method(cCPU, "num_active_cpu", cpu_num_active, 0);
+   rb_define_singleton_method(cCPU, "load_avg", cpu_load_avg, -1);
+   rb_define_singleton_method(cCPU, "architecture", cpu_architecture, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif

data/{lib/sys → ext/sunos}/sunos.c

@@ -8,8 +8,8 @@
  * The kstat code for load_avg() was taken largely from a post by Casper Dik
  * on comp.unix.solaris.
  *****************************************************************************/
-#include "ruby.h"
-#include "lib/version.h"
+#include <ruby.h>
+#include "version.h"
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/processor.h>
@@ -38,8 +38,8 @@ VALUE cCPUError;
  *    CPU.freq(cpu_num=0)
  *
  * Returns an integer indicating the speed (i.e. frequency in Mhz) of
- * +cpu_num+, or CPU 0 (zero) if no number is provided. If you provide an
- * invalid CPU number then a CPUError is raised.
+ * +cpu_num+, or cpu 0 (zero) if no number is provided. If you provide an
+ * invalid cpu number then a CPUError is raised.
  */
 static VALUE cpu_freq(int argc, VALUE *argv)
 {
@@ -74,7 +74,7 @@ static VALUE cpu_freq(int argc, VALUE *argv)
  * call-seq:
  *    CPU.state(cpu_num=0)
  *
- * Returns a string indicating the cpu state of +cpu_num+, or CPU 0 if no
+ * Returns a string indicating the cpu state of +cpu_num+, or cpu 0 if no
  * number is specified.  Raises a CPUError if an invalid +cpu_num+ is provided.
  */
 static VALUE cpu_state(int argc, VALUE *argv)
@@ -116,7 +116,7 @@ static VALUE cpu_state(int argc, VALUE *argv)
  * call-seq:
  *    CPU.num_cpu
  * 
- * Returns the number of CPU's on your system.
+ * Returns the number of cpu's on your system.
  */
 static VALUE cpu_num()
 {
@@ -127,7 +127,7 @@ static VALUE cpu_num()
 
 /*
  * call-seq:
- *    CPU.type
+ *    CPU.cpu_type
  *
  * Returns a string indicating the type of processor.  This is the
  * architecture (e.g. sparcv9), not the exact model (e.g. Ultra-IIe).
@@ -247,26 +247,29 @@ static VALUE cpu_load_avg()
    return la_ary;
 }
 
-/*
- * Provides information about your CPU, including load average information.
- */ 
 void Init_cpu()
 {
-   VALUE sys_mSys, cCPU;
+   VALUE mSys, cCPU;
 
-   /* Modules and Classes */
-   sys_mSys  = rb_define_module("Sys");
-   cCPU      = rb_define_class_under(sys_mSys, "CPU", rb_cObject);
-   cCPUError = rb_define_class_under(sys_mSys, "CPUError", rb_eStandardError);
+   /* The Sys module serves as a toplevel namespace only */
+   mSys = rb_define_module("Sys");
+   
+   /* The CPU class provides class methods for obtaining CPU information */
+   cCPU = rb_define_class_under(mSys, "CPU", rb_cObject);
+   
+   /* The CPU::Error Exception class is raised whenever any of the CPU class
+    * methods fail.
+    */
+   cCPUError = rb_define_class_under(cCPU, "Error", rb_eStandardError);
    
-   /* Constants */
+   /* 0.6.0: The version of this package, returned as a String */
    rb_define_const(cCPU, "VERSION", rb_str_new2(SYS_CPU_VERSION));
 
    /* Class Methods */
    rb_define_singleton_method(cCPU, "freq", cpu_freq, -1);
    rb_define_singleton_method(cCPU, "state", cpu_state, -1);
    rb_define_singleton_method(cCPU, "num_cpu", cpu_num, 0);
-   rb_define_singleton_method(cCPU, "type", cpu_type, 0);
+   rb_define_singleton_method(cCPU, "cpu_type", cpu_type, 0);
    rb_define_singleton_method(cCPU, "fpu_type", cpu_fpu_type, 0);
    rb_define_singleton_method(cCPU, "model", cpu_model, 0);
    rb_define_singleton_method(cCPU, "load_avg", cpu_load_avg, 0);

data/{lib → ext}/version.h

@@ -1,2 +1,2 @@
 /* version.h - one version to rule them all */
-#define SYS_CPU_VERSION "0.5.5"
+#define SYS_CPU_VERSION "0.6.0"

data/test/tc_bsd.rb

@@ -0,0 +1,56 @@
+#############################################################
+# tc_bsd.rb
+#
+# The test case for sys-cpu on BSD flavors, including OS X.
+#############################################################
+require "sys/cpu"
+require "test/unit"
+require "tc_version"
+include Sys
+
+class TC_BSD < Test::Unit::TestCase
+   def test_architecture
+      assert_respond_to(CPU, :architecture)
+      assert_nothing_raised{ CPU.architecture }
+      assert_kind_of(String, CPU.architecture)
+      assert_raises(ArgumentError){ CPU.architecture(0) }
+   end
+
+   unless RUBY_PLATFORM.match('darwin')
+      def test_cpu_freq
+         assert_respond_to(CPU, :freq)
+         assert_nothing_raised{ CPU.freq }
+         assert_kind_of(Integer, CPU.freq)
+         assert_raises(ArgumentError){ CPU.freq(0) }
+      end
+   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_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)
+      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)
+      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)
+      assert_raises(ArgumentError){ CPU.num_cpu(0) }
+   end
+end

data/test/tc_cpu.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+require 'tc_version'
+
+case RUBY_PLATFORM
+   when /bsd|darwin|mach|osx/i
+      require 'tc_bsd'
+   when /hpux/i
+      require 'tc_hpux'
+   when /linux/i
+      require 'tc_linux'
+   when /sunos|solaris/i
+      require 'tc_sunos'
+   when /mswin|win32|dos|mingw|cygwin/i
+      require 'tc_windows'
+   else
+      raise "Platform not supported"
+end

data/test/tc_hpux.rb

@@ -1,26 +1,12 @@
-####################################################
+#####################################################################
 # tc_hpux.rb
 #
-# Test suite for the HP-UX platform.  Note that this should only
-# be run *after* the make process.
-####################################################
-base = File.basename(Dir.pwd)
-if base == "test" || base =~ /sys-cpu/
-   require "ftools"
-   Dir.chdir ".." if base == "test"
-   
-   Dir.mkdir("sys") unless File.exists?("sys")
-   if File.exist?("cpu.sl")
-      File.copy("cpu.sl","sys")
-   else
-      puts "No cpu.sl file found.  Please run extconf.rb and make first"
-      exit
-   end
-   $LOAD_PATH.unshift Dir.pwd
-end
-
+# Test suite for the HP-UX platform. This should be run via the
+# 'rake test' task.
+#####################################################################
 require "sys/cpu"
 require "test/unit"
+require "tc_version"
 include Sys
 
 class TC_HPUX < Test::Unit::TestCase
@@ -28,25 +14,25 @@ class TC_HPUX < Test::Unit::TestCase
       assert_respond_to(CPU, :freq)
       assert_nothing_raised{ CPU.freq }
       assert_nothing_raised{ CPU.freq(0) }
-      assert_kind_of(Integer,CPU.freq,"Invalid Type")
+      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")
+      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")
+      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")
+      assert_kind_of(String, CPU.architecture, "Invalid Type")
    end
 
    def test_load_avg
@@ -55,9 +41,9 @@ class TC_HPUX < Test::Unit::TestCase
       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")
+      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/tc_linux.rb

@@ -1,19 +1,12 @@
-########################################
+###########################################################
 # tc_linux.rb
 #
-# Test Suite for sys-cpu for Linux
-########################################
-base = File.basename(Dir.pwd)
-if base == "test" || base =~ /sys-cpu/
-   require "ftools"
-   Dir.chdir ".." if base == "test"
-   Dir.mkdir("sys") unless File.exists?("sys")
-   File.copy("lib/sys/linux.rb","sys/cpu.rb")
-   $LOAD_PATH.unshift Dir.pwd
-end
-
+# Test Suite for sys-cpu for Linux. This should be run via
+# the 'rake test' task.
+###########################################################
 require "sys/cpu"
 require "test/unit"
+require "tc_version"
 include Sys
 
 class TC_Linux < Test::Unit::TestCase

data/test/tc_sunos.rb

@@ -1,31 +1,14 @@
 ###########################################################
 # tc_sunos.rb
 #
-# Test suite for sys-cpu on Solaris.  This should only be
-# run *after* the make process.
+# Test suite for sys-cpu on Solaris. This should be run
+# via the 'rake test' task.
 ###########################################################
-base = File.basename(Dir.pwd)
-if base == "test" || base =~ /sys-cpu/
-   require "ftools"
-   Dir.chdir ".." if base == "test"
-   
-   Dir.mkdir("sys") unless File.exist?("sys")
-
-   if File.exist?("cpu.so")
-      File.copy("cpu.so","sys")
-   else
-      puts "No cpu.so file found.  Please run extconf.rb and make first"
-      exit
-   end
-
-   $LOAD_PATH.unshift Dir.pwd
-end
-
 require "sys/cpu"
 require "test/unit"
+require "tc_version"
 include Sys
 
-# I could really use a mock object here
 class TC_SunOS < Test::Unit::TestCase
    def test_cpu_freq
       assert_respond_to(CPU, :freq)
@@ -35,9 +18,9 @@ class TC_SunOS < Test::Unit::TestCase
    end
 
    def test_cpu_type
-      assert_respond_to(CPU, :type)
-      assert_nothing_raised{ CPU.type }
-      assert_kind_of(String, CPU.type)
+      assert_respond_to(CPU, :cpu_type)
+      assert_nothing_raised{ CPU.cpu_type }
+      assert_kind_of(String, CPU.cpu_type)
    end
 
    def test_fpu_type
@@ -74,9 +57,9 @@ class TC_SunOS < Test::Unit::TestCase
    end
 
    def test_exceptions
-      assert_raises(Sys::CPUError){ CPU.state(55) }
+      assert_raises(Sys::CPU::Error){ CPU.state(55) }
       assert_raises(TypeError){ CPU.state("yo") }
-      assert_raises(Sys::CPUError){ CPU.freq(999) }
+      assert_raises(Sys::CPU::Error){ CPU.freq(999) }
       assert_raises(TypeError){ CPU.freq("yo") }
    end
 end

data/test/tc_version.rb

@@ -5,40 +5,12 @@
 # version.  This reduces the pain of having separate tests
 # for the VERSION constant in every single test case.
 ###########################################################
-base = File.basename(Dir.pwd)
-
-if base == "test" || base =~ /sys-cpu/
-   require "ftools"
-
-   Dir.chdir("..") if base == "test"
-   Dir.mkdir("sys") unless File.exist?("sys")
-
-   case RUBY_PLATFORM
-      when /mswin|dos|cygwin|mingw/i
-         file = 'lib/sys/windows.rb'
-      when /linux/i
-         file = 'lib/sys/linux.rb'
-      else
-         require "rbconfig"
-         file = "cpu." << Config::CONFIG["DLEXT"]
-   end
-
-   if File.exist?(file)
-      File.copy(file, "sys/cpu.rb")
-   else
-      puts "No '#{file}' file found.  Please run extconf.rb and make first"
-      exit
-   end
-
-   $LOAD_PATH.unshift Dir.pwd
-end
-
 require "sys/cpu"
 require "test/unit"
 include Sys
 
 class TC_Sys_CPU_VERSION < Test::Unit::TestCase
    def test_version
-      assert_equal('0.5.5', CPU::VERSION)
+      assert_equal('0.6.0', CPU::VERSION)
    end
 end

data/test/tc_windows.rb

@@ -1,19 +1,12 @@
 ######################################################################
 # tc_windows.rb
 #
-# Test suite for Win32 systems.
+# Test suite for MS Windows systems. This should be run via the
+# 'rake test' task.
 ######################################################################
-base =  File.basename(Dir.pwd)
-if base == "test" || base =~ /sys-cpu/
-   require "ftools" if base == "test"
-   Dir.chdir '..'
-   Dir.mkdir("sys") unless File.exists?("sys")
-   File.copy("lib/sys/windows.rb","sys/cpu.rb")
-   $LOAD_PATH.unshift Dir.pwd
-end
-
 require "test/unit"
 require "sys/cpu"
+require "tc_version"
 require "socket"
 include Sys
 
@@ -26,43 +19,43 @@ class TC_Windows_CPU < Test::Unit::TestCase
       assert_respond_to(CPU, :architecture)
       assert_nothing_raised{ CPU.architecture }
       assert_nothing_raised{ CPU.architecture(@host) }
-      assert_kind_of(String,CPU.architecture,"Invalid Type")
+      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")
+      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")
+      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")
+      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")
+      assert_kind_of(String, 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")
+      assert_nothing_raised{ CPU.load_avg(0, @host) }
+      assert_kind_of(Integer, CPU.load_avg, "Invalid Type")
    end
    
    def test_processors