Subversion Repositories SmartDukaan

<?php

/**

 * AppTest file.

 *

 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)

 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 *

 * Licensed under The MIT License

 * For full copyright and license information, please see the LICENSE.txt

 * Redistributions of files must retain the above copyright notice.

 *

 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 * @link          http://cakephp.org CakePHP(tm) Project

 * @package       Cake.Test.Case.Core

 * @since         CakePHP(tm) v 2.0

 * @license       http://www.opensource.org/licenses/mit-license.php MIT License

 */

/**

 * AppTest class

 *

 * @package       Cake.Test.Case.Core

 */

class AppTest extends CakeTestCase {

/**

 * tearDown method

 *

 * @return void

 */

	public function tearDown() {

		parent::tearDown();

		CakePlugin::unload();

	}

/**

 * testBuild method

 *

 * @return void

 */

	public function testBuild() {

		$old = App::path('Model');

		$expected = array(

			APP . 'Model' . DS

		);

		$this->assertEquals($expected, $old);

		App::build(array('Model' => array('/path/to/models/')));

		$new = App::path('Model');

		$expected = array(

			'/path/to/models/',

			APP . 'Model' . DS

		);

		$this->assertEquals($expected, $new);

		App::build();

		App::build(array('Model' => array('/path/to/models/')), App::PREPEND);

		$new = App::path('Model');

		$expected = array(

			'/path/to/models/',

			APP . 'Model' . DS

		);

		$this->assertEquals($expected, $new);

		App::build();

		App::build(array('Model' => array('/path/to/models/')), App::APPEND);

		$new = App::path('Model');

		$expected = array(

			APP . 'Model' . DS,

			'/path/to/models/'

		);

		$this->assertEquals($expected, $new);

		App::build();

		App::build(array(

			'Model' => array('/path/to/models/'),

			'Controller' => array('/path/to/controllers/'),

		), App::APPEND);

		$new = App::path('Model');

		$expected = array(

			APP . 'Model' . DS,

			'/path/to/models/'

		);

		$this->assertEquals($expected, $new);

		$new = App::path('Controller');

		$expected = array(

			APP . 'Controller' . DS,

			'/path/to/controllers/'

		);

		$this->assertEquals($expected, $new);

		App::build(); //reset defaults

		$defaults = App::path('Model');

		$this->assertEquals($old, $defaults);

	}

/**

 * tests that it is possible to set up paths using the CakePHP 1.3 notation for them (models, behaviors, controllers...)

 *

 * @return void

 */

	public function testCompatibleBuild() {

		$old = App::path('models');

		$expected = array(

			APP . 'Model' . DS

		);

		$this->assertEquals($expected, $old);

		App::build(array('models' => array('/path/to/models/')));

		$new = App::path('models');

		$expected = array(

			'/path/to/models/',

			APP . 'Model' . DS

		);

		$this->assertEquals($expected, $new);

		$this->assertEquals($expected, App::path('Model'));

		App::build(array('datasources' => array('/path/to/datasources/')));

		$expected = array(

			'/path/to/datasources/',

			APP . 'Model' . DS . 'Datasource' . DS

		);

		$result = App::path('datasources');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('Model/Datasource'));

		App::build(array('behaviors' => array('/path/to/behaviors/')));

		$expected = array(

			'/path/to/behaviors/',

			APP . 'Model' . DS . 'Behavior' . DS

		);

		$result = App::path('behaviors');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('Model/Behavior'));

		App::build(array('controllers' => array('/path/to/controllers/')));

		$expected = array(

			'/path/to/controllers/',

			APP . 'Controller' . DS

		);

		$result = App::path('controllers');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('Controller'));

		App::build(array('components' => array('/path/to/components/')));

		$expected = array(

			'/path/to/components/',

			APP . 'Controller' . DS . 'Component' . DS

		);

		$result = App::path('components');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('Controller/Component'));

		App::build(array('views' => array('/path/to/views/')));

		$expected = array(

			'/path/to/views/',

			APP . 'View' . DS

		);

		$result = App::path('views');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('View'));

		App::build(array('helpers' => array('/path/to/helpers/')));

		$expected = array(

			'/path/to/helpers/',

			APP . 'View' . DS . 'Helper' . DS

		);

		$result = App::path('helpers');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('View/Helper'));

		App::build(array('shells' => array('/path/to/shells/')));

		$expected = array(

			'/path/to/shells/',

			APP . 'Console' . DS . 'Command' . DS

		);

		$result = App::path('shells');

		$this->assertEquals($expected, $result);

		$this->assertEquals($expected, App::path('Console/Command'));

		App::build(); //reset defaults

		$defaults = App::path('Model');

		$this->assertEquals($old, $defaults);

	}

/**

 * test package build() with App::REGISTER.

 *

 * @return void

 */

	public function testBuildPackage() {

		$pluginPaths = array(

			'/foo/bar',

			APP . 'Plugin' . DS,

			dirname(dirname(CAKE)) . DS . 'plugins' . DS

		);

		App::build(array(

			'Plugin' => array(

				'/foo/bar'

			)

		));

		$result = App::path('Plugin');

		$this->assertEquals($pluginPaths, $result);

		$paths = App::path('Service');

		$this->assertEquals(array(), $paths);

		App::build(array(

			'Service' => array(

				'%s' . 'Service' . DS,

			),

		), App::REGISTER);

		$expected = array(

			APP . 'Service' . DS,

		);

		$result = App::path('Service');

		$this->assertEquals($expected, $result);

		//Ensure new paths registered for other packages are not affected

		$result = App::path('Plugin');

		$this->assertEquals($pluginPaths, $result);

		App::build();

		$paths = App::path('Service');

		$this->assertEquals(array(), $paths);

	}

/**

 * test path() with a plugin.

 *

 * @return void

 */

	public function testPathWithPlugins() {

		$basepath = CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS;

		App::build(array(

			'Plugin' => array($basepath),

		));

		CakePlugin::load('TestPlugin');

		$result = App::path('Vendor', 'TestPlugin');

		$this->assertEquals($basepath . 'TestPlugin' . DS . 'Vendor' . DS, $result[0]);

	}

/**

 * testBuildWithReset method

 *

 * @return void

 */

	public function testBuildWithReset() {

		$old = App::path('Model');

		$expected = array(

			APP . 'Model' . DS

		);

		$this->assertEquals($expected, $old);

		App::build(array('Model' => array('/path/to/models/')), App::RESET);

		$new = App::path('Model');

		$expected = array(

			'/path/to/models/'

		);

		$this->assertEquals($expected, $new);

		App::build(); //reset defaults

		$defaults = App::path('Model');

		$this->assertEquals($old, $defaults);

	}

/**

 * testCore method

 *

 * @return void

 */

	public function testCore() {

		$model = App::core('Model');

		$this->assertEquals(array(CAKE . 'Model' . DS), $model);

		$view = App::core('View');

		$this->assertEquals(array(CAKE . 'View' . DS), $view);

		$controller = App::core('Controller');

		$this->assertEquals(array(CAKE . 'Controller' . DS), $controller);

		$component = App::core('Controller/Component');

		$this->assertEquals(array(CAKE . 'Controller' . DS . 'Component' . DS), str_replace('/', DS, $component));

		$auth = App::core('Controller/Component/Auth');

		$this->assertEquals(array(CAKE . 'Controller' . DS . 'Component' . DS . 'Auth' . DS), str_replace('/', DS, $auth));

		$datasource = App::core('Model/Datasource');

		$this->assertEquals(array(CAKE . 'Model' . DS . 'Datasource' . DS), str_replace('/', DS, $datasource));

	}

/**

 * testListObjects method

 *

 * @return void

 */

	public function testListObjects() {

		$result = App::objects('class', CAKE . 'Routing', false);

		$this->assertTrue(in_array('Dispatcher', $result));

		$this->assertTrue(in_array('Router', $result));

		App::build(array(

			'Model/Behavior' => App::core('Model/Behavior'),

			'Controller' => App::core('Controller'),

			'Controller/Component' => App::core('Controller/Component'),

			'View' => App::core('View'),

			'Model' => App::core('Model'),

			'View/Helper' => App::core('View/Helper'),

		), App::RESET);

		$result = App::objects('behavior', null, false);

		$this->assertTrue(in_array('TreeBehavior', $result));

		$result = App::objects('Model/Behavior', null, false);

		$this->assertTrue(in_array('TreeBehavior', $result));

		$result = App::objects('component', null, false);

		$this->assertTrue(in_array('AuthComponent', $result));

		$result = App::objects('Controller/Component', null, false);

		$this->assertTrue(in_array('AuthComponent', $result));

		$result = App::objects('view', null, false);

		$this->assertTrue(in_array('MediaView', $result));

		$result = App::objects('View', null, false);

		$this->assertTrue(in_array('MediaView', $result));

		$result = App::objects('helper', null, false);

		$this->assertTrue(in_array('HtmlHelper', $result));

		$result = App::objects('View/Helper', null, false);

		$this->assertTrue(in_array('HtmlHelper', $result));

		$result = App::objects('model', null, false);

		$this->assertTrue(in_array('AcoAction', $result));

		$result = App::objects('Model', null, false);

		$this->assertTrue(in_array('AcoAction', $result));

		$result = App::objects('file');

		$this->assertFalse($result);

		$result = App::objects('file', 'non_existing_configure');

		$expected = array();

		$this->assertEquals($expected, $result);

		$result = App::objects('NonExistingType');

		$this->assertSame(array(), $result);

		App::build(array(

			'plugins' => array(

				CAKE . 'Test' . DS . 'test_app' . DS . 'Lib' . DS

			)

		));

		$result = App::objects('plugin', null, false);

		$this->assertTrue(in_array('Cache', $result));

		$this->assertTrue(in_array('Log', $result));

		App::build();

	}

/**

 * Make sure that .svn and friends are excluded from App::objects('plugin')

 */

	public function testListObjectsIgnoreDotDirectories() {

		$path = CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS;

		$this->skipIf(!is_writable($path), $path . ' is not writable.');

		App::build(array(

			'plugins' => array($path)

		), App::RESET);

		mkdir($path . '.svn');

		$result = App::objects('plugin', null, false);

		rmdir($path . '.svn');

		$this->assertNotContains('.svn', $result);

	}

/**

 * Tests listing objects within a plugin

 *

 * @return void

 */

	public function testListObjectsInPlugin() {

		App::build(array(

			'Model' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS),

			'plugins' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)

		), App::RESET);

		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));

		$result = App::objects('TestPlugin.model');

		$this->assertTrue(in_array('TestPluginPost', $result));

		$result = App::objects('TestPlugin.Model');

		$this->assertTrue(in_array('TestPluginPost', $result));

		$result = App::objects('TestPlugin.behavior');

		$this->assertTrue(in_array('TestPluginPersisterOneBehavior', $result));

		$result = App::objects('TestPlugin.Model/Behavior');

		$this->assertTrue(in_array('TestPluginPersisterOneBehavior', $result));

		$result = App::objects('TestPlugin.helper');

		$expected = array('OtherHelperHelper', 'PluggedHelperHelper', 'TestPluginAppHelper');

		$this->assertEquals($expected, $result);

		$result = App::objects('TestPlugin.View/Helper');

		$expected = array('OtherHelperHelper', 'PluggedHelperHelper', 'TestPluginAppHelper');

		$this->assertEquals($expected, $result);

		$result = App::objects('TestPlugin.component');

		$this->assertTrue(in_array('OtherComponent', $result));

		$result = App::objects('TestPlugin.Controller/Component');

		$this->assertTrue(in_array('OtherComponent', $result));

		$result = App::objects('TestPluginTwo.behavior');

		$this->assertSame(array(), $result);

		$result = App::objects('TestPluginTwo.Model/Behavior');

		$this->assertSame(array(), $result);

		$result = App::objects('model', null, false);

		$this->assertTrue(in_array('Comment', $result));

		$this->assertTrue(in_array('Post', $result));

		$result = App::objects('Model', null, false);

		$this->assertTrue(in_array('Comment', $result));

		$this->assertTrue(in_array('Post', $result));

		App::build();

	}

/**

 * test that pluginPath can find paths for plugins.

 *

 * @return void

 */

	public function testPluginPath() {

		App::build(array(

			'plugins' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)

		));

		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));

		$path = App::pluginPath('TestPlugin');

		$expected = CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS . 'TestPlugin' . DS;

		$this->assertEquals($expected, $path);

		$path = App::pluginPath('TestPluginTwo');

		$expected = CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS . 'TestPluginTwo' . DS;

		$this->assertEquals($expected, $path);

		App::build();

	}

/**

 * test that themePath can find paths for themes.

 *

 * @return void

 */

	public function testThemePath() {

		App::build(array(

			'View' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'View' . DS)

		));

		$path = App::themePath('test_theme');

		$expected = CAKE . 'Test' . DS . 'test_app' . DS . 'View' . DS . 'Themed' . DS . 'TestTheme' . DS;

		$this->assertEquals($expected, $path);

		$path = App::themePath('TestTheme');

		$expected = CAKE . 'Test' . DS . 'test_app' . DS . 'View' . DS . 'Themed' . DS . 'TestTheme' . DS;

		$this->assertEquals($expected, $path);

		App::build();

	}

/**

 * testClassLoading method

 *

 * @return void

 */

	public function testClassLoading() {

		$file = App::import('Model', 'Model', false);

		$this->assertTrue($file);

		$this->assertTrue(class_exists('Model'));

		$file = App::import('Controller', 'Controller', false);

		$this->assertTrue($file);

		$this->assertTrue(class_exists('Controller'));

		$file = App::import('Component', 'Auth', false);

		$this->assertTrue($file);

		$this->assertTrue(class_exists('AuthComponent'));

		$file = App::import('Shell', 'Shell', false);

		$this->assertTrue($file);

		$this->assertTrue(class_exists('Shell'));

		$file = App::import('Configure', 'PhpReader');

		$this->assertTrue($file);

		$this->assertTrue(class_exists('PhpReader'));

		$file = App::import('Model', 'SomeRandomModelThatDoesNotExist', false);

		$this->assertFalse($file);

		$file = App::import('Model', 'AppModel', false);

		$this->assertTrue($file);

		$this->assertTrue(class_exists('AppModel'));

		$file = App::import('WrongType', null, true, array(), '');

		$this->assertFalse($file);

		$file = App::import('Model', 'NonExistingPlugin.NonExistingModel', false);

		$this->assertFalse($file);

		$file = App::import('Model', array('NonExistingPlugin.NonExistingModel'), false);

		$this->assertFalse($file);

		if (!class_exists('AppController', false)) {

			$classes = array_flip(get_declared_classes());

			$this->assertFalse(isset($classes['PagesController']));

			$this->assertFalse(isset($classes['AppController']));

			$file = App::import('Controller', 'Pages');

			$this->assertTrue($file);

			$this->assertTrue(class_exists('PagesController'));

			$classes = array_flip(get_declared_classes());

			$this->assertTrue(isset($classes['PagesController']));

			$this->assertTrue(isset($classes['AppController']));

			$file = App::import('Behavior', 'Containable');

			$this->assertTrue($file);

			$this->assertTrue(class_exists('ContainableBehavior'));

			$file = App::import('Component', 'RequestHandler');

			$this->assertTrue($file);

			$this->assertTrue(class_exists('RequestHandlerComponent'));

			$file = App::import('Helper', 'Form');

			$this->assertTrue($file);

			$this->assertTrue(class_exists('FormHelper'));

			$file = App::import('Model', 'NonExistingModel');

			$this->assertFalse($file);

			$file = App::import('Datasource', 'DboSource');

			$this->assertTrue($file);

			$this->assertTrue(class_exists('DboSource'));

		}

		App::build();

	}

/**

 * test import() with plugins

 *

 * @return void

 */

	public function testPluginImporting() {

		App::build(array(

			'Lib' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Lib' . DS),

			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)

		));

		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));

		$result = App::import('Controller', 'TestPlugin.Tests');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('TestPluginAppController'));

		$this->assertTrue(class_exists('TestsController'));

		$result = App::import('Lib', 'TestPlugin.TestPluginLibrary');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('TestPluginLibrary'));

		$result = App::import('Lib', 'Library');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('Library'));

		$result = App::import('Helper', 'TestPlugin.OtherHelper');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('OtherHelperHelper'));

		$result = App::import('Helper', 'TestPlugin.TestPluginApp');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('TestPluginAppHelper'));

		$result = App::import('Datasource', 'TestPlugin.TestSource');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('TestSource'));

		App::uses('ExampleExample', 'TestPlugin.Vendor/Example');

		$this->assertTrue(class_exists('ExampleExample'));

		App::build();

	}

/**

 * test that building helper paths actually works.

 *

 * @return void

 * @link https://cakephp.lighthouseapp.com/projects/42648/tickets/410

 */

	public function testImportingHelpersFromAlternatePaths() {

		$this->assertFalse(class_exists('BananaHelper', false), 'BananaHelper exists, cannot test importing it.');

		App::build(array(

			'View/Helper' => array(

				CAKE . 'Test' . DS . 'test_app' . DS . 'View' . DS . 'Helper' . DS

			)

		));

		$this->assertFalse(class_exists('BananaHelper', false), 'BananaHelper exists, cannot test importing it.');

		App::import('Helper', 'Banana');

		$this->assertTrue(class_exists('BananaHelper', false), 'BananaHelper was not loaded.');

		App::build();

	}

/**

 * testFileLoading method

 *

 * @return void

 */

	public function testFileLoading() {

		$file = App::import('File', 'RealFile', false, array(), CAKE . 'Config' . DS . 'config.php');

		$this->assertTrue($file);

		$file = App::import('File', 'NoFile', false, array(), CAKE . 'Config' . DS . 'cake' . DS . 'config.php');

		$this->assertFalse($file);

	}

/**

 * testFileLoadingWithArray method

 *

 * @return void

 */

	public function testFileLoadingWithArray() {

		$type = array(

			'type' => 'File',

			'name' => 'SomeName',

			'parent' => false,

			'file' => CAKE . DS . 'Config' . DS . 'config.php'

		);

		$file = App::import($type);

		$this->assertTrue($file);

		$type = array(

			'type' => 'File',

			'name' => 'NoFile',

			'parent' => false,

			'file' => CAKE . 'Config' . DS . 'cake' . DS . 'config.php'

		);

		$file = App::import($type);

		$this->assertFalse($file);

	}

/**

 * testFileLoadingReturnValue method

 *

 * @return void

 */

	public function testFileLoadingReturnValue() {

		$file = App::import('File', 'Name', false, array(), CAKE . 'Config' . DS . 'config.php', true);

		$this->assertTrue(!empty($file));

		$this->assertTrue(isset($file['Cake.version']));

		$type = array(

			'type' => 'File',

			'name' => 'OtherName',

			'parent' => false,

			'file' => CAKE . 'Config' . DS . 'config.php', 'return' => true

		);

		$file = App::import($type);

		$this->assertTrue(!empty($file));

		$this->assertTrue(isset($file['Cake.version']));

	}

/**

 * testLoadingWithSearch method

 *

 * @return void

 */

	public function testLoadingWithSearch() {

		$file = App::import('File', 'NewName', false, array(CAKE . 'Config' . DS), 'config.php');

		$this->assertTrue($file);

		$file = App::import('File', 'AnotherNewName', false, array(CAKE), 'config.php');

		$this->assertFalse($file);

	}

/**

 * testLoadingWithSearchArray method

 *

 * @return void

 */

	public function testLoadingWithSearchArray() {

		$type = array(

			'type' => 'File',

			'name' => 'RandomName',

			'parent' => false,

			'file' => 'config.php',

			'search' => array(CAKE . 'Config' . DS)

		);

		$file = App::import($type);

		$this->assertTrue($file);

		$type = array(

			'type' => 'File',

			'name' => 'AnotherRandomName',

			'parent' => false,

			'file' => 'config.php',

			'search' => array(CAKE)

		);

		$file = App::import($type);

		$this->assertFalse($file);

	}

/**

 * testMultipleLoading method

 *

 * @return void

 */

	public function testMultipleLoading() {

		if (class_exists('PersisterOne', false) || class_exists('PersisterTwo', false)) {

			$this->markTestSkipped('Cannot test loading of classes that exist.');

		}

		App::build(array(

			'Model' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS)

		));

		$toLoad = array('PersisterOne', 'PersisterTwo');

		$load = App::import('Model', $toLoad);

		$this->assertTrue($load);

		$classes = array_flip(get_declared_classes());

		$this->assertTrue(isset($classes['PersisterOne']));

		$this->assertTrue(isset($classes['PersisterTwo']));

		$load = App::import('Model', array('PersisterOne', 'SomeNotFoundClass', 'PersisterTwo'));

		$this->assertFalse($load);

	}

	public function testLoadingVendor() {

		App::build(array(

			'plugins' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS),

			'vendors' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Vendor' . DS),

		), App::RESET);

		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));

		ob_start();

		$result = App::import('Vendor', 'css/TestAsset', array('ext' => 'css'));

		$text = ob_get_clean();

		$this->assertTrue($result);

		$this->assertEquals('/* this is the test asset css file */', trim($text));

		$result = App::import('Vendor', 'TestPlugin.sample/SamplePlugin');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('SamplePluginClassTestName'));

		$result = App::import('Vendor', 'sample/ConfigureTestVendorSample');

		$this->assertTrue($result);

		$this->assertTrue(class_exists('ConfigureTestVendorSample'));

		ob_start();

		$result = App::import('Vendor', 'SomeNameInSubfolder', array('file' => 'somename/some.name.php'));

		$text = ob_get_clean();

		$this->assertTrue($result);

		$this->assertEquals('This is a file with dot in file name', $text);

		ob_start();

		$result = App::import('Vendor', 'TestHello', array('file' => 'Test' . DS . 'hello.php'));

		$text = ob_get_clean();

		$this->assertTrue($result);

		$this->assertEquals('This is the hello.php file in Test directory', $text);

		ob_start();

		$result = App::import('Vendor', 'MyTest', array('file' => 'Test' . DS . 'MyTest.php'));

		$text = ob_get_clean();

		$this->assertTrue($result);

		$this->assertEquals('This is the MyTest.php file', $text);

		ob_start();

		$result = App::import('Vendor', 'Welcome');

		$text = ob_get_clean();

		$this->assertTrue($result);

		$this->assertEquals('This is the welcome.php file in vendors directory', $text);

		ob_start();

		$result = App::import('Vendor', 'TestPlugin.Welcome');

		$text = ob_get_clean();

		$this->assertTrue($result);

		$this->assertEquals('This is the welcome.php file in test_plugin/vendors directory', $text);

	}

/**

 * Tests that the automatic class loader will also find in "libs" folder for both

 * app and plugins if it does not find the class in other configured paths

 *

 */

	public function testLoadClassInLibs() {

		App::build(array(

			'libs' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Lib' . DS),

			'plugins' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)

		), App::RESET);

		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));

		$this->assertFalse(class_exists('CustomLibClass', false));

		App::uses('CustomLibClass', 'TestPlugin.Custom/Package');

		$this->assertTrue(class_exists('CustomLibClass'));

		$this->assertFalse(class_exists('TestUtilityClass', false));

		App::uses('TestUtilityClass', 'Utility');

		$this->assertTrue(class_exists('TestUtilityClass'));

	}

/**

 * Tests that App::location() returns the defined path for a class

 *

 * @return void

 */

	public function testClassLocation() {

		App::uses('MyCustomClass', 'MyPackage/Name');

		$this->assertEquals('MyPackage/Name', App::location('MyCustomClass'));

	}

/**

 * Test that paths() works.

 *

 * @return void

 */

	public function testPaths() {

		$result = App::paths();

		$this->assertArrayHasKey('Plugin', $result);

		$this->assertArrayHasKey('Controller', $result);

		$this->assertArrayHasKey('Controller/Component', $result);

	}

/**

 * Proves that it is possible to load plugin libraries in top

 * level Lib dir for plugins

 *

 * @return void

 */

	public function testPluginLibClasses() {

		App::build(array(

			'plugins' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)

		), App::RESET);

		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));

		$this->assertFalse(class_exists('TestPluginOtherLibrary', false));

		App::uses('TestPluginOtherLibrary', 'TestPlugin.Lib');

		$this->assertTrue(class_exists('TestPluginOtherLibrary'));

	}

}