Example #1
0
 /**
  * Main
  *
  * @param  string[] $args
  * @return int
  */
 public static function main(array $args)
 {
     $command = null;
     if (empty($args)) {
         $class = new XPClass(self::class);
         $source = $class->getClassLoader();
         $markdown = $class->getComment();
     } else {
         if ('@' === $args[0][0]) {
             $resource = substr($args[0], 1);
             if (null === ($source = ClassLoader::getDefault()->findResource($resource))) {
                 Console::$err->writeLine('No help topic named ', $resource);
                 return 2;
             }
             $markdown = $source->getResource($resource);
         } else {
             $class = $args[0];
             if (null === ($source = ClassLoader::getDefault()->findClass($class))) {
                 Console::$err->writeLine('No class named ', $class);
                 return 2;
             }
             $markdown = $source->loadClass($class)->getComment();
         }
     }
     self::render(Console::$out, $markdown, $source);
     return 1;
 }
 /**
  * Sets up test case
  *
  */
 public function setUp()
 {
     try {
         $this->classname = $this->testClassName();
         $this->interfacename = $this->testClassName('I');
     } catch (IllegalStateException $e) {
         throw new PrerequisitesNotMetError($e->getMessage());
     }
     // Create an archive
     $this->tempfile = new TempFile($this->name);
     $archive = new Archive($this->tempfile);
     $archive->open(ARCHIVE_CREATE);
     $this->add($archive, $this->classname, '
     uses("util.Comparator", "' . $this->interfacename . '");
     class ' . $this->classname . ' extends Object implements ' . $this->interfacename . ', Comparator { 
       public function compare($a, $b) {
         return strcmp($a, $b);
       }
     }
   ');
     $this->add($archive, $this->interfacename, 'interface ' . $this->interfacename . ' { } ');
     $archive->create();
     // Setup classloader
     $this->classloader = new ArchiveClassLoader($archive);
     ClassLoader::getDefault()->registerLoader($this->classloader, TRUE);
 }
 /**
  * Deploy
  *
  * @param   remote.server.deploy.Deployable deployment
  */
 public function deployBean($deployment)
 {
     if ($deployment instanceof IncompleteDeployment) {
         throw new DeployException('Incomplete deployment originating from ' . $deployment->origin, $deployment->cause);
     }
     $this->cat && $this->cat->info($this->getClassName(), 'Begin deployment of', $deployment);
     // Register beans classloader. This classloader must be put at the beginning
     // to prevent loading of the home interface not implmenenting BeanInterface
     $cl = $deployment->getClassLoader();
     ClassLoader::getDefault()->registerLoader($cl, TRUE);
     $impl = $cl->loadClass($deployment->getImplementation());
     $interface = $cl->loadClass($deployment->getInterface());
     $directoryName = $deployment->getDirectoryName();
     // Fetch naming directory
     $directory = NamingDirectory::getInstance();
     // Create beanContainer
     // TBI: Check which kind of bean container has to be created
     $beanContainer = StatelessSessionBeanContainer::forClass($impl);
     $this->cat && $beanContainer->setTrace($this->cat);
     // Create invocation handler
     $invocationHandler = new ContainerInvocationHandler();
     $invocationHandler->setContainer($beanContainer);
     // Now bind into directory
     $directory->bind($directoryName, Proxy::newProxyInstance($cl, array($interface), $invocationHandler));
     $this->cat && $this->cat->info($this->getClassName(), 'End deployment of', $impl->getName(), 'with ND entry', $directoryName);
     return $beanContainer;
 }
 /**
  * Constructor
  * 
  * @param   lang.ClassLoader classLoader
  */
 public function __construct($classLoader = NULL)
 {
     if (NULL === $classLoader) {
         $this->classLoader = ClassLoader::getDefault();
     } else {
         $this->classLoader = $classLoader;
     }
 }
 /**
  * Returns a value for the given serialized string
  *
  * @param   server.protocol.Serializer serializer
  * @param   remote.protocol.SerializedData serialized
  * @param   [:var] context default array()
  * @return  var
  */
 public function valueOf($serializer, $serialized, $context = array())
 {
     $oid = $serialized->consumeSize();
     $serialized->consume('{');
     $interface = $serializer->valueOf($serialized, $context);
     $serialized->consume('}');
     return Proxy::newProxyInstance(ClassLoader::getDefault(), array(XPClass::forName($serializer->packageMapping($interface))), RemoteInvocationHandler::newInstance((int) $oid, $context['handler']));
 }
 /**
  * Creates a fixrture
  *
  * @return  util.PropertyManager
  */
 private function fixture()
 {
     $class = ClassLoader::getDefault()->defineClass('NonSingletonPropertyManager', 'util.PropertyManager', array(), '{
     public static function newInstance() {
       return new self();
     }
   }');
     return $class->getMethod('newInstance')->invoke(NULL);
 }
 /**
  * Setup method.
  *
  * @param   string package
  * @param   string stateName
  * @param   string functionality
  * @param   [:var] params default array()
  */
 public function __construct($package, $stateName, $functionality, $params = array())
 {
     static $i = 0;
     parent::__construct($package);
     // Generate unique classname and put it into the environment
     // That way, the classloader will already know this class in
     // WorkflowScriptletRequest::initialize() and be able to load
     // and instantiate it.
     $stateName = 'Mock·' . $i++ . $stateName;
     $this->state = ClassLoader::getDefault()->defineClass($package . '.mock.state.' . $stateName . 'State', 'scriptlet.xml.workflow.AbstractState', array(), $functionality)->newInstance();
     $_SERVER['STATE'] = $stateName;
     // Set some defaults
     $_SERVER['PRODUCT'] = 'xp';
     $_SERVER['LANGUAGE'] = 'en_US';
 }
Example #8
0
 /**
  * Accessor method for a type matcher.
  * 
  * @param   typeName string
  */
 public static function anyOfType($typeName)
 {
     $builder = new MockProxyBuilder();
     $builder->setOverwriteExisting(FALSE);
     $interfaces = array(XPClass::forName('unittest.mock.arguments.IArgumentMatcher'));
     $parentClass = NULL;
     $type = XPClass::forName($typeName);
     if ($type->isInterface()) {
         $interfaces[] = $type;
     } else {
         $parentClass = $type;
     }
     $proxyClass = $builder->createProxyClass(ClassLoader::getDefault(), $interfaces, $parentClass);
     return $proxyClass->newInstance(new TypeMatcher($typeName));
 }
 /**
  * Builds a stub instance for the specified type.
  *
  * @param   string typeName
  * @param   boolean overrideAll
  * @return  lang.Object
  */
 public function createMock($typeName, $overrideAll = TRUE)
 {
     $type = Type::forName($typeName);
     if (!$type instanceof XPClass) {
         throw new IllegalArgumentException('Cannot mock other types than XPClass types.');
     }
     $parentClass = NULL;
     $interfaces = array(XPClass::forName('unittest.mock.IMock'));
     if ($type->isInterface()) {
         $interfaces[] = $type;
     } else {
         $parentClass = $type;
     }
     $proxy = new MockProxyBuilder();
     $proxy->setOverwriteExisting($overrideAll);
     $proxyClass = $proxy->createProxyClass(ClassLoader::getDefault(), $interfaces, $parentClass);
     $mock = $proxyClass->newInstance(new MockProxy());
     $this->mocks[] = $mock;
     return $mock;
 }
Example #10
0
 /**
  * Constructor
  *
  * @param   util.cmd.ParamString args
  */
 public function __construct(ParamString $args)
 {
     $dsn = new DSN($args->value(0));
     $this->adapter = self::$adapters[$dsn->getDriver()]->newInstance(DriverManager::getInstance()->getConnection($dsn->dsn));
     $this->package = $args->value('package', 'p', 'db');
     $this->host = $args->value('host', 'h', $dsn->getHost());
     $this->naming = $args->value('nstrategy', 'n', '');
     if ('' != $this->naming) {
         DBXMLNamingContext::setStrategy(XPClass::forName($this->naming)->newInstance());
     }
     $this->prefix = $args->value('prefix', 'pv', '');
     $this->ptargets = explode('|', $args->value('ptargets', 'pt', ''));
     $this->pexclude = $args->value('pexclude', 'pe', FALSE);
     $xsls = array();
     $lang = $args->value('lang', 'l', 'xp5.php');
     if ($this->getClass()->getPackage()->providesPackage(strtr($lang, '.', '_'))) {
         $resources = $this->getClass()->getPackage()->getPackage(strtr($lang, '.', '_'))->getResources();
         foreach ($resources as $resource) {
             $filename = substr($resource, strrpos($resource, DIRECTORY_SEPARATOR) + 1);
             if (substr($filename, -8, 8) !== '.php.xsl') {
                 continue;
             }
             $xsls[] = $resource;
         }
     } else {
         $packagepath = strtr($this->getClass()->getPackage()->getName(), '.', DIRECTORY_SEPARATOR);
         $xsls[] = $packagepath . DIRECTORY_SEPARATOR . $lang . '.xsl';
     }
     foreach ($xsls as $resource) {
         $processor = new DomXSLProcessor();
         $processor->setBase(__DIR__);
         $processor->setXSLBuf(ClassLoader::getDefault()->getResource($resource));
         $processor->setParam('package', $this->package);
         if ($this->prefix) {
             $processor->setParam('prefix', $this->prefix);
             $processor->setParam($this->pexclude ? 'exprefix' : 'incprefix', implode(',', $this->ptargets));
         }
         $this->processor[] = $processor;
     }
 }
 /**
  * Returns details for a given package. Note: Results from this method
  * are cached.
  *
  * @param   string package
  * @return  [:var] details or NULL
  */
 public static function detailsForPackage($package)
 {
     if (!isset(xp::$meta[$package])) {
         $cl = ClassLoader::getDefault();
         $info = strtr($package, '.', '/') . '/package-info.xp';
         if (!$cl->providesResource($info)) {
             return NULL;
         }
         $tokens = token_get_all($cl->getResource($info));
         $details = array();
         $comment = NULL;
         for ($i = 0, $s = sizeof($tokens); $i < $s; $i++) {
             switch ($tokens[$i][0]) {
                 case T_DOC_COMMENT:
                     $comment = $tokens[$i][1];
                     break;
                 case T_STRING:
                     if ('package' === $tokens[$i][1]) {
                         $details[DETAIL_COMMENT] = trim(preg_replace('/\\n \\* ?/', "\n", "\n" . substr($comment, 4, strpos($comment, '* @') - 2)));
                     }
                     break;
             }
         }
         xp::$meta[$package] = $details;
     }
     return xp::$meta[$package];
 }
 public function nonExistantResourceStream()
 {
     ClassLoader::getDefault()->getResourceAsStream('::DOES-NOT-EXIST::');
 }
 public function loadNonExistantUri()
 {
     ClassLoader::getDefault()->loadUri('non/existant/Class.class.php');
 }
 public function withPositionalOptionListenerOption()
 {
     $class = ClassLoader::getDefault()->defineClass('net.xp_framework.unittest.tests.WithPositionalOptionTestFixture', 'xp.unittest.DefaultListener', array(), '{
     public static $options= array();
     #[@arg(position= 0)]
     public function setOption($value) { self::$options[__FUNCTION__]= $value; }
   }');
     $return = $this->runner->run(array('-l', $class->getName(), '-', '-o', 'value'));
     $this->assertEquals(array('setOption' => 'value'), $class->getField('options')->get(NULL));
 }
Example #15
0
 public function nullInterfaces()
 {
     Proxy::getProxyClass(ClassLoader::getDefault(), null);
 }
Example #16
0
 /**
  * Main
  *
  * @param   string[] args
  */
 public static function main(array $args)
 {
     if (sizeof($args) < 1 || '' == $args[0]) {
         Console::$err->writeLine('*** No class or package name given');
         return 2;
     }
     // Check whether a file, class or a package directory or name is given
     $cl = ClassLoader::getDefault();
     if (strstr($args[0], xp::CLASS_FILE_EXT)) {
         $class = self::findClassBy(new File($args[0]));
     } else {
         if ($cl->providesClass($args[0])) {
             $class = XPClass::forName($args[0], $cl);
         } else {
             if (strcspn($args[0], '\\/') < strlen($args[0])) {
                 $package = self::findPackageBy(new Folder($args[0]));
             } else {
                 $package = $args[0];
             }
             $provided = FALSE;
             foreach (ClassLoader::getLoaders() as $loader) {
                 if (!$loader->providesPackage($package)) {
                     continue;
                 }
                 Console::writeLine('@', $loader);
                 $provided = TRUE;
             }
             if ($provided) {
                 self::printPackage(Package::forName($package));
                 return 0;
             }
             // Not found
             Console::$err->writeLine('*** Failed to locate either a class or a package named "', $args[0], '", tried all of {');
             foreach (ClassLoader::getLoaders() as $loader) {
                 Console::$err->writeLine('  ', $loader);
             }
             Console::$err->writeLine('}');
             return 1;
         }
     }
     Console::writeLine('@', $class->getClassLoader());
     if ($class->isInterface()) {
         self::printInterface($class);
     } else {
         if ($class->isEnum()) {
             self::printEnum($class);
         } else {
             self::printClass($class);
         }
     }
     return 0;
 }
 public function reserved_methods_should_not_be_overridden()
 {
     $proxyBuilder = new MockProxyBuilder();
     $proxyBuilder->setOverwriteExisting(TRUE);
     $class = $proxyBuilder->createProxyClass(ClassLoader::getDefault(), array(), XPClass::forName('net.xp_framework.unittest.tests.mock.AbstractDummy'));
     $proxy = $class->newInstance($this->handler);
     $proxy->equals(new Object());
     $this->assertFalse(isset($this->handler->invocations['equals_1']));
 }
 /**
  * Returns the XPClass object associated with the class with the given 
  * string name. Uses the default classloader if none is specified.
  *
  * @param   string name - e.g. "io.File", "rdbms.mysql.MySQL"
  * @param   lang.IClassLoader classloader default NULL
  * @return  lang.XPClass class object
  * @throws  lang.ClassNotFoundException when there is no such class
  */
 public static function forName($name, IClassLoader $classloader = NULL)
 {
     if (NULL === $classloader) {
         $classloader = ClassLoader::getDefault();
     }
     return $classloader->loadClass((string) $name);
 }
 /**
  * Runs the server. Loads the listener using XPClass::forName()
  * so that the class is loaded within the thread's process space
  * and will be recompiled whenever the thread is restarted.
  *
  * @throws  lang.XPException in case initializing the server fails
  * @throws  lang.SystemException in case setuid fails
  */
 public function run()
 {
     try {
         with($class = XPClass::forName('peer.ftp.server.FtpProtocol'), $cl = ClassLoader::getDefault());
         // Add listener
         $this->server->setProtocol($proto = $class->newInstance($storage = Proxy::newProxyInstance($cl, array(XPClass::forName('peer.ftp.server.storage.Storage')), $this->storageHandler), Proxy::newProxyInstance($cl, array(XPClass::forName('security.auth.Authenticator')), $this->authenticatorHandler)));
         // Copy interceptors to connection listener
         $proto->interceptors = $this->interceptors;
         // Enable debugging
         if ($this->cat) {
             $proto->setTrace($this->cat);
             $this->server instanceof Traceable && $this->server->setTrace($this->cat);
         }
         // Try to start the server
         $this->server->init();
     } catch (Throwable $e) {
         $this->server->shutdown();
         throw $e;
     }
     // Check if we should run child processes
     // with another uid/pid
     if (isset($this->processGroup)) {
         $group = posix_getgrnam($this->processGroup);
         $this->cat && $this->cat->debugf('Setting group to: %s (GID: %d)', $group['name'], $group['uid']);
         if (!posix_setgid($group['gid'])) {
             throw new SystemException('Could not set GID');
         }
     }
     if (isset($this->processOwner)) {
         $user = posix_getpwnam($this->processOwner);
         $this->cat && $this->cat->debugf('Setting user to: %s (UID: %d)', $user['name'], $user['uid']);
         if (!posix_setuid($user['uid'])) {
             throw new SystemException('Could not set UID');
         }
     }
     $this->server->service();
 }
 public function loadingClassoneFails()
 {
     ClassLoader::getDefault()->loadClass('net.xp_framework.unittest.reflection.classes.Classone');
 }
 /**
  * Retrieve associated loader
  *
  * @return  lang.IClassLoader
  */
 protected function getLoader()
 {
     return ClassLoader::getDefault();
 }
 public function defaultClassLoaderProvidesPackageOfDefinedClass()
 {
     $package = 'net.xp_framework.unittest.reflection.lostandfound';
     $this->defineClass($package . '.CL2', 'lang.Object', array(), '{ }');
     $this->assertTrue(ClassLoader::getDefault()->providesPackage($package));
 }
 /**
  * Finds a class by a given class name
  *
  * @param   string classname
  * @return  lang.IClassLoader the classloader providing the class
  */
 public function findClass($classname)
 {
     foreach (ClassLoader::getDefault()->getLoaders() as $loader) {
         if ($loader->providesClass($classname)) {
             return $loader;
         }
     }
     return NULL;
 }