PHP PHPUnit_Framework_TestCase::assertSame方法代码示例

 public function assertOnlyDeprecatedErrors(array $deprecationMessages)
 {
     $this->testCase->assertSame(count($deprecationMessages), $this->getCount());
     $this->testCase->assertSame(count($deprecationMessages), $this->getDeprecatedCount());
     foreach ($deprecationMessages as $index => $message) {
         $this->testCase->assertSame($message, $this->getMessage($index));
     }
 }

 /**
  * @test
  */
 public function getFormattedMessage()
 {
     $formatter = $this->getFormatterMock();
     $record = $this->getRecordMock();
     $formatter->expects(parent::once())->method('format')->with($record)->willReturn('foobar');
     $this->formatterContainer->setFormatter($formatter);
     parent::assertSame('foobar', $this->formatterContainer->getFormattedMessage($record));
 }

 /**
  * @param array $values
  * @param array $expected
  *
  * @test
  * @dataProvider getInstanceValues
  */
 public function getValues(array $values, $expected)
 {
     $collection = $this->getCollectionInstance($values);
     foreach ($expected as $key => $value) {
         parent::assertSame($value, $collection->get($key));
         parent::assertSame($value, $collection->{$key});
     }
 }

 public static function assertErrorMessages(TestCase $testCase, FormErrorSequence $formErrorSequence, array $expectedMessages)
 {
     $actualMessages = [];
     foreach ($formErrorSequence as $formError) {
         $actualMessages[$formError->getKey()] = $formError->getMessage();
     }
     $testCase->assertSame($expectedMessages, $actualMessages);
 }

 public static function assertErrorMessages(TestCase $testCase, ValidationResult $validationResult, array $expectedMessages)
 {
     $actualMessages = [];
     foreach ($validationResult->getValidationErrors() as $validationError) {
         $actualMessages[$validationError->getMessage()] = $validationError->getArguments();
     }
     $testCase->assertSame($expectedMessages, $actualMessages);
 }

 /**
  * @test
  */
 public function pushProcessors()
 {
     $processors = [$this->getProcessorMock(), $this->getProcessorMock()];
     foreach ($processors as $processor) {
         $this->processorContainer->pushProcessor($processor);
     }
     foreach ($this->processorContainer->getProcessors() as $x => $processor) {
         parent::assertSame($processors[$x], $processor);
     }
 }

 /**
  * @test
  */
 public function pushHandler()
 {
     $handlers = [$this->getHandlerMock(), $this->getHandlerMock()];
     foreach ($handlers as $handler) {
         $this->handlerContainer->pushHandler($handler);
     }
     foreach ($this->handlerContainer->getHandlers() as $x => $handler) {
         parent::assertSame($handlers[$x], $handler);
     }
 }

 public function testCallableChangeToConsistency()
 {
     $this->connection->callableConsistency(\CouchbaseN1qlQuery::REQUEST_PLUS, function (\Ytake\LaravelCouchbase\Database\CouchbaseConnection $con) {
         \Closure::bind(function () {
             PHPUnit_Framework_TestCase::assertSame(\CouchbaseN1qlQuery::REQUEST_PLUS, $this->consistency);
         }, $con, get_class($con))->__invoke();
     });
     \Closure::bind(function () {
         PHPUnit_Framework_TestCase::assertSame(\CouchbaseN1qlQuery::NOT_BOUNDED, $this->consistency);
     }, $this->connection, get_class($this->connection))->__invoke();
 }

 /**
  * @test
  */
 public function recursiveRecursiveGenerator()
 {
     $rounds = 5;
     $increment = 5;
     $modulus = $rounds * $increment;
     $generator = $this->getRecursiveRecursiveGenerator($rounds, $increment);
     $recursiveIterator = new \RecursiveIteratorIterator(new RecursiveGeneratorIterator($generator));
     $i = 0;
     foreach ($recursiveIterator as $key => $value) {
         parent::assertSame($i % $modulus, $key);
         parent::assertSame($i % $modulus, $value);
         $i++;
     }
     parent::assertSame($rounds * $modulus, $i);
 }

 public function testStripcslashes()
 {
     $t = new \Test\Strings();
     parent::assertSame(stripcslashes('\\abcd\\e\\f\\g\\h\\i\\j\\k\\l\\m\\n\\o\\pqrstuvwxy\\z'), $t->testStripcslashes('\\abcd\\e\\f\\g\\h\\i\\j\\k\\l\\m\\n\\o\\pqrstuvwxy\\z'));
     parent::assertSame(stripcslashes('\\065\\x64'), $t->testStripcslashes('\\065\\x64'));
     parent::assertSame(stripcslashes(''), $t->testStripcslashes(''));
 }

 /**
  * @param object $instance
  * @param string $propertyName
  * @param mixed $testItem
  */
 public static function assertPropertyCollection($instance, $propertyName, $testItem)
 {
     $propertyAccess = new CollectionAccessor($instance, $propertyName);
     // Check default value
     \PHPUnit_Framework_TestCase::assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $propertyAccess->getItems(), $propertyName . ': Default value must be instance of Collection');
     // Check default size
     \PHPUnit_Framework_TestCase::assertCount(0, $propertyAccess->getItems(), $propertyName . ': Default collection size must be 0');
     // Add first item
     \PHPUnit_Framework_TestCase::assertSame($instance, $propertyAccess->addItem($testItem), sprintf('%s::%s() - must return %s', ClassUtils::getClass($instance), $propertyAccess->getAddItemMethod(), ClassUtils::getClass($instance)));
     // Check added item
     \PHPUnit_Framework_TestCase::assertCount(1, $propertyAccess->getItems(), $propertyName . ': After add item - collection size must be 1');
     \PHPUnit_Framework_TestCase::assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $propertyAccess->getItems(), $propertyName . ': After addition of a first item - property value must be instance of Collection');
     \PHPUnit_Framework_TestCase::assertEquals([$testItem], $propertyAccess->getItems()->toArray(), $propertyName . ': After addition of a first item - collections must be equals');
     // Add already added item
     $propertyAccess->addItem($testItem);
     \PHPUnit_Framework_TestCase::assertCount(1, $propertyAccess->getItems(), $propertyName . ': After addition already added item - collection size must be same and equal 1');
     // Remove item
     \PHPUnit_Framework_TestCase::assertSame($instance, $propertyAccess->removeItem($testItem), sprintf('%s:%s() - must return %s', ClassUtils::getClass($instance), $propertyAccess->getRemoveItemMethod(), ClassUtils::getClass($instance)));
     \PHPUnit_Framework_TestCase::assertCount(0, $propertyAccess->getItems(), $propertyName . ': After removal of a single item - collection size must be 0');
     // Remove already removed item
     $propertyAccess->removeItem($testItem);
     \PHPUnit_Framework_TestCase::assertCount(0, $propertyAccess->getItems(), $propertyName . ': After removal already removed item - collection size must be same and equal 0');
     \PHPUnit_Framework_TestCase::assertNotContains($testItem, $propertyAccess->getItems()->toArray(), $propertyName . ': After removal of a single item - collection must not contains test item');
 }

 /**
  * @deprecated since 2.3
  * @static
  * @param mixed $expected
  * @param mixed $actual
  * @param string $message
  * @return void
  */
 public static function assertIdentical($expected, $actual, $message = '')
 {
     parent::assertSame($expected, $actual, $message);
 }

 /**
  * @param string $body
  *
  * @return ResponseAssertion
  */
 public function hasBody($body)
 {
     $this->testCase->assertSame($body, (string) $this->response->getBody());
     return $this;
 }

 /**
  * @test
  */
 public function toStringMethod()
 {
     $level = new Level();
     parent::assertSame((string) $level, sprintf('%s (%s)', $level->getName(), $level->getValue()));
 }

 /**
  * Helper method that checks a value object's value.
  *
  * @param VO $instance
  * @param string $checkedValue
  * @param string $attributeName
  */
 public static function assertValueObjectHasValue(VO $instance, $checkedValue, $attributeName = 'value')
 {
     $value = \PHPUnit_Framework_Assert::readAttribute($instance, $attributeName);
     \PHPUnit_Framework_TestCase::assertSame($checkedValue, $value);
 }