passenger 5.0.4 → 5.0.5

data/test/oxt/counter.hpp

@@ -1,55 +0,0 @@
-#ifndef _COUNTER_HPP_
-#define _COUNTER_HPP_
-
-#include <boost/shared_ptr.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/thread_time.hpp>
-
-struct Counter;
-typedef boost::shared_ptr<Counter> CounterPtr;
-
-/**
- * A synchronization mechanism with counter-like properties.
- *
- * To avoid memory corruption when unit tests fail, one should
- * never store Counter objects on the stack. Instead, one should
- * create them on the heap and use CounterPtr smart pointers.
- */
-struct Counter {
-	struct timeout_expired { };
-	
-	unsigned int value;
-	boost::mutex mutex;
-	boost::condition_variable cond;
-	
-	static CounterPtr create_ptr() {
-		return CounterPtr(new Counter());
-	}
-	
-	Counter() {
-		value = 0;
-	}
-	
-	/**
-	 * Wait until other threads have increment this counter to at least wanted_value.
-	 * If this doesn't happen within <tt>timeout</tt> miliseconds, then a timeout_expired
-	 * exception will be thrown.
-	 */
-	void wait_until(unsigned int wanted_value, unsigned int timeout = 1000) {
-		boost::unique_lock<boost::mutex> l(mutex);
-		while (value < wanted_value) {
-			if (!cond.timed_wait(l, boost::get_system_time() + boost::posix_time::milliseconds(timeout))) {
-				throw timeout_expired();
-			}
-		}
-	}
-	
-	/** Increment the counter by one. */
-	void increment() {
-		boost::unique_lock<boost::mutex> l(mutex);
-		value++;
-		cond.notify_all();
-	}
-};
-
-#endif /* _COUNTER_HPP_ */

data/test/oxt/dynamic_thread_group_test.cpp

@@ -1,131 +0,0 @@
-#include "../tut/tut.h"
-#include "counter.hpp"
-#include <boost/bind.hpp>
-#include <boost/thread/thread_time.hpp>
-#include <oxt/dynamic_thread_group.hpp>
-#include <oxt/system_calls.hpp>
-#include <unistd.h>
-
-using namespace boost;
-using namespace oxt;
-
-namespace tut {
-	struct dynamic_thread_group_test {
-		dynamic_thread_group group;
-	};
-	
-	DEFINE_TEST_GROUP(dynamic_thread_group_test);
-	
-	TEST_METHOD(1) {
-		// It has 0 threads in the beginning.
-		ensure_equals(group.num_threads(), 0u);
-	}
-	
-	static void wait_until_done(CounterPtr parent_counter, CounterPtr child_counter) {
-		// Tell parent thread that this thread has started.
-		parent_counter->increment();
-		
-		// Wait until parent says that we can quit.
-		child_counter->wait_until(1);
-	}
-	
-	TEST_METHOD(2) {
-		// Test whether newly created threads are added to the thread
-		// group, and whether they are automatically removed from the
-		// thread group upon termination.
-		
-		// Start 3 'f' threads.
-		CounterPtr f_parent_counter = Counter::create_ptr();
-		CounterPtr f_child_counter  = Counter::create_ptr();
-		boost::function<void()> f(boost::bind(wait_until_done, f_parent_counter, f_child_counter));
-		group.create_thread(f);
-		group.create_thread(f);
-		group.create_thread(f);
-		
-		// Start 1 'g' thread.
-		CounterPtr g_parent_counter = Counter::create_ptr();
-		CounterPtr g_child_counter  = Counter::create_ptr();
-		boost::function<void()> g(boost::bind(wait_until_done, g_parent_counter, g_child_counter));
-		group.create_thread(g);
-		
-		f_parent_counter->wait_until(3); // Wait until all 'f' threads have started.
-		g_parent_counter->wait_until(1); // Wait until the 'g' thread has started.
-		
-		ensure_equals("There are 4 threads in the group", group.num_threads(), 4u);
-		
-		// Tell all 'f' threads that they can quit now.
-		f_child_counter->increment();
-		usleep(25000); // Sleep time must be large enough for Valgrind.
-		ensure_equals(group.num_threads(), 1u);
-		
-		// Tell the 'g' thread that it can quit now.
-		g_child_counter->increment();
-		usleep(25000); // Sleep time must be large enough for Valgrind.
-		ensure_equals(group.num_threads(), 0u);
-	}
-	
-	static void sleep_and_set_true(CounterPtr counter, volatile bool *flag) {
-		// Tell parent thread that this thread has started.
-		counter->increment();
-		try {
-			syscalls::usleep(5000000);
-		} catch (thread_interrupted &) {
-			*flag = true;
-		}
-	}
-	
-	TEST_METHOD(3) {
-		// interrupt_and_join_all() works.
-		
-		// Create two threads.
-		CounterPtr counter = Counter::create_ptr();
-		volatile bool flag1 = false;
-		volatile bool flag2 = false;
-		boost::function<void ()> f(boost::bind(sleep_and_set_true, counter, &flag1));
-		boost::function<void ()> g(boost::bind(sleep_and_set_true, counter, &flag2));
-		group.create_thread(f);
-		group.create_thread(g);
-		// Wait until both threads have started.
-		counter->wait_until(2);
-		
-		// Now interrupt and join them.
-		group.interrupt_and_join_all();
-		// Both threads should have received a thread interruption
-		// request and terminated as a result.
-		ensure_equals(flag1, true);
-		ensure_equals(flag2, true);
-		ensure_equals(group.num_threads(), 0u);
-	}
-	
-	static void do_nothing(unsigned int max) {
-		unsigned int i;
-		for (i = 0; i < max; i++) { }
-	}
-	
-	static void create_threads(dynamic_thread_group *group) {
-		for (int i = 1000; i >= 0; i--) {
-			boost::function<void ()> f(boost::bind(do_nothing, i * 1000));
-			group->create_thread(f, "", 256 * 1024);
-		}
-	}
-	
-	static void interrupt_group(dynamic_thread_group *group) {
-		for (int i = 0; i < 1000; i++) {
-			group->interrupt_and_join_all();
-		}
-	}
-	
-	TEST_METHOD(4) {
-		// Stress test.
-		oxt::thread thr1(boost::bind(create_threads, &group));
-		oxt::thread thr2(boost::bind(interrupt_group, &group));
-		thr1.join();
-		thr2.join();
-		group.interrupt_and_join_all();
-		ensure_equals(group.num_threads(), 0u);
-	}
-	
-	TEST_METHOD(5) {
-		// If the thread function crashes then it will still be correctly removed from the pool.
-	}
-}

data/test/oxt/oxt_test_main.cpp

@@ -1,27 +0,0 @@
-#include "../tut/tut.h"
-#include "../tut/tut_reporter.h"
-#include <oxt/initialize.hpp>
-#include <oxt/system_calls.hpp>
-#include <signal.h>
-#include <cstdlib>
-
-namespace tut {
-	test_runner_singleton runner;
-}
-
-int main() {
-	tut::reporter reporter;
-	tut::runner.get().set_callback(&reporter);
-	signal(SIGPIPE, SIG_IGN);
-	setenv("RAILS_ENV", "production", 1);
-	setenv("TESTING_PASSENGER", "1", 1);
-	oxt::initialize();
-	oxt::setup_syscall_interruption_support();
-	try {
-		tut::runner.get().run_tests();
-	} catch (const std::exception &ex) {
-		std::cerr << "Exception raised: " << ex.what() << std::endl;
-		return 1;
-	}
-	return 0;
-}

data/test/oxt/spin_lock_test.cpp

@@ -1,59 +0,0 @@
-#include "../tut/tut.h"
-#include <boost/bind.hpp>
-#include <boost/thread.hpp>
-#include <oxt/spin_lock.hpp>
-
-using namespace boost;
-using namespace oxt;
-
-namespace tut {
-	struct spin_lock_test {
-		boost::mutex continue_mutex;
-		boost::condition_variable continue_cond;
-		bool continue_ok;
-		spin_lock lock;
-		volatile unsigned int counter;
-		
-		spin_lock_test() {
-			counter = 0;
-			continue_ok = false;
-		}
-		
-		void loop_increment(unsigned int inc) {
-			{
-				boost::mutex::scoped_lock l1(continue_mutex);
-				while (!continue_ok) {
-					continue_cond.wait(l1);
-				}
-			}
-			
-			for (unsigned int i = 0; i < inc; i++) {
-				spin_lock::scoped_lock l2(lock);
-				counter++;
-			}
-		}
-	};
-	
-	DEFINE_TEST_GROUP(spin_lock_test);
-
-	TEST_METHOD(1) {
-		boost::thread thr1(boost::bind(&spin_lock_test::loop_increment, this, 100000));
-		boost::thread thr2(boost::bind(&spin_lock_test::loop_increment, this, 100000));
-		boost::thread thr3(boost::bind(&spin_lock_test::loop_increment, this, 100000));
-		boost::thread thr4(boost::bind(&spin_lock_test::loop_increment, this, 100000));
-		
-		{
-			boost::mutex::scoped_lock l(continue_mutex);
-			continue_ok = true;
-			continue_cond.notify_all();
-		}
-		
-		thr1.join();
-		thr2.join();
-		thr3.join();
-		thr4.join();
-		
-		ensure_equals(counter, 400000u);
-	}
-}
-

data/test/oxt/syscall_interruption_test.cpp

@@ -1,39 +0,0 @@
-#include "../tut/tut.h"
-#include <boost/bind.hpp>
-#include <oxt/thread.hpp>
-#include <oxt/system_calls.hpp>
-#include <unistd.h>
-#include <ctime>
-
-using namespace oxt;
-using namespace std;
-using namespace boost;
-
-namespace tut {
-	struct syscall_interruption_test {
-	};
-	
-	DEFINE_TEST_GROUP(syscall_interruption_test);
-	
-	struct SleepFunction {
-		void operator()() {
-			syscalls::usleep(6000000);
-		}
-	};
-	
-	TEST_METHOD(1) {
-		// System call interruption works.
-		SleepFunction s;
-		oxt::thread thr(s);
-		usleep(20000);
-		
-		time_t begin, end, time_spent_in_thread;
-		begin = time(NULL);
-		thr.interrupt_and_join();
-		end = time(NULL);
-		time_spent_in_thread = end - begin;
-		
-		ensure(time_spent_in_thread <= 2);
-	}
-}
-

data/test/ruby/debug_logging_spec.rb

@@ -1,145 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-PhusionPassenger.require_passenger_lib 'debug_logging'
-require 'stringio'
-require 'tmpdir'
-require 'fileutils'
-
-module PhusionPassenger
-
-describe DebugLogging do
-  after :each do
-    DebugLogging.log_level = DEFAULT_LOG_LEVEL
-    DebugLogging.log_file = nil
-    DebugLogging.stderr_evaluator = nil
-    FileUtils.rm_rf(@tmpdir) if @tmpdir
-  end
-
-  class MyClass
-    include DebugLogging
-  end
-
-  def use_log_file!
-    @tmpdir = Dir.mktmpdir
-    @log_file = "#{@tmpdir}/debug.log"
-    DebugLogging.log_file = @log_file
-  end
-
-  describe "#debug" do
-    it "doesn't print the message if log level is LVL_INFO" do
-      use_log_file!
-      DebugLogging.log_level = LVL_INFO
-      DebugLogging.debug("hello")
-      File.exist?(@log_file).should be_false
-    end
-
-    it "prints the message if log level is LVL_DEBUG" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.debug("hello")
-      File.exist?(@log_file).should be_true
-    end
-
-    it "prints the message if log level is greater than LVL_DEBUG" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG2
-      DebugLogging.debug("hello")
-      File.exist?(@log_file).should be_true
-    end
-
-    it "prints the location of the calling function" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.debug("hello")
-      File.read(@log_file).should include("debug_logging_spec.rb")
-    end
-
-    it "prints to STDERR by default" do
-      io = StringIO.new
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.stderr_evaluator = lambda { io }
-      DebugLogging.debug("hello")
-      io.string.should include("hello")
-    end
-
-    it "reopens the log file handle if it has been closed" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.debug("hello")
-      DebugLogging._log_device.close
-      DebugLogging.debug("world")
-      File.read(@log_file).should include("world")
-    end
-
-    it "also works as included method" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG
-      MyClass.new.send(:debug, "hello")
-      File.read(@log_file).should include("hello")
-    end
-
-    it "is private when included" do
-      MyClass.private_method_defined?(:debug)
-    end
-  end
-
-  describe "#trace" do
-    specify "#trace(x, ...) doesn't print the message if the log level is lower than LVL_INFO + x" do
-      use_log_file!
-      DebugLogging.log_level = LVL_INFO + 1
-      DebugLogging.trace(2, "hello")
-      File.exist?(@log_file).should be_false
-    end
-
-    specify "#trace(x, ...) prints the message if the log level equals LVL_INFO + 2" do
-      use_log_file!
-      DebugLogging.log_level = LVL_INFO + 2
-      DebugLogging.trace(2, "hello")
-      File.exist?(@log_file).should be_true
-    end
-
-    specify "#trace(x, ...) prints the message if the log level is greater than LVL_INFO + 3" do
-      use_log_file!
-      DebugLogging.log_level = LVL_INFO + 3
-      DebugLogging.trace(2, "hello")
-      File.exist?(@log_file).should be_true
-    end
-
-    specify "#trace prints the location of the calling function" do
-      io = StringIO.new
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.stderr_evaluator = lambda { io }
-      DebugLogging.trace(1, "hello")
-      io.string.should include("hello")
-    end
-
-    it "prints to STDERR by default" do
-      io = StringIO.new
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.stderr_evaluator = lambda { io }
-      DebugLogging.trace(1, "hello")
-      io.string.should include("hello")
-    end
-
-    it "reopens the log file handle if it has been closed" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG
-      DebugLogging.trace(1, "hello")
-      DebugLogging._log_device.close
-      DebugLogging.trace(1, "world")
-      File.read(@log_file).should include("world")
-    end
-
-    it "also works as included method" do
-      use_log_file!
-      DebugLogging.log_level = LVL_DEBUG
-      MyClass.new.send(:trace, 1, "hello")
-      File.read(@log_file).should include("hello")
-    end
-
-    it "is private when included" do
-      MyClass.private_method_defined?(:trace)
-    end
-  end
-end
-
-end # module PhusionPassenger