public function setUp()
 {
     $this->checkSkipTest();
     $this->bundle = new Bundle\RackspaceCloudfiles();
     $this->bundle->setDocRoot(__DIR__ . '/_files');
     stream_wrapper_register('rscf', 'RackspaceCloudFilesStreamWrapper') or die("Failed to register rscf:// protocol");
 }

 /**
  *
  * Constructor for HiEngine
  *
  * Sets up the stream protocol handler
  */
 public function __construct()
 {
     $streams = stream_get_wrappers();
     if (!in_array('hi', $streams)) {
         stream_wrapper_register("hi", "HiEngineParser") or die(_t("Failed to register HiEngine stream protocol"));
     }
 }

 function setUpFS()
 {
     ArrayFileStream::set_filesystem(array('dynamic' => array('course' => array($this->avatar_id . '_normal.png' => '', $this->avatar_id . '_medium.png' => '', $this->avatar_id . '_small.png' => ''))));
     if (!stream_wrapper_register("var", "ArrayFileStream")) {
         new Exception("Failed to register protocol");
     }
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     // Set up an intercepting proxy for getimagesize() calls
     stream_wrapper_unregister('http');
     stream_wrapper_register('http', __CLASS__ . '_proxy');
 }

 public static function wrap()
 {
     foreach (static::$protocols as $protocol) {
         stream_wrapper_unregister($protocol);
         stream_wrapper_register($protocol, get_called_class());
     }
 }

 function __construct($orientation = 'P', $unit = 'mm', $size = 'A4')
 {
     parent::__construct($orientation, $unit, $size);
     $this->lineHeightPadding = 30 / $this->k;
     $this->SetAutoPageBreak(false);
     stream_wrapper_register("var", 'PhpSigep\\Pdf\\VariableStream') or die("Failed to register protocol");
 }

 /**
  * @expectedException \MockFs\Exception\StreamException
  */
 public function testRegisterAnAlreadyRegisteredSchemeThrowsException()
 {
     $protocol = 'mock';
     stream_wrapper_register($protocol, __CLASS__);
     $stream = Stream::getInstance();
     $stream->register($protocol);
 }

 public function set_up()
 {
     stream_wrapper_unregister('https');
     stream_wrapper_register('https', 'MockHttpStreamWrapper', STREAM_IS_URL);
     MockHttpStreamWrapper::clear();
     parent::set_up();
 }

 public function testEvent()
 {
     $provider = $this->getProvider();
     $provider->addFormat('big', array('width' => 200, 'height' => null, 'constraint' => true));
     $media = new Media();
     $media->setBinaryContent('x9wjql');
     $media->setId(1023456);
     stream_wrapper_unregister('http');
     stream_wrapper_register('http', 'Sonata\\MediaBundle\\Tests\\Provider\\FakeHttpWrapper');
     // pre persist the media
     $provider->prePersist($media);
     $this->assertEquals('Thomas Rabaix - les tests fonctionnels - Symfony Live 2009', $media->getName(), '::getName() return the file name');
     $this->assertEquals('x9wjql', $media->getProviderReference(), '::getProviderReference() is set');
     // post persit the media
     $provider->postPersist($media);
     $provider->postRemove($media);
     $media->setProviderStatus('fake');
     $provider->preUpdate($media);
     $this->assertEquals(MediaInterface::STATUS_OK, $media->getProviderStatus());
     $provider->postUpdate($media);
     $media->setProviderStatus('fake');
     $media->setBinaryContent(null);
     $provider->prePersist($media);
     $this->assertEquals('fake', $media->getProviderStatus());
     $provider->preUpdate($media);
     $this->assertEquals('fake', $media->getProviderStatus());
     $provider->postPersist($media);
     $this->assertEquals('fake', $media->getProviderStatus());
     $provider->preRemove($media);
     stream_wrapper_restore('http');
 }

 /**
  * TODO don't hardcode pool, use params
  * TODO check rados extensions are available
  * @param $params
  */
 public function __construct($params)
 {
     $this->pool = 'owncloud';
     if (!in_array("rados", stream_get_wrappers())) {
         stream_wrapper_register("rados", '\\OCA\\Rados\\RadosStream');
     }
 }

	function MEM_IMAGE($orientation='P',$unit='mm',$format='A4')
	{
		$this->FPDF($orientation, $unit, $format);
		//Register var stream protocol (requires PHP>=4.3.2)
		if(function_exists('stream_wrapper_register'))
			stream_wrapper_register('var','VariableStream');
	}

 public static function register($scheme, $container)
 {
     if (!stream_wrapper_register($scheme, static::class)) {
         throw new \RuntimeException('Cannot register stream wrapper');
     }
     self::$containers[$scheme] = $container;
 }

 /**
  * Constructs CustomURIResolver from scheme prefix string (e.g. "arg" or "http").
  * @param string $scheme Scheme prefix string
  */
 function __construct($scheme)
 {
     $this->scheme = $scheme;
     if (!in_array($scheme, stream_get_wrappers())) {
         stream_wrapper_register($scheme, "StringStream") or die("Failed to register '" . $scheme . "'");
     }
 }

 /**
  * Sets up this test case
  *
  * @return void
  */
 public function setUp()
 {
     Zend_Service_Amazon_S3::setKeys(constant('TESTS_ZEND_SERVICE_AMAZON_ONLINE_ACCESSKEYID'), constant('TESTS_ZEND_SERVICE_AMAZON_ONLINE_SECRETKEYID'));
     if (!stream_wrapper_register('s3', 'Zend_Service_Amazon_S3')) {
         $this->fail('Unable to register s3:// streams wrapper');
     }
 }

 /**
  * @return string
  */
 protected function create()
 {
     $id = uniqid('stream');
     eval(sprintf('namespace %s { class %s extends \\%s {}; }', __NAMESPACE__, self::PROXY_CLASSNAME . '_' . $id, __NAMESPACE__ . '\\' . self::PROXY_CLASSNAME));
     stream_wrapper_register($id, $this->getProxyClassName($id));
     return $id;
 }

 /**
  * Register the GridFS stream wrapper.
  */
 public static function register()
 {
     if (in_array('gridfs', stream_get_wrappers())) {
         stream_wrapper_unregister('gridfs');
     }
     stream_wrapper_register('gridfs', get_called_class(), \STREAM_IS_URL);
 }

 /**
  * Registers the stream wrapper to handle the specified scheme
  *
  * @param  string $schema Default is gaufrette
  */
 public static function register($scheme = 'gaufrette')
 {
     @stream_wrapper_unregister($scheme);
     if (!stream_wrapper_register($scheme, __CLASS__)) {
         throw new \RuntimeException(sprintf('Could not register stream wrapper class %s for scheme %s.', __CLASS__, $scheme));
     }
 }

 public static function register()
 {
     if (in_array('phpspec', stream_get_wrappers())) {
         stream_wrapper_unregister('phpspec');
     }
     stream_wrapper_register('phpspec', 'PhpSpec\\Loader\\StreamWrapper');
 }

 protected function init(Container $container, ResourceLocator $locator)
 {
     $schemes = $container['config']->get('streams.schemes');
     if (!$schemes) {
         return;
     }
     // Set locator to both streams.
     Stream::setLocator($locator);
     ReadOnlyStream::setLocator($locator);
     $registered = stream_get_wrappers();
     foreach ($schemes as $scheme => $config) {
         if (isset($config['paths'])) {
             $locator->addPath($scheme, '', $config['paths']);
         }
         if (isset($config['prefixes'])) {
             foreach ($config['prefixes'] as $prefix => $paths) {
                 $locator->addPath($scheme, $prefix, $paths);
             }
         }
         if (in_array($scheme, $registered)) {
             stream_wrapper_unregister($scheme);
         }
         $type = !empty($config['type']) ? $config['type'] : 'ReadOnlyStream';
         if ($type[0] != '\\') {
             $type = '\\Grav\\Component\\Filesystem\\StreamWrapper\\' . $type;
         }
         if (!stream_wrapper_register($scheme, $type)) {
             throw new \InvalidArgumentException("Stream '{$type}' could not be initialized.");
         }
     }
 }

 /**
  * Install this stream wrapper.
  */
 public static function install()
 {
     $wrappers = stream_get_wrappers();
     if (!in_array('madmodel', $wrappers)) {
         stream_wrapper_register('madmodel', 'Mad_Model_Stream');
     }
 }