Remove threading and use worker processes instead

All tests for threading and semaphores have been removed.  One
test was changed because it depended on a shared variable.

Tests will be replaced with tests to do process management
instead.

3 files changed, 3 insertions, 211 deletions

diff --git a/test/unit/test_semaphore.rb b/test/unit/test_semaphore.rb
deleted file mode 100644
index 115f159..0000000
--- a/test/unit/test_semaphore.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-root_dir = File.join(File.dirname(__FILE__), "../..")
-require File.join(root_dir, "test/test_helper")
-require File.join(root_dir, "lib/unicorn/semaphore")
-
-class TestSemaphore < Test::Unit::TestCase
-  def setup
-    super
-    
-    @semaphore = Semaphore.new
-  end
-  
-  def test_wait_prevents_thread_from_running
-    thread = Thread.new { @semaphore.wait }
-    give_up_my_time_slice
-    
-    assert thread.stop?
-  end
-  
-  def test_signal_allows_waiting_thread_to_run
-    ran = false
-    thread = Thread.new { @semaphore.wait; ran = true }
-    give_up_my_time_slice
-    
-    @semaphore.signal
-    give_up_my_time_slice
-    
-    assert ran
-  end
-  
-  def test_wait_allows_only_specified_number_of_resources
-    @semaphore = Semaphore.new(1)
-    
-    run_count = 0
-    thread1 = Thread.new { @semaphore.wait; run_count += 1 }
-    thread2 = Thread.new { @semaphore.wait; run_count += 1 }
-    give_up_my_time_slice
-    
-    assert_equal 1, run_count
-  end
-  
-  def test_semaphore_serializes_threads
-    @semaphore = Semaphore.new(1)
-    
-    result = ""
-    thread1 = Thread.new do
-      @semaphore.wait
-      4.times do |i|
-        give_up_my_time_slice
-        result << i.to_s
-      end
-      @semaphore.signal 
-    end
-    
-    thread2 = Thread.new do
-      @semaphore.wait
-      ("a".."d").each do |char|
-        give_up_my_time_slice
-        result << char
-      end
-      @semaphore.signal 
-    end
-    
-    give_up_my_time_slice
-    @semaphore.wait
-    
-    assert_equal "0123abcd", result
-  end
-  
-  def test_synchronize_many_threads
-    @semaphore = Semaphore.new(1)
-    
-    result = []
-    5.times do |i|
-      Thread.new do 
-        @semaphore.wait
-        2.times { |j| result << [i, j] }
-        @semaphore.signal
-      end
-    end
-    
-    give_up_my_time_slice
-    @semaphore.wait
-    
-    5.times do |i|
-      2.times do |j|
-        assert_equal i, result[2 * i + j][0]
-        assert_equal j, result[2 * i + j][1]
-      end
-    end
-  end
-  
-  def test_synchronize_ensures_signal
-    @semaphore = Semaphore.new(1)
-    threads = []
-    run_count = 0
-    threads << Thread.new do 
-      @semaphore.synchronize { run_count += 1 }
-    end
-    threads << Thread.new do
-      @semaphore.synchronize { run_count += 1; raise "I'm throwing an error." }
-    end
-    threads << Thread.new do
-      @semaphore.synchronize { run_count += 1 }
-    end
-    
-    give_up_my_time_slice
-    @semaphore.wait
-    
-    assert !threads.any? { |thread| thread.alive? }
-    assert_equal 3, run_count
-  end
-  
-  private 
-  
-  def give_up_my_time_slice
-    sleep(1)
-  end
-end
diff --git a/test/unit/test_server.rb b/test/unit/test_server.rb
index f5043b8..df57989 100644
--- a/test/unit/test_server.rb
+++ b/test/unit/test_server.rb
@@ -9,10 +9,8 @@ require 'test/test_helper'
 include Unicorn
 
 class TestHandler 
-  attr_reader :ran_test
 
   def call(env) 
-    @ran_test = true
   #   response.socket.write("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nhello!\n")
     [200, { 'Content-Type' => 'text/plain' }, ['hello!\n']]
    end
@@ -27,8 +25,7 @@ class WebServerTest < Test::Unit::TestCase
     @tester = TestHandler.new 
     @app = Rack::URLMap.new('/test' => @tester)
     redirect_test_io do
-      # We set max_queued_threads=1 so that we can test the reaping code
-      @server = HttpServer.new(@app, :Host => "127.0.0.1", :Port => @port, :Max_queued_threads => 1)
+      @server = HttpServer.new(@app, :Host => "127.0.0.1", :Port => @port)
     end
     @server.start
   end
@@ -40,8 +37,8 @@ class WebServerTest < Test::Unit::TestCase
   end
 
   def test_simple_server
-    hit(["http://localhost:#{@port}/test"])
-    assert @tester.ran_test, "Handler didn't really run"
+    results = hit(["http://localhost:#{@port}/test"])
+    assert_equal 'hello!\n', results[0], "Handler didn't really run"
   end
 
 
@@ -90,19 +87,6 @@ class WebServerTest < Test::Unit::TestCase
     end
   end
 
-  def test_max_queued_threads_overload
-    redirect_test_io do
-      assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
-        tests = [
-          Thread.new { do_test(@valid_request, 1) },
-          Thread.new { do_test(@valid_request, 10) },
-        ]
-
-        tests.each {|t| t.join}
-      end
-    end
-  end
-
   def test_file_streamed_request
     body = "a" * (Unicorn::Const::MAX_BODY * 2)
     long = "GET /test HTTP/1.1\r\nContent-length: #{body.length}\r\n\r\n" + body
diff --git a/test/unit/test_threading.rb b/test/unit/test_threading.rb
deleted file mode 100644
index 5551b53..0000000
--- a/test/unit/test_threading.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-root_dir = File.join(File.dirname(__FILE__), "../..")
-require File.join(root_dir, "test/test_helper")
-
-include Unicorn
-
-class FakeHandler
-  @@concurrent_threads = 0
-  @@threads = 0
-  
-  def self.max_concurrent_threads
-    @@threads ||= 0
-  end
-  
-  def initialize
-    super
-    @@mutex = Mutex.new
-  end
-  
-  def call(env)
-    @@mutex.synchronize do
-      @@concurrent_threads += 1 # !!! same for += and -=
-      @@threads = [@@concurrent_threads, @@threads].max
-    end
-    
-    sleep(0.1)
-    [200, {'Content-Type' => 'text/plain'}, ['hello!']]
-  ensure
-    @@mutex.synchronize { @@concurrent_threads -= 1 }
-  end
-end
-
-class ThreadingTest < Test::Unit::TestCase
-  def setup
-    @valid_request = "GET / HTTP/1.1\r\nHost: www.google.com\r\nContent-Type: text/plain\r\n\r\n"
-    @port = process_based_port
-    @app = Rack::URLMap.new('/test' => FakeHandler.new)
-    @threads = 4
-    redirect_test_io { @server = HttpServer.new(@app, :Host => "127.0.0.1", :Port => @port, :Max_concurrent_threads => @threads) }    
-    redirect_test_io { @server.start }
-  end
-
-  def teardown
-    redirect_test_io { @server.stop(true) }
-  end
-
-  def test_server_respects_max_concurrent_threads_option
-    threads = []
-    (@threads * 3).times do
-      threads << Thread.new do
-        send_data_over_socket("GET /test HTTP/1.1\r\nHost: localhost\r\nContent-Type: text/plain\r\n\r\n")
-      end
-    end
-    while threads.any? { |thread| thread.alive? }
-      sleep(0)
-    end
-    assert_equal @threads, FakeHandler.max_concurrent_threads
-  end
-  
-  private 
-  
-  def send_data_over_socket(string)
-    socket = TCPSocket.new("127.0.0.1", @port)
-    request = StringIO.new(string)
-
-    while data = request.read(8)
-      socket.write(data)
-      socket.flush
-      sleep(0)
-    end
-    sleep(0)
-    socket.write(" ") # Some platforms only raise the exception on attempted write
-    socket.flush
-  end
-end