Make Thread::Queue and Thread::SizedQueue generic

Author: soutaro

core/thread.rbs

@@ -1545,7 +1545,7 @@ end
 #
 #     consumer.join
 #
-class Thread::Queue < Object
+class Thread::Queue[Elem = untyped] < Object
   # <!-- rdoc-file=thread_sync.c -->
   # Pushes the given `object` to the queue.
   #
@@ -1661,7 +1661,7 @@ class Thread::Queue < Object
   # If `timeout` seconds have passed and no data is available `nil` is returned.
   # If `timeout` is `0` it returns immediately.
   #
-  def pop: (?boolish non_block, ?timeout: _ToF?) -> untyped
+  def pop: (?boolish non_block, ?timeout: _ToF?) -> Elem?
 
   # <!--
   #   rdoc-file=thread_sync.c
@@ -1671,7 +1671,7 @@ class Thread::Queue < Object
   # -->
   # Pushes the given `object` to the queue.
   #
-  def push: (untyped obj) -> void
+  def push: (Elem obj) -> void
 
   # <!--
   #   rdoc-file=thread_sync.rb
@@ -1692,7 +1692,7 @@ end
 #
 # See Thread::Queue for an example of how a Thread::SizedQueue works.
 #
-class Thread::SizedQueue < Thread::Queue
+class Thread::SizedQueue[Elem = untyped] < Thread::Queue[Elem]
   # <!--
   #   rdoc-file=thread_sync.rb
   #   - <<(object, non_block = false, timeout: nil)
@@ -1755,7 +1755,8 @@ class Thread::SizedQueue < Thread::Queue
   # If `timeout` seconds have passed and no space is available `nil` is returned.
   # If `timeout` is `0` it returns immediately. Otherwise it returns `self`.
   #
-  def push: (untyped obj, ?boolish non_block, timeout: _ToF?) -> void
+  def push: (Elem obj, ?boolish non_block) -> void
+          | (Elem obj, timeout: _ToF?) -> self?
 end
 
 class ConditionVariable = Thread::ConditionVariable

test/stdlib/ThreadQueue_test.rb

@@ -1,86 +1,197 @@
+# frozen_string_literal: true
+
 require_relative "test_helper"
+require "thread"
 
-class ThreadQueueTest < StdlibTest
-  target Thread::Queue
+class Thread__Queue__InstanceTest < Test::Unit::TestCase
+  include TestHelper
 
-  def test_lshift
-    q = Thread::Queue.new
-    q << :a
-  end
+  testing "::Thread::Queue[::Integer]"
 
-  def test_clear
-    q = Thread::Queue.new
-    q.clear
-  end
+  def test_push
+    queue = Thread::Queue.new
 
-  def test_close
-    q = Thread::Queue.new
-    q.close
+    assert_send_type(
+      "(::Integer) -> void",
+      queue, :push, 1
+    )
   end
 
-  def test_closed?
-    q = Thread::Queue.new
-    q.closed?
-    q.close
-    q.closed?
+  def test_length
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :length
+    )
   end
 
-  def test_deq
-    q = Thread::Queue.new
-    3.times { q << :a }
+  def test_num_waiting
+    queue = Thread::Queue.new
 
-    q.deq
-    q.deq(true)
-    q.deq(false)
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :num_waiting
+    )
   end
 
   def test_empty?
-    q = Thread::Queue.new
-    q.empty?
-    q << :a
-    q.empty?
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> bool",
+      queue, :empty?
+    )
   end
 
-  def test_enq
-    q = Thread::Queue.new
-    q.enq(:a)
+  def test_closed?
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> bool",
+      queue, :closed?
+    )
   end
 
-  def test_length
-    q = Thread::Queue.new
-    q.length
+  def test_close
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> void",
+      queue, :close
+    )
   end
 
-  def test_num_waiting
-    q = Thread::Queue.new
-    q.num_waiting
+  def test_clear
+    queue = Thread::Queue.new
+
+    assert_send_type(
+      "() -> void",
+      queue, :clear
+    )
   end
 
   def test_pop
-    q = Thread::Queue.new
-    3.times { q << :a }
-    q.pop
-    q.pop(true)
-    q.pop(false)
-    q.pop(timeout: 0.2)
-    q.pop(timeout: ToF.new(0.1).__with_object_methods(:==))
+    queue = Thread::Queue.new
+
+    queue.push(1)
+
+    # Get an Integer from the queue
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :pop
+    )
+
+    queue.push(2)
+
+    # Get an Integer from the queue with timeout
+    assert_send_type(
+      "(timeout: ::Float) -> ::Integer",
+      queue, :pop, timeout: 0.1
+    )
+
+    queue.push(3)
+
+    # Get an Integer from the queue with `nil` timeout
+    assert_send_type(
+      "(timeout: nil) -> ::Integer",
+      queue, :pop, timeout: nil
+    )
+
+    # Returns `nil` when the queue is empty and with timeout
+    assert_send_type(
+      "(timeout: ::Float) -> nil",
+      queue, :pop, timeout: 0.0
+    )
+
+    queue.push(4)
+
+    # With nonblocking is true, but queue is not empty
+    assert_send_type(
+      "(bool) -> ::Integer",
+      queue, :pop, true
+    )
+
+    # Raises an exception with nonblocking but queue is empty
+    begin
+      assert_send_type(
+        "(bool) -> bot",
+        queue, :pop, true
+      )
+    rescue ThreadError
+    end
+
+    queue.close()
+
+    # Returns `nil` if the queue is closed
+    assert_send_type(
+      "() -> nil",
+      queue, :pop
+    )
   end
+end
 
-  def test_push
-    q = Thread::Queue.new
-    q.push(:a)
+
+class Thread__SizedQueue__InstanceTest < Test::Unit::TestCase
+  include TestHelper
+
+  testing "::Thread::SizedQueue[::Integer]"
+
+  def test_max
+    queue = Thread::SizedQueue.new(10)
+
+    assert_send_type(
+      "() -> ::Integer",
+      queue, :max
+    )
   end
 
-  def test_shift
-    q = Thread::Queue.new
-    3.times { q << :a }
-    q.shift
-    q.shift(true)
-    q.shift(false)
+  def test_max=
+    queue = Thread::SizedQueue.new(10)
+
+    assert_send_type(
+      "(::Integer) -> ::Integer",
+      queue, :max=, 20
+    )
   end
 
-  def test_size
-    q = Thread::Queue.new
-    q.size
+  def test_push
+    queue = Thread::SizedQueue.new(1)
+
+    assert_send_type(
+      "(::Integer) -> void",
+      queue, :push, 1
+    )
+
+    queue.pop
+
+    # Nonblocking mode: queue is not full
+    assert_send_type(
+      "(::Integer, bool) -> void",
+      queue, :push, 2, true
+    )
+
+    # Nonblocking mode: queue is full
+    begin
+      assert_send_type(
+        "(::Integer, bool) -> bot",
+        queue, :push, 3, true
+      )
+    rescue ThreadError
+    end
+
+    queue.pop
+
+    # With timeout: queue is not full
+    assert_send_type(
+      "(::Integer, timeout: Float) -> ::Thread::SizedQueue[::Integer]",
+      queue, :push, 3, timeout: 0.3
+    )
+
+    # With timeout: queue is full
+    assert_send_type(
+      "(::Integer, timeout: Float) -> nil",
+      queue, :push, 4, timeout: 0.0
+    )
   end
 end