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.1.6/examples/MySQLi.php 0000664 0001750 0001750 00000004346 12657554542 013750 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.1.6/examples/ObjectsAsParameters.php 0000664 0001750 0001750 00000006103 12657554542 016524 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.1.6/examples/Pooling.php 0000664 0001750 0001750 00000006303 12657554542 014234 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 Threaded { /* * An example of some work that depends upon a shared logger * and a thread-local PDO connection */ public function run() { $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()); } } } 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){ if (is_callable($message)) { $message(...$args); } else echo vsprintf("{$message}\n", ... $args); }, $message, $args); } } $logger = new SafeLog(); /* * Constructing the Pool does not create any Threads */ $pool = new Pool(8, 'WebWorker', [$logger, ["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 */ $logger->log(function($pool) { var_dump($pool); }, $pool); /* * Shutdown Pools at the appropriate time, don't leave it to chance ! */ $pool->shutdown(); ?> pthreads-3.1.6/examples/SelectiveInheritance.php 0000664 0001750 0001750 00000003465 12657554542 016730 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.1.6/examples/SharingResources.php 0000664 0001750 0001750 00000005370 12657554542 016116 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.1.6/examples/SimpleWebRequest.php 0000664 0001750 0001750 00000001732 12657554542 016066 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.1.6/examples/Singleton.php 0000664 0001750 0001750 00000002765 12657554542 014577 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 Threaded { public function run() { var_dump($this->worker->getConnection()); } }); } $pool->shutdown(); ?> pthreads-3.1.6/examples/SocketServer.php 0000664 0001750 0001750 00000005464 12657554542 015253 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.1.6/examples/Sockets.php 0000664 0001750 0001750 00000001312 12657554542 014233 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.1.6/examples/StackableArray.php 0000664 0001750 0001750 00000004265 12657554542 015522 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.1.6/examples/Synchronization.php 0000664 0001750 0001750 00000001330 12657554542 016021 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.1.6/examples/stub.php 0000664 0001750 0001750 00000046031 12657554542 013604 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, Collectable
{
/**
* 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 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
*
* Garbage Collection interface for references to objects on Worker stacks
*
* @link http://www.php.net/manual/en/class.collectable.php
*/
interface Collectable
{
/**
* Determine whether an object is ready to be destroyed
*
* @return bool Whether the referenced object can be destroyed
*/
public function isGarbage() : bool;
}
pthreads-3.1.6/tests/anon-bound-inherited.phpt 0000664 0001750 0001750 00000000603 12657554542 016343 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.1.6/tests/anon-unbound-inherited.phpt 0000664 0001750 0001750 00000000614 12657554542 016710 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 Threaded {
public function run() {
var_dump($this instanceof Collectable);
}
};
$worker->stack($collectable);
$worker->shutdown();
--EXPECT--
bool(true)
pthreads-3.1.6/tests/binding.phpt 0000664 0001750 0001750 00000002162 12657554542 013746 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.1.6/tests/callstatic-etc.phpt 0000664 0001750 0001750 00000000756 12657554542 015237 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.1.6/tests/chunk.phpt 0000664 0001750 0001750 00000000734 12657554542 013447 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.1.6/tests/class-defaults.phpt 0000664 0001750 0001750 00000001454 12657554542 015251 0 ustar --TEST--
Test class defaults
--DESCRIPTION--
Class defaults should now initialize defaults properly
--FILE--
string = strrev($test->string);
$test->start();
$test->join();
?>
--EXPECTF--
object(Test)#%d (%d) {
["string"]=>
string(11) "dlrow olleh"
["array"]=>
object(Volatile)#%d (%d) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
["pstring"]=>
string(11) "world hello"
["parray"]=>
object(Volatile)#%d (%d) {
[0]=>
int(3)
[1]=>
int(2)
[2]=>
int(1)
}
}
pthreads-3.1.6/tests/closures-as-members.phpt 0000664 0001750 0001750 00000002525 12657554542 016227 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.1.6/tests/complex-statics-set-null.phpt 0000664 0001750 0001750 00000002331 12657554542 017212 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.1.6/tests/complex-statics.phpt 0000664 0001750 0001750 00000002261 12657554542 015453 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.1.6/tests/constant-ast-copy.phpt 0000664 0001750 0001750 00000001143 12657554542 015720 0 ustar --TEST--
Test constant AST copy bug #495
--DESCRIPTION--
AST in op array literals caused corrupted heaps because it wasn't copied properly.
--FILE--
start() && $t->join();
?>
--EXPECTF--
Fatal error: Uncaught Exception in %s:12
Stack trace:
#0 [internal function]: class@anonymous->run()
#1 {main}
thrown in %s on line 12
pthreads-3.1.6/tests/constants.phpt 0000664 0001750 0001750 00000000571 12657554542 014352 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.1.6/tests/corrupted-resources.phpt 0000664 0001750 0001750 00000001251 12657554542 016351 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.1.6/tests/counting-members.phpt 0000664 0001750 0001750 00000000435 12657554542 015613 0 ustar --TEST--
Testing member count
--DESCRIPTION--
This test verifies that getting member counts works
--FILE--
--EXPECT--
int(3)
pthreads-3.1.6/tests/crazy-refcounting-stuff.phpt 0000664 0001750 0001750 00000002316 12657554542 017133 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.1.6/tests/doc-comments.phpt 0000664 0001750 0001750 00000002204 12657554542 014721 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.1.6/tests/exception-handler-caught-nested.phpt 0000664 0001750 0001750 00000002603 12657554542 020476 0 ustar --TEST--
Test exception handler (nested caught) bug #498
--DESCRIPTION--
More mishandling of exceptions, regression test
--FILE--
start();
$test->join();
--EXPECTF--
string(6) "Caught"
object(Exception)#3 (7) {
["message":protected]=>
string(0) ""
["string":"Exception":private]=>
string(0) ""
["code":protected]=>
int(0)
["file":protected]=>
string(%d) "%s"
["line":protected]=>
int(16)
["trace":"Exception":private]=>
array(2) {
[0]=>
array(6) {
["file"]=>
string(%d) "%s"
["line"]=>
int(9)
["function"]=>
string(19) "processClassMethods"
["class"]=>
string(4) "Test"
["type"]=>
string(2) "::"
["args"]=>
array(0) {
}
}
[1]=>
array(4) {
["function"]=>
string(3) "run"
["class"]=>
string(4) "Test"
["type"]=>
string(2) "->"
["args"]=>
array(0) {
}
}
}
["previous":"Exception":private]=>
NULL
}
pthreads-3.1.6/tests/exception-handler-caught-uncaught.phpt 0000664 0001750 0001750 00000003045 12657554542 021033 0 ustar --TEST--
Test exception handler (caught and uncaught) bug #493
--DESCRIPTION--
Mishandling of exceptions caused catch() blocks to be ignored in some cases
--FILE--
start();
$test->join();
--EXPECTF--
string(6) "Caught"
object(Exception)#%d (%d) {
["message":protected]=>
string(0) ""
["string":"Exception":private]=>
string(0) ""
["code":protected]=>
int(0)
["file":protected]=>
string(%d) "%s"
["line":protected]=>
int(10)
["trace":"Exception":private]=>
array(1) {
[0]=>
array(4) {
["function"]=>
string(3) "run"
["class"]=>
string(4) "Test"
["type"]=>
string(2) "->"
["args"]=>
array(0) {
}
}
}
["previous":"Exception":private]=>
NULL
}
string(8) "Uncaught"
object(Exception)#%d (%d) {
["message":protected]=>
string(0) ""
["string":"Exception":private]=>
string(0) ""
["code":protected]=>
int(0)
["file":protected]=>
string(%d) "%s"
["line":protected]=>
int(15)
["trace":"Exception":private]=>
array(1) {
[0]=>
array(4) {
["function"]=>
string(3) "run"
["class"]=>
string(4) "Test"
["type"]=>
string(2) "->"
["args"]=>
array(0) {
}
}
}
["previous":"Exception":private]=>
NULL
}
pthreads-3.1.6/tests/exception-handler-fail.phpt 0000664 0001750 0001750 00000001352 12657554542 016656 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.1.6/tests/exception-handler-options.phpt 0000664 0001750 0001750 00000002251 12657554542 017435 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.1.6/tests/exception-handler.phpt 0000664 0001750 0001750 00000002642 12657554542 015750 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.1.6/tests/explicit-cast-arrays.phpt 0000664 0001750 0001750 00000001533 12657554542 016405 0 ustar --TEST--
Test Explicit Cast
--DESCRIPTION--
Normally, arrays are cast to Volatile objects when set as a member of a Threaded object.
Casting the array as you are setting will override this behaviour, this is useful when passing an array out of a thread.
For an example of that, see examples/ClosureFuture.php
--FILE--
member = (array) [
"hello",
"world"
];
var_dump($threaded);
$threaded->member = new Threaded;
$threaded->member[0] = (array) [
"hello",
"world"
];
var_dump($threaded);
?>
--EXPECTF--
object(Threaded)#%d (%d) {
["member"]=>
array(2) {
[0]=>
string(5) "hello"
[1]=>
string(5) "world"
}
}
object(Threaded)#%d (%d) {
["member"]=>
object(Threaded)#%d (%d) {
[0]=>
array(2) {
[0]=>
string(5) "hello"
[1]=>
string(5) "world"
}
}
}
pthreads-3.1.6/tests/foreign-private-members.phpt 0000664 0001750 0001750 00000001110 12657554542 017055 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.1.6/tests/functions.phpt 0000664 0001750 0001750 00000000613 12657554542 014343 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.1.6/tests/global-constants.phpt 0000664 0001750 0001750 00000001302 12657554542 015601 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.1.6/tests/gone.phpt 0000664 0001750 0001750 00000001147 12657554542 013266 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.1.6/tests/graceful-fatalities.phpt 0000664 0001750 0001750 00000001024 12657554542 016243 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.1.6/tests/hacking-serials.phpt 0000664 0001750 0001750 00000002374 12657554542 015405 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);
}
public function shutdown() {
$this->worker->shutdown();
}
}
class Work extends Threaded {
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();
$wrapper->shutdown();
--EXPECT--
Foo
pthreads-3.1.6/tests/immutable-threaded-members.phpt 0000664 0001750 0001750 00000004434 12657554542 017525 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.1.6/tests/included-files.phpt 0000664 0001750 0001750 00000000747 12657554542 015232 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.1.6/tests/includeme.inc 0000664 0001750 0001750 00000000036 12657554542 014075 0 ustar synchronized(function(){
echo "OK\n";
});
}
}
$test = new Test();
$test->start(PTHREADS_INHERIT_NONE);
$test->join();
--EXPECT--
OK
pthreads-3.1.6/tests/ini.phpt 0000664 0001750 0001750 00000000656 12657554542 013121 0 ustar --TEST--
Test INI inheritance (bug 20)
--DESCRIPTION--
This test will ensure that INI directives are inherited and or created upon initialization of new threads
--FILE--
start();
?>
--EXPECT--
Test::run: :/var/lib/other
pthreads-3.1.6/tests/interface.phpt 0000664 0001750 0001750 00000001113 12657554542 014267 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.1.6/tests/interfaces.phpt 0000664 0001750 0001750 00000001141 12657554542 014453 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.1.6/tests/isset-empty-compat.phpt 0000664 0001750 0001750 00000002366 12657554542 016106 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.1.6/tests/isset-unset.phpt 0000664 0001750 0001750 00000001670 12657554542 014622 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.1.6/tests/iterator-funcs.phpt 0000664 0001750 0001750 00000002412 12657554542 015277 0 ustar --TEST--
Testing iterator functions
--DESCRIPTION--
Iterator functions were not properly copied, causing unexpected results and unsafe execution.
--FILE--
items = array("joe", "bob", "fred");
$this->position = 0;
}
public function next() {
++$this->position;
}
public function key() {
return $this->position;
}
public function current() {
return $this->items[$this->position];
}
public function valid() {
return ($this->position < count($this->items));
}
public function rewind() {
$this->myProtectedMethod();
$this->position = 0;
}
protected function myProtectedMethod() {}
}
class MyThread extends \Thread {
public function run() {
$it = new \MyIterator();
foreach ($it as $item) {}
print "SUCCESS";
}
}
$items = new \MyIterator();
foreach ($items as $item) {}
$thread = new \MyThread();
$thread->start();
$thread->join();
--EXPECT--
SUCCESS
pthreads-3.1.6/tests/iterator-no-refs.phpt 0000664 0001750 0001750 00000000661 12657554542 015536 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.1.6/tests/legacy-ctor.phpt 0000664 0001750 0001750 00000001045 12657554542 014544 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.1.6/tests/lexical-vars.phpt 0000664 0001750 0001750 00000002552 12657554542 014731 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.1.6/tests/magic-methods-get-set.phpt 0000664 0001750 0001750 00000001043 12657554542 016420 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.1.6/tests/magic-methods-isset-unset.phpt 0000664 0001750 0001750 00000001147 12657554542 017340 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.1.6/tests/merge-non-threaded.phpt 0000664 0001750 0001750 00000001336 12657554542 016003 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 (%d) {
[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.1.6/tests/merging-members.phpt 0000664 0001750 0001750 00000001435 12657554542 015416 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.1.6/tests/merging-range.phpt 0000664 0001750 0001750 00000000467 12657554542 015064 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.1.6/tests/no-cloning.phpt 0000664 0001750 0001750 00000000506 12657554542 014377 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.1.6/tests/norefs.phpt 0000664 0001750 0001750 00000002143 12657554542 013627 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.1.6/tests/normal-reads.phpt 0000664 0001750 0001750 00000000654 12657554542 014724 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.1.6/tests/normalize-members.phpt 0000664 0001750 0001750 00000000545 12657554542 015767 0 ustar --TEST--
Testing normalizing members
--DESCRIPTION--
This tests that normalizing members works without effort
--FILE--
--EXPECT--
bool(true)
pthreads-3.1.6/tests/null-member-crash.phpt 0000664 0001750 0001750 00000000455 12657554542 015654 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.1.6/tests/object-cast.phpt 0000664 0001750 0001750 00000002070 12657554542 014530 0 ustar --TEST--
Test object cast
--DESCRIPTION--
If you pass two Thread objects (A,B) to a Thread, and set as B as a member of A, or vice versa
this will raise an exception when you try to access the member in the context that created A and B
if the Thread has been destroyed.
This is because A and B inside the Thread are objects that represent the original objects but are not physically
the same.
Explicitly casting Threaded to object upon access ensures you are referencing the original object.
This could be dangerous if misused ... please don't misuse it ...
--FILE--
thing = $thing;
$this->member = $member;
}
public function run() {
$this->thing->member =
(object) $this->member;
}
private $thing;
private $member;
}
$thing = new Threaded();
$member = new Threaded();
$test = new Test($thing, $member);
$test->start() && $test->join();
var_dump($thing);
?>
--EXPECT--
object(Threaded)#1 (1) {
["member"]=>
object(Threaded)#2 (0) {
}
}
pthreads-3.1.6/tests/object-comparison.phpt 0000664 0001750 0001750 00000002270 12657554542 015752 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.1.6/tests/oomethods.phpt 0000664 0001750 0001750 00000000712 12657554542 014334 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.1.6/tests/pools-default.phpt 0000664 0001750 0001750 00000001166 12657554542 015115 0 ustar --TEST--
Test pool defaults
--DESCRIPTION--
This test verifies pool defaults
--FILE--
submit(new Work());
$pool->shutdown();
$pool->collect(function(Collectable $work) {
return $work->isGarbage();
});
var_dump($pool);
?>
--EXPECTF--
object(Work)#%d (%d) {
["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.1.6/tests/pools.phpt 0000664 0001750 0001750 00000002752 12657554542 013475 0 ustar --TEST--
Test pooling
--DESCRIPTION--
This test verifies the functionality of selective inheritance
--FILE--
logger = $logger;
}
protected $loger;
}
class WebWork extends Threaded {
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.1.6/tests/recv-overload.phpt 0000664 0001750 0001750 00000001352 12657554542 015104 0 ustar --TEST--
Test RECV overload
--DESCRIPTION--
When using the explicit cast of objects, type hinting can be broken.
The class in the current context doesn't match the class of the object.
pthreads overrides ZEND_RECV to fix the problem, nothing else is affected.
--FILE--
member = $member;
}
public function run() {
$this->method(
(object)$this->member);
}
public function method(Custom $member) {}
private $member;
}
class Custom extends Threaded {}
$member = new Custom();
$test = new Test($member);
$test->start() && $test->join();
var_dump($test);
?>
--EXPECT--
object(Test)#2 (1) {
["member"]=>
object(Custom)#1 (0) {
}
}
pthreads-3.1.6/tests/resource-keeping.phpt 0000664 0001750 0001750 00000006110 12657554542 015600 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 Threaded {
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.1.6/tests/return-types.phpt 0000664 0001750 0001750 00000000535 12657554542 015017 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.1.6/tests/run-time-cache-corruption.phpt 0000664 0001750 0001750 00000002222 12657554542 017334 0 ustar --TEST--
Test run time cache bug #494
--DESCRIPTION--
Runtime Caches were being incorrectly used (shared!), this caused strange behaviour for various things
--FILE--
getInterfaceNames());
var_dump($objCreated instanceof \TestInterface);
}
}
class Test extends Thread {
public function run(){
Some::staticNess();
}
}
Some::staticNess();
$test = new class extends Thread {
public function run() {
Some::staticNess();
}
};
$test->start(PTHREADS_INHERIT_NONE |
PTHREADS_INHERIT_INI |
PTHREADS_ALLOW_HEADERS |
PTHREADS_INHERIT_COMMENTS |
PTHREADS_INHERIT_INCLUDES |
PTHREADS_INHERIT_FUNCTIONS |
PTHREADS_INHERIT_CLASSES) && $test->join();
?>
--EXPECT--
array(1) {
[0]=>
string(13) "TestInterface"
}
bool(true)
array(1) {
[0]=>
string(13) "TestInterface"
}
bool(true)
pthreads-3.1.6/tests/runtime-inheritance.phpt 0000664 0001750 0001750 00000000616 12657554542 016310 0 ustar --TEST--
Test runtime extension
--DESCRIPTION--
This test verifies functionality of runtime extension
--FILE--
--EXPECT--
bool(true)
bool(true)
pthreads-3.1.6/tests/selective-inheritance.phpt 0000664 0001750 0001750 00000001525 12657554542 016610 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.1.6/tests/shift-pop.phpt 0000664 0001750 0001750 00000006345 12657554542 014254 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.1.6/tests/shutdown-handler.phpt 0000664 0001750 0001750 00000000626 12657554542 015625 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.1.6/tests/stateful-fatalities.phpt 0000664 0001750 0001750 00000000746 12657554542 016314 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.1.6/tests/static-resolution.phpt 0000664 0001750 0001750 00000000775 12657554542 016034 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.1.6/tests/static-scope-vars.phpt 0000664 0001750 0001750 00000001373 12657554542 015706 0 ustar --TEST--
Test static scope vars gh issue #501
--DESCRIPTION--
Static member reference vars were not copied appropriately
--FILE--
method();
$objThread = new class extends Thread
{
public function run()
{
$objInstance = new Test();
$objInstance->method();
}
};
$objThread->start();
$objThread->join();
--EXPECT--
string(5) "value"
int(1)
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
string(5) "value"
int(1)
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
pthreads-3.1.6/tests/staticmethods.phpt 0000664 0001750 0001750 00000001001 12657554542 015176 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.1.6/tests/statics-thorn-in-other-side.phpt 0000664 0001750 0001750 00000001766 12657554542 017614 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.1.6/tests/statics.phpt 0000664 0001750 0001750 00000000641 12657554542 014006 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.1.6/tests/synchronization.phpt 0000664 0001750 0001750 00000001033 12657554542 015571 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.1.6/tests/thorn-in-side.phpt 0000664 0001750 0001750 00000000761 12657554542 015017 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.1.6/tests/thread.phpt 0000664 0001750 0001750 00000000470 12657554542 013603 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.1.6/tests/threaded-extend-abstract.phpt 0000664 0001750 0001750 00000000271 12657554542 017201 0 ustar --TEST--
Test extending abstract
--DESCRIPTION--
This is regression test for #409
--FILE--
--EXPECT--
bool(true)
pthreads-3.1.6/tests/trait-alias-bug.phpt 0000664 0001750 0001750 00000000635 12657554542 015324 0 ustar --TEST--
Test pthreads connections
--DESCRIPTION--
This test verifies that variables are bound properly by pthreads
--FILE--
start();
$a->join();
--EXPECTF--
%d
pthreads-3.1.6/tests/trait-aliases.phpt 0000664 0001750 0001750 00000001013 12657554542 015070 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.1.6/tests/traits-scope.inc 0000664 0001750 0001750 00000000174 12657554542 014550 0 ustar getSomething(true);
printf("OK\n");
}
}
pthreads-3.1.6/tests/traits-scope.phpt 0000664 0001750 0001750 00000000666 12657554542 014760 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.1.6/tests/unset-defaults.phpt 0000664 0001750 0001750 00000000566 12657554542 015305 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.1.6/tests/verify-overload.phpt 0000664 0001750 0001750 00000001313 12657554542 015446 0 ustar --TEST--
Test VERIFY_RETURN_TYPE overload
--DESCRIPTION--
When using the explicit cast of objects, return type hinting can be broken.
The class in the current context doesn't match the class of the object.
pthreads overrides ZEND_VERIFY_RETURN_TYPE to fix the problem, nothing else is affected.
--FILE--
custom = $custom;
}
public function method() : Custom {
return (object) $this->custom;
}
public function run() {
var_dump($this->method());
}
}
$custom = new Custom();
$test = new Test($custom);
$test->start() && $test->join();
?>
--EXPECT--
object(Custom)#1 (0) {
}
pthreads-3.1.6/tests/volatile-arrays.phpt 0000664 0001750 0001750 00000003340 12657554542 015451 0 ustar --TEST--
Test Volatile Arrays
--DESCRIPTION--
Arrays were difficult to use in pthreads, their behaviour was strange and inconsistent with Zend arrays.
pthreads v3 will coerce arrays to Volatile objects when they are set as members of Threaded objects.
Threaded objects have been made consistent with PHP arrays, so there should be no noticable difference between an array
and a volatile object.
--FILE--
test = [
"greeting" => "Hello World",
"child" => [
"of" => "mine",
"grandchild" => [
"of" => "parents"
]
]
];
/*
This looks strange, but needs to be consistent with zend, so we'll test here ...
*/
$threaded["0"] = [];
$threaded[1] = [];
var_dump($threaded);
/*
This kind of thing would simply fail before, creating really unexpected results
*/
$threaded->test["child"]["of"] = "yours";
$threaded->test["child"]["grandchild"]["of"] = "devil";
var_dump($threaded);
?>
--EXPECTF--
object(Threaded)#%d (%d) {
["test"]=>
object(Volatile)#%d (%d) {
["greeting"]=>
string(11) "Hello World"
["child"]=>
object(Volatile)#%d (%d) {
["of"]=>
string(4) "mine"
["grandchild"]=>
object(Volatile)#%d (%d) {
["of"]=>
string(7) "parents"
}
}
}
[0]=>
object(Volatile)#%d (%d) {
}
[1]=>
object(Volatile)#%d (%d) {
}
}
object(Threaded)#%d (%d) {
["test"]=>
object(Volatile)#%d (%d) {
["greeting"]=>
string(11) "Hello World"
["child"]=>
object(Volatile)#%d (%d) {
["of"]=>
string(5) "yours"
["grandchild"]=>
object(Volatile)#%d (%d) {
["of"]=>
string(5) "devil"
}
}
}
[0]=>
object(Volatile)#%d (%d) {
}
[1]=>
object(Volatile)#%d (%d) {
}
}
pthreads-3.1.6/tests/volatile-objects.phpt 0000664 0001750 0001750 00000003353 12657554542 015605 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, coerced to volatile ...
}
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--
object(Volatile)#%d (%d) {
[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.1.6/tests/wait.phpt 0000664 0001750 0001750 00000001173 12657554542 013301 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.1.6/tests/waiting-timeouts.phpt 0000664 0001750 0001750 00000001771 12657554542 015652 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.1.6/tests/workers-default-collector.phpt 0000664 0001750 0001750 00000001040 12657554542 017430 0 ustar --TEST--
Test pthreads workers default collector
--DESCRIPTION--
This test verifies that the default collector works as expected
--FILE--
start();
$i = 0;
while ($i<10) {
$worker->stack(new class extends Threaded {
public function run() {
$this->g = true;
}
public function isGarbage() : bool {
return $this->g;
}
public $g = false;
});
$i++;
}
var_dump($i);
while ($worker->collect()) continue;
var_dump($worker->getStacked());
$worker->shutdown();
?>
--EXPECTF--
int(10)
int(0)
pthreads-3.1.6/tests/workers-no-collect.phpt 0000664 0001750 0001750 00000001262 12657554542 016065 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.1.6/tests/workers-no-join.phpt 0000664 0001750 0001750 00000001162 12657554542 015376 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.1.6/tests/workers-no-shutdown-before-start.phpt 0000664 0001750 0001750 00000000722 12657554542 020706 0 ustar --TEST--
Test pthreads Worker::shutdown
--DESCRIPTION--
This test verifies shutdown of a Worker (or Thread) not yet started doesn't fault
--FILE--
stack(new class extends Threaded {
public function run() {
var_dump($this);
}
});
$worker->shutdown();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: Worker has not been started in %s:10
Stack trace:
#0 %s(10): Worker->shutdown()
#1 {main}
thrown in %s on line 10
pthreads-3.1.6/tests/workers-no-stack.phpt 0000664 0001750 0001750 00000001311 12657554542 015540 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 Work();
$this->worker
->stack($c);
}
}
$worker = new Worker();
$worker->start();
$test = new Test($worker);
$test->start();
$test->join();
$worker->shutdown();
?>
--EXPECTF--
Fatal error: Uncaught RuntimeException: only the creator of this Worker may call stack in %s:%d
Stack trace:
#0 %s(%d): Worker->stack(Object(Work))
#1 [internal function]: Test->run()
#2 {main}
thrown in %s on line %d
pthreads-3.1.6/tests/workers-no-start.phpt 0000664 0001750 0001750 00000001130 12657554542 015567 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.1.6/tests/workers-no-unstack.phpt 0000664 0001750 0001750 00000001167 12657554542 016114 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.1.6/tests/workers-ok-unstack.phpt 0000664 0001750 0001750 00000000506 12657554542 016105 0 ustar --TEST--
Test pthreads Worker::unstack
--DESCRIPTION--
This test verifies that unstack functions as intended
--FILE--
stack(new class extends Threaded {
public function run() {
var_dump($this);
}
});
var_dump($worker->unstack());
?>
--EXPECTF--
object(class@anonymous)#%d (%d) {
}
pthreads-3.1.6/src/copy.h 0000664 0001750 0001750 00000021747 12657554542 012221 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