/**
  * @inheritDoc
  */
 public function disable()
 {
     self::$requestCallback = null;
     stream_wrapper_restore('http');
     stream_wrapper_restore('https');
     $this->status = self::DISABLED;
 }

 /**
  * Restore PHP built-in HTTP stream wrapper and perform any other clean-up.
  *
  * @param \PHPUnit_Framework_TestSuite $suite
  * @return bool
  */
 public function endTestSuite(\PHPUnit_Framework_TestSuite $suite)
 {
     foreach ($this->wrappers as $wrapper) {
         \stream_wrapper_restore($wrapper);
     }
     return TRUE;
 }

 public static function restoreDefault()
 {
     // Reset static values
     self::$_returnValues = array();
     self::$_arguments = array();
     // Restore original stream wrapper
     stream_wrapper_restore('php');
 }

 public static function tearDownAfterClass()
 {
     // Restore the built-in HTTP wrapper for other unit tests.
     \stream_wrapper_restore('http');
     // Clean up all ignore files.
     $removeFiles = \glob(FIXTURES_PATH . DIRECTORY_SEPARATOR . 'ignore*');
     \array_map('unlink', $removeFiles);
 }

 public function testCanGetRawPostDataFromInputStream()
 {
     stream_wrapper_unregister("php");
     stream_wrapper_register("php", PhpStreamMock::class);
     file_put_contents('php://input', 'Unit-Test');
     $postRequest = new PostRequest(RequestInfo::fromEnv(), [], []);
     $this->assertEquals('Unit-Test', $postRequest->getRawData());
     stream_wrapper_restore("php");
 }

 public static function tearDownAfterClass()
 {
     \stream_wrapper_restore('http');
     \stream_wrapper_restore('https');
     // TODO: Move this where it will execute after the entire suite runs.
     // Clean up all ignore files.
     $removeFiles = \glob(FIXTURES_PATH . DIRECTORY_SEPARATOR . 'ignore*');
     \array_map('unlink', $removeFiles);
 }

 public function testCanCreateFromRawPost()
 {
     // Prep php://input with mocked data
     MockPhpStream::setStartingData(json_encode($this->messageData));
     stream_wrapper_unregister('php');
     stream_wrapper_register('php', __NAMESPACE__ . '\\MockPhpStream');
     $message = Message::fromRawPostData();
     $this->assertInstanceOf('Aws\\Sns\\MessageValidator\\Message', $message);
     stream_wrapper_restore("php");
 }

 public function testCanAccessRawDataFromRequest()
 {
     stream_wrapper_unregister("php");
     stream_wrapper_register("php", PhpStreamMock::class);
     file_put_contents('php://input', 'Unit-Test');
     $postRequest = new PostRequest(RequestInfo::fromEnv(), [], []);
     $command = new TestDomainCommand($postRequest);
     $this->assertEquals('Unit-Test', $command->getBody());
     stream_wrapper_restore("php");
 }

 public static function reset()
 {
     foreach (self::$existingWrappers as $wrapper) {
         stream_wrapper_unregister($wrapper);
         if (in_array($wrapper, self::$originalWrappers)) {
             stream_wrapper_restore($wrapper);
         }
     }
     self::$originalWrappers = array();
     self::$existingWrappers = array();
 }

 /**
  * Capture output
  *
  * @param   lang.Runnable r
  * @param   array<string, string> initial
  * @return  array<string, string>
  */
 public static function capture(Runnable $r, $initial = [])
 {
     self::$streams = $initial;
     stream_wrapper_unregister('php');
     stream_wrapper_register('php', __CLASS__);
     try {
         $r->run();
     } finally {
         stream_wrapper_restore('php');
     }
     return self::$streams;
 }

 public function testCanCreateFromRawPost()
 {
     $_SERVER['HTTP_X_AMZ_SNS_MESSAGE_TYPE'] = 'Notification';
     // Prep php://input with mocked data
     MockPhpStream::setStartingData(json_encode($this->messageData));
     stream_wrapper_unregister('php');
     stream_wrapper_register('php', __NAMESPACE__ . '\\MockPhpStream');
     $message = Message::fromRawPostData();
     $this->assertInstanceOf('Aws\\Sns\\Message', $message);
     stream_wrapper_restore("php");
     unset($_SERVER['HTTP_X_AMZ_SNS_MESSAGE_TYPE']);
 }

 /**
  * Attempt to locate a class by name.
  *
  * If class already exists, simply use internal reflection API to get the
  * filename and store it.
  *
  * If class does not exist, we make an assumption that whatever autoloaders
  * that are registered will be loading a file. We then override the file://
  * protocol stream wrapper to "capture" the filename we expect the class to
  * be in, and then restore it. Note that class_exists will cause an error
  * that it cannot find the file, so we squelch the errors by overriding the
  * error handler temporarily.
  *
  * @param string $className
  * @return string
  */
 private function locateClassByName($className)
 {
     if (class_exists($className, false) || interface_exists($className, false) || trait_exists($className, false)) {
         return (new \ReflectionClass($className))->getFileName();
     }
     self::$autoloadLocatedFile = null;
     $previousErrorHandler = set_error_handler(function () {
     });
     stream_wrapper_unregister('file');
     stream_wrapper_register('file', self::class);
     class_exists($className);
     stream_wrapper_restore('file');
     set_error_handler($previousErrorHandler);
     return self::$autoloadLocatedFile;
 }

 /**
  * 
  * @param string $wsdl
  * @param array $options 
  */
 function SoapClientAuth($wsdl, $options = NULL)
 {
     stream_wrapper_unregister('https');
     stream_wrapper_unregister('http');
     stream_wrapper_register('https', 'streamWrapperHttpAuth');
     stream_wrapper_register('http', 'streamWrapperHttpAuth');
     if ($options) {
         $this->Username = $options['login'];
         streamWrapperHttpAuth::$Username = $this->Username;
         $this->Password = $options['password'];
         streamWrapperHttpAuth::$Password = $this->Password;
     }
     parent::SoapClient($wsdl, $options ? $options : array());
     stream_wrapper_restore('https');
     stream_wrapper_restore('http');
 }

 /**
  * Capture output
  *
  * @param   lang.Runnable r
  * @param   array<string, string> initial
  * @return  array<string, string>
  */
 public static function capture(Runnable $r, $initial = array())
 {
     self::$streams = $initial;
     stream_wrapper_unregister('php');
     stream_wrapper_register('php', __CLASS__);
     try {
         $r->run();
     } catch (Exception $e) {
     }
     ensure($e);
     stream_wrapper_restore('php');
     if ($e) {
         throw $e;
     }
     return self::$streams;
 }

 /**
  * @runInSeparateProcess
  */
 public function testCanGetBodyDataFromInputStream()
 {
     stream_wrapper_unregister("php");
     stream_wrapper_register("php", PhpStreamMock::class);
     file_put_contents('php://input', 'body data');
     $requestInfo = new RequestInfo(['REQUEST_METHOD' => 'POST', 'REQUEST_URI' => '/domain/test_body_data']);
     $expectedWriteRequest = new WriteRequest($requestInfo, new WriteRequestInput('body data', []));
     $requestHandler = $this->getMockBuilder(HandlesPostRequest::class)->getMockForAbstractClass();
     $requestHandler->expects($this->once())->method('handle')->with($this->equalTo($expectedWriteRequest));
     $writeRoute = new WriteRoute(new Literal('/domain/test_body_data'), $requestHandler);
     $config = $this->getMockBuilder(ConfiguresIceHawk::class)->getMockForAbstractClass();
     $config->method('getRequestInfo')->willReturn($requestInfo);
     $config->expects($this->once())->method('getWriteRoutes')->willReturn([$writeRoute]);
     $writeRequestHandler = new WriteRequestHandler($config, new EventPublisher());
     $writeRequestHandler->handleRequest();
     stream_wrapper_restore("php");
 }

 public function url_stat($path, $flags)
 {
     restore_error_handler();
     //запрос stat проводим к реальной файловой системе
     stream_wrapper_restore("file") or die(__FILE__ . __LINE__);
     //$filename = self::parse_path(parse_url($path,PHP_URL_PATH));
     // если адрес выполняемого скрипта фейковый, то просто подставляем исполняемый файл
     //if(file_exists($filename)) {
     //    $stat=stat($filename);
     //} else {
     $stat = stat(__FILE__);
     //}
     stream_wrapper_unregister("file") or die(__FILE__ . __LINE__);
     stream_wrapper_register("file", get_class($this)) or die(__FILE__ . __LINE__);
     //set_error_handler(array(static::CLASSNAME,"xsltErrorHandler"));
     return $stat;
 }

 function callWsMethod($methodName, $paramArray)
 {
     try {
         if ($methodName == 'DeleteDws' || $methodName == 'GetListCollection') {
             $strResult = "";
             $strResult = $this->client->{$methodName}($paramArray = "");
             return $strResult;
         } else {
             $strResult = "";
             $strResult = $this->client->{$methodName}($paramArray);
             return $strResult;
         }
     } catch (SoapFault $fault) {
         echo 'Fault code: ' . $fault->faultcode;
         echo 'Fault string: ' . $fault->faultstring;
     }
     stream_wrapper_restore('http');
 }

 /**
  *
  * @param string $wsdl
  * @param array $options
  */
 public function __construct($wsdl, $options = NULL)
 {
     $wrappers = stream_get_wrappers();
     stream_wrapper_unregister('http');
     stream_wrapper_register('http', '\\Thybag\\Auth\\StreamWrapperHttpAuth');
     if (in_array("https", $wrappers)) {
         stream_wrapper_unregister('https');
         stream_wrapper_register('https', '\\Thybag\\Auth\\StreamWrapperHttpAuth');
     }
     if ($options) {
         $this->Username = $options['login'];
         \Thybag\Auth\StreamWrapperHttpAuth::$Username = $this->Username;
         $this->Password = $options['password'];
         \Thybag\Auth\StreamWrapperHttpAuth::$Password = $this->Password;
     }
     parent::SoapClient($wsdl, $options ? $options : array());
     stream_wrapper_restore('http');
     if (in_array("https", $wrappers)) {
         stream_wrapper_restore('https');
     }
 }

 /**
  *
  * @param String $url The WSDL url
  * @param Array $data Soap options, it should contain ntlm_username and ntlm_password fields
  * @param LoggerAwareInterface|LoggerInterface $logger
  * @throws Exception
  * @see \SoapClient::__construct()
  */
 public function __construct($url, $data, LoggerInterface $logger = null)
 {
     if ($logger) {
         $this->setLogger($logger);
     }
     $this->options = $data;
     if (empty($data['ntlm_username']) && empty($data['ntlm_password'])) {
         parent::__construct($url, $data);
     } else {
         $this->use_ntlm = true;
         HttpStream\NTLMStream::$user = $data['ntlm_username'];
         HttpStream\NTLMStream::$password = $data['ntlm_password'];
         stream_wrapper_unregister('http');
         if (!stream_wrapper_register('http', '\\NTLMSoap\\HttpStream\\NTLMStream')) {
             throw new Exception("Unable to register HTTP Handler");
         }
         $time_start = microtime(true);
         parent::__construct($url, $data);
         if (!empty($this->logger) && ($end_time = microtime(true) - $time_start) > 0.1) {
             $this->logger->debug("WSDL Timer", array("time" => $end_time, "url" => $url));
         }
         stream_wrapper_restore('http');
     }
 }

 /**
  * Restores the original file stream wrapper status.
  *
  * @return void
  */
 public function restore()
 {
     stream_wrapper_restore(self::PROTOCOL);
 }