public function get_contents_read_returns_less_than_size() { $f = new File(Streams::readableFd(newinstance(MemoryInputStream::class, ['Test'], ['read' => function ($size = 4096) { return parent::read(min(1, $size)); }]))); $this->assertEquals('Test', FileUtil::getContents($f)); }
public function calls_equals_method_in_maps($value, $outcome) { $object = newinstance('lang.Object', [], ['equals' => function ($cmp) { return 'Test' === $cmp; }]); $this->assertEquals($outcome, (new IsEqual(['key' => $object]))->matches($value)); }
static function __static() { self::$UNKNOWN = newinstance(__CLASS__, [0.0, 0.0, []], '{ static function __static() { } public function toString() { return "com.maxmind.geoip.Location(UNKNOWN)"; } }'); }
/** * Sets up test case and backups Console::$err stream. * */ public function setUp() { $this->cat = (new LogCategory('default'))->withAppender((new ConsoleAppender())->withLayout(newinstance(Layout::class, [], ['format' => function (LoggingEvent $event) { return implode(' ', $event->getArguments()); }]))); $this->stream = Console::$err->getStream(); }
/** * Compile and then run sourcecode * * @param string source * @return lang.Runnable */ protected function compile($source) { $decl = ' import integrationtests.ArrayExtensions; class FixturePrimitiveExtensionMethodsIntegrationTest·%d implements Runnable { public var run() { %s } }'; $emitter = new V54Emitter(); $task = new CompilationTask(new StringSource(sprintf($decl, $this->counter++, $source), self::$syntax, $this->name), new NullDiagnosticListener(), newinstance(FileManager::class, [$this->getClass()->getClassLoader()], '{ protected $cl; public function __construct($cl) { $this->cl= $cl; } public function findClass($qualified) { return new FileSource($this->cl->getResourceAsStream("net/xp_lang/tests/integration/src/".strtr($qualified, ".", "/").".xp")); } public function write($r, File $target) { // DEBUG $r->writeTo(Console::$out->getStream()); $r->executeWith(array()); // Defines the class } }'), $emitter); $type = $task->run(); return XPClass::forName($type->name())->newInstance(); }
public function noTimeout() { $r = $this->suite->runTest(newinstance(TestCase::class, ['fixture'], ['#[@test, @limit(time= 0.010)] fixture' => function () { /* No timeout */ }])); $this->assertEquals(1, $r->successCount()); }
/** * Setup record handlers * * @see http://infocenter.sybase.com/help/topic/com.sybase.dc35823_1500/html/uconfig/uconfig111.htm * @see http://infocenter.sybase.com/help/topic/com.sybase.dc38421_1500/html/ntconfig/ntconfig80.htm * @return [:rdbms.tds.TdsRecord] handlers */ protected function setupRecords() { $records[self::T_NUMERIC] = newinstance('rdbms.tds.TdsRecord', array(), '{ public function unmarshal($stream, $field) { if (-1 === ($len= $stream->getByte()- 1)) return NULL; $pos= $stream->getByte(); $bytes= $stream->read($len); if ($i= ($len % 4)) { $bytes= str_repeat("\\0", 4 - $i).$bytes; $len+= 4 - $i; } for ($n= 0, $m= $pos ? -1 : 1, $i= $len- 4; $i >= 0; $i-= 4, $m= bcmul($m, "4294967296", 0)) { $n= bcadd($n, bcmul(sprintf("%u", current(unpack("N", substr($bytes, $i, 4)))), $m, 0), 0); } return $this->toNumber($n, $field["scale"], $field["prec"]); } }'); $records[self::T_DECIMAL] = $records[self::T_NUMERIC]; $records[self::T_BINARY] = newinstance('rdbms.tds.TdsRecord', array(), '{ public function unmarshal($stream, $field) { if (0 === ($len= $stream->getByte())) return NULL; $string= $stream->read($len); return iconv($field["conv"], "iso-8859-1", substr($string, 0, strcspn($string, "\\0"))); } }'); $records[self::T_IMAGE] = newinstance('rdbms.tds.TdsRecord', array(), '{ public function unmarshal($stream, $field) { $has= $stream->getByte(); if ($has !== 16) return NULL; // Seems to always be 16 - obsolete? $stream->read(24); // Skip 16 Byte TEXTPTR, 8 Byte TIMESTAMP $len= $stream->getLong(); if (0 === $len) return NULL; $r= $stream->read($len); // HACK - cannot figure out why UNITEXT is not being returned as such // but as IMAGE type with different inside layout! return iconv( strlen($r) > 1 && "\\0" === $r{1} ? "ucs-2le" : $field["conv"], "iso-8859-1", $r ); } }'); $records[self::T_VARBINARY] = newinstance('rdbms.tds.TdsRecord', array(), '{ public function unmarshal($stream, $field) { if (0 === ($len= $stream->getByte())) return NULL; return iconv($field["conv"], "iso-8859-1", $stream->read($len)); } }'); $records[self::T_LONGBINARY] = newinstance('rdbms.tds.TdsRecord', array(), '{ public function unmarshal($stream, $field) { $len= $stream->getLong(); return $stream->getString($len / 2); } }'); return $records; }
protected function newConnection(URL $url) { return newinstance(Connection::class, [$url], ['response' => '', 'sent' => null, 'in' => null, 'out' => null, '__construct' => function ($url) { parent::__construct($url); $this->_connect($url); // FIXME: Required for unittest }, '_connect' => function (URL $url) { $this->in = new StringReader(new MemoryInputStream($this->response)); $this->out = new StringWriter(new MemoryOutputStream()); }, '_disconnect' => function () { $this->sent = $this->out->getStream()->getBytes(); $this->in = null; $this->out = null; }, 'setResponseBytes' => function ($s) { $this->in = new StringReader(new MemoryInputStream($s)); $this->response = $s; }, 'readSentBytes' => function () { // Case of DISCONNECT if (null !== $this->sent) { $sent = $this->sent; $this->sent = null; return $sent; } return $this->out->getStream()->getBytes(); }, 'clearSentBytes' => function () { $this->_connect(new URL()); $this->sent = null; }]); }
/** @return lang.Object */ protected function hashCodeCounter() { return newinstance(Object::class, [], ['invoked' => 0, 'hashCode' => function () { $this->invoked++; return parent::hashCode(); }]); }
/** * Returns a testcase with getName() as test method * * @return unittest.TestCase */ protected function getNameCase() { return newinstance('unittest.TestCase', ['getName'], '{ #[@test] public function getName($compound= FALSE) { } }'); }
static function __static() { self::$EQUALS = newinstance(__CLASS__, array(1, 'EQUALS', '='), '{ static function __static() {} }'); self::$NOT_EQUALS = newinstance(__CLASS__, array(1, 'NOT_EQUALS', '!='), '{ static function __static() {} }'); self::$GREATER_THAN = newinstance(__CLASS__, array(1, 'GREATER_THAN', '>'), '{ static function __static() {} }'); self::$GREATER_EQUALS = newinstance(__CLASS__, array(1, 'GREATER_EQUALS', '>='), '{ static function __static() {} }'); self::$LESS_THAN = newinstance(__CLASS__, array(1, 'LESS_THAN', '<'), '{ static function __static() {} }'); self::$LESS_EQUALS = newinstance(__CLASS__, array(1, 'LESS_EQUALS', '<='), '{ static function __static() {} }'); self::$IN = newinstance(__CLASS__, array(1, 'IN', 'in'), '{ static function __static() {} function forValue($value) { return $this->op." (".implode(", ", (array)$value).")"; } }'); self::$NOT_IN = newinstance(__CLASS__, array(1, 'NOT_IN', 'not in'), '{ static function __static() {} function forValue($value) { return $this->op." (".implode(", ", (array)$value).")"; } }'); }
public function newinstance() { $runnable = newinstance(Runnable::class, [], ['run' => function () { return 'Test'; }]); $this->assertEquals('Test', cast($runnable, Runnable::class)->run()); }
public function newinstance() { $runnable = newinstance('lang.Runnable', array(), '{ public function run() { return "RUN"; } }'); $this->assertEquals('RUN', cast($runnable, 'lang.Runnable')->run()); }
/** * Creates underlying base for class loader, e.g. a directory or a .XAR file * * @return net.xp_framework.unittest.reflection.ClassFromUriBase */ protected static function baseImpl() { return newinstance('net.xp_framework.unittest.reflection.ClassFromUriBase', array(), '{ protected $t= NULL; public function create() { $this->t= new \\io\\Folder(\\lang\\System::tempDir(), "fsclt"); $this->t->create(); } public function delete() { $this->t->unlink(); } public function newFile($name, $contents) { $file= new \\io\\File($this->t, $name); $path= new \\io\\Folder($file->getPath()); $path->exists() || $path->create(); \\io\\FileUtil::setContents($file, $contents); } public function path() { return rtrim($this->t->getURI(), DIRECTORY_SEPARATOR); } }'); }
/** * Sets up test case */ public function setUp() { $this->fixture = newinstance(ImapStore::class, [], ['connect' => [], '_connect' => function ($mbx, $user, $pass, $flags) { $this->connect = ['mbx' => $mbx, 'user' => $user, 'pass' => $pass, 'flags' => $flags]; return true; }]); }
static function __static() { self::$sources['cookie'] = self::$COOKIE = newinstance(__CLASS__, array(1, 'cookie'), '{ static function __static() { } public function read($name, $target, $request) { if (NULL === ($cookie= $request->getCookie($name, NULL))) return NULL; return $cookie->getValue(); } }'); self::$sources['header'] = self::$HEADER = newinstance(__CLASS__, array(2, 'header'), '{ static function __static() { } public function read($name, $target, $request) { return $request->getHeader($name, NULL); } }'); self::$sources['param'] = self::$PARAM = newinstance(__CLASS__, array(3, 'param'), '{ static function __static() { } public function read($name, $target, $request) { return $request->getParam($name, NULL); } }'); self::$sources['path'] = self::$PATH = newinstance(__CLASS__, array(4, 'path'), '{ static function __static() { } public function read($name, $target, $request) { return isset($target["segments"][$name]) ? rawurldecode($target["segments"][$name]) : NULL; } }'); self::$sources['body'] = self::$BODY = newinstance(__CLASS__, array(5, 'body'), '{ static function __static() { } public function read($name, $target, $request) { return RestFormat::forMediaType($target["input"])->read($request->getInputStream(), Type::$VAR); } }'); }
static function __static() { self::$CLEANLY = newinstance(self::class, [], '{ static function __static() { } public function isError() { return false; } }'); }
static function __static() { self::$UNKNOWN = newinstance(__CLASS__, [null, [], null], '{ static function __static() { } public function toString() { return "com.maxmind.geoip.Name(UNKNOWN)"; } }'); }
/** * Sets up test case * */ public function setUp() { $this->builder = new MarkupBuilder(); $this->builder->registerProcessor('summary', newinstance('text.doclet.markup.DelegatingProcessor', [$this->builder->processors['default']], ['tag' => function () { return "summary"; }])); }
/** * Initialize streams * * @param bool console */ public static function initialize($console) { if ($console) { self::$in = new StringReader(new ConsoleInputStream(STDIN)); self::$out = new StringWriter(new ConsoleOutputStream(STDOUT)); self::$err = new StringWriter(new ConsoleOutputStream(STDERR)); } else { self::$in = newinstance('io.streams.InputStreamReader', [null], '{ public function __construct($in) { } public function getStream() { return null; } public function raise() { throw new \\lang\\IllegalStateException("There is no console present"); } public function read($count= 8192) { $this->raise(); } public function readLine() { $this->raise(); } }'); self::$out = self::$err = newinstance('io.streams.OutputStreamWriter', [null], '{ public function __construct($out) { } public function getStream() { return null; } public function flush() { $this->raise(); } public function raise() { throw new \\lang\\IllegalStateException("There is no console present"); } public function write() { $this->raise(); } public function writeLine() { $this->raise(); } public function writef() { $this->raise(); } public function writeLinef() { $this->raise(); } }'); } }
public function invocation() { $methods = newinstance('net.xp_framework.unittest.core.generics.ArrayFilter<lang.reflect.Method>', [], ['accept' => function ($method) { return 'invocation' === $method->getName(); }]); $this->assertEquals([$this->getClass()->getMethod('invocation')], $methods->filter($this->getClass()->getMethods())); }
/** * Initialize members. */ public function __construct() { $this->typeName = new Tokens(T_STRING, T_NS_SEPARATOR); $this->collectMembers = newinstance('text.parse.rules.Collection', [], '{ public function collect(&$values, $value) { $values[$value["kind"]][$value["name"]]= $value; } }'); $this->collectElements = newinstance('text.parse.rules.Collection', [], '{ public function collect(&$values, $value) { if (is_array($value)) { $values[key($value)]= current($value); } else { $values[]= $value; } } }'); $this->collectAnnotations = newinstance('text.parse.rules.Collection', [], '{ public function collect(&$values, $value) { $target= $value["target"]; $values[$target[0]][$target[1]]= $value["value"]; } }'); parent::__construct(); }
static function __static() { self::$iterate = newinstance('Iterator', [], '{ private $i= 0, $c; private function value($n) { if (!$n->hasChildren()) return $n->getContent(); $names= array(); foreach ($n->getChildren() as $c) { $names[$c->getName()]= TRUE; } $result= array(); if (sizeof($names) > 1) foreach ($n->getChildren() as $c) { $result[$c->getName()]= $this->value($c); } else foreach ($n->getChildren() as $c) { $result[]= $this->value($c); } return $result; } public function on($c) { $self= new self(); $self->c= $c; return $self; } public function current() { return $this->value($this->c[$this->i]); } public function key() { return $this->c[$this->i]->getName(); } public function next() { $this->i++; } public function rewind() { $this->i= 0; } public function valid() { return $this->i < sizeof($this->c); } }'); }
/** * Start server * * @param string[] args */ public static function main(array $args) { $stor = new TestingStorage(); $stor->add(new TestingCollection('/', $stor)); $stor->add(new TestingCollection('/.trash', $stor)); $stor->add(new TestingElement('/.trash/do-not-remove.txt', $stor)); $stor->add(new TestingCollection('/htdocs', $stor)); $stor->add(new TestingElement('/htdocs/file with whitespaces.html', $stor)); $stor->add(new TestingElement('/htdocs/index.html', $stor, "<html/>\n")); $stor->add(new TestingCollection('/outer', $stor)); $stor->add(new TestingCollection('/outer/inner', $stor)); $stor->add(new TestingElement('/outer/inner/index.html', $stor)); $auth = newinstance('lang.Object', array(), '{ public function authenticate($user, $password) { return ("testtest" == $user.$password); } }'); $protocol = newinstance('peer.ftp.server.FtpProtocol', array($stor, $auth), '{ public function onShutdown($socket, $params) { $this->answer($socket, 200, "Shutting down"); $this->server->terminate= TRUE; } }'); isset($args[0]) && $protocol->setTrace(Logger::getInstance()->getCategory()->withAppender(new FileAppender($args[0]))); $s = new Server('127.0.0.1', 0); try { $s->setProtocol($protocol); $s->init(); Console::writeLinef('+ Service %s:%d', $s->socket->host, $s->socket->port); $s->service(); Console::writeLine('+ Done'); } catch (Throwable $e) { Console::writeLine('- ', $e->getMessage()); } }
/** * Sets up test case * */ public function setUp() { $this->builder = new MarkupBuilder(); $this->builder->registerProcessor('summary', newinstance('text.doclet.markup.DelegatingProcessor', array($this->builder->processors['default']), '{ public function tag() { return "summary"; } }')); }
static function __static() { if (defined('HHVM_VERSION')) { $reflect = 'FromHHVM'; } else { if (PHP_VERSION < '7.0.0') { $reflect = 'From'; } else { $reflect = 'FromPhp7'; } } self::$REFLECTION = newinstance(self::class, [1, 'REFLECTION'], sprintf('{ static function __static() { } public function reflect($class, $source= null) { if ($class instanceof \\ReflectionClass) { return new %1$sReflection($class, $source ?: $this); } else if ($class instanceof \\lang\\XPClass) { return new %1$sReflection($class->reflect(), $source ?: $this); } $literal= strtr($class, ".", "\\\\"); if (class_exists($literal) || interface_exists($literal) || trait_exists($literal)) { return new %1$sReflection(new \\ReflectionClass($literal), $source ?: $this); } $dotted= strtr($class, "\\\\", "."); if (\\lang\\ClassLoader::getDefault()->providesClass($dotted)) { return new %1$sCode($dotted, $source ?: $this); } else { return new FromIncomplete($literal); } } }', $reflect)); self::$CODE = newinstance(self::class, [2, 'CODE'], sprintf('{ static function __static() { } public function reflect($class, $source= null) { if ($class instanceof \\ReflectionClass) { return new %1$sReflection($class, $source ?: $this); } else if ($class instanceof \\lang\\XPClass) { return new %1$sReflection($class->reflect(), $source ?: $this); } $dotted= strtr($class, "\\\\", "."); if (\\lang\\ClassLoader::getDefault()->providesClass($dotted)) { return new %1$sCode($dotted, $source ?: $this); } $literal= strtr($class, ".", "\\\\"); if (class_exists($literal) || interface_exists($literal) || trait_exists($literal)) { return new %1$sReflection(new \\ReflectionClass($literal), $source ?: $this); } else { return new FromIncomplete($literal); } } }', $reflect)); self::$DEFAULT = self::$REFLECTION; }
public function can_optionally_be_given_bindings() { $inject = new Injector($this->bindings, newinstance(Bindings::class, [], ['configure' => function ($inject) { $inject->bind(Currency::class, Currency::$EUR, 'EUR'); }])); $this->assertInstanceOf(FileSystem::class, $inject->get(Storage::class)); $this->assertEquals(Currency::$EUR, $inject->get(Currency::class, 'EUR')); }
public function cloneInterceptorThrowsException() { clone newinstance('lang.Object', array(), '{ public function __clone() { throw new CloneNotSupportedException("I am *UN*Cloneable"); } }'); }
public function register_algorithm() { $algorithm = newinstance(Algorithm::class, [], ['strengthOf' => function ($password) { return 0; }]); PasswordStrength::setAlgorithm('test', typeof($algorithm)); $this->assertInstanceOf(nameof($algorithm), PasswordStrength::getAlgorithm('test')); }
/** @return void */ public function setUp() { $this->handler = newinstance(InvocationHandler::class, [], ['invocations' => [], 'invoke' => function ($proxy, $method, $args) { $this->invocations[$method . '_' . sizeof($args)] = $args; }]); $this->iteratorClass = XPClass::forName(XPIterator::class); $this->observerClass = XPClass::forName(Observer::class); }