MemoizedCallableTest.php

Go to the documentation of this file.

<?php
class ArrayBackedMemoizedCallable extends MemoizedCallable {
    private $cache = [];
 
    protected function fetchResult( $key, &$success ) {
        if ( array_key_exists( $key, $this->cache ) ) {
            $success = true;
            return $this->cache[$key];
        }
        $success = false;
        return false;
    }
 
    protected function storeResult( $key, $result ) {
        $this->cache[$key] = $result;
    }
}
 
class MemoizedCallableTest extends PHPUnit_Framework_TestCase {
 
    public function testReturnValuePassedThrough() {
        $mock = $this->getMockBuilder( 'stdClass' )
            ->setMethods( [ 'reverse' ] )->getMock();
        $mock->expects( $this->any() )
            ->method( 'reverse' )
            ->will( $this->returnCallback( 'strrev' ) );
 
        $memoized = new MemoizedCallable( [ $mock, 'reverse' ] );
        $this->assertEquals( 'flow', $memoized->invoke( 'wolf' ) );
    }
 
    public function testCallableMemoized() {
        $observer = $this->getMockBuilder( 'stdClass' )
            ->setMethods( [ 'computeSomething' ] )->getMock();
        $observer->expects( $this->once() )
            ->method( 'computeSomething' )
            ->will( $this->returnValue( 'ok' ) );
 
        $memoized = new ArrayBackedMemoizedCallable( [ $observer, 'computeSomething' ] );
 
        // First invocation -- delegates to $observer->computeSomething()
        $this->assertEquals( 'ok', $memoized->invoke() );
 
        // Second invocation -- returns memoized result
        $this->assertEquals( 'ok', $memoized->invoke() );
    }
 
    public function testInvokeVariadic() {
        $memoized = new MemoizedCallable( 'sprintf' );
        $this->assertEquals(
            $memoized->invokeArgs( [ 'this is %s', 'correct' ] ),
            $memoized->invoke( 'this is %s', 'correct' )
        );
    }
 
    public function testShortcutMethod() {
        $this->assertEquals(
            'this is correct',
            MemoizedCallable::call( 'sprintf', [ 'this is %s', 'correct' ] )
        );
    }
 
    public function testTTLMaxMin() {
        $memoized = new MemoizedCallable( 'abs', 100000 );
        $this->assertEquals( 86400, $this->readAttribute( $memoized, 'ttl' ) );
 
        $memoized = new MemoizedCallable( 'abs', -10 );
        $this->assertEquals( 1, $this->readAttribute( $memoized, 'ttl' ) );
    }
 
    public function testMemoizedClosure() {
        $a = new MemoizedCallable( function () {
            return 'a';
        } );
 
        $b = new MemoizedCallable( function () {
            return 'b';
        } );
 
        $this->assertEquals( $a->invokeArgs(), 'a' );
        $this->assertEquals( $b->invokeArgs(), 'b' );
 
        $this->assertNotEquals(
            $this->readAttribute( $a, 'callableName' ),
            $this->readAttribute( $b, 'callableName' )
        );
 
        $c = new ArrayBackedMemoizedCallable( function () {
            return rand();
        } );
        $this->assertEquals( $c->invokeArgs(), $c->invokeArgs(), 'memoized random' );
    }
 
    public function testNonScalarArguments() {
        $memoized = new MemoizedCallable( 'gettype' );
        $memoized->invoke( new stdClass() );
    }
 
    public function testNotCallable() {
        $memoized = new MemoizedCallable( 14 );
    }
}