Asserts that the body of the response is equal to a given string.
@param string $inExpected The expected response's body.
@param Response $inResponse HTTP response.
@param string $message
330376
public function assertResponseBodyEquals($inExpected, Response $inResponse, $message = '') {
        \PHPUnit_Framework_Assert::assertEquals($inExpected, $inResponse->getBody(), $message);
    }
1193631
public static function assertStringIsEmpty($actual, string $message = '')
    {
        AssertHelper::assertMethodDependency(__CLASS__, __TRAIT__, 'assertStringIsEmpty', ['assertThat', 'assertEmpty']);
        self::assertThat($actual, new IsType('string'), $message);
        self::assertEmpty($actual, $message);
    }
320279
public function assertSameSize($expected, $message = '')
    {
        Assert::assertSameSize($expected, $this->getData(), $message);

        return $this;
    }
473609
public static void assertCauseMessage(final Throwable ex, final String expectedMessage) {
        assertThat(ex.getCause()).isNotNull();
        assertThat(ex.getCause().getMessage()).isEqualTo(expectedMessage);
    }
574998
private function parseSuccess($responseInJson)
    {
        if (array_key_exists(self::MESSAGE_ID, $responseInJson)) {
            $this->messageId = $responseInJson[ self::MESSAGE_ID ];
        }
    }
378758
public function notStrictEqual($actual, $expected, $message = '')
    {
        $this->assertion->setActual($actual);

        return $this->assertion->to->not->equal($expected, $message);
    }
186921
private function fillWithBodyMatches(Expectation $expectation, ServerRequestInterface $httpRequest, $responseBody)
    {
        if ($this->bodyConditionIsRegex($expectation)) {
            return $this->replaceMatches(
                'body',
                $expectation->getRequest()->getBody()->getValue(),
                $httpRequest->getBody()->__toString(),
                $responseBody
            );
        }

        return $responseBody;
    }
1016839
public function respondCreatedWithPayload($payload = null, $message = "Created")
    {

        $reponse = $this->setStatusCode(ResponseHTTP::HTTP_CREATED)
            ->respondWithMessageAndPayload($payload, $message);
        return $reponse;
    }
976392
public function responseReceived(Swift_Events_ResponseEvent $evt)
    {
        $response = $evt->getResponse();
        $this->in += strlen($response);
    }
1089797
protected function assertNotEquals($expected, $actual, $message = '', $delta = 0.0)
    {
        \PHPUnit\Framework\Assert::assertNotEquals($expected, $actual, $message, $delta);
    }
140023
protected function processResponse(Response $response, $expectedCode = 200)
	{
		if (202 == $response->code)
		{
			throw new \DomainException(
				'GitHub is building the statistics data. Please try again in a few moments.',
				$response->code
			);
		}

		return parent::processResponse($response, $expectedCode);
	}
167823
protected function assertRegExp($pattern, $string, $message = '')
    {
        \PHPUnit\Framework\Assert::assertRegExp($pattern, $string, $message);
    }
874679
static void assertEquals(String message, Object comparison1, Object comparison2)
    {
        if(comparison1 == comparison2)
        {
            return;
        }
        if(comparison1.equals(comparison2))
        {
            return;
        }

        System.err.println(message);
    }
380934
public static function assumeThat($actual, Matcher $matcher, $message = ''): void
    {
        if (!$matcher->matches($actual)) {
            throw new AssumptionViolatedException($actual, $matcher, $message);
        }
    }
1001493
public static function assertEqualsRegExp($compare, $string)
    {
        if (is_array($compare)) {
            $compare = implode('{{ \s* }}', $compare);
            $compare = str_replace(array('{{ \s* }}{{ ', ' }}{{ \s* }}'), array('{{ ', ' }}'), $compare);
        }
        if (empty($compare)) {
            return self::assertEquals($compare, $string);
        }
        $string = trim(str_replace(array("\r", "\n", "\t"), '', $string));
        $error = $string;
        preg_match_all('/{{\s[^\}]*\s}}/', $compare, $regexp);
        $equals = preg_split('/{{\s[^\}]*\s}}/', $compare);
        foreach ($equals as $key => $value) {
            if (!empty($value)) {
                try {
                    self::assertEquals($value, substr($string, 0, strlen($value)));
                } catch (\Exception $e) {
                    self::fail(implode("\n", array(
                        $e->getMessage(),
                        '--- Expected',
                        '+++ Actual',
                        '@@ @@',
                        self::merge(array_slice($equals, 0, $key, true), $regexp[0]),
                        '',
                        "-'".$value."'",
                        "+'".$string."'",
                    )));
                }
                $string = substr($string, strlen($value));
            }
            $next = (isset($equals[$key + 1])) ? $equals[$key + 1] : '';
            $length = (!empty($next)) ? strpos($string, $next) : 0;
            if (isset($regexp[0][$key]) && $length !== false) {
                $pattern = substr($regexp[0][$key], 3, -3);
                try {
                    self::assertRegExp('/^'.$pattern.'$/', substr($string, 0, $length));
                } catch (\Exception $e) {
                    if ('{{ '.$pattern.' }}' == substr($string, 0, $length)) {
                        // a literal (string) match
                    } else {
                        self::fail(implode("\n", array(
                            self::merge(array_slice($equals, 0, $key, true), $regexp[0]),
                            '',
                            $e->getMessage(),
                            $value.$regexp[0][$key].$next,
                            '',
                            self::merge(array_slice($equals, $key + 2, null, true), $regexp[0]),
                        )));
                    }
                }
                $string = substr($string, $length);
            }
        }
        if (!empty($string)) {
            return self::assertEquals(strstr($error, $string, true), $error);
        }
    }
778821
public static void assertEquals(String message, Object expected, Object actual) {
        if (expected == null && actual != null || expected != null && !expected.equals(actual)) {
            fail(message);
        }
    }
390162
private function requestBodyMatchesExpectation(ServerRequestInterface $httpRequest, Request $expectedRequest)
    {
        $inputSource = $this->inputSourceFactory->createFromConfig([
            'body' => null,
        ]);
        $matcher = $this->matcherFactory->createFromConfig([
            $expectedRequest->getBody()->getMatcher() => $expectedRequest->getBody()->getValue(),
        ]);

        return $this->evaluate($inputSource, $matcher, $httpRequest);
    }