/**
  * Handle a "given" step.
  *
  * @param array  &$world    Joined "world" of variables.
  * @param string $action    The description of the step.
  * @param array  $arguments Additional arguments to the step.
  *
  * @return mixed The outcome of the step.
  */
 public function runGiven(&$world, $action, $arguments)
 {
     switch ($action) {
         case 'an incoming message on host':
             $world['hostname'] = $arguments[0];
             $world['type'] = 'Incoming';
             break;
         case 'the SMTP sender address is':
             $world['sender'] = $arguments[0];
             break;
         case 'the SMTP recipient address is':
             $world['recipient'] = $arguments[0];
             break;
         case 'the client address is':
             $world['client'] = $arguments[0];
             break;
         case 'the hostname is':
             $world['hostname'] = $arguments[0];
             break;
         case 'the unmodified message content is':
             $world['infile'] = $arguments[0];
             $world['fp'] = fopen($world['infile'], 'r');
             break;
         case 'the modified message template is':
             $world['infile'] = $arguments[0];
             $world['fp'] = fopen($world['infile'], 'r');
             stream_filter_register('addresses', 'Horde_Kolab_Filter_Helper_AddressFilter');
             stream_filter_append($world['fp'], 'addresses', STREAM_FILTER_READ, array('recipient' => $world['recipient'], 'sender' => $world['sender']));
             break;
         default:
             return $this->notImplemented($action);
     }
 }

function main()
{
    stream_filter_register('test.md5', 'Md5Filter');
    stream_filter_register('test.ucase', 'UpperCaseFilter');
    doTest('stream_filter_append');
    doTest('stream_filter_prepend');
}

 public function setup()
 {
     stream_filter_register('horde_crc32', 'Horde_Stream_Filter_Crc32');
     $this->testdata = str_repeat("0123456789ABCDE", 1000);
     $this->fp = fopen('php://temp', 'r+');
     fwrite($this->fp, $this->testdata);
 }

 public function setup()
 {
     stream_filter_register('horde_null', 'Horde_Stream_Filter_Null');
     $this->testdata = "abcdefghij";
     $this->fp = fopen('php://temp', 'r+');
     fwrite($this->fp, $this->testdata);
 }

 /**
  * Attaches the current filter to a stream.
  *
  * @return bool true on success or false on failure.
  */
 public function register()
 {
     if (!$this->isRegistered) {
         $this->isRegistered = stream_filter_register(static::NAME, get_called_class());
     }
     return $this->isRegistered;
 }

function register_default_stream_filters()
{
    \stream_filter_register('zlib.deflate', '__SystemLib\\DeflateStreamFilter');
    \stream_filter_register('zlib.inflate', '__SystemLib\\InflateStreamFilter');
    \stream_filter_register('string.rot13', '__SystemLib\\StringRot13StreamFilter');
    \stream_filter_Register('string.toupper', '__SystemLib\\StringToUpperStreamFilter');
    \stream_filter_Register('string.tolower', '__SystemLib\\StringToLowerStreamFilter');
}

 public function setUp()
 {
     // register filter
     $filters = stream_get_filters();
     if (!in_array('crypto.filter', $filters)) {
         stream_filter_register('crypto.filter', 'Fruit\\CryptoKit\\CryptoFilter');
     }
 }

 /**
  * Register Influence loader and filter.
  */
 private function registerModules()
 {
     $loaders = spl_autoload_functions();
     foreach ($loaders as $loader) {
         spl_autoload_unregister($loader);
     }
     spl_autoload_register([$this, 'loadClass']);
     stream_filter_register('influence.reader', 'Influence\\Filter');
 }

function sgregister()
{
    static $registered = null;
    if ($registered === null) {
        $registered = 'stream-callback';
        stream_filter_register($registered, 'CallbackFilter');
    }
    return $registered;
}

 /**
  * Register the stream filter
  *
  * @return bool
  */
 public static function register()
 {
     $result = false;
     $name = self::getName();
     if (!empty($name) && !in_array($name, stream_get_filters())) {
         $result = stream_filter_register(self::getName(), get_called_class());
     }
     return $result;
 }

 /**
  * Register this class as a stream filter
  * @throws \RuntimeException
  */
 public static function register()
 {
     if (self::$hasBeenRegistered === true) {
         return;
     }
     if (stream_filter_register(self::getFilterName(), __CLASS__) === false) {
         throw new RuntimeException('Failed to register stream filter: ' . self::getFilterName());
     }
     self::$hasBeenRegistered = true;
 }

 static function register($filter = null, $class = null)
 {
     if (empty($filter)) {
         $filter = empty($class) ? new static() : new $class();
     }
     $class = get_class($filter);
     self::$registry[$class] = $filter;
     stream_filter_register($class, $class);
     return $filter->filterPrefix = 'php://filter/read=' . $class . '/resource=';
 }

 /**
  * @dataProvider bodyFilterProvider()
  */
 public function testBodyFilter($data, $result)
 {
     $params = new stdClass();
     $stream = fopen('php://temp', 'r+');
     stream_filter_register('horde_smtp_body', 'Horde_Smtp_Filter_Body');
     stream_filter_append($stream, 'horde_smtp_body', STREAM_FILTER_WRITE, $params);
     fwrite($stream, $data);
     fclose($stream);
     $this->assertEquals($result, $params->body);
 }

 public function testUserFilter()
 {
     stream_filter_register("strtoupper", "strtoupper_filter");
     $fp = fopen("php://memory", 'r+');
     stream_filter_append($fp, "strtoupper");
     fputs($fp, "test\n");
     rewind($fp);
     $contents = stream_get_contents($fp);
     $this->assertEquals("TEST\n", $contents);
 }

 /**
  * @dataProvider provideBrokenParameters
  */
 public function testFilterHandlesBrokenParameter($param)
 {
     $fp = fopen('php://memory', 'w+');
     $append = "hello {$param}\n";
     fputs($fp, str_repeat('a', 16384 - strlen($append)) . $append . str_repeat('test', 300));
     rewind($fp);
     stream_filter_register('addresses', 'Horde_Kolab_Filter_Helper_AddressFilter');
     stream_filter_append($fp, 'addresses');
     fread($fp, 16384 - strlen($append));
     $this->assertEquals("hello {$param}\n", fread($fp, strlen($append)));
 }

 /**
  * Register current loader as stream filter in PHP
  *
  * @param string $filterId Identifier for the filter
  * @throws \RuntimeException If registration was failed
  */
 public static function register($filterId = self::FILTER_IDENTIFIER)
 {
     if (!empty(self::$filterId)) {
         throw new \RuntimeException('Stream filter already registered');
     }
     $result = stream_filter_register($filterId, __CLASS__);
     if (!$result) {
         throw new \RuntimeException('Stream filter was not registered');
     }
     self::$filterId = $filterId;
 }

function register_default_stream_filters()
{
    \stream_filter_register('zlib.deflate', '__SystemLib\\DeflateStreamFilter');
    \stream_filter_register('zlib.inflate', '__SystemLib\\InflateStreamFilter');
    \stream_filter_register('string.rot13', '__SystemLib\\StringRot13StreamFilter');
    \stream_filter_Register('string.toupper', '__SystemLib\\StringToUpperStreamFilter');
    \stream_filter_Register('string.tolower', '__SystemLib\\StringToLowerStreamFilter');
    \stream_filter_Register('convert.iconv.*', '__SystemLib\\ConvertIconvFilter');
    \stream_filter_Register('convert.*', '__SystemLib\\ConvertFilter');
    \stream_filter_Register('bzip2.*', '__SystemLib\\Bzip2Filter');
}

 public function __construct(MessageFactoryInterface $messageFactory, $entrypoint, $context = null, $useTls = null)
 {
     if ($context === null) {
         $context = stream_context_create();
     }
     $this->entrypoint = $entrypoint;
     $this->messageFactory = $messageFactory;
     $this->context = $context;
     $this->useTls = $useTls;
     stream_filter_register('chunk', '\\Docker\\Http\\Stream\\Filter\\Chunk');
     stream_filter_register('event', '\\Docker\\Http\\Stream\\Filter\\Event');
 }

function main()
{
    $fname = tempnam('/tmp', 'foo');
    stream_filter_register('ClosingFilter', 'ClosingFilter');
    $f = fopen($fname, 'r+');
    stream_filter_append($f, 'ClosingFilter', STREAM_FILTER_WRITE);
    fwrite($f, 'foo bar');
    fwrite($f, 'herp derp');
    fclose($f);
    var_dump(file_get_contents($fname));
    unlink($fname);
}

 /**
  * Return the escaped string as a stream.
  *
  * @return resource  The IMAP escaped stream.
  */
 public function escapeStream()
 {
     if ($this->literal()) {
         throw new Horde_Imap_Client_Data_Format_Exception('String requires literal to output.');
     }
     rewind($this->_data->stream);
     $stream = new Horde_Stream_Temp();
     $stream->add($this->_data, true);
     stream_filter_register('horde_imap_client_string_quote', 'Horde_Imap_Client_Data_Format_Filter_Quote');
     stream_filter_append($stream->stream, 'horde_imap_client_string_quote', STREAM_FILTER_READ);
     return $stream->stream;
 }