public function bytestring($data)
 {
     $a = new \SplFixedArray(strlen($data));
     for ($i = 0; $i < strlen($data); $i++) {
         $a[$i] = str_pad(ord($data[$i]), 3, ' ', STR_PAD_LEFT);
     }
     return implode(' ', $a->toArray());
 }

 /**
  * Returns a Collection of the values.
  *
  * @return Collection
  */
 public function values()
 {
     $count = $this->count()->toNative();
     $valuesArray = new \SplFixedArray($count);
     foreach ($this->items as $key => $item) {
         $valuesArray->offsetSet($key, $item->getValue());
     }
     return new Collection($valuesArray);
 }

 /**
  * {@inheritdoc}
  */
 public function sort(\SplFixedArray $array)
 {
     $length = $array->count();
     for ($i = 1; $i < $length; $i++) {
         $key = $array[$i];
         $j = $i - 1;
         while ($j >= 0 && $array[$j] > $key) {
             $array[$j + 1] = $array[$j];
             $j--;
         }
         $array[$j + 1] = $key;
     }
     return $array;
 }

 public function testFromArrayDisordered()
 {
     $array = array(1 => 'foo', 3 => 'bar', 2 => 'baz', 0 => 'qux');
     $the_DS = DynamicArray::fromArray($array);
     $SPL_DS = \SplFixedArray::fromArray($array);
     $this->assertMethodsEqual($SPL_DS, $the_DS);
 }

 /**
  * Create a new instance.
  *
  * @param array            $matchRegexps The regexes to match files.
  *
  * @param AbstractFilter[] $filters      The filters to apply.
  */
 public function __construct(array $matchRegexps, $filters)
 {
     foreach ($matchRegexps as $pattern) {
         $this->matchRegexps[] = $this->toRegex($pattern);
     }
     $this->filters = \SplFixedArray::fromArray($filters);
 }

 /**
  * {@inheritdoc}
  */
 public function sort(\SplFixedArray $array)
 {
     $length = $array->count();
     for ($i = 0; $i < $length - 1; $i++) {
         $smallest = $i;
         for ($j = $i + 1; $j < $length; $j++) {
             if ($array[$j] < $array[$smallest]) {
                 $smallest = $j;
             }
         }
         $tmp = $array[$i];
         $array[$i] = $array[$smallest];
         $array[$smallest] = $tmp;
     }
     return $array;
 }

 /**
  * @param array $array
  * @param boolean $save_indexes = true
  * @return SplFixedArray, DataStructures\SerializableFixedArray
  */
 public static function fromArray(array $array, $save_indexes = true)
 {
     if (self::$_useSpl === null) {
         self::_checkEnvironment();
     }
     return self::$_useSpl ? \SplFixedArray::fromArray($array, $save_indexes) : new self(count($array), $save_indexes ? $array : array_values($array));
 }

 public function testMapTraversable()
 {
     $expected = [1, 2, 3, 4];
     $arr = \SplFixedArray::fromArray($expected);
     $actual = t::into([], t::map(t::value()), $arr);
     $this->assertEquals($expected, $actual);
 }

 /**
  * Create a new ImmutableVector from the given traversable.
  * @param array|Traversable $traversable
  * @param bool $preserveKeys
  * @return ImmutableVector
  */
 public static function copyOf($traversable, $preserveKeys = true)
 {
     if (is_array($traversable)) {
         return new self(\SplFixedArray::fromArray($traversable, $preserveKeys));
     } else {
         return new self(\SplFixedArray::fromArray(iterator_to_array($traversable), $preserveKeys));
     }
 }

 /**
  * @param int|string $start
  * @param int|string $length
  * @return $this
  */
 public function slice($start, $length)
 {
     $end = $this->set->getSize();
     if ($start > $end || $length > $end) {
         throw new \RuntimeException('Invalid start or length');
     }
     $this->set = \SplFixedArray::fromArray(array_slice($this->set->toArray(), $start, $length));
     return $this;
 }

 public function valuesDataProvider()
 {
     $splFixedArrayIn = \SplFixedArray::fromArray([2, 154, 2342, 1001, 7651, 4523, 1343, 756, 6324, 1]);
     $expected = [1, 2, 154, 756, 1001, 1343, 2342, 4523, 6324, 7651];
     $splFixedArrayIn2 = clone $splFixedArrayIn;
     $splFixedArrayIn2[9] = 8000;
     $expected2 = [2, 154, 756, 1001, 1343, 2342, 4523, 6324, 7651, 8000];
     return [[$splFixedArrayIn, $expected], [$splFixedArrayIn2, $expected2]];
 }

 /**
  * Imports a PHP array in a FixedArray instance.
  *
  * This method needs to be reimplemented as SplFixedArray does not return `new static`.
  * @see https://bugs.php.net/bug.php?id=55128
  *
  * Subclasses of FixedArray do not need to reimplement this method.
  *
  * @param array   $array
  * @param boolean $saveIndexes
  *
  * @return FixedArray
  *
  * @throws \InvalidArgumentException If the array contains non-numeric or negative indexes.
  */
 public static function fromArray($array, $saveIndexes = true)
 {
     $splFixedArray = \SplFixedArray::fromArray($array, $saveIndexes);
     $result = new static($splFixedArray->count());
     $source = $saveIndexes ? $array : $splFixedArray;
     foreach ($source as $key => $value) {
         $result[$key] = $value;
     }
     return $result;
 }

 /**
  * 
  * @param PointInterface[] $points
  * @param LineFactoryInterface $lineFactory
  */
 public function __construct(array $points, LineFactoryInterface $lineFactory)
 {
     $items = [];
     for ($i = 0; $i < count($points) - 1;) {
         $items[] = $lineFactory->createLineSegment($points[$i], $points[++$i]);
     }
     // and add last segment
     $items[] = $lineFactory->createLineSegment($points[$i], $points[0]);
     $this->items = \SplFixedArray::fromArray($items);
 }

 public function testItReceivesAResultWhenBodyFollowsResponse()
 {
     $command = $this->createCommandInstance();
     $response = $this->getMockBuilder('Rvdv\\Nntp\\Response\\MultiLineResponse')->disableOriginalConstructor()->getMock();
     $lines = \SplFixedArray::fromArray(['Lorem ipsum dolor sit amet, ', 'consectetur adipiscing elit. ', 'Sed volutpat sit amet leo sit amet sagittis.']);
     $response->expects($this->once())->method('getLines')->will($this->returnValue($lines));
     $command->onBodyFollows($response);
     $result = $command->getResult();
     $this->assertEquals(implode("\r\n", $lines->toArray()), $result);
 }

 public function testWhenThereIsAFailedReport()
 {
     $report_mock = \Mockery::mock('\\SimpleHealth\\EndpointReport');
     $report_mock->pass = false;
     $report_mock->message = StringLiteral::fromNative('');
     $reports = new Collection(\SplFixedArray::fromArray([$report_mock]));
     $subject = new NodeValidator();
     $report = $subject->isValid($reports);
     $this->assertEquals($report->pass, false);
 }

 /**
  * insert
  *
  * @param array/string $data
  * @access public
  * @return void
  */
 public function insert($data)
 {
     if (is_array($data)) {
         $data = \SplFixedArray::fromArray($data);
     }
     if (!$data instanceof \Iterator) {
         $data = \SplFixedArray::fromArray([$data]);
     }
     $transformedList = $this->transformer->transform($data);
     return $this->writer->insert($transformedList);
 }

 public function build()
 {
     $endpoints = \SplFixedArray::fromArray($this->endpoints);
     for ($i = 0, $len = count($endpoints); $i < $len; $i++) {
         $endpoints[$i] = Url::fromNative($endpoints[$i]);
     }
     $endpoints = new Collection($endpoints);
     $node_healthcheck_factory = new NodeHealthCheckFactory();
     $node_healthcheck = $node_healthcheck_factory->make($endpoints);
     return new SimpleHealth($endpoints, $node_healthcheck);
 }

 public function testCacheGet()
 {
     $curlFactoryMock = new \mock\M6Web\Bundle\GuzzleHttpBundle\Handler\CurlFactory(3);
     $cacheMock = new \mock\M6Web\Bundle\GuzzleHttpBundle\Cache\CacheInterface();
     $cacheMock->getMockController()->has = true;
     $cacheMock->getMockController()->get = $this->getSerializedResponse(new Response(200, [], "The answer is 42", '1.1', 'OK'));
     $cacheMock->getMockController()->ttl = 256;
     $this->if($testedClass = new TestedClass(['handle_factory' => $curlFactoryMock]))->and($testedClass->setCache($cacheMock, 500, false))->and($testedClass->setDebug(true))->and($request = new Request('GET', 'http://httpbin.org'))->then->object($response = $testedClass($request, [])->wait())->isInstanceOf('GuzzleHttp\\Psr7\\Response')->integer($response->getStatuscode())->isEqualTo(200)->string($response->getReasonPhrase())->isEqualTo('OK')->string($response->getBody()->__toString())->isEqualTo('The answer is 42')->boolean($response->cached)->isTrue()->integer($response->cacheTtl)->isEqualTo(256)->mock($cacheMock)->call('get')->withArguments(md5($request->getMethod() . $request->getUri()))->once()->call('ttl')->withArguments(md5($request->getMethod() . $request->getUri()))->once()->mock($curlFactoryMock)->call('release')->never();
     // Test unserialize issue
     $cacheMock->getMockController()->get = serialize(\SplFixedArray::fromArray([null, null, null, null, null]));
     $this->object($response = $testedClass($request, [])->wait())->isInstanceOf('GuzzleHttp\\Psr7\\Response')->integer($response->getStatuscode())->isEqualTo(200)->boolean(isset($response->cached) ? $response->cached : false)->isFalse()->mock($cacheMock)->call('get')->withArguments(md5($request->getMethod() . $request->getUri()))->twice()->call('ttl')->withArguments(md5($request->getMethod() . $request->getUri()))->once()->mock($curlFactoryMock)->call('release')->once();
 }

 public function testSameValueAs()
 {
     $array = \SplFixedArray::fromArray(array(new StringLiteral('one'), new StringLiteral('two'), new Integer(3)));
     $collection2 = new Collection($array);
     $array = \SplFixedArray::fromArray(array('one', 'two', array(1, 2)));
     $collection3 = Collection::fromNative($array);
     $this->assertTrue($this->collection->sameValueAs($collection2));
     $this->assertTrue($collection2->sameValueAs($this->collection));
     $this->assertFalse($this->collection->sameValueAs($collection3));
     $mock = $this->getMock('EmbarkNow\\ValueObjects\\ValueObjectInterface');
     $this->assertFalse($this->collection->sameValueAs($mock));
 }

function selectionsort(SplFixedArray $arr)
{
    $sIndex = 0;
    $smallestIndex = 0;
    $tmp = null;
    $count = $arr->count();
    while ($sIndex < $count) {
        $smallestIndex = $sIndex;
        for ($i = $sIndex; $i < $count; $i++) {
            if ($arr[$i] < $arr[$smallestIndex]) {
                $smallestIndex = $i;
            }
        }
        if ($sIndex < $smallestIndex) {
            $tmp = $arr[$smallestIndex];
            $arr[$smallestIndex] = $arr[$sIndex];
            $arr[$sIndex] = $tmp;
        }
        $sIndex++;
    }
}