Generated by thread: ' . $threadId . '
' . var_export($_SESSION, true) . '
'; // prepare header with content-length $contentLength = strlen($body); $headers[] = "Content-Length: $contentLength"; // check if this will be the last requests handled by this thread if ($availableRequests > 0) { $headers[] = "Connection: keep-alive"; $headers[] = "Keep-Alive: max=$availableRequests, timeout=$timeout, thread={$this->getThreadId()}"; } else { $headers[] = "Connection: close"; } // prepare the response head/body $response = array( "head" => implode("\r\n", $headers) . "\r\n", "body" => $body ); // write the result back to the socket socket_write($client, implode("\r\n", $response)); // check if this is the last request if ($availableRequests <= 0) { // if yes, close the socket and end the do/while socket_close($client); $connectionOpen = false; } } } while ($connectionOpen); } } // intialize the threads and the socket $workers = array(); $socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP); socket_bind($socket, '0.0.0.0', $argv[1]); socket_listen($socket); // we start 5 worker threads here if ($socket) { $worker = 0; while (++ $worker < 5) { $workers[$worker] = new Test($socket); $workers[$worker]->start(PTHREADS_INHERIT_ALL|PTHREADS_ALLOW_HEADERS); } foreach ($workers as $worker) { $worker->join(); } } pthreads-3.0.2/examples/MySQLi.php 0000664 0001750 0001750 00000004346 12575220121 013721 0 ustar hostname = $hostname; $this->username = $username; $this->password = $password; $this->database = $database; $this->port = $port; } public function getConnection() { if (!self::$link) { self::$link = new mysqli( $this->hostname, $this->username, $this->password, $this->database, $this->port); } /* do some exception/error stuff here maybe */ return self::$link; } protected $hostname; protected $username; protected $password; protected $database; protected $port; /** * Note that the link is stored statically, which for pthreads, means thread local **/ protected static $link; } class Query extends Threaded { public function __construct($sql) { $this->sql = $sql; } public function run() { $mysqli = $this->worker->getConnection(); $result = $mysqli->query($this->sql); if ($result) { while (($row = $result->fetch_assoc())) { $rows[] = $row; } } $this->result = $rows; } public function getResult() { return $this->result; } protected $sql; protected $result; } $pool = new Pool(4, "Connect", ["localhost", "root", "", "mysql"]); $pool->submit (new Query("SHOW PROCESSLIST;")); $pool->submit (new Query("SHOW PROCESSLIST;")); $pool->submit (new Query("SHOW PROCESSLIST;")); $pool->submit (new Query("SHOW PROCESSLIST;")); $pool->submit (new Query("SHOW PROCESSLIST;")); $pool->submit (new Query("SHOW PROCESSLIST;")); $pool->shutdown(); /* ::collect is used here for shorthand to dump query results */ $pool->collect(function($query){ var_dump( $done = $query->getResult()); return count($done); }); ?> pthreads-3.0.2/examples/ObjectsAsParameters.php 0000664 0001750 0001750 00000006103 12575220121 016475 0 ustar url = $url; $this->start = 0; $this->finish = 0; $this->data = null; $this->length = 0; } public function setStart($start) { $this->start = $start; } public function setFinish($finish) { $this->finish = $finish; } public function setData($data) { $this->data = $data; $this->length = strlen($this->data); } public function getUrl() { return $this->url; } public function getDuration() { return $this->finish - $this->start; } public function getLength() { return $this->length; } public function getData() { return $this->data; } public function getStart() { return $this->start; } public function getFinish() { return $this->finish; } public function run(){ /* this particular object won't run */ } } class Request extends Thread { /* * You could have more parameters but an object can hold everything ... */ public function __construct($response){ $this->response = $response; } /* * Populate the response object for creating context */ public function run(){ /* * NOTE: * Referencing threaded objects inside a thread: * If you plan to heavily manipulate any object then retain a reference in the method scope * Anytime you read and write the object context of a threaded object locking occurs * Retaining method scope references avoids some * $response retains the connection to the reference in the thread that created the request * If you have a threaded member that you only plan to execute ONE time: * (isWaiting/isRunning for example) then it is acceptable to reference the member via the object context * Referencing the object context on every call will have no adverse affects ( no leaks/errors ) * The hints above are best practices but not required. */ if($this->response->getUrl()){ $this->response->setStart(microtime(true)); $this->response->setData(file_get_contents($this->response->getUrl())); $this->response->setFinish(microtime(true)); } } } /* * We can retain the reference to the response object !! */ $response = new Response( sprintf("http://www.google.com/?q=%s", md5(rand()*time())) ); /* * Initialize a new threaded request with a response object as the only parameter */ $request = new Request($response); /* * Tell you all about it ... */ printf("Fetching: %s ", $response->getUrl()); if($request->start()){ /* do something during runtime */ while($request->isRunning()) { echo "."; $request->synchronized(function() use($request) { $request->wait(100); }); } /* you do not need to join: when a thread returns false for isRunning then your code is no longer being executed pthreads will cleanup the variable when it goes out of scope like any other variable in php */ printf(" got %d bytes in %f seconds\n", $response->getLength(), $response->getDuration()); } $request->join(); ?> pthreads-3.0.2/examples/Pooling.php 0000664 0001750 0001750 00000006464 12575220121 014215 0 ustar logger = $logger; $this->config = $config; } /* * The only thing to do here is setup the PDO object */ public function run() { if (isset($this->config)) { self::$connection = new PDO(... $this->config); } } public function getLogger() { return $this->logger; } public function getConnection() { return self::$connection; } private $logger; private $config; private static $connection; } class WebWork extends Collectable { /* * An example of some work that depends upon a shared logger * and a thread-local PDO connection */ public function run() { try { $logger = $this->worker->getLogger(); $logger->log("%s executing in Thread #%lu", __CLASS__, $this->worker->getThreadId()); if ($this->worker->getConnection()) { $logger->log("%s has PDO in Thread #%lu", __CLASS__, $this->worker->getThreadId()); } } catch(Throwable $thrown) { var_dump($thrown); } finally { /* * You must setGarbage to avoid infinite loops in the main context * doing it in finally is probably best */ $this->setGarbage(); } } } class SafeLog extends Threaded { /* * If logging were allowed to occur without synchronizing * the output would be illegible */ public function log($message, ... $args) { $this->synchronized(function($message, ... $args){ echo vsprintf("{$message}\n", ... $args); }, $message, $args); } } /* * Constructing the Pool does not create any Threads */ $pool = new Pool(8, 'WebWorker', [new SafeLog(), ["sqlite:example.db"]]); /* * Only when there is work to do are threads created */ $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); $pool->submit(new WebWork()); /* * The Workers in the Pool retain references to the WebWork objects submitted * in order to release that memory the Pool::collect method must be invoked in the same * context that created the Pool. * * The Worker::collect method is invoked for every Worker in the Pool, the garbage list * for each Worker is traversed and each Collectable is passed to the provided Closure. * * The Closure must return true if the Collectable can be removed from the garbage list. * * Worker::collect returns the size of the garbage list, Pool::collect returns the sum of the size of * the garbage list of all Workers in the Pool. * * Collecting in a continuous loop will cause the garbage list to be emptied. */ while ($pool->collect(function($work){ return $work->isGarbage(); })) continue; /* * We could submit more stuff here, the Pool is still waiting for Collectables */ var_dump($pool); /* * Shutdown Pools at the appropriate time, don't leave it to chance ! */ $pool->shutdown(); ?> pthreads-3.0.2/examples/SelectiveInheritance.php 0000664 0001750 0001750 00000003465 12575220121 016701 0 ustar expect: bool(false) bool(false) bool(false) start(PTHREADS_INHERIT_NONE); $test->join(); ?> ======================================= expect: bool(false) bool(true) bool(true) start(PTHREADS_INHERIT_ALL & ~PTHREADS_INHERIT_FUNCTIONS); $test->join(); ?> ======================================= expect: bool(false) bool(false) bool(true) start(PTHREADS_INHERIT_INI | PTHREADS_INHERIT_CONSTANTS); $test->join(); ?> ======================================= expect: bool(true) bool(true) bool(true) start(); $test->join(); ?> pthreads-3.0.2/examples/SharingResources.php 0000664 0001750 0001750 00000005370 12575220121 016067 0 ustar mysql = $mysql; $this->lock = $lock; } public function run(){ if ($this->lock) { $this->lock->synchronized(function(){ $this->doStuff(); }); } else $this->doStuff(); } private function doStuff() { if (($result = mysql_query("SHOW PROCESSLIST;", $this->mysql))) { while(($row = mysql_fetch_assoc($result))) { print_r($row); } } } } $mysql = mysql_connect("127.0.0.1", "root", ""); if ($mysql) { $lock = new Threaded(); $instances = array(new MyShared($mysql, $lock), new MyShared($mysql, $lock), new MyShared($mysql, $lock)); foreach($instances as $instance) $instance->start(); foreach($instances as $instance) $instance->join(); } ?> pthreads-3.0.2/examples/SimpleWebRequest.php 0000664 0001750 0001750 00000001732 12575220121 016037 0 ustar url = $url; } public function run(){ if(($url = $this->url)){ /* * If a large amount of data is being requested, you might want to * fsockopen and read using usleep in between reads */ $this->data = file_get_contents($url); } else printf("Thread #%lu was not provided a URL\n", $this->getThreadId()); } } $t = microtime(true); $g = new WebRequest(sprintf("http://www.google.com/?q=%s", rand()*10)); /* starting synchronized */ if($g->start()){ printf("Request took %f seconds to start ", microtime(true)-$t); while($g->isRunning()){ echo "."; $g->synchronized(function() use($g) { $g->wait(100); }); } if ($g->join()){ printf(" and %f seconds to finish receiving %d bytes\n", microtime(true)-$t, strlen($g->data)); } else printf(" and %f seconds to finish, request failed\n", microtime(true)-$t); } ?> pthreads-3.0.2/examples/Singleton.php 0000664 0001750 0001750 00000002770 12575220121 014544 0 ustar config = $config; } public function run() { self::$connection = new PDO(...$this->config); } public function getConnection() { return self::$connection; } private $config; /* * static variables are treated as thread-local by pthreads */ private static $connection; } /* * When the Pool starts new Worker threads, they will construct the * PDO object before any Collectable objects are executed. */ $pool = new Pool(4, PDOWorker::class, [["sqlite:example.db"]]); /* * Now we can submit work to the Pool */ while (@$i++<10) { $pool->submit(new class extends Collectable { public function run() { var_dump($this->worker->getConnection()); } }); } $pool->shutdown(); ?> pthreads-3.0.2/examples/SocketServer.php 0000664 0001750 0001750 00000005464 12575220121 015224 0 ustar socket = $socket; $this->start(); } public function run(){ $client = $this->socket; if ($client) { $header = 0; while(($chars = socket_read($client, 1024, PHP_NORMAL_READ))) { $head[$header]=trim($chars); if ($header>0) { if (!$head[$header] && !$head[$header-1]) break; } $header++; } foreach($head as $header) { if ($header) { $headers[]=$header; } } $response = array( "head" => array( "HTTP/1.0 200 OK", "Content-Type: text/html" ), "body" => array() ); socket_getpeername($client, $address, $port); $response["body"][]=""; $response["body"][]=""; $response["body"][]="";
foreach($headers as $header)
$response["body"][]="{$header}";
$response["body"][]="";
$response["body"][]="";
$response["body"][]="";
$response["body"] = implode("\r\n", $response["body"]);
$response["head"][] = sprintf("Content-Length: %d", strlen($response["body"]));
$response["head"] = implode("\r\n", $response["head"]);
socket_write($client, $response["head"]);
socket_write($client, "\r\n\r\n");
socket_write($client, $response["body"]);
socket_close($client);
}
}
}
/* ladies and gentlemen, the world first multi-threaded socket server in PHP :) */
$server = socket_create_listen(13000);
while(($client = socket_accept($server))){
$clients[]=new Client($client);
/* we will serve a few clients and quit, to show that memory is freed and there are no errors on shutdown (hopefully) */
/* in the real world, do something here to ensure clients not running are destroyed */
/* the nature of a socket server is an endless loop,
if you do not do something to explicitly destroy clients you create this may leak */
}
/* that is all */
?>
pthreads-3.0.2/examples/Sockets.php 0000664 0001750 0001750 00000001312 12575220121 014204 0 ustar socket = $socket;
}
public function run(){
while(++$clients < 10 &&
($client = socket_accept($this->socket))){
printf("Accept in %lu\n", $this->getThreadId());
var_dump($client);
var_dump($this->socket);
socket_close($client);
}
}
}
$workers = array();
$sock = socket_create_listen($argv[1]);
if ($sock) {
while(++$worker<5){
$workers[$worker] = new Test($sock);
$workers[$worker]->start();
}
printf("%d threads waiting on port %d\n", count($workers), $argv[1]);
}
foreach ($workers as $thread)
$thread->join();
?>
pthreads-3.0.2/examples/StackableArray.php 0000664 0001750 0001750 00000004265 12575220121 015473 0 ustar test = $test;
$this->start();
}
public function run(){
/*
* NOTE
* If your editing of an array is this simple
* then don't protect these instructions
* you will incurr additional unecessary locking
*/
$this->test[]=rand(0, 10);
}
}
/* create the array here for passing */
$s = new StackableArray();
/* set a pointless value */
$s[]="h";
/* show it was set */
print_r($s);
$ts = array();
/* hammer the crap out of the array */
while(@$i++ < $hammers){
$ts[]=new T($s);
}
printf("GOT %d T's\n", count($ts));
/* we want all threads to complete */
foreach($ts as $t)
$t->join();
/* show it was all set without corruption */
print_r($s);
?>
pthreads-3.0.2/examples/Synchronization.php 0000664 0001750 0001750 00000001330 12575220121 015772 0 ustar synchronized(function(){
$this->awake = true;
$this->notify();
});
}
};
$thread->start();
$thread->synchronized(function() use($thread) {
while (!$thread->awake) {
/*
If there was no precondition above and the Thread
managed to send notification before we entered this synchronized block
we would wait forever!
We check the precondition in a loop because a Thread can be awoken
by signals other than the one you are waiting for.
*/
$thread->wait();
}
});
$thread->join();
?>
pthreads-3.0.2/examples/stub.php 0000664 0001750 0001750 00000046650 12575220121 013564 0 ustar
* @version 2.0.0
*/
/**
* The default inheritance mask used when starting Threads and Workers
*/
define('PTHREADS_INHERIT_ALL', 0x111111);
/**
* Nothing will be inherited by the new context
*/
define('PTHREADS_INHERIT_NONE', 0);
/**
* Determines whether the ini entries are inherited by the new context
*/
define('PTHREADS_INHERIT_INI', 0x1);
/**
* Determines whether the constants are inherited by the new context
*/
define('PTHREADS_INHERIT_CONSTANTS', 0x10);
/**
* Determines whether the class table is inherited by the new context
*/
define('PTHREADS_INHERIT_CLASSES', 0x100);
/**
* Determines whether the function table is inherited by the new context
*/
define('PTHREADS_INHERIT_FUNCTIONS', 0x100);
/**
* Determines whether the included_files table is inherited by the new context
*/
define('PTHREADS_INHERIT_INCLUDES', 0x10000);
/**
* Determines whether the comments are inherited by the new context
*/
define('PTHREADS_INHERIT_COMMENTS', 0x100000);
/**
* Allow output headers from the threads
*/
define('PTHREADS_ALLOW_HEADERS', 0x1000000);
/**
* Allow global inheritance for new threads
*/
define('PTHREADS_ALLOW_GLOBALS', 0x10000000);
/**
* Threaded class
*
* Threaded objects form the basis of pthreads ability to execute user code in parallel;
* they expose and include synchronization methods and various useful interfaces.
*
* Threaded objects, most importantly, provide implicit safety for the programmer;
* all operations on the object scope are safe.
*
* @link http://www.php.net/manual/en/class.threaded.php
* @since 2.0.0
*/
class Threaded implements Traversable, Countable, ArrayAccess
{
/**
* Fetches a chunk of the objects properties table of the given size
*
* @param int $size The number of items to fetch
*
* @link http://www.php.net/manual/en/threaded.chunk.php
* @return array An array of items from the objects member table
*/
public function chunk($size) {}
/**
* {@inheritdoc}
*/
public function count() {}
/**
* Retrieves terminal error information from the referenced object
*
* @link http://www.php.net/manual/en/threaded.getterminationinfo.php
* @return array|bool array containing the termination conditions of the referenced object
*/
public function getTerminationInfo() {}
/**
* Tell if the referenced object is executing
*
* @link http://www.php.net/manual/en/threaded.isrunning.php
* @return bool A boolean indication of state
*/
public function isRunning() {}
/**
* Tell if the referenced object exited, suffered fatal errors, or threw uncaught exceptions during execution
*
* @link http://www.php.net/manual/en/threaded.isterminated.php
* @return bool A boolean indication of state
*/
public function isTerminated() {}
/**
* Tell if the referenced object is waiting for notification
*
* @link http://www.php.net/manual/en/threaded.iswaiting.php
* @return bool A boolean indication of state
*/
public function isWaiting() {}
/**
* Lock the referenced objects property table
*
* @link http://www.php.net/manual/en/threaded.lock.php
* @return bool A boolean indication of state
*/
public function lock() {}
/**
* Merges data into the current object
*
* @param mixed $from The data to merge
* @param bool $overwrite Overwrite existing keys flag, by default true
*
* @link http://www.php.net/manual/en/threaded.merge.php
* @return bool A boolean indication of success
*/
public function merge($from, $overwrite = true) {}
/**
* Send notification to the referenced object
*
* @link http://www.php.net/manual/en/threaded.notify.php
* @return bool A boolean indication of success
*/
public function notify() {}
/**
* {@inheritdoc}
*/
public function offsetGet($offset) {}
/**
* {@inheritdoc}
*/
public function offsetSet($offset, $value) {}
/**
* {@inheritdoc}
*/
public function offsetExists($offset) {}
/**
* {@inheritdoc}
*/
public function offsetUnset($offset) {}
/**
* Pops an item from the objects property table
*
* @link http://www.php.net/manual/en/threaded.pop.php
* @return mixed The last item from the objects properties table
*/
public function pop() {}
/**
* The programmer should always implement the run method for objects that are intended for execution.
*
* @link http://www.php.net/manual/en/threaded.run.php
* @return void The methods return value, if used, will be ignored
*/
public function run() {}
/**
* Shifts an item from the objects properties table
*
* @link http://www.php.net/manual/en/threaded.shift.php
* @return mixed The first item from the objects properties table
*/
public function shift() {}
/**
* Executes the block while retaining the synchronization lock for the current context.
*
* @param \Closure $function The block of code to execute
* @param mixed $args... Variable length list of arguments to use as function arguments to the block
*
* @link http://www.php.net/manual/en/threaded.synchronized.php
* @return mixed The return value from the block
*/
public function synchronized(\Closure $function, $args = null) {}
/**
* Unlock the referenced objects storage for the calling context
*
* @link http://www.php.net/manual/en/threaded.unlock.php
* @return bool A boolean indication of success
*/
public function unlock() {}
/**
* Waits for notification from the Stackable
*
* @param int $timeout An optional timeout in microseconds
*
* @link http://www.php.net/manual/en/threaded.wait.php
* @return bool A boolean indication of success
*/
public function wait($timeout) {}
}
/**
* Basic thread implementation
*
* An implementation of a Thread should extend this declaration, implementing the run method.
* When the start method of that object is called, the run method code will be executed in separate Thread.
*
* @link http://www.php.net/manual/en/class.thread.php
*/
class Thread extends Threaded
{
/**
* Detaches a thread
*
* @return bool A boolean indication of success
*/
public function detach() {}
/**
* Will return the identity of the Thread that created the referenced Thread
*
* @link http://www.php.net/manual/en/thread.getcreatorid.php
* @return int A numeric identity
*/
public function getCreatorId() {}
/**
* Will return the instance of currently executing thread
*
* @return static
*/
public static function getCurrentThread() {}
/**
* Will return the identity of the currently executing thread
*
* @link http://www.php.net/manual/en/thread.getcurrentthreadid.php
* @return int
*/
public static function getCurrentThreadId() {}
/**
* Will return the identity of the referenced Thread
*
* @link http://www.php.net/manual/en/thread.getthreadid.php
* @return int
*/
public function getThreadId() {}
/**
* Tell if the referenced Thread has been joined by another context
*
* @link http://www.php.net/manual/en/thread.isjoined.php
* @return bool A boolean indication of state
*/
public function isJoined() {}
/**
* Tell if the referenced Thread has been started
*
* @link http://www.php.net/manual/en/thread.isstarted.php
* @return bool A boolean indication of state
*/
public function isStarted() {}
/**
* Causes the calling context to wait for the referenced Thread to finish executing
*
* @link http://www.php.net/manual/en/thread.join.php
* @return bool A boolean indication of state
*/
public function join() {}
/**
* Kills the referenced thread, dangerously !
*
* @link http://www.php.net/manual/en/thread.kill.php
*/
public function kill() {}
/**
* Will start a new Thread to execute the implemented run method
*
* @param int $options An optional mask of inheritance constants, by default PTHREADS_INHERIT_ALL
*
* @link http://www.php.net/manual/en/thread.start.php
* @return bool A boolean indication of success
*/
public function start($options = PTHREADS_INHERIT_ALL) {}
/**
* Will execute the Callable in the global scope
*
* @param Callable $block The code to execute
* @param ... $args Variable length list of arguments to pass to the Callable upon execution
* @link http://www.php.net/manual/en/thread.start.php
* @return bool A boolean indication of success
*/
public static function globally(Callable $block, $args) {}
}
/**
* Worker
*
* Worker Threads have a persistent context, as such should be used over Threads in most cases.
*
* When a Worker is started, the run method will be executed, but the Thread will not leave until one
* of the following conditions are met:
* - the Worker goes out of scope (no more references remain)
* - the programmer calls shutdown
* - the script dies
* This means the programmer can reuse the context throughout execution; placing objects on the stack of
* the Worker will cause the Worker to execute the stacked objects run method.
*
* @link http://www.php.net/manual/en/class.worker.php
*/
class Worker extends Thread
{
/**
* Returns the number of threaded tasks waiting to be executed by the referenced Worker
*
* @link http://www.php.net/manual/en/worker.getstacked.php
* @return int An integral value
*/
public function getStacked() {}
/**
* Tell if the referenced Worker has been shutdown
*
* @link http://www.php.net/manual/en/worker.isshutdown.php
* @return bool A boolean indication of state
*/
public function isShutdown() {}
/**
* Tell if a Worker is executing threaded tasks
*
* @link http://www.php.net/manual/en/worker.isworking.php
* @return bool A boolean indication of state
*/
public function isWorking() {}
/**
* Shuts down the Worker after executing all the threaded tasks previously stacked
*
* @link http://www.php.net/manual/en/worker.shutdown.php
* @return bool A boolean indication of success
*/
public function shutdown() {}
/**
* Appends the referenced object to the stack of the referenced Worker
*
* @param Threaded $work Threaded object to be executed by the referenced Worker
*
* @link http://www.php.net/manual/en/worker.stack.php
* @return int The new length of the stack
*/
public function stack(Threaded &$work) {}
/**
* Removes the referenced object ( or all objects if parameter is null ) from stack of the referenced Worker
*
* @param Threaded $work Threaded object previously stacked onto Worker
*
* @link http://www.php.net/manual/en/worker.unstack.php
* @return int The new length of the stack
*/
public function unstack(Threaded &$work = null) {}
}
/**
* Mutex class
*
* The static methods contained in the Mutex class provide direct access to Posix Mutex functionality.
*
* @link http://www.php.net/manual/en/class.mutex.php
*/
class Mutex
{
/**
* Create, and optionally lock a new Mutex for the caller
*
* @param bool $lock Setting lock to true will lock the Mutex for the caller before returning the handle
*
* @link http://www.php.net/manual/en/mutex.create.php
* @return int A newly created and optionally locked Mutex handle
*/
final public static function create($lock = false) {}
/**
* Destroy mutex
*
* Destroying Mutex handles must be carried out explicitly by the programmer when they are
* finished with the Mutex handle.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
*
* @link http://www.php.net/manual/en/mutex.destroy.php
* @return bool A boolean indication of success
*/
final public static function destroy($mutex) {}
/**
* Attempt to lock the Mutex for the caller.
*
* An attempt to lock a Mutex owned (locked) by another Thread will result in blocking.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
*
* @link http://www.php.net/manual/en/mutex.lock.php
* @return bool A boolean indication of success
*/
final public static function lock($mutex) {}
/**
* Attempt to lock the Mutex for the caller without blocking if the Mutex is owned (locked) by another Thread.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
*
* @link http://www.php.net/manual/en/mutex.trylock.php
* @return bool A boolean indication of success
*/
final public static function trylock($mutex) {}
/**
* Release mutex
*
* Attempts to unlock the Mutex for the caller, optionally destroying the Mutex handle.
* The calling thread should own the Mutex at the time of the call.
*
* @param int $mutex A handle returned by a previous call to Mutex::create().
* @param bool $destroy When true pthreads will destroy the Mutex after a successful unlock.
*
* @link http://www.php.net/manual/en/mutex.unlock.php
* @return bool A boolean indication of success
*/
final public static function unlock($mutex, $destroy = false) {}
}
/**
* Condition class
*
* The static methods contained in the Cond class provide direct access to Posix Condition Variables.
*
* @link http://www.php.net/manual/en/class.cond.php
*/
class Cond
{
/**
* Broadcast to all Threads blocking on a call to Cond::wait().
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
*
* @link http://www.php.net/manual/en/cond.broadcast.php
* @return bool A boolean indication of success
*/
final public static function broadcast($condition) {}
/**
* Creates a new Condition Variable for the caller.
*
* @link http://www.php.net/manual/en/cond.create.php
* @return int A handle to a Condition Variable
*/
final public static function create() {}
/**
* Destroy a condition
*
* Destroying Condition Variable handles must be carried out explicitly by the programmer when they are
* finished with the Condition Variable.
* No Threads should be blocking on a call to Cond::wait() when the call to Cond::destroy() takes place.
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
*
* @link http://www.php.net/manual/en/cond.destroy.php
* @return bool A boolean indication of success
*/
final public static function destroy($condition) {}
/**
* Signal a Condition
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
*
* @link http://www.php.net/manual/en/cond.signal.php
* @return bool A boolean indication of success
*/
final public static function signal($condition) {}
/**
* Wait for a signal on a Condition Variable, optionally specifying a timeout to limit waiting time.
*
* @param int $condition A handle to a Condition Variable returned by a previous call to Cond::create()
* @param int $mutex A handle returned by a previous call to Mutex::create() and owned (locked) by the caller.
* @param int $timeout An optional timeout, in microseconds
*
* @return bool A boolean indication of success
*/
final public static function wait($condition, $mutex, $timeout = null) {}
}
/**
* Pool class
*
* A Pool is a container for, and controller of, a number of Worker threads, the number of threads can be adjusted
* during execution, additionally the Pool provides an easy mechanism to maintain and collect references in the
* proper way.
*
* @link http://www.php.net/manual/en/class.pool.php
*/
class Pool
{
/**
* The maximum number of Worker threads allowed in this Pool
*
* @var integer
*/
protected $size;
/**
* The name of the Worker class for this Pool
*
* @var string
*/
protected $class;
/**
* The array of Worker threads for this Pool
*
* @var array|Worker[]
*/
protected $workers;
/**
* The array of Stackables submitted to this Pool for execution
*
* @var array|Threaded[]
*/
protected $work;
/**
* The constructor arguments to be passed by this Pool to new Workers upon construction
*
* @var array
*/
protected $ctor;
/**
* The numeric identifier for the last Worker used by this Pool
*
* @var integer
*/
protected $last;
/**
* Construct a new Pool of Workers
*
* @param integer $size The maximum number of Workers this Pool can create
* @param string $class The class for new Workers
* @param array $ctor An array of arguments to be passed to new Workers
*
* @link http://www.php.net/manual/en/pool.__construct.php
*/
public function __construct($size, $class, array $ctor = array()) {}
/**
* Shuts down all Workers, and collect all Stackables, finally destroys the Pool
*
* @link http://www.php.net/manual/en/pool.__destruct.php
*/
public function __destruct() {}
/**
* Collect references to completed tasks
*
* Allows the Pool to collect references determined to be garbage by the given collector
*
* @param callable $collector
*
* @link http://www.php.net/manual/en/pool.collect.php
*/
public function collect(callable $collector) {}
/**
* Resize the Pool
*
* @param integer $size The maximum number of Workers this Pool can create
*
* @link http://www.php.net/manual/en/pool.resize.php
*/
public function resize($size) {}
/**
* Shutdown all Workers in this Pool
*
* @link http://www.php.net/manual/en/pool.shutdown.php
*/
public function shutdown() {}
/**
* Submit the task to the next Worker in the Pool
*
* @param Threaded $task The task for execution
*
* @return int the identifier of the Worker executing the object
*/
public function submit(Threaded $task) {}
/**
* Submit the task to the specific Worker in the Pool
*
* @param int $worker The worker for execution
* @param Threaded $task The task for execution
*
* @return int the identifier of the Worker that accepted the object
*/
public function submitTo($worker, Threaded $task) {}
}
/**
* Collectable Class
*
* Represents a garbage-collectable object.
*
* Collectable objects are intended to be used by the Pool class, replacing Threaded objects as the unit of work.
* They provide methods to set and detect the collectability of an object.
*
* @link http://www.php.net/manual/en/class.collectable.php
*/
class Collectable extends Threaded
{
/**
* Determine whether an object has been marked as garbage
*
* @return bool Whether the referenced object is marked as garbage
*/
public function isGarbage() {}
/**
* Mark an object as garbage
*
* @return void
*/
public function setGarbage() {}
}
pthreads-3.0.2/tests/anon-bound-inherited.phpt 0000664 0001750 0001750 00000000613 12575220121 016315 0 ustar --TEST--
Test anonymous classes (bound inherited class)
--DESCRIPTION--
This test verifies that anonymous Threaded objects work as expected
--FILE--
start();
$worker->stack($collectable);
$worker->shutdown();
--EXPECT--
bool(true)
pthreads-3.0.2/tests/anon-unbound-inherited.phpt 0000664 0001750 0001750 00000000620 12575220121 016656 0 ustar --TEST--
Test anonymous classes (unbound inherited class)
--DESCRIPTION--mae
This test verifies that anonymous Threaded objects work as expected
--FILE--
start();
$collectable = new class extends Collectable {
public function run() {
var_dump($this instanceof Collectable);
}
};
$worker->stack($collectable);
$worker->shutdown();
--EXPECT--
bool(true)
pthreads-3.0.2/tests/binding.phpt 0000664 0001750 0001750 00000002162 12575220121 013717 0 ustar --TEST--
Test pthreads connections
--DESCRIPTION--
This test verifies that variables are bound properly by pthreads
--FILE--
other = $other;
}
public function run(){
$this->synchronized(function($that) {
$that->done = true;
$that->notify();
}, $this);
}
}
class ThreadTest extends Thread {
public $other;
public $done;
public function setOther($other){
$this->other = $other;
}
public function run(){
$this->synchronized(function($that) {
$that->done = true;
$that->notify();
}, $this);
}
}
$threads[0]=new ThreadTesting();
$threads[1]=new ThreadTest();
$threads[0]->setOther($threads[1]);
$threads[1]->setOther($threads[0]);
foreach($threads as $thread)
$thread->start();
foreach($threads as $thread) {
$thread->synchronized(function() use($thread){
if (!$thread->done)
var_dump($thread->wait());
else var_dump($thread->done);
});
}
foreach ($threads as $thread)
$thread->join();
?>
--EXPECT--
bool(true)
bool(true)
pthreads-3.0.2/tests/callstatic-etc.phpt 0000664 0001750 0001750 00000000756 12575220121 015210 0 ustar --TEST--
Testing extended object functionality, magic methods bug #34
--DESCRIPTION--
Test that the fix for bug #34 is a success
--FILE--
start();
?>
--EXPECT--
string(11) "called_func"
array(1) {
[0]=>
string(8) "argument"
}
pthreads-3.0.2/tests/chunk.phpt 0000664 0001750 0001750 00000000757 12575220121 013425 0 ustar --TEST--
Check chunking
--DESCRIPTION--
This test verifies functionality of ::chunk
--FILE--
merge(array_fill(0, 10000, true));
var_dump($s->chunk(10));
?>
--EXPECT--
array(10) {
["0"]=>
bool(true)
["1"]=>
bool(true)
["2"]=>
bool(true)
["3"]=>
bool(true)
["4"]=>
bool(true)
["5"]=>
bool(true)
["6"]=>
bool(true)
["7"]=>
bool(true)
["8"]=>
bool(true)
["9"]=>
bool(true)
}
pthreads-3.0.2/tests/class-defaults.phpt 0000664 0001750 0001750 00000001410 12575220121 015212 0 ustar --TEST--
Test class defaults
--DESCRIPTION--
Class defaults should now initialize defaults properly
--FILE--
string = strrev($test->string);
$test->start();
$test->join();
?>
--EXPECT--
object(Test)#1 (4) {
["string"]=>
string(11) "dlrow olleh"
["array"]=>
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
["pstring"]=>
string(11) "world hello"
["parray"]=>
array(3) {
[0]=>
int(3)
[1]=>
int(2)
[2]=>
int(1)
}
}
pthreads-3.0.2/tests/closures-as-members.phpt 0000664 0001750 0001750 00000002525 12575220121 016200 0 ustar --TEST--
Testing closure members
--DESCRIPTION--
This test verifies that closures can be set as members and called from anywhere
--FILE--
some = function(){
echo "Hello Some\n";
};
class T extends Thread {
public function __construct($test) {
$this->test = $test;
}
public function run() {
/* call original closure */
$this->call($this->test->some);
/* set new closure */
$this->synchronized(function(){
$this->set = true;
$this->test->some = function() {
echo "Hello World\n";
};
$this->notify();
});
/* wait for new closure execution */
$this->synchronized(function(){
while (!$this->used)
$this->wait();
});
}
public function call(Closure $closure) {
$closure();
}
}
/* start thread to call closure */
$t = new T($test);
$t->start();
/* wait for new closure */
$t->synchronized(function() use($t) {
while (!$t->set)
$t->wait();
});
/* call new closure */
$some = $test->some;
$some();
/* allow new closure to be dtored with old context */
$t->synchronized(function() use($t) {
$t->used = true;
$t->notify();
});
$t->join();
unset($t);
--EXPECTF--
Hello Some
Hello World
pthreads-3.0.2/tests/complex-statics-set-null.phpt 0000664 0001750 0001750 00000002331 12575220121 017163 0 ustar --TEST--
Test NULLing ressources in arrays
--FILE--
start();
$thread->join();
?>
--EXPECTF--
file::_get: something1
array(1) {
[%i]=>
resource(5) of type (stream)
}
file::_get: something2
array(1) {
[%i]=>
resource(5) of type (stream)
}
file::_get: something3
array(1) {
[%i]=>
resource(2) of type (stream)
}
file::_get: something4
array(1) {
[%i]=>
resource(2) of type (stream)
}
pthreads-3.0.2/tests/complex-statics.phpt 0000664 0001750 0001750 00000002261 12575220121 015424 0 ustar --TEST--
Test complex statics bug #32
--DESCRIPTION--
This test verifies that complex static types are ignored when creating thread contexts, leading to predictable stable behaviour
--FILE--
start();
?>
--EXPECT--
sql::_query: SELECT * FROM mysql.user
sql::_query: SELECT * FROM mysql.user
sql::_query: SELECT * FROM mysql.user
sql::_query: SELECT * FROM mysql.user
pthreads-3.0.2/tests/constants.phpt 0000664 0001750 0001750 00000000571 12575220121 014323 0 ustar --TEST--
Test constants (bug 19)
--DESCRIPTION--
This test verifies that constant members in declarations made outside of threads are available inside threads without error
--FILE--
start();
?>
--EXPECT--
Y-m-d\TH:i:sO
pthreads-3.0.2/tests/corrupted-resources.phpt 0000664 0001750 0001750 00000001251 12575220121 016322 0 ustar --TEST--
Testing sane handling of resources and objects bug #39
--DESCRIPTION--
Test that resources and objects are not corrupted when written to thread storage
--FILE--
test = $test;
print_r($this->test);
var_dump($this->test);
$stream = tmpfile();
var_dump($stream);
$this->stream = $stream;
stream_set_blocking($this->stream, 0);
var_dump($this->stream);
}
}
$test =new Test();
$test->start();
?>
--EXPECTF--
Work Object
(
)
object(Work)#2 (0) {
}
resource(%d) of type (stream)
resource(%d) of type (stream)
pthreads-3.0.2/tests/counting-members.phpt 0000664 0001750 0001750 00000000435 12575220121 015564 0 ustar --TEST--
Testing member count
--DESCRIPTION--
This test verifies that getting member counts works
--FILE--
--EXPECT--
int(3)
pthreads-3.0.2/tests/crazy-refcounting-stuff.phpt 0000664 0001750 0001750 00000002316 12575220121 017104 0 ustar --TEST--
Test managing refcount in userland (super advanced voodoo shit, leave it alone)
--DESCRIPTION--
pthreads v3 does allow the programmer to store references to other Threaded objects as members without references.
It still might be useful in a complex system to manipulate the refcount of Threaded objects, so this stays.
This is an advanced feature, if you don't know what you're doing, *don't touch it*.
*I will be EXTREMELY reluctant to help with issues caused by the programmer trying to deal with refcounts*
--FILE--
addRef();
$this->owner =
Thread::getCurrentThreadId();
}
public function __destruct() {
if (Thread::getCurrentThreadId() == $this->owner) {
$this->delRef();
}
}
}
class Test extends Thread {
public function __construct() {
$this->inctor = new Managed();
}
public function run() {
$this->inrun = new Managed();
var_dump($this);
}
}
$thread = new Test();
$thread->start();
$thread->join();
--EXPECTF--
object(Test)#1 (2) {
["inctor"]=>
object(Managed)#3 (1) {
["owner"]=>
int(%s)
}
["inrun"]=>
object(Managed)#2 (1) {
["owner"]=>
int(%s)
}
}
pthreads-3.0.2/tests/doc-comments.phpt 0000664 0001750 0001750 00000002204 12575220121 014672 0 ustar --TEST--
Test doc comments are copied properly
--DESCRIPTION--
Test that doc comments are copied, no leaking/errors
--FILE--
getDocComment());
}
}
$t = new T();
$t->start();
$t->join();
$reflect = new ReflectionMethod("T", "run");
var_dump($reflect);
var_dump($reflect->getDocComment());
?>
--EXPECTF--
object(ReflectionMethod)#2 (2) {
["name"]=>
string(3) "run"
["class"]=>
string(1) "T"
}
string(%d) "/**
* Method comment
* @doc comment
* @package package
* @subpackage subpackage
*/"
object(ReflectionMethod)#2 (2) {
["name"]=>
string(3) "run"
["class"]=>
string(1) "T"
}
string(%d) "/**
* Method comment
* @doc comment
* @package package
* @subpackage subpackage
*/"
pthreads-3.0.2/tests/exception-handler-fail.phpt 0000664 0001750 0001750 00000001352 12575220121 016627 0 ustar --TEST--
Test exception handler inheritance (non threaded objects)
--DESCRIPTION--
Non-threaded objects caused pthreads up to v3.0.1 to fault when used as excepion handlers.
Before we start a new thread, we apply a function to the exception handler stack that rebuilds their
property tables.
--FILE--
getMessage();
}
}
class ExceptionThread extends Thread
{
public function traceable() {
throw new Exception("OK");
}
public function run()
{
$this->traceable();
}
}
$handler = new ExceptionHandler();
set_exception_handler([$handler, "handle"]);
$t = new ExceptionThread();
$t->start();
$t->join();
?>
--EXPECT--
OK
pthreads-3.0.2/tests/exception-handler-options.phpt 0000664 0001750 0001750 00000002251 12575220121 017406 0 ustar --TEST--
Test exception handler inheritance (options)
--DESCRIPTION--
PTHREADS_INHERIT_CLASSES and PTHREADS_INHERIT_FUNCTIONS effect the handlers that can be copied.
This test ensures that the various options are sensibly covered, and hopefully nothing crashes.
--FILE--
getMessage());
}
}
class Test extends Thread {
public function run () {
throw new Exception("oh dear");
}
}
$handler = new Handler();
set_exception_handler([$handler, "handle"]); # needs classes
$test = new Test();
$test->start(PTHREADS_INHERIT_FUNCTIONS); # uncaught
$test->join();
$test = new Test();
$test->start(PTHREADS_INHERIT_CLASSES); # caught
$test->join();
restore_exception_handler();
set_exception_handler(function($ex){
var_dump(__FUNCTION__, $ex->getMessage());
});
$test = new Test();
$test->start(PTHREADS_INHERIT_FUNCTIONS); # caught
$test->join();
?>
--EXPECTF--
Fatal error: Uncaught Exception: oh dear in %s:10
Stack trace:
#0 [internal function]: Test->run()
#1 {main}
thrown in %s on line 10
string(15) "Handler::handle"
string(7) "oh dear"
string(9) "{closure}"
string(7) "oh dear"
pthreads-3.0.2/tests/exception-handler.phpt 0000664 0001750 0001750 00000002642 12575220121 015721 0 ustar --TEST--
Test exception handler inheritance (ok)
--DESCRIPTION--
This test verifies that user exception handler is invoked by pthreads if set
--FILE--
traceable();
}
}
/* this is now copied from parent, as you would expect it to be */
set_exception_handler(array("ExceptionHandler", "handle"));
$t = new ExceptionThread();
$t->start();
$t->join();
?>
--EXPECTF--
object(Exception)#2 (%d) {
["message":protected]=>
string(0) ""
["string":"Exception":private]=>
string(0) ""
["code":protected]=>
int(0)
["file":protected]=>
string(%d) "%s"
["line":protected]=>
int(13)
["trace":"Exception":private]=>
array(2) {
[0]=>
array(6) {
["file"]=>
string(%d) "%s"
["line"]=>
int(17)
["function"]=>
string(9) "traceable"
["class"]=>
string(15) "ExceptionThread"
["type"]=>
string(2) "->"
["args"]=>
array(0) {
}
}
[1]=>
array(4) {
["function"]=>
string(3) "run"
["class"]=>
string(15) "ExceptionThread"
["type"]=>
string(2) "->"
["args"]=>
array(0) {
}
}
}
["previous":"Exception":private]=>
NULL
}
pthreads-3.0.2/tests/foreign-private-members.phpt 0000664 0001750 0001750 00000001110 12575220121 017026 0 ustar --TEST--
Testing foreign private member access, magic methods bug #32
--DESCRIPTION--
Test that the fix for bug #32 is a success
--FILE--
test;
}
}
class TEST extends Thread {
public function __construct($my) {
$this->my = $my;
}
public function run(){
printf("TEST: %s\n", $this->my->getTest());
}
}
$my = new MY();
$test = new TEST($my);
$test->start();
--EXPECT--
TEST: Hello World
pthreads-3.0.2/tests/functions.phpt 0000664 0001750 0001750 00000000613 12575220121 014314 0 ustar --TEST--
Test function table inheritance
--DESCRIPTION--
This test verifies that the function table is inherited by pthreads correctly
--FILE--
start();
?>
--EXPECT--
TestFunction
pthreads-3.0.2/tests/global-constants.phpt 0000664 0001750 0001750 00000001302 12575220121 015552 0 ustar --TEST--
Test global constants
--DESCRIPTION--
This test verifies that global constants are inherited
--FILE--
SCONST,
"long" => LCONST,
"double" => DCONST,
"null" => NCONST,
"boolean" => BCONST
) as $key => $constant) {
printf("%s:", $key);
var_dump($constant);
}
}
}
$thread = new TestThread();
$thread->start();
?>
--EXPECT--
string:string(8) "mystring"
long:int(10)
double:float(1.19)
null:NULL
boolean:bool(true)
pthreads-3.0.2/tests/gone.phpt 0000664 0001750 0001750 00000001147 12575220121 013237 0 ustar --TEST--
Test objects that have gone away
--DESCRIPTION--
This test verifies that objects that have gone away do not cause segfaults
--FILE--
o = new O();
/* this will disappear with this context */
$this->o["data"] = true;
}
}
$t = new T();
$t->start();
$t->join();
var_dump($t->o);
?>
--EXPECTF--
Fatal error: Uncaught %s: pthreads detected an attempt to connect to an object which has already been destroyed in %s:22
Stack trace:
#0 {main}
thrown in %s on line 22
pthreads-3.0.2/tests/graceful-fatalities.phpt 0000664 0001750 0001750 00000001024 12575220121 016214 0 ustar --TEST--
Test graceful fatalities
--DESCRIPTION--
This test verifies that fatalities are graceful with regard to state
--FILE--
start();
$test->join();
var_dump($test->isTerminated());
?>
--EXPECTF--
Fatal error: Uncaught Error: Class 'MY' not found in %s:5
Stack trace:
#0 [internal function]: TestThread->run()
#1 {main}
thrown in %s on line 5
bool(true)
pthreads-3.0.2/tests/hacking-serials.phpt 0000664 0001750 0001750 00000002245 12575220121 015353 0 ustar --TEST--
Check graceful serialization of Threaded objects as members of non Threaded objects
--DESCRIPTION--
We don't need to serialize Threaded objects when they are set as members of other Threaded
objects. However, a non-threaded object who has a Threaded object as a member must still serialize
the Threaded object when that non-threaded object is set as a member of yet another Threaded object.
So while Threaded objects can store other Threaded objects without hacky serialization routines, normal objects
still require a hack.
This test ensures the hack is right.
--FILE--
worker = new Worker;
$this->worker->start();
}
public function stack(Collectable $work) {
$this->worker->stack($work);
}
}
class Work extends Collectable {
public $wrapper;
public function __construct(Wrapper $wrapper) {
$this->wrapper = $wrapper;
}
public function stack() {
$this->wrapper->stack($this);
}
public function run() {
echo "Foo\n";
}
}
$wrapper = new Wrapper;
$work = new Work($wrapper);
$work->stack();
--EXPECT--
Foo
pthreads-3.0.2/tests/immutable-threaded-members.phpt 0000664 0001750 0001750 00000004434 12575220121 017476 0 ustar --TEST--
Test immutability
--DESCRIPTION--
To provide the best performance and and predictability, members of Threaded objects that are set to
other Threaded objects are immutable, that is you cannot unset or write a member of a Threaded object
if the member itself is a Threaded object.
This test ensures that immutability works as intended with no strange side effects.
--FILE--
t = new Threaded(); # now immutable
$this->t->set = true; # fine
$this->s = new stdClass(); # fine, not immutable
}
public function run(){
$this->synchronized(function(){
while (!$this->printed) {
$this->wait(); # wait for object to be printed in main context
}
});
try {
$this->t = new Threaded(); # can't do it, immutable member
} catch(Exception $ex) {
printf("%s in %s on line %d\n", $ex->getMessage(), $ex->getFile(), $ex->getLine());
}
try {
unset($this->t); # can't do it, immutable member
} catch(Exception $ex) {
printf("%s in %s on line %d\n", $ex->getMessage(), $ex->getFile(), $ex->getLine());
}
}
}
$t = new T();
var_dump($t->t, $t->s);
$t->start();
$t->synchronized(function() use($t) {
var_dump($t->t, $t->s);
$t->printed = true;
$t->notify();
});
$t->join();
try {
$t->t = new Threaded(); # can't do it, immutable member
} catch(Exception $ex) {
printf("%s in %s on line %d\n", $ex->getMessage(), $ex->getFile(), $ex->getLine());
}
try {
unset($t->t); # can't do it, immutable member
} catch(Exception $ex) {
printf("%s in %s on line %d\n", $ex->getMessage(), $ex->getFile(), $ex->getLine());
}
var_dump($t->t); # not mutated
--EXPECTF--
object(Threaded)#%d (%d) {
["set"]=>
bool(true)
}
object(stdClass)#%d (%d) {
}
object(Threaded)#%d (%d) {
["set"]=>
bool(true)
}
object(stdClass)#%d (%d) {
}
Threaded members previously set to Threaded objects are immutable, cannot overwrite t in %s on line 18
Threaded members previously set to Threaded objects are immutable, cannot overwrite t in %s on line 24
Threaded members previously set to Threaded objects are immutable, cannot overwrite t in %s on line 44
Threaded members previously set to Threaded objects are immutable, cannot overwrite t in %s on line 50
object(Threaded)#%d (%d) {
["set"]=>
bool(true)
}
pthreads-3.0.2/tests/included-files.phpt 0000664 0001750 0001750 00000000747 12575220121 015203 0 ustar --TEST--
Test include/require functions as expected
--DESCRIPTION--
This test verifies that require_once and include are working as expected
--FILE--
start();
?>
--EXPECT--
OK
pthreads-3.0.2/tests/includeme.inc 0000664 0001750 0001750 00000000036 12575220121 014046 0 ustar start();
?>
--EXPECT--
Test::run: :/var/lib/other
pthreads-3.0.2/tests/interface.phpt 0000664 0001750 0001750 00000001113 12575220121 014240 0 ustar --TEST--
Test interface functionality
--DESCRIPTION--
This test verifies that interfaces are handled properly by pthreads
--FILE--
name = $name;
}
public function getName() {
return $this->name;
}
public function run() { printf("%s\n", $this->getName()); }
}
$thread = new TestThread();
$thread->setName("InterfaceTest");
$thread->start();
?>
--EXPECT--
InterfaceTest
pthreads-3.0.2/tests/interfaces.phpt 0000664 0001750 0001750 00000001141 12575220121 014424 0 ustar --TEST--
Testing interfaces inheritance (#124)
--DESCRIPTION--
Test if interfaces are stored in thread
--FILE--
test;
}
}
class TEST extends Thread {
public function __construct() {
}
public function run(){
$MY = new MY();
var_dump(in_array("iMY",get_declared_interfaces()));
var_dump(in_array("iMY",class_implements($MY)));
}
}
$test = new TEST();
$test->start();
?>
--EXPECT--
bool(true)
bool(true)
pthreads-3.0.2/tests/isset-empty-compat.phpt 0000664 0001750 0001750 00000002366 12575220121 016057 0 ustar --TEST--
Test isset and empty are compliant with standard objects (fix bug #347)
--FILE--
$prop) == isset($threaded->$prop));
var_dump(empty($stdObject->$prop) == empty($threaded->$prop));
printf("\n");
}
--EXPECT--
t_false:
bool(true)
bool(true)
t_null:
bool(true)
bool(true)
t_emptyStr:
bool(true)
bool(true)
t_zero1:
bool(true)
bool(true)
t_zero2:
bool(true)
bool(true)
t_zero3:
bool(true)
bool(true)
t_notSet:
bool(true)
bool(true)
t_notEmpty:
bool(true)
bool(true)
pthreads-3.0.2/tests/isset-unset.phpt 0000664 0001750 0001750 00000001714 12575220121 014572 0 ustar --TEST--
Testing isset unset
--DESCRIPTION--
This tests that isset and unset are working properly
--FILE--
merge(range(1, 10));
var_dump($storage);
for($i = 0; $i < 10; $i ++) {
var_dump(isset($storage[$i]));
var_dump($storage[$i]);
unset($storage[$i]);
var_dump(isset($storage[$i]));
printf("\n");
}
?>
--EXPECT--
object(Storage)#1 (10) {
["0"]=>
int(1)
["1"]=>
int(2)
["2"]=>
int(3)
["3"]=>
int(4)
["4"]=>
int(5)
["5"]=>
int(6)
["6"]=>
int(7)
["7"]=>
int(8)
["8"]=>
int(9)
["9"]=>
int(10)
}
bool(true)
int(1)
bool(false)
bool(true)
int(2)
bool(false)
bool(true)
int(3)
bool(false)
bool(true)
int(4)
bool(false)
bool(true)
int(5)
bool(false)
bool(true)
int(6)
bool(false)
bool(true)
int(7)
bool(false)
bool(true)
int(8)
bool(false)
bool(true)
int(9)
bool(false)
bool(true)
int(10)
bool(false)
pthreads-3.0.2/tests/iterator-no-refs.phpt 0000664 0001750 0001750 00000000661 12575220121 015507 0 ustar --TEST--
Test disallowing iteration by reference
--DESCRIPTION--
We cannot supply a reference to properties, as modifying them would not have the desired result
To avoid surprises, we throw an exception ...
--FILE--
&$v) {}
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: iteration by reference is not allowed on Threaded objects in %s:2
Stack trace:
#0 {main}
thrown in %s on line 2
pthreads-3.0.2/tests/killed-info.phpt 0000664 0001750 0001750 00000000614 12575220121 014502 0 ustar --TEST--
Test kill
--DESCRIPTION--
This test verifies that ::kill sets state
--SKIPIF--
--FILE--
start();
$t->kill();
$t->join();
var_dump($t->isTerminated());
?>
--EXPECT--
bool(true)
pthreads-3.0.2/tests/legacy-ctor.phpt 0000664 0001750 0001750 00000001045 12575220121 014515 0 ustar --TEST--
Test legacy constructor (issue #336)
--DESCRIPTION--
This test verifies that legacy ctors do not induce failure
--FILE--
start();
$t->join();
--EXPECTF--
Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; test2 has a deprecated constructor in %s on line %d
ctor test2
pthreads-3.0.2/tests/lexical-vars.phpt 0000664 0001750 0001750 00000002552 12575220121 014702 0 ustar --TEST--
Test lexical vars
--DESCRIPTION--
In pthreads v2, it was difficult to support lexical or function-static
scope vars, for various reasons.
In pthreads v3, it is now possible to have some support, the following things will work
Threaded objects
Closures
Arrays
Scalars
The following things will not work:
Non-threaded objects
Resources
Unsupported types should not raise notices, they will simply be undefined in the function scope.
--FILE--
function = $function;
}
public function run()
{
$function = $this->function;
$function();
}
}
$scalar = 1; # will work
$string = "thing"; # will work
$res = fopen("php://stdin", "r"); # won't work
$threaded = new Threaded(); # will work
$closure = function() { # will work
echo "hi";
};
$array = [1, 2, 3, 4, 5]; # will work
$std = new stdClass; # won't work
$thread = new TestThread(function () use ($scalar, $string, $res, $threaded, $closure, $array, $std) {
var_dump($scalar, $string, $res, $threaded, $closure, $array, $std);
});
$thread->start();
--EXPECTF--
int(1)
string(5) "thing"
NULL
object(Threaded)#2 (0) {
}
object(Closure)#3 (0) {
}
array(5) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
}
NULL
pthreads-3.0.2/tests/magic-methods-get-set.phpt 0000664 0001750 0001750 00000001043 12575220121 016371 0 ustar --TEST--
Test magic __get and __set
--DESCRIPTION--
This test verifies that __set and __get work as expected
--FILE--
one = "one";
var_dump($test->one);
?>
--EXPECT--
magic __set
magic __get
string(3) "one"
pthreads-3.0.2/tests/magic-methods-isset-unset.phpt 0000664 0001750 0001750 00000001147 12575220121 017311 0 ustar --TEST--
Test magic __isset and __unset
--DESCRIPTION--
This test verifies that __isset and __unset work as expected
--FILE--
one = 1;
var_dump(isset($test->one));
unset($test->one);
var_dump(isset($test->one));
?>
--EXPECT--
magic __isset
bool(true)
magic __unset
magic __isset
bool(false)
pthreads-3.0.2/tests/merge-non-threaded.phpt 0000664 0001750 0001750 00000001363 12575220121 015754 0 ustar --TEST--
Test merge non-threaded
--DESCRIPTION--
This test verifies that merging with non-threaded classes works as expected
--FILE--
foo = "foo";
$stdClass->bar = "bar";
$stdClass->baz = "baz";
$safe = new Threaded();
$safe->merge($array);
$safe->foo = "bar";
$safe->merge($stdClass, false);
var_dump($safe);
?>
--EXPECTF--
object(Threaded)#%d (13) {
["0"]=>
int(0)
["1"]=>
int(1)
["2"]=>
int(2)
["3"]=>
int(3)
["4"]=>
int(4)
["5"]=>
int(5)
["6"]=>
int(6)
["7"]=>
int(7)
["8"]=>
int(8)
["9"]=>
int(9)
["foo"]=>
string(3) "bar"
["bar"]=>
string(3) "bar"
["baz"]=>
string(3) "baz"
}
pthreads-3.0.2/tests/merging-members.phpt 0000664 0001750 0001750 00000001435 12575220121 015367 0 ustar --TEST--
Testing merging members
--DESCRIPTION--
This tests that merging members works as expected
--FILE--
test = "one";
$stores[1]->other = "when";
$stores[1]->test = "two";
$stores[1]->next = 0.01;
$stores[0]->merge($stores[1]);
var_dump($stores[0]);
$stores[0]->test = "one";
$stores[1]->other = "when";
$stores[1]->test = "two";
$stores[1]->next = 0.01;
$stores[0]->merge($stores[1], false);
var_dump($stores[0]);
?>
--EXPECT--
object(Store)#1 (3) {
["test"]=>
string(3) "two"
["other"]=>
string(4) "when"
["next"]=>
float(0.01)
}
object(Store)#1 (3) {
["test"]=>
string(3) "one"
["other"]=>
string(4) "when"
["next"]=>
float(0.01)
}
pthreads-3.0.2/tests/merging-range.phpt 0000664 0001750 0001750 00000000467 12575220121 015035 0 ustar --TEST--
Testing merging members (long keys)
--DESCRIPTION--
This tests that merging ranges works as expected (long keys)
--FILE--
merge(range("0", "3"));
var_dump(count($storage));
?>
--EXPECTF--
int(4)
pthreads-3.0.2/tests/no-cloning.phpt 0000664 0001750 0001750 00000000506 12575220121 014350 0 ustar --TEST--
Test no cloning
--DESCRIPTION--
This test that clone will not operate (or have strange side effects)
--FILE--
--EXPECTF--
Fatal error: Uncaught RuntimeException: Threaded objects cannot be cloned in %s:3
Stack trace:
#0 {main}
thrown in %s on line 3
pthreads-3.0.2/tests/no-sleeping.phpt 0000664 0001750 0001750 00000001201 12575220121 014516 0 ustar --TEST--
Check override of sleep and usleep
--DESCRIPTION--
sleep() and usleep() are not suitable for use in multi-threaded applications
therefore pthreads disallows their invokation.
proper synchronization should *always* be used, *no exceptions*
--FILE--
getMessage());
}
try {
sleep(1);
} catch(Exception $ex) {
var_dump($ex->getMessage());
}
--EXPECT--
string(94) "usleep is not suitable for use in multi threaded applications, use synchronized Threaded::wait"
string(93) "sleep is not suitable for use in multi threaded applications, use synchronized Threaded::wait"
pthreads-3.0.2/tests/norefs.phpt 0000664 0001750 0001750 00000002143 12575220121 013600 0 ustar --TEST--
Test members (typeof object) with no other references
--DESCRIPTION--
In pthreads v2, you were charged with responsability of the objects you create, however in pthreads v3, a Threaded object
is able to retain a reference to another Threaded object, this makes programming Thread objects a lot simpler,
the code in this test would fail with pthreads v2 and will work as expected with pthreads v3, which is a win for everyone ...
--FILE--
t = new O();
$this->t->set = true;
$this->s = new stdClass();
}
public function run(){
var_dump($this->t, $this->s, $this);
}
}
$t = new T();
var_dump($t);
$t->start();
$t->join();
?>
--EXPECTF--
object(T)#%d (%d) {
["t"]=>
object(O)#%d (%d) {
["set"]=>
bool(true)
}
["s"]=>
object(stdClass)#%d (%d) {
}
}
object(O)#2 (%d) {
["set"]=>
bool(true)
}
object(stdClass)#%d (%d) {
}
object(T)#%d (%d) {
["t"]=>
object(O)#%d (%d) {
["set"]=>
bool(true)
}
["s"]=>
object(stdClass)#%d (%d) {
}
}
pthreads-3.0.2/tests/normal-reads.phpt 0000664 0001750 0001750 00000000654 12575220121 014675 0 ustar --TEST--
Test reading object properties without debug info
--DESCRIPTION--
This test verifies that reading properties from the object without var_dump/print_r will work
--FILE--
name = sprintf("%s", __CLASS__);
}
}
$thread = new Test();
$thread->start();
$thread->join();
foreach($thread as $key => $value)
var_dump($value);
?>
--EXPECT--
string(4) "Test"
pthreads-3.0.2/tests/normalize-members.phpt 0000664 0001750 0001750 00000000545 12575220121 015740 0 ustar --TEST--
Testing normalizing members
--DESCRIPTION--
This tests that normalizing members works without effort
--FILE--
--EXPECT--
bool(true)
pthreads-3.0.2/tests/null-member-crash.phpt 0000664 0001750 0001750 00000000457 12575220121 015627 0 ustar --TEST--
Null member crash
--DESCRIPTION--
This test verifies that null members do not crash php
--FILE--
--EXPECTF--
object(Test)#1 (1) {
["0"]=>
string(4) "what"
}
pthreads-3.0.2/tests/object-comparison.phpt 0000664 0001750 0001750 00000002270 12575220121 015723 0 ustar --TEST--
Test object comparison
--DESCRIPTION--
Threaded object comparison was broken in pthreads v2, the handler was not implemented.
In pthreads v3 we implement the handler, but not in the way Zend is expecting us too.
To traverse (and reconstruct in most cases) the property store in order to perform a comparison is extremely inefficient.
In addition, because of the way pthreads works, it might be useful to determine if two references from two different contexts are infact references
to the same object from some other context.
So pthreads v3 implements the comparison handler and returns true when two references are for the same Threaded object, this differs from normal object
comparison which would return true if the property tables of two distinct objects are uniform.
--FILE--
args = $args;
}
public function run () {
var_dump($this->args[0] == $this->args[1]);
}
}
$a = new Threaded();
$b = new Threaded();
$test = new Test($a, $b); # bool(false)
$test->start();
$test->join();
$test = new Test($a, $a); # bool(true)
$test->start();
$test->join();
?>
--EXPECT--
bool(false)
bool(true)
pthreads-3.0.2/tests/oomethods.phpt 0000664 0001750 0001750 00000000712 12575220121 014305 0 ustar --TEST--
Test access to user defined methods in the object context
--DESCRIPTION--
User methods are now imported from your declared class into the thread
--FILE--
value;
}
public function run(){
$this->value = 1;
}
}
$thread = new ThreadTest();
if($thread->start()) {
$thread->join();
var_dump($thread->objectTest());
}
?>
--EXPECT--
int(1) pthreads-3.0.2/tests/pools-default.phpt 0000664 0001750 0001750 00000001202 12575220121 015055 0 ustar --TEST--
Test pool defaults
--DESCRIPTION--
This test verifies pool defaults
--FILE--
submit(new Work());
$pool->shutdown();
$pool->collect(function(Work $work) {
return true;
});
var_dump($pool);
?>
--EXPECTF--
object(Work)#%d (%d) {
["garbage"]=>
bool(false)
["worker"]=>
object(Worker)#%d (0) {
}
}
object(Pool)#%d (%d) {
["size":protected]=>
int(1)
["class":protected]=>
string(6) "Worker"
["workers":protected]=>
array(0) {
}
["ctor":protected]=>
NULL
["last":protected]=>
int(1)
}
pthreads-3.0.2/tests/pools.phpt 0000664 0001750 0001750 00000002755 12575220121 013451 0 ustar --TEST--
Test pooling
--DESCRIPTION--
This test verifies the functionality of selective inheritance
--FILE--
logger = $logger;
}
protected $loger;
}
class WebWork extends Collectable {
public function __construct(int $id) {
$this->id = $id;
}
public function run() {
$this->worker
->logger
->log("%s(%d) executing in Thread #%lu",
__CLASS__, $this->id, $this->worker->getThreadId());
}
protected $id;
}
class SafeLog extends Threaded {
public function log($message, ... $args) {
$this->synchronized(function($message, ... $args) {
echo vsprintf("{$message}\n", ...$args);
}, $message, $args);
}
}
$pool = new Pool(8, 'WebWorker', array(new SafeLog()));
while (@$i++<10)
$pool->submit(new WebWork($i));
$pool->shutdown();
var_dump($pool);
?>
--EXPECTF--
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
WebWork(%d) executing in Thread #%d
object(Pool)#%d (%d) {
["size":protected]=>
int(8)
["class":protected]=>
string(9) "WebWorker"
["workers":protected]=>
array(0) {
}
["ctor":protected]=>
array(1) {
[0]=>
object(SafeLog)#%d (0) {
}
}
["last":protected]=>
int(%d)
}
pthreads-3.0.2/tests/resource-keeping.phpt 0000664 0001750 0001750 00000006113 12575220121 015554 0 ustar --TEST--
Test sane handling of resources from foreign contexts
--DESCRIPTION--
Test that resources from other thread contexts can properly be accessed and are only destroyed by their owner
--FILE--
foreignResource = $useResource;
var_dump([
'Resource received and stored:',
is_resource($useResource),
is_resource($this->foreignResource),
]);
}
public function run () {
// polute EG(regular_list) with another resource of our own
$localThreadFP = tmpfile();
var_dump(array(
'Foreign resource conversion test:',
// test conversion followed by destruction
// the resource shall be added and removed from
// PTHREADS_ZG(resources) and EG(regular_list) by the following
// statement:
is_resource($this->foreignResource),
// now make the resource permanently available locally to tasks by
// storing it in a variable. It will stay in PTHREADS_ZG(resources)
// and EG(regular_list) until the worker is shutdown):
is_resource($foreignResource = $this->foreignResource),
// test that we still get the correct resource when it's already in
// EG(regular_list)
$foreignResource === $this->foreignResource
));
fclose($localThreadFP);
}
}
class Work extends Collectable {
public function run () {
$foreignResource = $this->worker->foreignResource;
var_dump(array(
'Foreign resource is accessible from task:',
is_resource($foreignResource),
$foreignResource === $this->worker->foreignResource,
'wrote ' . fwrite($foreignResource, '42') . ' bytes',
));
}
}
$fp = tmpfile();
$task = new Work();
$worker = new myWorker($fp);
$worker->start();
$worker->stack($task);
var_dump(array(
'Our worker is shutdown:',
$worker->shutdown(),
));
var_dump(array(
'Our resource is still valid:',
is_resource($fp) && rewind($fp),
fread($fp, 2) === "42",
));
var_dump(array(
'Our resource can be closed:',
fclose($fp),
));
var_dump(array(
'Our resource is closed:',
!is_resource($fp),
));
?>
--EXPECT--
array(3) {
[0]=>
string(29) "Resource received and stored:"
[1]=>
bool(true)
[2]=>
bool(true)
}
array(4) {
[0]=>
string(33) "Foreign resource conversion test:"
[1]=>
bool(true)
[2]=>
bool(true)
[3]=>
bool(true)
}
array(4) {
[0]=>
string(41) "Foreign resource is accessible from task:"
[1]=>
bool(true)
[2]=>
bool(true)
[3]=>
string(13) "wrote 2 bytes"
}
array(2) {
[0]=>
string(23) "Our worker is shutdown:"
[1]=>
bool(true)
}
array(3) {
[0]=>
string(28) "Our resource is still valid:"
[1]=>
bool(true)
[2]=>
bool(true)
}
array(2) {
[0]=>
string(27) "Our resource can be closed:"
[1]=>
bool(true)
}
array(2) {
[0]=>
string(23) "Our resource is closed:"
[1]=>
bool(true)
}
pthreads-3.0.2/tests/return-types.phpt 0000664 0001750 0001750 00000000535 12575220121 014770 0 ustar --TEST--
Test return types
--DESCRIPTION--
This test verifies that functions with a typed return are copied and execute properly
--FILE--
start();
$thread->join();
--EXPECT--
string(4) "some"
pthreads-3.0.2/tests/runtime-inheritance.phpt 0000664 0001750 0001750 00000000616 12575220121 016261 0 ustar --TEST--
Test runtime extension
--DESCRIPTION--
This test verifies functionality of runtime extension
--FILE--
--EXPECT--
bool(true)
bool(true)
pthreads-3.0.2/tests/selective-inheritance.phpt 0000664 0001750 0001750 00000001525 12575220121 016561 0 ustar --TEST--
Test selective inheritance
--DESCRIPTION--
This test verifies the functionality of selective inheritance
--FILE--
start();
$thread->join();
unset($thread);
$thread = new TestThread();
$thread->start(PTHREADS_INHERIT_NONE);
$thread->join();
unset($thread);
$thread = new TestThread();
$thread->start(PTHREADS_INHERIT_FUNCTIONS | PTHREADS_INHERIT_CLASSES);
$thread->join();
unset($thread);
?>
--EXPECT--
bool(true)
bool(true)
bool(true)
bool(false)
bool(false)
bool(false)
bool(true)
bool(false)
bool(true)
pthreads-3.0.2/tests/shift-pop.phpt 0000664 0001750 0001750 00000006662 12575220121 014227 0 ustar --TEST--
Test shift and pop
--DESCRIPTION--
This test verifies that shift and pop functionality are working
--FILE--
shift());
var_dump($s);
$s[] = "next";
var_dump($s);
var_dump($s->pop());
var_dump($s);
while (@$i++<100)
$s[$i]=$i;
var_dump($s);
while (($next = $s->pop())) {
var_dump($next);
}
?>
--EXPECT--
object(S)#1 (1) {
["0"]=>
string(4) "help"
}
string(4) "help"
object(S)#1 (0) {
}
object(S)#1 (1) {
["1"]=>
string(4) "next"
}
string(4) "next"
object(S)#1 (0) {
}
object(S)#1 (100) {
["1"]=>
int(1)
["2"]=>
int(2)
["3"]=>
int(3)
["4"]=>
int(4)
["5"]=>
int(5)
["6"]=>
int(6)
["7"]=>
int(7)
["8"]=>
int(8)
["9"]=>
int(9)
["10"]=>
int(10)
["11"]=>
int(11)
["12"]=>
int(12)
["13"]=>
int(13)
["14"]=>
int(14)
["15"]=>
int(15)
["16"]=>
int(16)
["17"]=>
int(17)
["18"]=>
int(18)
["19"]=>
int(19)
["20"]=>
int(20)
["21"]=>
int(21)
["22"]=>
int(22)
["23"]=>
int(23)
["24"]=>
int(24)
["25"]=>
int(25)
["26"]=>
int(26)
["27"]=>
int(27)
["28"]=>
int(28)
["29"]=>
int(29)
["30"]=>
int(30)
["31"]=>
int(31)
["32"]=>
int(32)
["33"]=>
int(33)
["34"]=>
int(34)
["35"]=>
int(35)
["36"]=>
int(36)
["37"]=>
int(37)
["38"]=>
int(38)
["39"]=>
int(39)
["40"]=>
int(40)
["41"]=>
int(41)
["42"]=>
int(42)
["43"]=>
int(43)
["44"]=>
int(44)
["45"]=>
int(45)
["46"]=>
int(46)
["47"]=>
int(47)
["48"]=>
int(48)
["49"]=>
int(49)
["50"]=>
int(50)
["51"]=>
int(51)
["52"]=>
int(52)
["53"]=>
int(53)
["54"]=>
int(54)
["55"]=>
int(55)
["56"]=>
int(56)
["57"]=>
int(57)
["58"]=>
int(58)
["59"]=>
int(59)
["60"]=>
int(60)
["61"]=>
int(61)
["62"]=>
int(62)
["63"]=>
int(63)
["64"]=>
int(64)
["65"]=>
int(65)
["66"]=>
int(66)
["67"]=>
int(67)
["68"]=>
int(68)
["69"]=>
int(69)
["70"]=>
int(70)
["71"]=>
int(71)
["72"]=>
int(72)
["73"]=>
int(73)
["74"]=>
int(74)
["75"]=>
int(75)
["76"]=>
int(76)
["77"]=>
int(77)
["78"]=>
int(78)
["79"]=>
int(79)
["80"]=>
int(80)
["81"]=>
int(81)
["82"]=>
int(82)
["83"]=>
int(83)
["84"]=>
int(84)
["85"]=>
int(85)
["86"]=>
int(86)
["87"]=>
int(87)
["88"]=>
int(88)
["89"]=>
int(89)
["90"]=>
int(90)
["91"]=>
int(91)
["92"]=>
int(92)
["93"]=>
int(93)
["94"]=>
int(94)
["95"]=>
int(95)
["96"]=>
int(96)
["97"]=>
int(97)
["98"]=>
int(98)
["99"]=>
int(99)
["100"]=>
int(100)
}
int(100)
int(99)
int(98)
int(97)
int(96)
int(95)
int(94)
int(93)
int(92)
int(91)
int(90)
int(89)
int(88)
int(87)
int(86)
int(85)
int(84)
int(83)
int(82)
int(81)
int(80)
int(79)
int(78)
int(77)
int(76)
int(75)
int(74)
int(73)
int(72)
int(71)
int(70)
int(69)
int(68)
int(67)
int(66)
int(65)
int(64)
int(63)
int(62)
int(61)
int(60)
int(59)
int(58)
int(57)
int(56)
int(55)
int(54)
int(53)
int(52)
int(51)
int(50)
int(49)
int(48)
int(47)
int(46)
int(45)
int(44)
int(43)
int(42)
int(41)
int(40)
int(39)
int(38)
int(37)
int(36)
int(35)
int(34)
int(33)
int(32)
int(31)
int(30)
int(29)
int(28)
int(27)
int(26)
int(25)
int(24)
int(23)
int(22)
int(21)
int(20)
int(19)
int(18)
int(17)
int(16)
int(15)
int(14)
int(13)
int(12)
int(11)
int(10)
int(9)
int(8)
int(7)
int(6)
int(5)
int(4)
int(3)
int(2)
int(1)
pthreads-3.0.2/tests/shutdown-handler.phpt 0000664 0001750 0001750 00000000626 12575220121 015576 0 ustar --TEST--
Test shutdown handlers #204
--DESCRIPTION--
Shutdown handlers that were closures were causing segfaults
--FILE--
start();
?>
--EXPECTF--
object(stdClass)#%d (0) {
}
pthreads-3.0.2/tests/stateful-fatalities.phpt 0000664 0001750 0001750 00000000746 12575220121 016265 0 ustar --TEST--
Test stateful fatalities
--DESCRIPTION--
This test verifies that state includes fatalities
--FILE--
start();
$test->join();
var_dump($test->isTerminated());
?>
--EXPECTF--
Fatal error: Uncaught Error: Call to undefined function i_do_not_exist() in %s:4
Stack trace:
#0 [internal function]: TestThread->run()
#1 {main}
thrown in %s on line 4
bool(true)
pthreads-3.0.2/tests/static-resolution.phpt 0000664 0001750 0001750 00000000775 12575220121 016005 0 ustar --TEST--
Test static:: regression
--DESCRIPTION--
Bug #210 shows static:: requires different logic to self::
--FILE--
start();
?>
--EXPECT--
int(123)
int(123)
int(123)
int(123)
pthreads-3.0.2/tests/staticmethods.phpt 0000664 0001750 0001750 00000001001 12575220121 015147 0 ustar --TEST--
Test access to static methods from within user threads
--DESCRIPTION--
Static methods as declared in the users implementation of Thread should now be available for calling in the thread scope
--FILE--
result = self::staticTest();
}
}
$thread = new ThreadTest();
if($thread->start())
if ($thread->join())
var_dump($thread->result);
?>
--EXPECT--
int(1) pthreads-3.0.2/tests/statics-thorn-in-other-side.phpt 0000664 0001750 0001750 00000001766 12575220121 017565 0 ustar --TEST--
Test statics aren't getting fucked with when starting new threads (many bugs)
--FILE--
start();
echo "AFTER\n";
var_dump(StaticClass::$list, StaticClass::$test, StaticClass::$testObject);
echo "\n";
--EXPECTF--
BEFORE:
array(2) {
[0]=>
object(StaticClass)#1 (0) {
}
[1]=>
object(StaticClass)#2 (0) {
}
}
string(11) "randomvalue"
object(StaticClass)#2 (0) {
}
AFTER
array(2) {
[0]=>
object(StaticClass)#1 (0) {
}
[1]=>
object(StaticClass)#2 (0) {
}
}
string(11) "randomvalue"
object(StaticClass)#2 (0) {
}
pthreads-3.0.2/tests/statics.phpt 0000664 0001750 0001750 00000000641 12575220121 013757 0 ustar --TEST--
Test statics (bug 19)
--DESCRIPTION--
This test verifies that static members in declarations made outside of threads are available inside threads without error
--FILE--
start();
?>
--EXPECT--
string(15) "pthreads rocks!"
pthreads-3.0.2/tests/synchronization.phpt 0000664 0001750 0001750 00000001033 12575220121 015542 0 ustar --TEST--
Test synchronized blocks
--DESCRIPTION--
This test verifies that syncronization is working
--FILE--
synchronized(function($thread){
$thread->data = true;
$thread->notify();
}, $this);
}
}
$t = new T;
$t->start();
$t->synchronized(function($thread){
if (!$thread->data) {
var_dump($thread->wait());
} else var_dump($thread->data);
}, $t);
?>
--EXPECT--
bool(true)
pthreads-3.0.2/tests/thorn-in-side.phpt 0000664 0001750 0001750 00000000761 12575220121 014770 0 ustar --TEST--
Testing thorn in my side hasn't returned
--DESCRIPTION--
This test verifies my nemisis has not returned (bug #48)
--FILE--
var;
}
}
class childClass extends parentClass {
}
class clientThread extends Thread {
public function run() {
$objChild = new childClass();
}
}
$objClientThread = new clientThread();
$objClientThread->start();
--EXPECT--
pthreads-3.0.2/tests/thread.phpt 0000664 0001750 0001750 00000000470 12575220121 013554 0 ustar --TEST--
Test basic threading
--DESCRIPTION--
This test will create and join a simple thread
--FILE--
start())
var_dump($thread->join());
?>
--EXPECT--
bool(true)
pthreads-3.0.2/tests/threaded-extend-abstract.phpt 0000664 0001750 0001750 00000000271 12575220121 017152 0 ustar --TEST--
Test extending abstract
--DESCRIPTION--
This is regression test for #409
--FILE--
--EXPECT--
bool(true)
pthreads-3.0.2/tests/trait-aliases.phpt 0000664 0001750 0001750 00000001013 12575220121 015041 0 ustar --TEST--
Test trait aliases
--SKIPIF--
--DESCRIPTION--
Fix bug #274, trait aliases causing memory errors
--FILE--
fromTrait('blah');
}
}
$t = new myThread();
$t->start();
$t->join();
--EXPECT--
string(9) "fromTrait"
pthreads-3.0.2/tests/traits-scope.inc 0000664 0001750 0001750 00000000174 12575220121 014521 0 ustar getSomething(true);
printf("OK\n");
}
}
pthreads-3.0.2/tests/traits-scope.phpt 0000664 0001750 0001750 00000000671 12575220121 014725 0 ustar --TEST--
Test traits scope (gh issue #484)
--FILE--
getSomething();
}
}
trait MyTrait {
protected function getSomething($test = false) {
if (!$test) {
require_once 'traits-scope.inc';
return (new \MyClass())->doSomething();
}
}
}
$pool = new \Pool(1, \Worker::class);
$pool->submit(new MyWork());
$pool->shutdown();
--EXPECT--
OK
pthreads-3.0.2/tests/unset-defaults.phpt 0000664 0001750 0001750 00000000566 12575220121 015256 0 ustar --TEST--
Test unset defaults [moot: default values are ignored]
--DESCRIPTION--
This test verifies that unset members do not cause a problem in pthreads objects
--FILE--
default);
}
}
$thread = new TestThread();
$thread->start();
?>
--EXPECT--
NULL
pthreads-3.0.2/tests/volatile-objects.phpt 0000664 0001750 0001750 00000003333 12575220121 015554 0 ustar --TEST--
Test Volatile objects
--DESCRIPTION--
Threaded members of Threaded objects are immutable, for the sake of performance and ease of use.
Volatile objects' members are excempt from immutability, but can still be an immutable property.
This test both demonstrates and tests volatility and immutability.
--FILE--
thing = $thing; # fine, not threaded anyway ...
}
public function setThreaded() {
$this->threaded = new Threaded(); # fine, volatile, threaded without refs, still works
$this->threaded->merge($this->thing); # fine, but expensive
}
public function condition() {
return true;
}
}
class Test extends Thread {
public function __construct(Member $member) {
$this->member = $member; # immutable, Volatile is still Threaded and this is a normal
# Threaded object (Thread extends Threaded)
}
public function run() {
$members = [];
if ($this->member->condition()) { # calls to Volatile object methods still fast for this object
$this->member
->method([1,2,3,4,5]);
var_dump($this->member->thing); # fine will display ^Threaded
$this->member->setThreaded(); # fine not immutable because volatile
$this->member = new Threaded(); # not fine, immutable
}
}
}
$member = new Member();
$test = new Test($member);
$test->start();
$test->join();
?>
--EXPECTF--
array(5) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
}
Fatal error: Uncaught RuntimeException: Threaded members previously set to Threaded objects are immutable, cannot overwrite member in %s:33
Stack trace:
#0 [internal function]: Test->run()
#1 {main}
thrown in %s on line 33
pthreads-3.0.2/tests/wait.phpt 0000664 0001750 0001750 00000001173 12575220121 013252 0 ustar --TEST--
Test wait/notify
--DESCRIPTION--
This test will verify wait/notify functionality
--FILE--
sent = false;
}
public function run(){
$this->synchronized(function($self){
$self->sent = true;
$self->notify();
}, $this);
}
}
$thread = new ThreadTest();
if($thread->start()) {
$thread->synchronized(function($me){
if (!$me->sent) {
var_dump($me->wait());
} else var_dump($me->sent);
}, $thread);
} else printf("bool(false)\n");
?>
--EXPECT--
bool(true)
pthreads-3.0.2/tests/waiting-timeouts.phpt 0000664 0001750 0001750 00000001771 12575220121 015623 0 ustar --TEST--
Test waiting timeouts
--DESCRIPTION--
This test verifies that reaching a timeout returns the correct value
Note that this is a dodgy test, ONLY EVER WAIT FOR SOMETHING
We assume, wrongly, that the thread will be active and waiting within 3
seconds.
--SKIPIF--
--FILE--
synchronized(function() use($start) {
while (time() - $start < 3) {
$this->wait(100000);
}
});
}
}
$t = new T;
$t->start();
$t->synchronized(function($thread){
var_dump($thread->wait(100)); # should return false because no notification sent
# but may wake up (and return true) because notification might come from
# somewhere else in the system and there is no precondition
# we are testing for faults rather than output here ...
}, $t);
?>
--EXPECTF--
bool(%s)
pthreads-3.0.2/tests/workers-no-collect.phpt 0000664 0001750 0001750 00000001262 12575220121 016036 0 ustar --TEST--
Test pthreads workers rules (collect)
--DESCRIPTION--
This test verifies that workers cannot be misused (collect)
--FILE--
worker = $worker;
}
public function run() {
$this->worker->collect(function($t){
return $t->isGarbage();
});
}
}
$worker = new Worker();
$worker->start();
$test = new Test($worker);
$test->start();
$test->join();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: only the creator of this Worker may call collect in %s:10
Stack trace:
#0 %s(10): Worker->collect(Object(Closure))
#1 [internal function]: Test->run()
#2 {main}
thrown in %s on line 10
pthreads-3.0.2/tests/workers-no-join.phpt 0000664 0001750 0001750 00000001162 12575220121 015347 0 ustar --TEST--
Test pthreads workers rules (join)
--DESCRIPTION--
This test verifies that workers cannot be misused (join)
--FILE--
worker = $worker;
}
public function run() {
$this->worker->shutdown();
}
}
$worker = new Worker();
$worker->start();
$test = new Test($worker);
$test->start();
$test->join();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: only the creator of this Worker may join with it in %s:8
Stack trace:
#0 %s(8): Worker->shutdown()
#1 [internal function]: Test->run()
#2 {main}
thrown in %s on line 8
pthreads-3.0.2/tests/workers-no-stack.phpt 0000664 0001750 0001750 00000001241 12575220121 015513 0 ustar --TEST--
Test pthreads workers rules (stack)
--DESCRIPTION--
This test verifies that workers cannot be misused (stack)
--FILE--
worker = $worker;
}
public function run() {
$c = new Collectable();
$this->worker
->stack($c);
}
}
$worker = new Worker();
$worker->start();
$test = new Test($worker);
$test->start();
$test->join();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: only the creator of this Worker may call stack in %s:10
Stack trace:
#0 %s(10): Worker->stack(Object(Collectable))
#1 [internal function]: Test->run()
#2 {main}
thrown in %s on line 10
pthreads-3.0.2/tests/workers-no-start.phpt 0000664 0001750 0001750 00000001130 12575220121 015540 0 ustar --TEST--
Test pthreads workers rules (start)
--DESCRIPTION--
This test verifies that workers cannot be misused (start)
--FILE--
worker = $worker;
}
public function run() {
$this->worker->start();
}
}
$worker = new Worker();
$test = new Test($worker);
$test->start();
$test->join();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: only the creator of this Worker may start it in %s:8
Stack trace:
#0 %s(8): Thread->start()
#1 [internal function]: Test->run()
#2 {main}
thrown in %s on line 8
pthreads-3.0.2/tests/workers-no-unstack.phpt 0000664 0001750 0001750 00000001167 12575220121 016065 0 ustar --TEST--
Test pthreads workers rules (unstack)
--DESCRIPTION--
This test verifies that workers cannot be misused (unstack)
--FILE--
worker = $worker;
}
public function run() {
$this->worker->unstack();
}
}
$worker = new Worker();
$worker->start();
$test = new Test($worker);
$test->start();
$test->join();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: only the creator of this Worker may call unstack in %s:8
Stack trace:
#0 %s(8): Worker->unstack()
#1 [internal function]: Test->run()
#2 {main}
thrown in %s on line 8
pthreads-3.0.2/tests/workers-ok-unstack.phpt 0000664 0001750 0001750 00000000547 12575220121 016063 0 ustar --TEST--
Test pthreads Worker::unstack
--DESCRIPTION--
This test verifies that unstack functions as intended
--FILE--
stack(new class extends Collectable {
public function run() {
var_dump($this);
}
});
var_dump($worker->unstack());
?>
--EXPECTF--
object(class@anonymous)#%d (1) {
["garbage"]=>
bool(false)
}
pthreads-3.0.2/src/copy.h 0000664 0001750 0001750 00000020414 12575220121 012160 0 ustar /*
+----------------------------------------------------------------------+
| pthreads |
+----------------------------------------------------------------------+
| Copyright (c) Joe Watkins 2012 - 2015 |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Joe Watkins