/**
  * @test
  */
 public function writesToStandardOutputBuffer()
 {
     $out = new StandardOutputStream();
     ob_start();
     $out->write('foo');
     assert(ob_get_contents(), equals('foo'));
     ob_end_clean();
 }

 /**
  * @test
  */
 public function canIterateOverNonSeekableInputStream()
 {
     $inputStream = NewInstance::of(InputStream::class)->mapCalls(['readLine' => onConsecutiveCalls('foo', 'bar', 'baz', ''), 'eof' => onConsecutiveCalls(false, false, false, true)]);
     $content = [];
     foreach (linesOf($inputStream) as $lineNumber => $line) {
         $content[$lineNumber] = $line;
     }
     assert($content, equals([1 => 'foo', 2 => 'bar', 3 => 'baz']));
 }

 /**
  * @test
  */
 public function keyConsumerIsNotCalledWhenNoKeyInForeachRequested()
 {
     $i = 0;
     $peek = new Peek(new \ArrayIterator(['foo' => 303, 'bar' => 404, 'baz' => 505]), function () {
     }, function () {
         fail('Key consumer is not expected to be called');
     });
     foreach ($peek as $value) {
         $i++;
     }
     assert($i, equals(3));
 }

 /**
  * @test
  */
 public function infiniteGeneratorDoesStopOnlyWhenBreakOutOfLoop()
 {
     $i = 0;
     foreach (Generator::infinite(0, function ($value) {
         return $value + 2;
     }) as $key => $value) {
         if (1000 > $key) {
             $i++;
         } else {
             break;
         }
     }
     assert($i, equals(1000));
 }

 /**
  * @test
  */
 public function parseRecognizesHttpsUris()
 {
     assert(Parse::toType('https://example.net/'), equals(HttpUri::fromString('https://example.net/')));
 }

 /**
  * @test
  */
 public function handleSignalsResultOfResponsibleErrorHandlerIfErrorReportingEnabled()
 {
     $oldLevel = error_reporting(E_ALL);
     try {
         $this->errorHandler1->mapCalls(['isResponsible' => false]);
         $this->errorHandler2->mapCalls(['isResponsible' => true, 'isSupressable' => false, 'handle' => ErrorHandler::STOP_ERROR_HANDLING]);
         assert($this->errorHandlers->handle(1, 'foo'), equals(ErrorHandler::STOP_ERROR_HANDLING));
     } finally {
         error_reporting($oldLevel);
     }
 }

 /**
  * @test
  * @since  3.2.0
  */
 public function writeLinesWritesBytesIntoBuffer()
 {
     $this->memoryOutputStream->writeLines(['hello', 'world']);
     assert($this->memoryOutputStream->buffer(), equals("hello\nworld\n"));
 }

 /**
  * @param  mixed   $value
  * @param  string  $expectedType
  * @test
  * @dataProvider  valueTypes
  * @since  7.0.0
  */
 public function typeOfOtherValuesReturnsNativeType($value, string $expectedType)
 {
     assert(typeOf($value), equals($expectedType));
 }

 /**
  * @since   2.0.0
  * @test
  */
 public function deleteWritesCorrectRequestWithVersion()
 {
     $this->createHttpRequest()->delete(5, HttpVersion::HTTP_1_0);
     assert($this->memory, equals(Http::lines('DELETE /foo/resource HTTP/1.0', 'Host: example.com', 'X-Binford: 6100', '')));
 }

 /**
  * @test
  * @since  4.1.0
  */
 public function returnsParsedValuesForCommonProperties()
 {
     assert($this->createPropertyBinding('DEV')->getInstance($this->injector, 'baz'), equals(reflect(Properties::class)));
 }

 /**
  * @test
  */
 public function bytesLeftCallsDecoratedStream()
 {
     assert($this->decoratedInputStream->bytesLeft(), equals(4));
 }

 /**
  * @test
  * @since  3.2.0
  */
 public function writeLinesPassesBytesWithLinebreakIntoStream()
 {
     $file = vfsStream::newFile('test.txt')->at($this->root);
     $resourceOutputStream = $this->createResourceOutputStream(fopen(vfsStream::url('root/test.txt'), 'w'));
     assert($resourceOutputStream->writeLines(['foo', 'bar', 'baz']), equals(15));
     assert($file->getContent(), equals("foo\r\nbar\r\nbaz\r\n"));
 }

 /**
  * @test
  */
 public function partitioningByWithSum()
 {
     assert(Sequence::of($this->people)->collect()->inPartitions(function (Employee $e) {
         return $e->years() > 10;
     }, Collector::forSum(function (Employee $e) {
         return $e->years();
     })), equals([true => 29, false => 4]));
 }

 /**
  * @test
  * @since  8.0.0
  */
 public function startsAtPositionZero()
 {
     assert($this->standardInputStream->tell(), equals(0));
 }

 /**
  * @test
  * @since  7.0.0
  */
 public function headerListCanBeCastedToString()
 {
     $headers = "Binford: 6100\r\nX-Power: More power!";
     assert((string) parseHeaders($headers), equals($headers));
 }

 /**
  * @test
  */
 public function createInputStreamUsesGivenStringAsStreamContent()
 {
     $memoryInputStream = $this->memoryStreamFactory->createInputStream('buffer');
     assert($memoryInputStream->readLine(), equals('buffer'));
 }

 /**
  * @test
  */
 public function exportsAnyThingElseWithDefault()
 {
     assert(Provides::values([1])->describeValue(exporter(), 'foo'), equals('\'foo\''));
 }

 /**
  * @test
  */
 public function mixedAnnotations()
 {
     $plugin = NewInstance::of(Plugin::class);
     $binder = new Binder();
     $binder->bindList('listConfig');
     $binder->bindMap('mapConfig');
     $binder->bind(Plugin::class)->named('foo')->toInstance($plugin);
     $binder->bindConstant('foo')->to(42);
     $binder->bindList('aList')->withValue(313);
     $binder->bindMap('aMap')->withEntry('tb', 303);
     assert($this->createPluginHandler($binder)->getArgs(), equals(['std' => $plugin, 'answer' => 42, 'list' => [313], 'map' => ['tb' => 303]]));
 }

 /**
  * @test
  */
 public function namedConstructorInjectionWithMultipleParamAndNamedParamGroup()
 {
     $binder = new Binder();
     $binder->bind(Employee::class)->named('schst')->to(Boss::class);
     $binder->bind(Employee::class)->to(TeamMember::class);
     $injector = $binder->getInjector();
     $group = $injector->getInstance(DevelopersMultipleConstructorParamsGroupedName::class);
     assert($group, equals(new DevelopersMultipleConstructorParamsGroupedName(new Boss(), new Boss())));
 }

 /**
  * @test
  * @since  8.0.0
  */
 public function writeLinesReturnsOnlyAmountOfUnfilteredBytedWritten()
 {
     assert($this->filteredOutputStream->writeLines(['foo', 'bar']), equals(4));
 }