net-ping 2.1.0-universal-linux

data/test/test_net_ping_icmp.rb

@@ -0,0 +1,199 @@
+#######################################################################
+# test_net_ping_icmp.rb
+#
+# Test case for the Net::PingICMP class. You must run this test case
+# with root privileges on UNIX systems. This should be run via the
+# 'test' or 'test:icmp' Rake task.
+#######################################################################
+require 'test-unit'
+require 'net/ping/icmp'
+require 'thread'
+
+if File::ALT_SEPARATOR
+  require 'win32/security'
+
+  unless Win32::Security.elevated_security?
+    raise "The test:icmp task must be run with elevated security rights"
+  end
+else
+
+  begin
+    # If we have cap2; raise error unless we are root, or have net_raw
+    require 'cap2'
+    current_process = Cap2.process
+    unless Process.euid == 0 \
+      || current_process.permitted?(:net_raw) \
+      && current_process.enabled?(:net_raw)
+      raise StandardError, 'requires root privileges or setcap net_raw'
+    end
+  rescue LoadError
+    # Without cap2; raise error unless we are root
+    unless Process.euid == 0
+      raise StandardError, 'requires root privileges or setcap net_raw'
+    end
+  end
+
+end
+
+class TC_PingICMP < Test::Unit::TestCase
+  def self.startup
+    @@jruby = RUBY_PLATFORM == 'java'
+  end
+
+  def setup
+    @host = '127.0.0.1' # 'localhost'
+    @icmp = Net::Ping::ICMP.new(@host)
+    @concurrency = 2
+  end
+
+  test "icmp ping basic functionality" do
+    assert_respond_to(@icmp, :ping)
+    omit_if(@@jruby)
+    assert_nothing_raised{ @icmp.ping }
+  end
+
+  test "icmp ping accepts a host" do
+    omit_if(@@jruby)
+    assert_nothing_raised{ @icmp.ping(@host) }
+  end
+
+  test "icmp ping returns a float" do
+    omit_if(@@jruby)
+    assert_kind_of(Float, @icmp.ping)
+    assert_kind_of(Float, @icmp.ping(@host))
+  end
+
+  test "icmp ping of local host is successful" do
+    omit_if(@@jruby)
+    assert_true(Net::Ping::ICMP.new(@host).ping?)
+    assert_true(Net::Ping::ICMP.new('127.0.0.1').ping?)
+  end
+
+  test "threaded icmp ping returns expected results" do
+    omit_if(@@jruby)
+    # ips = ['8.8.4.4', '8.8.9.9', '127.0.0.1', '8.8.8.8', '8.8.8.9']
+    ips = ['127.0.0.1', '8.8.8.9']
+    queue = Queue.new
+    threads = []
+
+    ips.each{ |ip| queue <<  ip }
+
+    @concurrency.times{
+      threads << Thread.new(queue) do |q|
+        ip = q.pop
+        icmp = Net::Ping::ICMP.new(ip, nil, 1)
+        if ip =~ /\.9$/
+          assert_false(icmp.ping?, "#{ip} should not be pingable")
+        else
+          assert_true(icmp.ping?, "#{ip} should be pingable")
+        end
+      end
+    }
+
+    threads.each{ |t| t.join }
+  end
+
+  test "ping? is inherited" do
+    assert_respond_to(@icmp, :ping?)
+  end
+
+  test "pingecho is inherited" do
+    assert_respond_to(@icmp, :pingecho)
+  end
+
+  test "icmp ping fails if host is invalid" do
+    omit_if(@@jruby)
+    assert_false(Net::Ping::ICMP.new('bogus').ping?)
+    assert_false(Net::Ping::ICMP.new('http://www.asdfhjklasdfhlkj.com').ping?)
+  end
+
+  test "bind method basic functionality" do
+    assert_respond_to(@icmp, :bind)
+    assert_nothing_raised{ @icmp.bind(Socket.gethostname) }
+    assert_nothing_raised{ @icmp.bind(Socket.gethostname, 80) }
+  end
+
+  test "duration method basic functionality" do
+    omit_if(@@jruby)
+    assert_nothing_raised{ @icmp.ping }
+    assert_respond_to(@icmp, :duration)
+    assert_kind_of(Float, @icmp.duration)
+  end
+
+  test "host getter method basic functionality" do
+    assert_respond_to(@icmp, :host)
+    assert_equal(@host, @icmp.host)
+  end
+
+  test "host setter method basic functionality" do
+    assert_respond_to(@icmp, :host=)
+    assert_nothing_raised{ @icmp.host = '192.168.0.1' }
+    assert_equal(@icmp.host, '192.168.0.1')
+  end
+
+  test "port method basic functionality" do
+    assert_respond_to(@icmp, :port)
+    assert_equal(nil, @icmp.port)
+  end
+
+  test "timeout getter method basic functionality" do
+    assert_respond_to(@icmp, :timeout)
+    assert_equal(5, @icmp.timeout)
+  end
+
+  test "timeout setter method basic functionality" do
+    assert_respond_to(@icmp, :timeout=)
+    assert_nothing_raised{ @icmp.timeout = 7 }
+    assert_equal(7, @icmp.timeout)
+  end
+
+  test "timeout works as expected" do
+    omit_if(@@jruby)
+    icmp = Net::Ping::ICMP.new('8.8.8.8', nil, 0.000001)
+    assert_false(icmp.ping?)
+    assert_kind_of(Timeout::Error, icmp.exception)
+  end
+
+  test "exception method basic functionality" do
+    assert_respond_to(@icmp, :exception)
+  end
+
+  test "exception method returns nil if no ping has happened yet" do
+    assert_nil(@icmp.exception)
+  end
+
+  test "warning method basic functionality" do
+    assert_respond_to(@icmp, :warning)
+  end
+
+  test "data_size getter method basic functionality" do
+    assert_respond_to(@icmp, :data_size)
+    assert_nothing_raised{ @icmp.data_size }
+    assert_kind_of(Numeric, @icmp.data_size)
+  end
+
+  test "data_size returns expected value" do
+    assert_equal(56, @icmp.data_size)
+  end
+
+  test "data_size setter method basic functionality" do
+    assert_respond_to(@icmp, :data_size=)
+    assert_nothing_raised{ @icmp.data_size = 22 }
+  end
+
+  test "setting an odd data_size is valid" do
+    omit_if(@@jruby)
+    assert_nothing_raised{ @icmp.data_size = 57 }
+    assert_kind_of(Float, @icmp.ping)
+  end
+
+  def teardown
+    @host = nil
+    @icmp = nil
+    @concurrency = nil
+  end
+
+  def self.shutdown
+    @@jruby = nil
+  end
+end

data/test/test_net_ping_tcp.rb

@@ -0,0 +1,106 @@
+#####################################################################
+# test_net_ping_tcp.rb
+#
+# Test case for the Net::PingTCP class. This test should be run via
+# the 'test' or 'test:tcp' Rake task.
+#####################################################################
+require 'test-unit'
+require 'net/ping/tcp'
+include Net
+
+class TC_PingTCP < Test::Unit::TestCase
+  def setup
+    @host = 'localhost'
+    @port = 22
+    @tcp  = Ping::TCP.new(@host, @port)
+  end
+
+  def test_ping
+    assert_respond_to(@tcp, :ping)
+    assert_nothing_raised{ @tcp.ping }
+    assert_nothing_raised{ @tcp.ping(@host) }
+  end
+
+  def test_ping_aliases
+    assert_respond_to(@tcp, :ping?)
+    assert_respond_to(@tcp, :pingecho)
+    assert_nothing_raised{ @tcp.ping? }
+    assert_nothing_raised{ @tcp.ping?(@host) }
+    assert_nothing_raised{ @tcp.pingecho }
+    assert_nothing_raised{ @tcp.pingecho(@host) }
+  end
+
+  def test_ping_service_check_false
+    msg = "+this test may fail depending on your network environment+"
+    Ping::TCP.service_check = false
+    @tcp = Ping::TCP.new('localhost')
+    assert_false(@tcp.ping?, msg)
+    assert_false(@tcp.exception.nil?, "Bad exception data")
+  end
+
+  def test_ping_service_check_true
+    msg = "+this test may fail depending on your network environment+"
+    Ping::TCP.service_check = true
+    assert_true(@tcp.ping?, msg)
+  end
+   
+  def test_service_check
+    assert_respond_to(Ping::TCP, :service_check)
+    assert_respond_to(Ping::TCP, :service_check=)    
+  end
+   
+  # These will be removed eventually
+  def test_service_check_aliases
+    assert_respond_to(Ping::TCP, :econnrefused)
+    assert_respond_to(Ping::TCP, :econnrefused=)
+    assert_respond_to(Ping::TCP, :ecr)
+    assert_respond_to(Ping::TCP, :ecr=)     
+  end
+   
+  def test_service_check_expected_errors
+    assert_raises(ArgumentError){ Ping::TCP.service_check = "blah" }
+  end
+   
+  # If the ping failed, the duration will be nil
+  def test_duration
+    assert_nothing_raised{ @tcp.ping }
+    assert_respond_to(@tcp, :duration)
+    omit_if(@tcp.duration.nil?, 'ping failed, skipping')
+    assert_kind_of(Float, @tcp.duration)
+  end
+
+  def test_host
+    assert_respond_to(@tcp, :host)
+    assert_respond_to(@tcp, :host=)
+    assert_equal(@host, @tcp.host)
+  end
+
+  def test_port
+    assert_respond_to(@tcp, :port)
+    assert_respond_to(@tcp, :port=)
+    assert_equal(22, @tcp.port)
+  end
+
+  def test_timeout
+    assert_respond_to(@tcp, :timeout)
+    assert_respond_to(@tcp, :timeout=)
+    assert_equal(5, @tcp.timeout)
+  end
+
+  def test_exception
+    msg = "+this test may fail depending on your network environment+"
+    assert_respond_to(@tcp, :exception)
+    assert_nothing_raised{ @tcp.ping }
+    # XXX: In some environment, it will get some execption
+    assert(@tcp.exception.nil? || @tcp.exception == Errno::ECONNREFUSED, msg)
+  end
+
+  def test_warning
+    assert_respond_to(@tcp, :warning)
+  end
+
+  def teardown
+    @host = nil
+    @tcp  = nil
+  end
+end

data/test/test_net_ping_udp.rb

@@ -0,0 +1,117 @@
+########################################################################
+# test_net_ping_udp.rb
+#
+# Test case for the Net::Ping::UDP class. This should be run via the
+# 'test' or 'test:udp' Rake tasks.
+#
+# If someone could provide me a host where a udp ping actually
+# works (with a service check), I would appreciate it. :)
+########################################################################
+require 'test-unit'
+require 'net/ping/udp'
+
+class TC_Net_Ping_UDP < Test::Unit::TestCase
+  def setup
+    Net::Ping::UDP.service_check = false
+    @host = '127.0.0.1'
+    @udp  = Net::Ping::UDP.new(@host)
+  end
+
+  test "ping basic functionality" do
+    assert_respond_to(@udp, :ping)
+    assert_nothing_raised{ @udp.ping }
+  end
+
+  test "ping accepts a host as an argument" do
+    assert_nothing_raised{ @udp.ping(@host) }
+  end
+
+  test "ping? is inherited" do
+    assert_respond_to(@udp, :ping?)
+  end
+
+  test "pingecho is inherited" do
+    assert_respond_to(@udp, :pingecho)
+  end
+
+  test "a successful udp ping returns true" do
+    assert_true(@udp.ping?)
+  end
+
+  test "bind basic functionality" do
+    assert_respond_to(@udp, :bind)
+    assert_nothing_raised{ @udp.bind('127.0.0.1', 80) }
+  end
+   
+  test "duration basic functionality" do
+    assert_nothing_raised{ @udp.ping }
+    assert_respond_to(@udp, :duration)
+    assert_kind_of(Float, @udp.duration)
+  end
+
+  test "host basic functionality" do
+    assert_respond_to(@udp, :host)
+    assert_respond_to(@udp, :host=)
+    assert_equal('127.0.0.1', @udp.host)
+  end
+
+  test "port basic functionality" do
+    assert_respond_to(@udp, :port)
+    assert_respond_to(@udp, :port=)
+    assert_equal(7, @udp.port)
+  end
+
+  test "timeout basic functionality" do
+    assert_respond_to(@udp, :timeout)
+    assert_respond_to(@udp, :timeout=)
+  end
+
+  test "timeout default value is five" do
+    assert_equal(5, @udp.timeout)
+  end
+
+  test "exception basic functionality" do
+    assert_respond_to(@udp, :exception)
+  end
+
+  test "the exception attribute returns nil if the ping is successful" do
+    assert_true(@udp.ping?)
+    assert_nil(@udp.exception)
+  end
+
+  test "the exception attribute is not nil if the ping is unsuccessful" do
+    assert_false(@udp.ping?('www.ruby-lang.org'))
+    assert_not_nil(@udp.exception)
+  end
+
+  test "warning basic functionality" do
+    assert_respond_to(@udp, :warning)
+  end
+
+  test "the warning attribute returns nil if the ping is successful" do
+    assert_true(@udp.ping?)
+    assert_nil(@udp.warning)
+  end
+   
+  test "service_check basic functionality" do
+    assert_respond_to(Net::Ping::UDP, :service_check)
+    assert_respond_to(Net::Ping::UDP, :service_check=)
+  end
+
+  test "service_check attribute has been set to false" do
+    assert_false(Net::Ping::UDP.service_check)
+  end
+   
+  test "service_check getter method does not accept arguments" do
+    assert_raise(ArgumentError){ Net::Ping::UDP.service_check(1) }
+  end
+
+  test "service_check setter method only accepts boolean arguments" do
+    assert_raise(ArgumentError){ Net::Ping::UDP.service_check = 1 }
+  end
+
+  def teardown
+    @host = nil
+    @udp  = nil
+  end
+end

data/test/test_net_ping_wmi.rb

@@ -0,0 +1,81 @@
+#######################################################################
+# test_net_ping_wmi.rb
+#
+# Test case for the Net::Ping::WMI class. These tests will only be
+# run MS Windows.  You should run this test via the 'test' or
+# 'test:wmi' Rake task.
+#######################################################################
+require 'test-unit'
+require 'net/ping/wmi'
+include Net
+
+class TC_Ping_WMI < Test::Unit::TestCase
+   def self.startup
+      @@windows = File::ALT_SEPARATOR
+   end
+
+   def setup
+      @host = "www.ruby-lang.org"
+      @wmi = Ping::WMI.new(@host) if @@windows
+   end
+
+   def test_ping_basic
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_respond_to(@wmi, :ping)
+      assert_nothing_raised{ @wmi.ping }
+   end
+
+   def test_ping_with_host
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_nothing_raised{ @wmi.ping(@host) }
+   end
+
+   def test_ping_with_options
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_nothing_raised{ @wmi.ping(@host, :NoFragmentation => true) }
+   end
+
+   def test_pingecho_alias
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_respond_to(@wmi, :pingecho)
+      assert_nothing_raised{ @wmi.pingecho }
+      assert_nothing_raised{ @wmi.pingecho(@host) }
+   end
+
+   def test_ping_returns_struct
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_kind_of(Struct::PingStatus, @wmi.ping)
+   end
+
+   def test_ping_returns_boolean
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_boolean(@wmi.ping?)
+      assert_boolean(@wmi.ping?(@host))
+   end
+
+   def test_ping_expected_failure
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_false(Ping::WMI.new('bogus').ping?)
+      assert_false(Ping::WMI.new('http://www.asdfhjklasdfhlkj.com').ping?)
+   end
+
+   def test_exception
+      omit_unless(@@windows, 'skipped on Unix platforms')
+      assert_respond_to(@wmi, :exception)
+      assert_nothing_raised{ @wmi.ping }
+      assert_nil(@wmi.exception)
+   end
+
+   def test_warning
+      assert_respond_to(@wmi, :warning)
+   end
+
+   def teardown
+      @host = nil
+      @wmi  = nil
+   end
+
+   def self.shutdown
+      @@windows = nil
+   end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: net-ping
+version: !ruby/object:Gem::Version
+  version: 2.1.0
+platform: universal-linux
+authors:
+- Chris Chernesky
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cap2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+description: |2
+      The net-ping library provides a ping interface for Ruby. It includes
+      separate TCP, HTTP, LDAP, ICMP, UDP, WMI (for Windows) and external ping
+      classes.
+email: chris.netping@tinderglow.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGES
+- doc/ping.txt
+files:
+- CHANGES
+- CHANGES.out_of_date
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- MANIFEST
+- README.md
+- Rakefile
+- doc/ping.txt
+- docs/superpowers/plans/2026-07-25-platform-specific-gems.md
+- docs/superpowers/specs/2026-07-25-platform-specific-gems-design.md
+- examples/example_pingexternal.rb
+- examples/example_pinghttp.rb
+- examples/example_pingtcp.rb
+- examples/example_pingudp.rb
+- lib/net/ping.rb
+- lib/net/ping/external.rb
+- lib/net/ping/http.rb
+- lib/net/ping/icmp.rb
+- lib/net/ping/ping.rb
+- lib/net/ping/tcp.rb
+- lib/net/ping/udp.rb
+- lib/net/ping/version.rb
+- lib/net/ping/wmi.rb
+- net-ping-universal-linux.gemspec
+- net-ping-universal-mingw-ucrt.gemspec
+- net-ping.gemspec
+- test/test_net_ping.rb
+- test/test_net_ping_external.rb
+- test/test_net_ping_gem_packaging.rb
+- test/test_net_ping_http.rb
+- test/test_net_ping_icmp.rb
+- test/test_net_ping_tcp.rb
+- test/test_net_ping_udp.rb
+- test/test_net_ping_wmi.rb
+homepage: https://github.com/chernesk/net-ping
+licenses:
+- Artistic 2.0
+metadata:
+  bug_tracker_uri: https://github.com/chernesk/net-ping/issues
+  changelog_uri: https://github.com/chernesk/net-ping/blob/master/CHANGES
+  documentation_uri: https://www.rubydoc.info/gems/net-ping
+  homepage_uri: https://github.com/chernesk/net-ping
+  source_code_uri: https://github.com/chernesk/net-ping
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A ping interface for Ruby.
+test_files:
+- test/test_net_ping.rb