1 files changed, 121 insertions, 19 deletions
diff --git a/spec/ruby/core/process/clock_gettime_spec.rb b/spec/ruby/core/process/clock_gettime_spec.rb
index a7b6bd2b02..88158904e1 100644
--- a/spec/ruby/core/process/clock_gettime_spec.rb
+++ b/spec/ruby/core/process/clock_gettime_spec.rb
@@ -1,50 +1,152 @@
 require_relative '../../spec_helper'
+require_relative 'fixtures/clocks'
 
 describe "Process.clock_gettime" do
-  platform_is_not :windows, :solaris do
-    Process.constants.select { |c|
-      c.to_s.start_with?('CLOCK_') &&
-      # These require CAP_WAKE_ALARM and are not documented in clock_gettime(),
-      # they return EINVAL if the permission is not granted.
-      c != :CLOCK_BOOTTIME_ALARM &&
-      c != :CLOCK_REALTIME_ALARM
-    }.each do |c|
-      it "can be called with Process::#{c}" do
-        value = Process.const_get(c)
-        Process.clock_gettime(value).should be_an_instance_of(Float)
-      end
+  ProcessSpecs.clock_constants.each do |name, value|
+    it "can be called with Process::#{name}" do
+      Process.clock_gettime(value).should.instance_of?(Float)
     end
   end
 
   describe 'time units' do
     it 'handles a fixed set of time units' do
       [:nanosecond, :microsecond, :millisecond, :second].each do |unit|
-        Process.clock_gettime(Process::CLOCK_MONOTONIC, unit).should be_kind_of(Integer)
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, unit).should.is_a?(Integer)
       end
 
       [:float_microsecond, :float_millisecond, :float_second].each do |unit|
-        Process.clock_gettime(Process::CLOCK_MONOTONIC, unit).should be_an_instance_of(Float)
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, unit).should.instance_of?(Float)
       end
     end
 
     it 'raises an ArgumentError for an invalid time unit' do
-      lambda { Process.clock_gettime(Process::CLOCK_MONOTONIC, :bad) }.should raise_error(ArgumentError)
+      -> { Process.clock_gettime(Process::CLOCK_MONOTONIC, :bad) }.should.raise(ArgumentError)
     end
 
     it 'defaults to :float_second' do
       t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second)
 
-      t1.should be_an_instance_of(Float)
-      t2.should be_close(t1, 2.0)  # 2.0 is chosen arbitrarily to allow for time skew without admitting failure cases, which would be off by an order of magnitude.
+      t1.should.instance_of?(Float)
+      t2.should.instance_of?(Float)
+      t2.should be_close(t1, TIME_TOLERANCE)
     end
 
     it 'uses the default time unit (:float_second) when passed nil' do
       t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC, nil)
       t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second)
 
-      t1.should be_an_instance_of(Float)
-      t2.should be_close(t1, 2.0) # 2.0 is chosen arbitrarily to allow for time skew without admitting failure cases, which would be off by an order of magnitude.
+      t1.should.instance_of?(Float)
+      t2.should.instance_of?(Float)
+      t2.should be_close(t1, TIME_TOLERANCE)
+    end
+  end
+
+  describe "supports the platform clocks mentioned in the documentation" do
+    it "CLOCK_REALTIME" do
+      Process.clock_gettime(Process::CLOCK_REALTIME).should.instance_of?(Float)
+    end
+
+    it "CLOCK_MONOTONIC" do
+      Process.clock_gettime(Process::CLOCK_MONOTONIC).should.instance_of?(Float)
+    end
+
+    # These specs need macOS 10.12+ / darwin 16+
+    guard -> { platform_is_not(:darwin) or kernel_version_is '16' } do
+      platform_is :linux, :openbsd, :darwin do
+        it "CLOCK_PROCESS_CPUTIME_ID" do
+          Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID).should.instance_of?(Float)
+        end
+      end
+
+      platform_is :linux, :freebsd, :openbsd, :darwin do
+        it "CLOCK_THREAD_CPUTIME_ID" do
+          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID).should.instance_of?(Float)
+        end
+      end
+
+      platform_is :linux, :darwin do
+        it "CLOCK_MONOTONIC_RAW" do
+          Process.clock_gettime(Process::CLOCK_MONOTONIC_RAW).should.instance_of?(Float)
+        end
+      end
+
+      platform_is :darwin do
+        it "CLOCK_MONOTONIC_RAW_APPROX" do
+          Process.clock_gettime(Process::CLOCK_MONOTONIC_RAW_APPROX).should.instance_of?(Float)
+        end
+
+        it "CLOCK_UPTIME_RAW and CLOCK_UPTIME_RAW_APPROX" do
+          Process.clock_gettime(Process::CLOCK_UPTIME_RAW).should.instance_of?(Float)
+          Process.clock_gettime(Process::CLOCK_UPTIME_RAW_APPROX).should.instance_of?(Float)
+        end
+      end
+    end
+
+    platform_is :freebsd do
+      it "CLOCK_VIRTUAL" do
+        Process.clock_gettime(Process::CLOCK_VIRTUAL).should.instance_of?(Float)
+      end
+
+      it "CLOCK_PROF" do
+        Process.clock_gettime(Process::CLOCK_PROF).should.instance_of?(Float)
+      end
+    end
+
+    platform_is :freebsd, :openbsd do
+      it "CLOCK_UPTIME" do
+        Process.clock_gettime(Process::CLOCK_UPTIME).should.instance_of?(Float)
+      end
+    end
+
+    platform_is :freebsd do
+      it "CLOCK_REALTIME_FAST and CLOCK_REALTIME_PRECISE" do
+        Process.clock_gettime(Process::CLOCK_REALTIME_FAST).should.instance_of?(Float)
+        Process.clock_gettime(Process::CLOCK_REALTIME_PRECISE).should.instance_of?(Float)
+      end
+
+      it "CLOCK_MONOTONIC_FAST and CLOCK_MONOTONIC_PRECISE" do
+        Process.clock_gettime(Process::CLOCK_MONOTONIC_FAST).should.instance_of?(Float)
+        Process.clock_gettime(Process::CLOCK_MONOTONIC_PRECISE).should.instance_of?(Float)
+      end
+
+      it "CLOCK_UPTIME_FAST and CLOCK_UPTIME_PRECISE" do
+        Process.clock_gettime(Process::CLOCK_UPTIME_FAST).should.instance_of?(Float)
+        Process.clock_gettime(Process::CLOCK_UPTIME_PRECISE).should.instance_of?(Float)
+      end
+
+      it "CLOCK_SECOND" do
+        Process.clock_gettime(Process::CLOCK_SECOND).should.instance_of?(Float)
+      end
+    end
+
+    guard -> { platform_is :linux and kernel_version_is '2.6.32' } do
+      it "CLOCK_REALTIME_COARSE" do
+        Process.clock_gettime(Process::CLOCK_REALTIME_COARSE).should.instance_of?(Float)
+      end
+
+      it "CLOCK_MONOTONIC_COARSE" do
+        Process.clock_gettime(Process::CLOCK_MONOTONIC_COARSE).should.instance_of?(Float)
+      end
+    end
+
+    guard -> { platform_is :linux and kernel_version_is '2.6.39' } do
+      it "CLOCK_BOOTTIME" do
+        skip "No Process::CLOCK_BOOTTIME" unless defined?(Process::CLOCK_BOOTTIME)
+        Process.clock_gettime(Process::CLOCK_BOOTTIME).should.instance_of?(Float)
+      end
+    end
+
+    guard -> { platform_is "x86_64-linux" and kernel_version_is '3.0' } do
+      it "CLOCK_REALTIME_ALARM" do
+        skip "No Process::CLOCK_REALTIME_ALARM" unless defined?(Process::CLOCK_REALTIME_ALARM)
+        Process.clock_gettime(Process::CLOCK_REALTIME_ALARM).should.instance_of?(Float)
+      end
+
+      it "CLOCK_BOOTTIME_ALARM" do
+        skip "No Process::CLOCK_BOOTTIME_ALARM" unless defined?(Process::CLOCK_BOOTTIME_ALARM)
+        Process.clock_gettime(Process::CLOCK_BOOTTIME_ALARM).should.instance_of?(Float)
+      end
     end
   end
 end