PHP generate_mock_once函数代码示例

 function testURIDefinitionValidation()
 {
     $parser = new HTMLPurifier_URIParser();
     $uri = $parser->parse('http://example.com');
     $this->config->set('URI.DefinitionID', 'HTMLPurifier_AttrDef_URITest->testURIDefinitionValidation');
     generate_mock_once('HTMLPurifier_URIDefinition');
     $uri_def = new HTMLPurifier_URIDefinitionMock();
     $uri_def->expectOnce('filter', array($uri, '*', '*'));
     $uri_def->setReturnValue('filter', true, array($uri, '*', '*'));
     $uri_def->expectOnce('postFilter', array($uri, '*', '*'));
     $uri_def->setReturnValue('postFilter', true, array($uri, '*', '*'));
     $uri_def->setup = true;
     // Since definitions are no longer passed by reference, we need
     // to muck around with the cache to insert our mock. This is
     // technically a little bad, since the cache shouldn't change
     // behavior, but I don't feel too good about letting users
     // overload entire definitions.
     generate_mock_once('HTMLPurifier_DefinitionCache');
     $cache_mock = new HTMLPurifier_DefinitionCacheMock();
     $cache_mock->setReturnValue('get', $uri_def);
     generate_mock_once('HTMLPurifier_DefinitionCacheFactory');
     $factory_mock = new HTMLPurifier_DefinitionCacheFactoryMock();
     $old = HTMLPurifier_DefinitionCacheFactory::instance();
     HTMLPurifier_DefinitionCacheFactory::instance($factory_mock);
     $factory_mock->setReturnValue('create', $cache_mock);
     $this->assertDef('http://example.com');
     HTMLPurifier_DefinitionCacheFactory::instance($old);
 }

 function test()
 {
     generate_mock_once('HTMLPurifier_URIScheme');
     $config = HTMLPurifier_Config::create(array('URI.AllowedSchemes' => 'http, telnet', 'URI.OverrideAllowedSchemes' => true));
     $context = new HTMLPurifier_Context();
     $registry = new HTMLPurifier_URISchemeRegistry();
     $this->assertIsA($registry->getScheme('http', $config, $context), 'HTMLPurifier_URIScheme_http');
     $scheme_http = new HTMLPurifier_URISchemeMock();
     $scheme_telnet = new HTMLPurifier_URISchemeMock();
     $scheme_foobar = new HTMLPurifier_URISchemeMock();
     // register a new scheme
     $registry->register('telnet', $scheme_telnet);
     $this->assertIdentical($registry->getScheme('telnet', $config, $context), $scheme_telnet);
     // overload a scheme, this is FINAL (forget about defaults)
     $registry->register('http', $scheme_http);
     $this->assertIdentical($registry->getScheme('http', $config, $context), $scheme_http);
     // when we register a scheme, it's automatically allowed
     $registry->register('foobar', $scheme_foobar);
     $this->assertIdentical($registry->getScheme('foobar', $config, $context), $scheme_foobar);
     // now, test when overriding is not allowed
     $config = HTMLPurifier_Config::create(array('URI.AllowedSchemes' => 'http, telnet', 'URI.OverrideAllowedSchemes' => false));
     $this->assertNull($registry->getScheme('foobar', $config, $context));
     // scheme not allowed and never registered
     $this->assertNull($registry->getScheme('ftp', $config, $context));
 }

 public function test()
 {
     generate_mock_once('HTMLPurifier_Strategy');
     generate_mock_once('HTMLPurifier_Config');
     generate_mock_once('HTMLPurifier_Context');
     // setup a bunch of mock strategies to inject into our composite test
     $mock_1 = new HTMLPurifier_StrategyMock();
     $mock_2 = new HTMLPurifier_StrategyMock();
     $mock_3 = new HTMLPurifier_StrategyMock();
     // setup the object
     $strategies = array(&$mock_1, &$mock_2, &$mock_3);
     $composite = new HTMLPurifier_Strategy_Composite_Test($strategies);
     // setup expectations
     $input_1 = 'This is raw data';
     $input_2 = 'Processed by 1';
     $input_3 = 'Processed by 1 and 2';
     $input_4 = 'Processed by 1, 2 and 3';
     // expected output
     $config = new HTMLPurifier_ConfigMock();
     $context = new HTMLPurifier_ContextMock();
     $params_1 = array($input_1, $config, $context);
     $params_2 = array($input_2, $config, $context);
     $params_3 = array($input_3, $config, $context);
     $mock_1->expectOnce('execute', $params_1);
     $mock_1->setReturnValue('execute', $input_2, $params_1);
     $mock_2->expectOnce('execute', $params_2);
     $mock_2->setReturnValue('execute', $input_3, $params_2);
     $mock_3->expectOnce('execute', $params_3);
     $mock_3->setReturnValue('execute', $input_4, $params_3);
     // perform test
     $output = $composite->execute($input_1, $config, $context);
     $this->assertIdentical($input_4, $output);
 }

 public function setUp()
 {
     parent::setUp();
     generate_mock_once('HTMLPurifier_AttrDef');
     $this->with = new HTMLPurifier_AttrDefMock();
     $this->without = new HTMLPurifier_AttrDefMock();
     $this->def = new HTMLPurifier_AttrDef_Switch('tag', $this->with, $this->without);
 }

 protected function &setUpSchemeRegistryMock()
 {
     $this->oldRegistry = HTMLPurifier_URISchemeRegistry::instance();
     generate_mock_once('HTMLPurifier_URIScheme');
     generate_mock_once('HTMLPurifier_URISchemeRegistry');
     $registry = HTMLPurifier_URISchemeRegistry::instance(new HTMLPurifier_URISchemeRegistryMock());
     return $registry;
 }

 /**
  * Generate a configuration mock object that returns $values
  * to a getBatch() call
  * @param $values Values to return when getBatch is invoked
  */
 protected function generateConfigMock($serial = 'defaultserial')
 {
     generate_mock_once('HTMLPurifier_Config');
     $config = new HTMLPurifier_ConfigMock();
     $config->setReturnValue('getBatchSerial', $serial, array('Test'));
     $config->version = '1.0.0';
     return $config;
 }

 public function test_register()
 {
     generate_mock_once('HTMLPurifier_DefinitionCache');
     $this->config->set('Cache.DefinitionImpl', 'TestCache');
     $this->factory->register('TestCache', $class = 'HTMLPurifier_DefinitionCacheMock');
     $cache = $this->factory->create('Test', $this->config);
     $this->assertIsA($cache, $class);
 }

 public function setUp()
 {
     parent::setUp();
     $this->obj = new HTMLPurifier_Strategy_MakeWellFormed();
     $this->config->set('AutoFormat.AutoParagraph', true);
     $this->config->set('AutoFormat.Linkify', true);
     $this->config->set('AutoFormat.RemoveEmpty', true);
     generate_mock_once('HTMLPurifier_Injector');
 }

 function test_addFilter_deprecated()
 {
     $this->expectError('HTMLPurifier->addFilter() is deprecated, use configuration directives in the Filter namespace or Filter.Custom');
     generate_mock_once('HTMLPurifier_Filter');
     $this->purifier->addFilter($mock = new HTMLPurifier_FilterMock());
     $mock->expectOnce('preFilter');
     $mock->expectOnce('postFilter');
     $this->purifier->purify('foo');
 }

 public function setup()
 {
     $this->config = HTMLPurifier_Config::create(array('Core.CollectErrors' => true));
     $this->context = new HTMLPurifier_Context();
     generate_mock_once('HTMLPurifier_ErrorCollector');
     $this->collector = new HTMLPurifier_ErrorCollectorEMock();
     $this->collector->prepare($this->context);
     $this->context->register('ErrorCollector', $this->collector);
     $this->callCount = 0;
 }

 protected function createManager()
 {
     $manager = new HTMLPurifier_HTMLModuleManager();
     $this->config->set('HTML.CustomDoctype', 'Blank');
     $manager->doctypes->register('Blank');
     $attrdef_nmtokens = new HTMLPurifier_AttrDef_HTML_Nmtokens();
     generate_mock_once('HTMLPurifier_AttrDef');
     $attrdef = new HTMLPurifier_AttrDefMock();
     $attrdef->setReturnValue('make', $attrdef_nmtokens);
     $manager->attrTypes->set('NMTOKENS', $attrdef);
     return $manager;
 }

 public function test_expandIdentifiers()
 {
     generate_mock_once('HTMLPurifier_AttrTypes');
     $types = new HTMLPurifier_AttrTypesMock();
     $collections = new HTMLPurifier_AttrCollections($types, array());
     $attr = array('attr1' => 'Color', 'attr2*' => 'URI');
     $c_object = new HTMLPurifier_AttrDef_HTML_Color();
     $u_object = new HTMLPurifier_AttrDef_URI();
     $types->setReturnValue('get', $c_object, array('Color'));
     $types->setReturnValue('get', $u_object, array('URI'));
     $collections->expandIdentifiers($attr, $types);
     $u_object->required = true;
     $this->assertIdentical($attr, array('attr1' => $c_object, 'attr2' => $u_object));
 }

 function test()
 {
     generate_mock_once('HTMLPurifier_AttrDef');
     $config = HTMLPurifier_Config::createDefault();
     $context = new HTMLPurifier_Context();
     // first test: value properly validates on first definition
     // so second def is never called
     $def1 = new HTMLPurifier_AttrDefMock();
     $def2 = new HTMLPurifier_AttrDefMock();
     $defs = array(&$def1, &$def2);
     $def = new HTMLPurifier_AttrDef_CSS_Composite_Testable($defs);
     $input = 'FOOBAR';
     $output = 'foobar';
     $def1_params = array($input, $config, $context);
     $def1->expectOnce('validate', $def1_params);
     $def1->setReturnValue('validate', $output, $def1_params);
     $def2->expectNever('validate');
     $result = $def->validate($input, $config, $context);
     $this->assertIdentical($output, $result);
     // second test, first def fails, second def works
     $def1 = new HTMLPurifier_AttrDefMock();
     $def2 = new HTMLPurifier_AttrDefMock();
     $defs = array(&$def1, &$def2);
     $def = new HTMLPurifier_AttrDef_CSS_Composite_Testable($defs);
     $input = 'BOOMA';
     $output = 'booma';
     $def_params = array($input, $config, $context);
     $def1->expectOnce('validate', $def_params);
     $def1->setReturnValue('validate', false, $def_params);
     $def2->expectOnce('validate', $def_params);
     $def2->setReturnValue('validate', $output, $def_params);
     $result = $def->validate($input, $config, $context);
     $this->assertIdentical($output, $result);
     // third test, all fail, so composite faiils
     $def1 = new HTMLPurifier_AttrDefMock();
     $def2 = new HTMLPurifier_AttrDefMock();
     $defs = array(&$def1, &$def2);
     $def = new HTMLPurifier_AttrDef_CSS_Composite_Testable($defs);
     $input = 'BOOMA';
     $output = false;
     $def_params = array($input, $config, $context);
     $def1->expectOnce('validate', $def_params);
     $def1->setReturnValue('validate', false, $def_params);
     $def2->expectOnce('validate', $def_params);
     $def2->setReturnValue('validate', false, $def_params);
     $result = $def->validate($input, $config, $context);
     $this->assertIdentical($output, $result);
 }

 protected function createFilterMock($expect = true, $result = true, $post = false, $setup = true)
 {
     static $i = 0;
     generate_mock_once('HTMLPurifier_URIFilter');
     $mock = new HTMLPurifier_URIFilterMock();
     if ($expect) {
         $mock->expectOnce('filter');
     } else {
         $mock->expectNever('filter');
     }
     $mock->setReturnValue('filter', $result);
     $mock->setReturnValue('prepare', $setup);
     $mock->name = $i++;
     $mock->post = $post;
     return $mock;
 }

 public function testAttributesTransformedGlobalPre()
 {
     $def = $this->config->getHTMLDefinition(true);
     generate_mock_once('HTMLPurifier_AttrTransform');
     $transform = new HTMLPurifier_AttrTransformMock();
     $input = array('original' => 'value');
     $output = array('class' => 'value');
     // must be valid
     $transform->setReturnValue('transform', $output, array($input, new AnythingExpectation(), new AnythingExpectation()));
     $def->info_attr_transform_pre[] = $transform;
     $token = new HTMLPurifier_Token_Start('span', $input, 1);
     $this->invoke($token);
     $result = $this->collector->getRaw();
     $expect = array(array(1, E_NOTICE, 'Attributes on <span> transformed from original to class', array()));
     $this->assertIdentical($result, $expect);
 }