/**
  * 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);
 }

 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');
 }

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

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

 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.");
         }
     }
 }

 /**
  * Registers current class as the PHP file stream wrapper.
  *
  * @return void
  */
 public function intercept()
 {
     if (!$this->isIntercepting) {
         stream_wrapper_unregister(self::PROTOCOL);
         $this->isIntercepting = stream_wrapper_register(self::PROTOCOL, __CLASS__);
     }
 }

 /**
  * unregisters vfsStreamWrapper
  */
 public static function unregister()
 {
     if (in_array(vfsStream::SCHEME, stream_get_wrappers()) === true) {
         stream_wrapper_unregister(vfsStream::SCHEME);
     }
     self::$registered = false;
 }

 protected function setUp()
 {
     if (in_array('sfImageSource', stream_get_wrappers())) {
         stream_wrapper_unregister('sfImageSource');
     }
     stream_wrapper_register('sfImageSource', 'sfImageSourceMock') or die('Failed to register protocol..');
 }

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

 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 function setUp()
 {
     parent::setUp();
     if (in_array($this->protocol, stream_get_wrappers())) {
         stream_wrapper_unregister($this->protocol);
     }
 }

 public function testRegisterWithArgument()
 {
     $protocol = 'sftptest';
     $this->assertTrue(Stream::register($protocol));
     $this->assertContains($protocol, stream_get_wrappers());
     $this->assertTrue(stream_wrapper_unregister($protocol));
 }

 public static function unregisterWrapper()
 {
     $existed = in_array('stack', stream_get_wrappers());
     if ($existed) {
         stream_wrapper_unregister('stack');
     }
 }

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

 /**
  * Register a stream wrapper according to its scheme and class.
  * Must called prior the opening of first stream under this scheme
  */
 public static function registerStreamWrapper()
 {
     if (in_array(static::SCHEME, stream_get_wrappers())) {
         stream_wrapper_unregister(static::SCHEME);
     }
     stream_register_wrapper(static::SCHEME, get_called_class());
 }

 /**
  * 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));
     }
 }

function disable_wrappers()
{
    $wrappers = array("php", "http", "https", "ftp", "ftps", "compress.zlib", "compress.bzip2", "zip", "glob", "data");
    foreach ($wrappers as $v) {
        stream_wrapper_unregister($v);
    }
}

 /**
  * Tear down the hooks, url filtering etc for S3 Uploads
  */
 public function tear_down()
 {
     stream_wrapper_unregister('s3');
     remove_filter('upload_dir', array($this, 'filter_upload_dir'));
     remove_filter('wp_image_editors', array($this, 'filter_editors'), 9);
     remove_filter('wp_handle_sideload_prefilter', array($this, 'filter_sideload_move_temp_file_to_s3'));
 }

 public static function enable()
 {
     if (!isset(self::$intercept) || !isset(self::$replacement)) {
         throw new NoIncludeInterceptSetException('Set a file to intercept and its replacement before enabling wrapper');
     }
     stream_wrapper_unregister('file');
     stream_wrapper_register('file', __CLASS__);
 }

 /**
  * @param array $options the options for the context to wrap the stream with
  * @param string $class
  * @return resource
  */
 protected static function wrapWithOptions($options, $class)
 {
     $context = stream_context_create($options);
     stream_wrapper_register('dirwrapper', $class);
     $wrapped = opendir('dirwrapper://', $context);
     stream_wrapper_unregister('dirwrapper');
     return $wrapped;
 }