/** @test */
 public function simpleStubWithPhake()
 {
     $service = \Phake::mock('\\Acme\\ServiceInterface');
     \Phake::when($service)->readTemp()->thenReturn(10)->thenReturn(12)->thenReturn(14);
     $temperature = new Temperature($service);
     $this->assertEquals(12, $temperature->average());
 }

 /**
  * @test
  */
 public function parseNormal()
 {
     \Phake::when($this->commentsParser)->parse(\Phake::anyParameters())->thenReturn(null);
     $stmts = (include __DIR__ . '/../fixtures/1/Model/Product.php.property_base.cache');
     $this->parser->parse($stmts, $this->property, $this->class);
     \Phake::verify($this->commentsParser)->parse(\Phake::anyParameters());
 }

 protected function setUp()
 {
     parent::setUp();
     Phake::when($this->facade)->is_user_logged_in()->thenReturn(true);
     Phake::when($this->facade)->wp_get_current_user()->thenReturn($this->user);
     Phake::when($this->wpdb)->get_var(Phake::anyParameters())->thenReturn('true');
 }

 public function initialize($object)
 {
     $reflectionClass = new ReflectionClass($object);
     $reader = new Phake_Annotation_Reader($reflectionClass);
     if ($this->useDoctrineParser()) {
         $parser = new \Doctrine\Common\Annotations\PhpParser();
     }
     $properties = $reader->getPropertiesWithAnnotation('Mock');
     foreach ($properties as $property) {
         $annotations = $reader->getPropertyAnnotations($property);
         if ($annotations['Mock'] !== true) {
             $mockedClass = $annotations['Mock'];
         } else {
             $mockedClass = $annotations['var'];
         }
         if (isset($parser)) {
             // Ignore it if the class start with a backslash
             if (substr($mockedClass, 0, 1) !== '\\') {
                 $useStatements = $parser->parseClass($reflectionClass);
                 $key = strtolower($mockedClass);
                 if (array_key_exists($key, $useStatements)) {
                     $mockedClass = $useStatements[$key];
                 }
             }
         }
         $reflProp = new ReflectionProperty(get_class($object), $property);
         $reflProp->setAccessible(true);
         $reflProp->setValue($object, Phake::mock($mockedClass));
     }
 }

 public function testToString()
 {
     Phake::when($this->adapted)->__toString->thenReturn('test string');
     $result = $this->matcher->__toString();
     Phake::verify($this->adapted)->__toString();
     $this->assertEquals('test string', $result);
 }

 public function testStorageDestruct()
 {
     $this->Web->queries($this->queries);
     $this->Web->crawl();
     // assertion maximus
     \Phake::verify($this->Storage, \Phake::times(1))->destruct();
 }

 /**
  * @test
  */
 public function parseClassComment()
 {
     \Phake::when($this->annotationsParser)->parse(\Phake::anyParameters())->thenReturn([]);
     $stmts = (include __DIR__ . '/../fixtures/1/Model/Product.php.class.cache');
     $class = $this->parser->parse($stmts, '', '');
     $this->assertThat($class->comment, $this->equalTo('商品エンティティ'));
 }

 /**
  * Sets up test fixture
  */
 public function setUp()
 {
     $this->matcher1 = Phake::mock('Phake_Matchers_IChainableArgumentMatcher');
     $this->obj = $this->getMock('Phake_IMock');
     PhakeTestUtil::setStubMapper($this->obj, Phake::mock('Phake_Stubber_StubMapper'));
     $this->proxy = new Phake_Proxies_CallStubberProxy($this->matcher1, false);
 }

 public function testGetUrl()
 {
     $container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
     \Phake::when($container)->getParameter(ModeraFileRepositoryExtension::CONFIG_KEY . '.default_url_generator')->thenReturn('default_url_generator');
     \Phake::when($container)->getParameter(ModeraFileRepositoryExtension::CONFIG_KEY . '.url_generators')->thenReturn(array('foo' => 'foo_url_generator', 'bar' => 'bar_url_generator'));
     $defaultUrlGenerator = \Phake::mock('Modera\\FileRepositoryBundle\\StoredFile\\UrlGeneratorInterface');
     \Phake::when($container)->get('default_url_generator')->thenReturn($defaultUrlGenerator);
     $fooUrlGenerator = \Phake::mock('Modera\\FileRepositoryBundle\\StoredFile\\UrlGeneratorInterface');
     \Phake::when($container)->get('foo_url_generator')->thenReturn($fooUrlGenerator);
     \Phake::when($container)->get('bar_url_generator')->thenReturn('not_url_generator');
     $context = array();
     $splFile = new \SplFileInfo(__FILE__);
     $repository = \Phake::mock('Modera\\FileRepositoryBundle\\Entity\\Repository');
     \Phake::when($repository)->generateStorageKey($splFile, $context)->thenReturn('storage-key');
     $storedFile = new StoredFile($repository, $splFile, $context);
     $storedFile->init($container);
     \Phake::when($defaultUrlGenerator)->generateUrl($storedFile)->thenReturn('default_url');
     \Phake::when($fooUrlGenerator)->generateUrl($storedFile)->thenReturn('foo_url');
     \Phake::when($repository)->getConfig()->thenReturn(array('filesystem' => 'foo'));
     $this->assertEquals('foo_url', $storedFile->getUrl());
     \Phake::when($repository)->getConfig()->thenReturn(array('filesystem' => 'bar'));
     $this->assertEquals('default_url', $storedFile->getUrl());
     \Phake::when($repository)->getConfig()->thenReturn(array('filesystem' => 'baz'));
     $this->assertEquals('default_url', $storedFile->getUrl());
 }

 /** @test */
 public function should_convert_segment_to_string()
 {
     $segment = new Segment('XXX');
     $segment->var = 'value';
     $segmentMapping = new SegmentMapping('XXX');
     $segmentMapping->addDataElement(1, new DataElementMapping(2345, true, DataElementType::A, 'var'));
     $message = new Message();
     $message->setReferenceNumber(34834);
     $message->setIdentifier(["type" => 'TEST', "version" => 'S', "release" => '404', "controllingAgency" => 'PG']);
     $message->addSegment($segment);
     //        $messageMapping = new MessageMapping();
     //        $messageMapping->setDefaults(["0065" => 'TEST', "0052" => 'S', "0054" => '404', "0051" => 'PG']);
     //        $messageMapping->addSegment(new MessageSegmentMapping('UNH', 1, true));
     //        $messageMapping->addSegment(new MessageSegmentMapping('XXX', 99, true));
     //        $messageMapping->addSegment(new MessageSegmentMapping('UNT', 1, true));
     $interchange = new Interchange();
     $interchange->setSyntax(["name" => 'UNOC', "version" => 3]);
     $interchange->setSender(['id' => 'zenon']);
     $interchange->setRecipient(['id' => 'stefan']);
     $interchange->setTime(['date' => '20150101', 'time' => '1034']);
     $interchange->setControlReference('17');
     $interchange->setMessages([$message]);
     $mappingLoader = \Phake::mock(MappingLoader::class);
     \Phake::when($mappingLoader)->loadSegments(\Phake::anyParameters())->thenReturn(['XXX' => $segmentMapping]);
     $encoder = new Encoder(new AnnotationPrinter(new AnnotationReader()), new SegmentPrinter(), $mappingLoader);
     $result = $encoder->encode($interchange);
     $this->assertEquals("UNB+UNOC:3+zenon+stefan+20150101:1034+17'UNH+34834+TEST:S:404:PG'XXX+value'UNT+1+34834'UNZ+1+17'", $result);
 }

 public function testFindInTrans()
 {
     $this->target->begin();
     $this->target->find('hoge', 'ssd', array('a', 'b', 3), 'fuga');
     \Phake::verify($this->write)->find('hoge', 'ssd', array('a', 'b', 3), 'fuga');
     \Phake::verify($this->read, \Phake::never())->find('hoge', 'ssd', array('a', 'b', 3), 'fuga');
 }

 public function setUp()
 {
     $this->mock = $this->getMock('Phake_IMock');
     $this->mockReader = Phake::mock('Phake_MockReader');
     Phake::when($this->mockReader)->getName($this->mock)->thenReturn('Phake_IMock');
     $this->call = new Phake_CallRecorder_Call($this->mock, 'someMethod', array('foo', 'bar'), $this->mockReader);
 }

 public function testCorrelationDataIsAttached()
 {
     CorrelationDataHolder::setCorrelationData(array('correlationId' => 'test'));
     $this->testSubject->send(new HelloCommand('Hi !!!'));
     \Phake::verify($this->mockCommandBus)->dispatch(\Phake::capture($command), null);
     $this->assertEquals(array('correlationId' => 'test'), $command->getMetaData()->all());
 }

 public function invoke($mock, $method, array $arguments, array &$argumentReference)
 {
     if ($this->mockInfo->isObjectFrozen()) {
         $result = new Phake_CallRecorder_VerifierResult(false, array(), 'This object has been frozen.');
         Phake::getClient()->processVerifierResult($result);
     }
 }

 /**
  * @param Phake_IMock $mock
  * @return Phake_Mock_Info
  */
 public static function getMockedInfo(Phake_IMock $mock)
 {
     if (empty($mock->__PHAKE_info)) {
         $mock->__PHAKE_info = Phake::mock('Phake_Mock_Info');
     }
     return $mock->__PHAKE_info;
 }

 public function testEventWithoutStringShouldThrowInvalidArgumentExceptionError()
 {
     $this->setExpectedExceptionRegExp('InvalidArgumentException', '/^Invalid argument: the submitted variable must be a string when you enable the json_format option.$/');
     $json = ['invalid json'];
     \Phake::when($this->formEvent)->getData()->thenReturn($json);
     $this->jsonExtensionListener->onPreSubmit($this->formEvent);
 }

 public function testReset()
 {
     $this->registry->resetAll();
     Phake::verify($this->info1)->resetInfo();
     Phake::verify($this->info2)->resetInfo();
     Phake::verify($this->info3)->resetInfo();
 }

 private function createIUT(array $cssAssets = array(), array $jsAssets = array())
 {
     $container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
     \Phake::when($container)->get('modera_mjr_integration.css_resources_provider')->thenReturn($this->createMockProvider($cssAssets));
     \Phake::when($container)->get('modera_mjr_integration.js_resources_provider')->thenReturn($this->createMockProvider($jsAssets));
     return new AssetsProvider($container);
 }

 public function testConfigureCustomAggregateFactory()
 {
     $this->fixture->registerAggregateFactory($this->mockAggregateFactory);
     $this->fixture->registerAnnotatedCommandHandler(new MyCommandHandler($this->fixture->getRepository(), $this->fixture->getEventBus()));
     $this->fixture->given([new MyEvent("id1", 1)])->when(new TestCommand("id1"));
     \Phake::verify($this->mockAggregateFactory, \Phake::atLeast(1))->createAggregate(\Phake::equalTo("id1"), \Phake::anyParameters());
 }

 protected function setUp()
 {
     $this->paginUrl = \Phake::mock('Behoimi\\Pager\\PagingUrl');
     \Phake::when($this->paginUrl)->getPrev()->thenReturn('hoge');
     \Phake::when($this->paginUrl)->getNext()->thenReturn('fuga');
     $this->target = new ListResult(true, array((object) array('id' => 1, 'name' => 'name')), $this->paginUrl, null);
 }