芝麻web文件管理V1.00

编辑当前文件:/home/qrafawbu/joolsmen.com/chat/vendor/ratchet/rfc6455/tests/unit/Messaging/MessageBufferTest.php

<?php

namespace Ratchet\RFC6455\Test\Unit\Messaging;

use Ratchet\RFC6455\Messaging\CloseFrameChecker;
use Ratchet\RFC6455\Messaging\Frame;
use Ratchet\RFC6455\Messaging\Message;
use Ratchet\RFC6455\Messaging\MessageBuffer;
use React\EventLoop\Factory;

class MessageBufferTest extends \PHPUnit_Framework_TestCase
{
    /**
     * This is to test that MessageBuffer can handle a large receive
     * buffer with many many frames without blowing the stack (pre-v0.4 issue)
     */
    public function testProcessingLotsOfFramesInASingleChunk() {
        $frame = new Frame('a', true, Frame::OP_TEXT);

$frameRaw = $frame->getContents();

$data = str_repeat($frameRaw, 1000);

$messageCount = 0;

$messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) use (&$messageCount) {
                $messageCount++;
                $this->assertEquals('a', $message->getPayload());
            },
            null,
            false
        );

$messageBuffer->onData($data);

$this->assertEquals(1000, $messageCount);
    }

public function testProcessingMessagesAsynchronouslyWhileBlockingInMessageHandler() {
        $loop = Factory::create();

$frameA = new Frame('a', true, Frame::OP_TEXT);
        $frameB = new Frame('b', true, Frame::OP_TEXT);

$bReceived = false;

$messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) use (&$messageCount, &$bReceived, $loop) {
                $payload = $message->getPayload();
                $bReceived = $payload === 'b';

if (!$bReceived) {
                    $loop->run();
                }
            },
            null,
            false
        );

$loop->addPeriodicTimer(0.1, function () use ($messageBuffer, $frameB, $loop) {
            $loop->stop();
            $messageBuffer->onData($frameB->getContents());
        });

$messageBuffer->onData($frameA->getContents());

$this->assertTrue($bReceived);
    }

public function testInvalidFrameLength() {
        $frame = new Frame(str_repeat('a', 200), true, Frame::OP_TEXT);

$frameRaw = $frame->getContents();

$frameRaw[1] = "\x7f"; // 127 in the first spot

$frameRaw[2] = "\xff"; // this will unpack to -1
        $frameRaw[3] = "\xff";
        $frameRaw[4] = "\xff";
        $frameRaw[5] = "\xff";
        $frameRaw[6] = "\xff";
        $frameRaw[7] = "\xff";
        $frameRaw[8] = "\xff";
        $frameRaw[9] = "\xff";

/** @var Frame $controlFrame */
        $controlFrame = null;
        $messageCount = 0;

$messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) use (&$messageCount) {
                $messageCount++;
            },
            function (Frame $frame) use (&$controlFrame) {
                $this->assertNull($controlFrame);
                $controlFrame = $frame;
            },
            false,
            null,
            0,
            10
        );

$messageBuffer->onData($frameRaw);

$this->assertEquals(0, $messageCount);
        $this->assertTrue($controlFrame instanceof Frame);
        $this->assertEquals(Frame::OP_CLOSE, $controlFrame->getOpcode());
        $this->assertEquals([Frame::CLOSE_PROTOCOL], array_merge(unpack('n*', substr($controlFrame->getPayload(), 0, 2))));

}

public function testFrameLengthTooBig() {
        $frame = new Frame(str_repeat('a', 200), true, Frame::OP_TEXT);

$frameRaw = $frame->getContents();

$frameRaw[1] = "\x7f"; // 127 in the first spot

$frameRaw[2] = "\x7f"; // this will unpack to -1
        $frameRaw[3] = "\xff";
        $frameRaw[4] = "\xff";
        $frameRaw[5] = "\xff";
        $frameRaw[6] = "\xff";
        $frameRaw[7] = "\xff";
        $frameRaw[8] = "\xff";
        $frameRaw[9] = "\xff";

/** @var Frame $controlFrame */
        $controlFrame = null;
        $messageCount = 0;

$messageBuffer->onData($frameRaw);

$this->assertEquals(0, $messageCount);
        $this->assertTrue($controlFrame instanceof Frame);
        $this->assertEquals(Frame::OP_CLOSE, $controlFrame->getOpcode());
        $this->assertEquals([Frame::CLOSE_TOO_BIG], array_merge(unpack('n*', substr($controlFrame->getPayload(), 0, 2))));
    }

public function testFrameLengthBiggerThanMaxMessagePayload() {
        $frame = new Frame(str_repeat('a', 200), true, Frame::OP_TEXT);

$frameRaw = $frame->getContents();

/** @var Frame $controlFrame */
        $controlFrame = null;
        $messageCount = 0;

$messageBuffer->onData($frameRaw);

$this->assertEquals(0, $messageCount);
        $this->assertTrue($controlFrame instanceof Frame);
        $this->assertEquals(Frame::OP_CLOSE, $controlFrame->getOpcode());
        $this->assertEquals([Frame::CLOSE_TOO_BIG], array_merge(unpack('n*', substr($controlFrame->getPayload(), 0, 2))));
    }

public function testSecondFrameLengthPushesPastMaxMessagePayload() {
        $frame = new Frame(str_repeat('a', 200), false, Frame::OP_TEXT);
        $firstFrameRaw = $frame->getContents();
        $frame = new Frame(str_repeat('b', 200), true, Frame::OP_TEXT);
        $secondFrameRaw = $frame->getContents();

/** @var Frame $controlFrame */
        $controlFrame = null;
        $messageCount = 0;

$messageBuffer->onData($firstFrameRaw);
        // only put part of the second frame in to watch it fail fast
        $messageBuffer->onData(substr($secondFrameRaw, 0, 150));

$this->assertEquals(0, $messageCount);
        $this->assertTrue($controlFrame instanceof Frame);
        $this->assertEquals(Frame::OP_CLOSE, $controlFrame->getOpcode());
        $this->assertEquals([Frame::CLOSE_TOO_BIG], array_merge(unpack('n*', substr($controlFrame->getPayload(), 0, 2))));
    }

/**
     * Some test cases from memory limit inspired by https://github.com/BrandEmbassy/php-memory
     *
     * Here is the license for that project:
     * MIT License
     *
     * Copyright (c) 2018 Brand Embassy
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in all
     * copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     * SOFTWARE.
     */

/**
     * @dataProvider phpConfigurationProvider
     *
     * @param string $phpConfigurationValue
     * @param int $expectedLimit
     */
    public function testMemoryLimits($phpConfigurationValue, $expectedLimit) {
        $method = new \ReflectionMethod('Ratchet\RFC6455\Messaging\MessageBuffer', 'getMemoryLimit');
        $method->setAccessible(true);
        $actualLimit = $method->invoke(null, $phpConfigurationValue);

$this->assertSame($expectedLimit, $actualLimit);
    }

public function phpConfigurationProvider() {
        return [
            'without unit type, just bytes' => ['500', 500],
            '1 GB with big "G"' => ['1G', 1 * 1024 * 1024 * 1024],
            '128 MB with big "M"' => ['128M', 128 * 1024 * 1024],
            '128 MB with small "m"' => ['128m', 128 * 1024 * 1024],
            '24 kB with small "k"' => ['24k', 24 * 1024],
            '2 GB with small "g"' => ['2g', 2 * 1024 * 1024 * 1024],
            'unlimited memory' => ['-1', 0],
            'invalid float value' => ['2.5M', 2 * 1024 * 1024],
            'empty value' => ['', 0],
            'invalid ini setting' => ['whatever it takes', 0]
        ];
    }

/**
     * @expectedException \InvalidArgumentException
     */
    public function testInvalidMaxFramePayloadSizes() {
        $messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) {},
            function (Frame $frame) {},
            false,
            null,
            0,
            0x8000000000000000
        );
    }

/**
     * @expectedException \InvalidArgumentException
     */
    public function testInvalidMaxMessagePayloadSizes() {
        $messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) {},
            function (Frame $frame) {},
            false,
            null,
            0x8000000000000000,
            0
        );
    }

/**
     * @dataProvider phpConfigurationProvider
     *
     * @param string $phpConfigurationValue
     * @param int $expectedLimit
     *
     * @runInSeparateProcess
     * @requires PHP 7.0
     */
    public function testIniSizes($phpConfigurationValue, $expectedLimit) {
        ini_set('memory_limit', $phpConfigurationValue);
        $messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) {},
            function (Frame $frame) {},
            false,
            null
        );

if ($expectedLimit === -1) {
            $expectedLimit = 0;
        }

$prop = new \ReflectionProperty($messageBuffer, 'maxMessagePayloadSize');
        $prop->setAccessible(true);
        $this->assertEquals($expectedLimit / 4, $prop->getValue($messageBuffer));

$prop = new \ReflectionProperty($messageBuffer, 'maxFramePayloadSize');
        $prop->setAccessible(true);
        $this->assertEquals($expectedLimit / 4, $prop->getValue($messageBuffer));
    }

/**
     * @runInSeparateProcess
     * @requires PHP 7.0
     */
    public function testInvalidIniSize() {
        ini_set('memory_limit', 'lots of memory');
        $messageBuffer = new MessageBuffer(
            new CloseFrameChecker(),
            function (Message $message) {},
            function (Frame $frame) {},
            false,
            null
        );

$prop = new \ReflectionProperty($messageBuffer, 'maxMessagePayloadSize');
        $prop->setAccessible(true);
        $this->assertEquals(0, $prop->getValue($messageBuffer));

$prop = new \ReflectionProperty($messageBuffer, 'maxFramePayloadSize');
        $prop->setAccessible(true);
        $this->assertEquals(0, $prop->getValue($messageBuffer));
    }
}