sys-proctable 1.2.5 → 1.2.7

data/spec/sys_proctable_all_spec.rb

@@ -2,89 +2,89 @@
 # sys_proctable_all_spec.rb
 #
 # Test suite for methods common to all platforms. Generally speaking
-# you should run these specs using the 'rake test' task.
+# you should run these specs using the 'rake spec' task.
 #######################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_top_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe 'common' do
   let(:windows) { File::ALT_SEPARATOR }
 
   before(:all) do
     @pid = Process.pid
   end
 
-  it "has a VERSION constant set to the expected value" do
-    expect(Sys::ProcTable::VERSION).to eql('1.2.5')
-    expect(Sys::ProcTable::VERSION).to be_frozen
-  end
+  context 'constants' do
+    it 'has a VERSION constant set to the expected value' do
+      expect(Sys::ProcTable::VERSION).to eql('1.2.7')
+      expect(Sys::ProcTable::VERSION).to be_frozen
+    end
 
-  it "defines a custom error class" do
-    expect{ Sys::ProcTable::Error }.to_not raise_error
-    expect(Sys::ProcTable::Error.new).to be_kind_of(StandardError)
+    it 'defines a custom error class' do
+      expect{ Sys::ProcTable::Error }.not_to raise_error
+      expect(Sys::ProcTable::Error.new).to be_kind_of(StandardError)
+    end
   end
 
-  context "fields" do
-    it "has a fields singleton method" do
-      expect(described_class).to respond_to(:fields)
+  context 'fields' do
+    it 'has a fields singleton method' do
+      expect(Sys::ProcTable).to respond_to(:fields)
     end
 
-    it "returns the expected data type for the fields singleton method" do
-      expect(described_class.fields).to be_kind_of(Array)
-      expect(described_class.fields.first).to be_kind_of(String)
+    it 'returns the expected data type for the fields singleton method' do
+      expect(Sys::ProcTable.fields).to be_kind_of(Array)
+      expect(Sys::ProcTable.fields.first).to be_kind_of(String)
     end
   end
 
-  context "ps" do
-    it "defines a ps singleton method" do
-      expect(described_class).to respond_to(:ps)
+  context 'ps' do
+    it 'defines a ps singleton method' do
+      expect(Sys::ProcTable).to respond_to(:ps)
     end
 
-    it "allows a pid option as an argument" do
-      expect{ described_class.ps(pid: 0) }.to_not raise_error
+    it 'allows a pid option as an argument' do
+      expect{ Sys::ProcTable.ps(:pid => 0) }.not_to raise_error
     end
 
-    it "allows the pid to be nil" do
-      expect{ described_class.ps(pid: nil) }.to_not raise_error
-      expect(described_class.ps(pid: nil)).to be_kind_of(Array)
+    it 'allows the pid to be nil' do
+      expect{ Sys::ProcTable.ps(:pid => nil) }.not_to raise_error
+      expect(Sys::ProcTable.ps(:pid => nil)).to be_kind_of(Array)
     end
 
-    it "returns expected results with no arguments" do
-      expect(described_class.ps).to be_kind_of(Array)
+    it 'returns expected results with no arguments' do
+      expect(Sys::ProcTable.ps).to be_kind_of(Array)
     end
 
-    it "returns expected results with a pid argument" do
-      expect(described_class.ps(pid: @pid)).to be_kind_of(Struct::ProcTableStruct)
+    it 'returns expected results with a pid argument' do
+      expect(Sys::ProcTable.ps(:pid => @pid)).to be_kind_of(Struct::ProcTableStruct)
     end
 
-    it "returns nil if the process does not exist" do
-      expect(described_class.ps(pid: 999999999)).to be_nil
+    it 'returns nil if the process does not exist' do
+      expect(Sys::ProcTable.ps(:pid => 999999999)).to be_nil
     end
 
-    it "returns nil in block form whether or not a pid was provided" do
-      expect(described_class.ps{}).to be_nil
-      expect(described_class.ps(pid: 999999999){}).to be_nil
+    it 'returns nil in block form whether or not a pid was provided' do
+      expect(Sys::ProcTable.ps{}).to be_nil
+      expect(Sys::ProcTable.ps(:pid => 999999999){}).to be_nil
     end
 
-    it "returns frozen structs" do
-      expect(described_class.ps.first.frozen?).to eql(true)
+    it 'returns frozen structs' do
+      expect(Sys::ProcTable.ps.first.frozen?).to be(true)
     end
 
-    it "expects a numeric pid argument if present" do
-      expect{ described_class.ps(pid: 'vim') }.to raise_error(TypeError)
+    it 'expects a numeric pid argument if present' do
+      expect{ Sys::ProcTable.ps(:pid => 'vim') }.to raise_error(TypeError)
     end
 
-    it "accepts keyword arguments only" do
-      expect{ described_class.ps(0, 'localhost') }.to raise_error(ArgumentError)
+    it 'accepts keyword arguments only' do
+      expect{ Sys::ProcTable.ps(0, 'localhost') }.to raise_error(ArgumentError)
     end
 
-    it "disables the traditional constructor" do
-      expect{ described_class.new }.to raise_error(NoMethodError)
+    it 'disables the traditional constructor' do
+      expect{ Sys::ProcTable.new }.to raise_error(NoMethodError)
     end
 
-    it "works within a thread" do
-      expect{ Thread.new{ described_class.ps }.value }.to_not raise_error
+    it 'works within a thread' do
+      expect{ Thread.new{ Sys::ProcTable.ps }.value }.not_to raise_error
     end
   end
 end

data/spec/sys_proctable_darwin_spec.rb

@@ -4,11 +4,9 @@
 # Test suite for the Darwin version of the sys-proctable library. You
 # should run these tests via the 'rake test' task.
 ########################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_proctable_all_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe Sys::ProcTable, :darwin do
   let(:fields){
     %w[
       flags status xstatus pid ppid uid gid ruid rgid svuid svgid rfu1 comm
@@ -21,8 +19,8 @@ describe Sys::ProcTable do
   }
 
   before(:all) do
-    @pid1 = fork { exec('env', '-i', 'A=B', 'Z=', 'sleep', '60') }
-    @pid2 = fork { exec('ruby', '-Ilib', '-e', 'sleep \'120\'.to_i', '--', 'foo bar') }
+    @pid1 = Process.spawn({'A' => 'B', 'Z' => nil}, 'sleep 60')
+    @pid2 = Process.spawn('ruby', '-Ilib', '-e', "sleep \'120\'.to_i", '--', 'foo bar')
     sleep 1 # wait to make sure env is replaced by sleep
   end
 
@@ -31,90 +29,119 @@ describe Sys::ProcTable do
     Process.kill('TERM', @pid2)
   end
 
-  context "fields singleton method" do
-    it "responds to a fields method" do
+  context 'fields singleton method' do
+    it 'responds to a fields method' do
       expect(described_class).to respond_to(:fields)
     end
 
-    it "returns the expected results for the fields method" do
+    it 'returns the expected results for the fields method' do
       expect(described_class.fields).to be_kind_of(Array)
-      expect(described_class.fields).to eql(fields)
+      expect(described_class.fields).to eq(fields)
     end
   end
 
-  context "ProcTable::Struct members" do
-    subject { described_class.ps(pid: @pid1) }
+  context 'ProcTable::Struct members' do
+    subject(:process){ described_class.ps(:pid => @pid1) }
 
-    it "contains a pid member and returns the expected value" do
-      expect(subject).to respond_to(:pid)
-      expect(subject.pid).to be_kind_of(Numeric)
-      expect(subject.pid).to eql(@pid1)
+    it 'contains a pid member and returns the expected value' do
+      expect(process).to respond_to(:pid)
+      expect(process.pid).to be_kind_of(Numeric)
+      expect(process.pid).to eq(@pid1)
     end
 
-    it "contains a ppid member and returns the expected value" do
-      expect(subject).to respond_to(:ppid)
-      expect(subject.ppid).to be_kind_of(Numeric)
-      expect(subject.ppid).to eql(Process.pid)
+    it 'contains a ppid member and returns the expected value' do
+      expect(process).to respond_to(:ppid)
+      expect(process.ppid).to be_kind_of(Numeric)
+      expect(process.ppid).to eq(Process.pid)
     end
 
-    it "contains a pgid member and returns the expected value" do
-      expect(subject).to respond_to(:pgid)
-      expect(subject.pgid).to be_kind_of(Numeric)
-      expect(subject.pgid).to eql(Process.getpgrp)
+    it 'contains a pgid member and returns the expected value' do
+      expect(process).to respond_to(:pgid)
+      expect(process.pgid).to be_kind_of(Numeric)
+      expect(process.pgid).to eq(Process.getpgrp)
     end
 
-    it "contains a ruid member and returns the expected value" do
-      expect(subject).to respond_to(:ruid)
-      expect(subject.ruid).to be_kind_of(Numeric)
-      expect(subject.ruid).to eql(Process.uid)
+    it 'contains a ruid member and returns the expected value' do
+      expect(process).to respond_to(:ruid)
+      expect(process.ruid).to be_kind_of(Numeric)
+      expect(process.ruid).to eq(Process.uid)
     end
 
-    it "contains an rgid member and returns the expected value" do
-      expect(subject).to respond_to(:rgid)
-      expect(subject.rgid).to be_kind_of(Numeric)
-      expect(subject.rgid).to eql(Process.gid)
+    it 'contains an rgid member and returns the expected value' do
+      expect(process).to respond_to(:rgid)
+      expect(process.rgid).to be_kind_of(Numeric)
+      expect(process.rgid).to eq(Process.gid)
     end
 
-    it "contains an svuid member and returns the expected value" do
-      expect(subject).to respond_to(:svuid)
-      expect(subject.svuid).to be_kind_of(Numeric)
-      expect(subject.svuid).to eql(Process.uid)
+    it 'contains an svuid member and returns the expected value' do
+      expect(process).to respond_to(:svuid)
+      expect(process.svuid).to be_kind_of(Numeric)
+      expect(process.svuid).to eq(Process.uid)
     end
 
-    it "contains an svgid member and returns the expected value" do
-      expect(subject).to respond_to(:svgid)
-      expect(subject.svgid).to be_kind_of(Numeric)
-      expect(subject.svgid).to eql(Process.gid)
+    it 'contains an svgid member and returns the expected value' do
+      expect(process).to respond_to(:svgid)
+      expect(process.svgid).to be_kind_of(Numeric)
+      expect(process.svgid).to eq(Process.gid)
     end
 
-    it "contains a comm member and returns the expected value", :skip_jruby do
-      expect(subject).to respond_to(:comm)
-      expect(subject.comm).to be_kind_of(String)
-      expect(subject.comm).to eql('sleep')
+    it 'contains a comm member and returns the expected value' do
+      expect(process).to respond_to(:comm)
+      expect(process.comm).to be_kind_of(String)
+      expect(process.comm).to eq('sleep')
     end
 
-    it "contains a cmdline member and returns the expected value", :skip_jruby do
-      expect(subject).to respond_to(:cmdline)
-      expect(subject.cmdline).to be_kind_of(String)
-      expect(subject.cmdline).to eql('sleep 60')
+    it 'contains a cmdline member and returns the expected value' do
+      expect(process).to respond_to(:cmdline)
+      expect(process.cmdline).to be_kind_of(String)
+      expect(process.cmdline).to eq('sleep 60')
     end
 
-    it "returns a string with the expected arguments for the cmdline member", :skip_jruby do
-      ptable = Sys::ProcTable.ps(pid: @pid2)
-      expect(ptable.cmdline).to eql('ruby -Ilib -e sleep \'120\'.to_i -- foo bar')
+    it 'returns a string with the expected arguments for the cmdline member', :skip => :jruby do
+      ptable = Sys::ProcTable.ps(:pid => @pid2)
+      expect(ptable.cmdline).to eq('ruby -Ilib -e sleep \'120\'.to_i -- foo bar')
     end
 
-    it "contains an exe member and returns the expected value", :skip_jruby do
-      expect(subject).to respond_to(:exe)
-      expect(subject.exe).to be_kind_of(String)
-      expect(subject.exe).to eql(`which sleep`.chomp)
+    it 'contains an exe member and returns the expected value' do
+      expect(process).to respond_to(:exe)
+      expect(process.exe).to be_kind_of(String)
+      expect(process.exe).to eq(`which sleep`.chomp)
     end
 
-    it "contains an environ member and returns the expected value", :skip_jruby do
-      expect(subject).to respond_to(:environ)
-      expect(subject.environ).to be_kind_of(Hash)
-      expect(subject.environ['A']).to eql('B')
-      expect(subject.environ['Z']).to be_nil
+    it 'contains an environ member and returns the expected value' do
+      skip 'It appears to no longer be possible to get environ on spawned processes on Catalina or later in most cases'
+      expect(process).to respond_to(:environ)
+      expect(process.environ).to be_kind_of(Hash)
+      expect(process.environ['A']).to eq('B')
+      expect(process.environ['Z']).to be_nil
+    end
+  end
+
+  context 'private constants' do
+    it 'makes FFI methods private' do
+      expect(described_class).not_to respond_to(:sysctl)
+      expect(described_class).not_to respond_to(:proc_listallpids)
+      expect(described_class).not_to respond_to(:proc_pidinfo)
+    end
+
+    it 'makes FFI structs private' do
+      expect(described_class.constants).not_to include(:ProcBsdInfo)
+      expect(described_class.constants).not_to include(:ProcThreadInfo)
+      expect(described_class.constants).not_to include(:ProcTaskInfo)
+      expect(described_class.constants).not_to include(:ProcTaskAllInfo)
+    end
+
+    it 'makes internal constants private' do
+      expect(described_class.constants).not_to include(:PROC_PIDTASKALLINFO)
+      expect(described_class.constants).not_to include(:PROC_PIDTHREADINFO)
+      expect(described_class.constants).not_to include(:PROC_PIDLISTTHREADS)
+      expect(described_class.constants).not_to include(:CTL_KERN)
+      expect(described_class.constants).not_to include(:KERN_PROCARGS)
+      expect(described_class.constants).not_to include(:KERN_PROCARGS2)
+      expect(described_class.constants).not_to include(:MAX_COMLEN)
+      expect(described_class.constants).not_to include(:MAX_PATHLEN)
+      expect(described_class.constants).not_to include(:MAXTHREADNAMESIZE)
+      expect(described_class.constants).not_to include(:PROC_PIDPATHINFO_MAXSIZE)
     end
   end
 end

data/spec/sys_proctable_freebsd_spec.rb

@@ -2,13 +2,11 @@
 # sys_proctable_freebsd_rspec.rb
 #
 # Test suite for FreeBSD for the sys-proctable library.
-# You should run these tests via 'rake test'.
+# You should run these tests via the 'rake spec' task.
 ################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_proctable_all_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe Sys::ProcTable, :freebsd do
   let(:fields){
     %w[
       pid ppid pgid tpgid sid tsid jobc uid ruid rgid
@@ -21,190 +19,190 @@ describe Sys::ProcTable do
     ]
   }
 
-  context "fields singleton method" do
-    it "responds to a fields method" do
+  context 'fields singleton method' do
+    it 'responds to a fields method' do
       expect(described_class).to respond_to(:fields)
     end
 
-    it "returns the expected results for the fields method" do
+    it 'returns the expected results for the fields method' do
       expect(described_class.fields).to be_kind_of(Array)
       expect(described_class.fields).to eql(fields)
     end
   end
 
-  context "ProcTable::Struct members" do
-    subject { described_class.ps(pid: Process.pid) }
+  context 'ProcTable::Struct members' do
+    subject(:process){ described_class.ps(:pid => Process.pid) }
 
-    it "contains a pid member and returns the expected value" do
-      expect(subject).to respond_to(:pid)
-      expect(subject.pid).to be_kind_of(Numeric)
-      expect(subject.pid).to eql(Process.pid)
+    it 'contains a pid member and returns the expected value' do
+      expect(process).to respond_to(:pid)
+      expect(process.pid).to be_kind_of(Numeric)
+      expect(process.pid).to eql(Process.pid)
     end
 
-    it "contains a ppid member and returns the expected value" do
-      expect(subject).to respond_to(:ppid)
-      expect(subject.ppid).to be_kind_of(Fixnum)
+    it 'contains a ppid member and returns the expected value' do
+      expect(process).to respond_to(:ppid)
+      expect(process.ppid).to be_kind_of(Integer)
     end
 
-    it "contains a pgid member and returns the expected value" do
-      expect(subject).to respond_to(:pgid)
-      expect(subject.pgid).to be_kind_of(Fixnum)
+    it 'contains a pgid member and returns the expected value' do
+      expect(process).to respond_to(:pgid)
+      expect(process.pgid).to be_kind_of(Integer)
     end
 
-    it "contains a ruid member and returns the expected value" do
-      expect(subject).to respond_to(:ruid)
-      expect(subject.ruid).to be_kind_of(Fixnum)
+    it 'contains a ruid member and returns the expected value' do
+      expect(process).to respond_to(:ruid)
+      expect(process.ruid).to be_kind_of(Integer)
     end
 
-    it "contains a rgid member and returns the expected value" do
-      expect(subject).to respond_to(:rgid)
-      expect(subject.rgid).to be_kind_of(Fixnum)
+    it 'contains a rgid member and returns the expected value' do
+      expect(process).to respond_to(:rgid)
+      expect(process.rgid).to be_kind_of(Integer)
     end
 
-    it "contains a comm member and returns the expected value" do
-      expect(subject).to respond_to(:comm)
-      expect(subject.comm).to be_kind_of(String)
+    it 'contains a comm member and returns the expected value' do
+      expect(process).to respond_to(:comm)
+      expect(process.comm).to be_kind_of(String)
     end
 
-    it "contains a state member and returns the expected value" do
-      expect(subject).to respond_to(:state)
-      expect(subject.state).to be_kind_of(String)
+    it 'contains a state member and returns the expected value' do
+      expect(process).to respond_to(:state)
+      expect(process.state).to be_kind_of(String)
     end
 
-    it "contains a pctcpu member and returns the expected value" do
-      expect(subject).to respond_to(:pctcpu)
-      expect(subject.pctcpu).to be_kind_of(Float)
+    it 'contains a pctcpu member and returns the expected value' do
+      expect(process).to respond_to(:pctcpu)
+      expect(process.pctcpu).to be_kind_of(Float)
     end
 
-    it "contains a oncpu member and returns the expected value" do
-      expect(subject).to respond_to(:oncpu)
-      expect(subject.oncpu).to be_kind_of(Fixnum)
+    it 'contains a oncpu member and returns the expected value' do
+      expect(process).to respond_to(:oncpu)
+      expect(process.oncpu).to be_kind_of(Integer)
     end
 
-    it "contains a ttynum member and returns the expected value" do
-      expect(subject).to respond_to(:ttynum)
-      expect(subject.ttynum).to be_kind_of(Fixnum)
+    it 'contains a ttynum member and returns the expected value' do
+      expect(process).to respond_to(:ttynum)
+      expect(process.ttynum).to be_kind_of(Integer)
     end
 
-    it "contains a ttydev member and returns the expected value" do
-      expect(subject).to respond_to(:ttydev)
-      expect(subject.ttydev).to be_kind_of(String)
+    it 'contains a ttydev member and returns the expected value' do
+      expect(process).to respond_to(:ttydev)
+      expect(process.ttydev).to be_kind_of(String)
     end
 
-    it "contains a wmesg member and returns the expected value" do
-      expect(subject).to respond_to(:wmesg)
-      expect(subject.wmesg).to be_kind_of(String)
+    it 'contains a wmesg member and returns the expected value' do
+      expect(process).to respond_to(:wmesg)
+      expect(process.wmesg).to be_kind_of(String)
     end
 
-    it "contains a runtime member and returns the expected value" do
-      expect(subject).to respond_to(:runtime)
-      expect(subject.runtime).to be_kind_of(Fixnum)
+    it 'contains a runtime member and returns the expected value' do
+      expect(process).to respond_to(:runtime)
+      expect(process.runtime).to be_kind_of(Integer)
     end
 
-    it "contains a priority member and returns the expected value" do
-      expect(subject).to respond_to(:priority)
-      expect(subject.priority).to be_kind_of(Fixnum)
+    it 'contains a priority member and returns the expected value' do
+      expect(process).to respond_to(:priority)
+      expect(process.priority).to be_kind_of(Integer)
     end
 
-    it "contains a usrpri member and returns the expected value" do
-      expect(subject).to respond_to(:usrpri)
-      expect(subject.usrpri).to be_kind_of(Fixnum)
+    it 'contains a usrpri member and returns the expected value' do
+      expect(process).to respond_to(:usrpri)
+      expect(process.usrpri).to be_kind_of(Integer)
     end
 
-    it "contains a nice member and returns the expected value" do
-      expect(subject).to respond_to(:nice)
-      expect(subject.nice).to be_kind_of(Fixnum)
+    it 'contains a nice member and returns the expected value' do
+      expect(process).to respond_to(:nice)
+      expect(process.nice).to be_kind_of(Integer)
     end
 
-    it "contains a cmdline member and returns the expected value" do
-      expect(subject).to respond_to(:cmdline)
-      expect(subject.cmdline).to be_kind_of(String)
+    it 'contains a cmdline member and returns the expected value' do
+      expect(process).to respond_to(:cmdline)
+      expect(process.cmdline).to be_kind_of(String)
     end
 
-    it "contains a start member and returns the expected value" do
-      expect(subject).to respond_to(:start)
-      expect(subject.start).to be_kind_of(Time)
+    it 'contains a start member and returns the expected value' do
+      expect(process).to respond_to(:start)
+      expect(process.start).to be_kind_of(Time)
     end
 
-    it "contains a maxrss member and returns the expected value" do
-      expect(subject).to respond_to(:maxrss)
-      expect(subject.maxrss).to be_kind_of(Fixnum)
+    it 'contains a maxrss member and returns the expected value' do
+      expect(process).to respond_to(:maxrss)
+      expect(process.maxrss).to be_kind_of(Integer)
     end
 
-    it "contains a ixrss member and returns the expected value" do
-      expect(subject).to respond_to(:ixrss)
-      expect(subject.ixrss).to be_kind_of(Fixnum)
+    it 'contains a ixrss member and returns the expected value' do
+      expect(process).to respond_to(:ixrss)
+      expect(process.ixrss).to be_kind_of(Integer)
     end
 
     # TODO: The value returned on PC BSD 10 does not appear to be valid. Investigate.
-    it "contains a idrss member and returns the expected value" do
-      expect(subject).to respond_to(:idrss)
-      expect(subject.idrss).to be_kind_of(Numeric)
+    it 'contains a idrss member and returns the expected value' do
+      expect(process).to respond_to(:idrss)
+      expect(process.idrss).to be_kind_of(Numeric)
     end
 
-    it "contains a isrss member and returns the expected value" do
-      expect(subject).to respond_to(:isrss)
-      expect(subject.isrss).to be_kind_of(Fixnum)
+    it 'contains a isrss member and returns the expected value' do
+      expect(process).to respond_to(:isrss)
+      expect(process.isrss).to be_kind_of(Integer)
     end
 
-    it "contains a minflt member and returns the expected value" do
-      expect(subject).to respond_to(:minflt)
-      expect(subject.minflt).to be_kind_of(Fixnum)
+    it 'contains a minflt member and returns the expected value' do
+      expect(process).to respond_to(:minflt)
+      expect(process.minflt).to be_kind_of(Integer)
     end
 
-    it "contains a majflt member and returns the expected value" do
-      expect(subject).to respond_to(:majflt)
-      expect(subject.majflt).to be_kind_of(Fixnum)
+    it 'contains a majflt member and returns the expected value' do
+      expect(process).to respond_to(:majflt)
+      expect(process.majflt).to be_kind_of(Integer)
     end
 
-    it "contains a nswap member and returns the expected value" do
-      expect(subject).to respond_to(:nswap)
-      expect(subject.nswap).to be_kind_of(Fixnum)
+    it 'contains a nswap member and returns the expected value' do
+      expect(process).to respond_to(:nswap)
+      expect(process.nswap).to be_kind_of(Integer)
     end
 
-    it "contains a inblock member and returns the expected value" do
-      expect(subject).to respond_to(:inblock)
-      expect(subject.inblock).to be_kind_of(Fixnum)
+    it 'contains a inblock member and returns the expected value' do
+      expect(process).to respond_to(:inblock)
+      expect(process.inblock).to be_kind_of(Integer)
     end
 
-    it "contains a oublock member and returns the expected value" do
-      expect(subject).to respond_to(:oublock)
-      expect(subject.oublock).to be_kind_of(Fixnum)
+    it 'contains a oublock member and returns the expected value' do
+      expect(process).to respond_to(:oublock)
+      expect(process.oublock).to be_kind_of(Integer)
     end
 
-    it "contains a msgsnd member and returns the expected value" do
-      expect(subject).to respond_to(:msgsnd)
-      expect(subject.msgsnd).to be_kind_of(Fixnum)
+    it 'contains a msgsnd member and returns the expected value' do
+      expect(process).to respond_to(:msgsnd)
+      expect(process.msgsnd).to be_kind_of(Integer)
     end
 
-    it "contains a msgrcv member and returns the expected value" do
-      expect(subject).to respond_to(:msgrcv)
-      expect(subject.msgrcv).to be_kind_of(Fixnum)
+    it 'contains a msgrcv member and returns the expected value' do
+      expect(process).to respond_to(:msgrcv)
+      expect(process.msgrcv).to be_kind_of(Integer)
     end
 
-    it "contains a nsignals member and returns the expected value" do
-      expect(subject).to respond_to(:nsignals)
-      expect(subject.nsignals).to be_kind_of(Fixnum)
+    it 'contains a nsignals member and returns the expected value' do
+      expect(process).to respond_to(:nsignals)
+      expect(process.nsignals).to be_kind_of(Integer)
     end
 
-    it "contains a nvcsw member and returns the expected value" do
-      expect(subject).to respond_to(:nvcsw)
-      expect(subject.nvcsw).to be_kind_of(Fixnum)
+    it 'contains a nvcsw member and returns the expected value' do
+      expect(process).to respond_to(:nvcsw)
+      expect(process.nvcsw).to be_kind_of(Integer)
     end
 
-    it "contains a nivcsw member and returns the expected value" do
-      expect(subject).to respond_to(:nivcsw)
-      expect(subject.nivcsw).to be_kind_of(Fixnum)
+    it 'contains a nivcsw member and returns the expected value' do
+      expect(process).to respond_to(:nivcsw)
+      expect(process.nivcsw).to be_kind_of(Integer)
     end
 
-    it "contains a utime member and returns the expected value" do
-      expect(subject).to respond_to(:utime)
-      expect(subject.utime).to be_kind_of(Fixnum)
+    it 'contains a utime member and returns the expected value' do
+      expect(process).to respond_to(:utime)
+      expect(process.utime).to be_kind_of(Integer)
     end
 
-    it "contains a stime member and returns the expected value" do
-      expect(subject).to respond_to(:stime)
-      expect(subject.stime).to be_kind_of(Fixnum)
+    it 'contains a stime member and returns the expected value' do
+      expect(process).to respond_to(:stime)
+      expect(process.stime).to be_kind_of(Integer)
     end
   end
 end