aboutsummaryrefslogtreecommitdiff
path: root/vendors/simpletest/expectation.php
diff options
context:
space:
mode:
authorbrettp <brettp@36083f99-b078-4883-b0ff-0f9b5a30f544>2009-10-02 18:40:04 +0000
committerbrettp <brettp@36083f99-b078-4883-b0ff-0f9b5a30f544>2009-10-02 18:40:04 +0000
commit322bb9cd2be9e51422cb2b82684692e825c2bfb7 (patch)
tree1e8e75c1ff0c47d6eda9db114a13dfa2b83adf72 /vendors/simpletest/expectation.php
parent4ffb02ad9c1b95013a0fbf97cefde827600ecc3f (diff)
downloadelgg-322bb9cd2be9e51422cb2b82684692e825c2bfb7.tar.gz
elgg-322bb9cd2be9e51422cb2b82684692e825c2bfb7.tar.bz2
Added simpletest and start of unit tests.
git-svn-id: http://code.elgg.org/elgg/trunk@3503 36083f99-b078-4883-b0ff-0f9b5a30f544
Diffstat (limited to 'vendors/simpletest/expectation.php')
-rwxr-xr-xvendors/simpletest/expectation.php895
1 files changed, 895 insertions, 0 deletions
diff --git a/vendors/simpletest/expectation.php b/vendors/simpletest/expectation.php
new file mode 100755
index 000000000..194afd5c7
--- /dev/null
+++ b/vendors/simpletest/expectation.php
@@ -0,0 +1,895 @@
+<?php
+/**
+ * base include file for SimpleTest
+ * @package SimpleTest
+ * @subpackage UnitTester
+ * @version $Id: expectation.php 1723 2008-04-08 00:34:10Z lastcraft $
+ */
+
+/**#@+
+ * include other SimpleTest class files
+ */
+require_once(dirname(__FILE__) . '/dumper.php');
+require_once(dirname(__FILE__) . '/compatibility.php');
+/**#@-*/
+
+/**
+ * Assertion that can display failure information.
+ * Also includes various helper methods.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ * @abstract
+ */
+class SimpleExpectation {
+ var $_dumper = false;
+ var $_message;
+
+ /**
+ * Creates a dumper for displaying values and sets
+ * the test message.
+ * @param string $message Customised message on failure.
+ */
+ function SimpleExpectation($message = '%s') {
+ $this->_message = $message;
+ }
+
+ /**
+ * Tests the expectation. True if correct.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ * @abstract
+ */
+ function test($compare) {
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ * @abstract
+ */
+ function testMessage($compare) {
+ }
+
+ /**
+ * Overlays the generated message onto the stored user
+ * message. An additional message can be interjected.
+ * @param mixed $compare Comparison value.
+ * @param SimpleDumper $dumper For formatting the results.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function overlayMessage($compare, $dumper) {
+ $this->_dumper = $dumper;
+ return sprintf($this->_message, $this->testMessage($compare));
+ }
+
+ /**
+ * Accessor for the dumper.
+ * @return SimpleDumper Current value dumper.
+ * @access protected
+ */
+ function &_getDumper() {
+ if (! $this->_dumper) {
+ $dumper = &new SimpleDumper();
+ return $dumper;
+ }
+ return $this->_dumper;
+ }
+
+ /**
+ * Test to see if a value is an expectation object.
+ * A useful utility method.
+ * @param mixed $expectation Hopefully an Epectation
+ * class.
+ * @return boolean True if descended from
+ * this class.
+ * @access public
+ * @static
+ */
+ function isExpectation($expectation) {
+ return is_object($expectation) &&
+ SimpleTestCompatibility::isA($expectation, 'SimpleExpectation');
+ }
+}
+
+/**
+ * A wildcard expectation always matches.
+ * @package SimpleTest
+ * @subpackage MockObjects
+ */
+class AnythingExpectation extends SimpleExpectation {
+
+ /**
+ * Tests the expectation. Always true.
+ * @param mixed $compare Ignored.
+ * @return boolean True.
+ * @access public
+ */
+ function test($compare) {
+ return true;
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ return 'Anything always matches [' . $dumper->describeValue($compare) . ']';
+ }
+}
+
+/**
+ * An expectation that never matches.
+ * @package SimpleTest
+ * @subpackage MockObjects
+ */
+class FailedExpectation extends SimpleExpectation {
+
+ /**
+ * Tests the expectation. Always false.
+ * @param mixed $compare Ignored.
+ * @return boolean True.
+ * @access public
+ */
+ function test($compare) {
+ return false;
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ return 'Failed expectation never matches [' . $dumper->describeValue($compare) . ']';
+ }
+}
+
+/**
+ * An expectation that passes on boolean true.
+ * @package SimpleTest
+ * @subpackage MockObjects
+ */
+class TrueExpectation extends SimpleExpectation {
+
+ /**
+ * Tests the expectation.
+ * @param mixed $compare Should be true.
+ * @return boolean True on match.
+ * @access public
+ */
+ function test($compare) {
+ return (boolean)$compare;
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ return 'Expected true, got [' . $dumper->describeValue($compare) . ']';
+ }
+}
+
+/**
+ * An expectation that passes on boolean false.
+ * @package SimpleTest
+ * @subpackage MockObjects
+ */
+class FalseExpectation extends SimpleExpectation {
+
+ /**
+ * Tests the expectation.
+ * @param mixed $compare Should be false.
+ * @return boolean True on match.
+ * @access public
+ */
+ function test($compare) {
+ return ! (boolean)$compare;
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ return 'Expected false, got [' . $dumper->describeValue($compare) . ']';
+ }
+}
+
+/**
+ * Test for equality.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class EqualExpectation extends SimpleExpectation {
+ var $_value;
+
+ /**
+ * Sets the value to compare against.
+ * @param mixed $value Test value to match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function EqualExpectation($value, $message = '%s') {
+ $this->SimpleExpectation($message);
+ $this->_value = $value;
+ }
+
+ /**
+ * Tests the expectation. True if it matches the
+ * held value.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return (($this->_value == $compare) && ($compare == $this->_value));
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ if ($this->test($compare)) {
+ return "Equal expectation [" . $this->_dumper->describeValue($this->_value) . "]";
+ } else {
+ return "Equal expectation fails " .
+ $this->_dumper->describeDifference($this->_value, $compare);
+ }
+ }
+
+ /**
+ * Accessor for comparison value.
+ * @return mixed Held value to compare with.
+ * @access protected
+ */
+ function _getValue() {
+ return $this->_value;
+ }
+}
+
+/**
+ * Test for inequality.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class NotEqualExpectation extends EqualExpectation {
+
+ /**
+ * Sets the value to compare against.
+ * @param mixed $value Test value to match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function NotEqualExpectation($value, $message = '%s') {
+ $this->EqualExpectation($value, $message);
+ }
+
+ /**
+ * Tests the expectation. True if it differs from the
+ * held value.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return ! parent::test($compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ if ($this->test($compare)) {
+ return "Not equal expectation passes " .
+ $dumper->describeDifference($this->_getValue(), $compare);
+ } else {
+ return "Not equal expectation fails [" .
+ $dumper->describeValue($this->_getValue()) .
+ "] matches";
+ }
+ }
+}
+
+/**
+ * Test for being within a range.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class WithinMarginExpectation extends SimpleExpectation {
+ var $_upper;
+ var $_lower;
+
+ /**
+ * Sets the value to compare against and the fuzziness of
+ * the match. Used for comparing floating point values.
+ * @param mixed $value Test value to match.
+ * @param mixed $margin Fuzziness of match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function WithinMarginExpectation($value, $margin, $message = '%s') {
+ $this->SimpleExpectation($message);
+ $this->_upper = $value + $margin;
+ $this->_lower = $value - $margin;
+ }
+
+ /**
+ * Tests the expectation. True if it matches the
+ * held value.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return (($compare <= $this->_upper) && ($compare >= $this->_lower));
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ if ($this->test($compare)) {
+ return $this->_withinMessage($compare);
+ } else {
+ return $this->_outsideMessage($compare);
+ }
+ }
+
+ /**
+ * Creates a the message for being within the range.
+ * @param mixed $compare Value being tested.
+ * @access private
+ */
+ function _withinMessage($compare) {
+ return "Within expectation [" . $this->_dumper->describeValue($this->_lower) . "] and [" .
+ $this->_dumper->describeValue($this->_upper) . "]";
+ }
+
+ /**
+ * Creates a the message for being within the range.
+ * @param mixed $compare Value being tested.
+ * @access private
+ */
+ function _outsideMessage($compare) {
+ if ($compare > $this->_upper) {
+ return "Outside expectation " .
+ $this->_dumper->describeDifference($compare, $this->_upper);
+ } else {
+ return "Outside expectation " .
+ $this->_dumper->describeDifference($compare, $this->_lower);
+ }
+ }
+}
+
+/**
+ * Test for being outside of a range.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class OutsideMarginExpectation extends WithinMarginExpectation {
+
+ /**
+ * Sets the value to compare against and the fuzziness of
+ * the match. Used for comparing floating point values.
+ * @param mixed $value Test value to not match.
+ * @param mixed $margin Fuzziness of match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function OutsideMarginExpectation($value, $margin, $message = '%s') {
+ $this->WithinMarginExpectation($value, $margin, $message);
+ }
+
+ /**
+ * Tests the expectation. True if it matches the
+ * held value.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return ! parent::test($compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ if (! $this->test($compare)) {
+ return $this->_withinMessage($compare);
+ } else {
+ return $this->_outsideMessage($compare);
+ }
+ }
+}
+
+/**
+ * Test for reference.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class ReferenceExpectation extends SimpleExpectation {
+ var $_value;
+
+ /**
+ * Sets the reference value to compare against.
+ * @param mixed $value Test reference to match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function ReferenceExpectation(&$value, $message = '%s') {
+ $this->SimpleExpectation($message);
+ $this->_value =& $value;
+ }
+
+ /**
+ * Tests the expectation. True if it exactly
+ * references the held value.
+ * @param mixed $compare Comparison reference.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test(&$compare) {
+ return SimpleTestCompatibility::isReference($this->_value, $compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ if ($this->test($compare)) {
+ return "Reference expectation [" . $this->_dumper->describeValue($this->_value) . "]";
+ } else {
+ return "Reference expectation fails " .
+ $this->_dumper->describeDifference($this->_value, $compare);
+ }
+ }
+
+ function _getValue() {
+ return $this->_value;
+ }
+}
+
+/**
+ * Test for identity.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class IdenticalExpectation extends EqualExpectation {
+
+ /**
+ * Sets the value to compare against.
+ * @param mixed $value Test value to match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function IdenticalExpectation($value, $message = '%s') {
+ $this->EqualExpectation($value, $message);
+ }
+
+ /**
+ * Tests the expectation. True if it exactly
+ * matches the held value.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return SimpleTestCompatibility::isIdentical($this->_getValue(), $compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ if ($this->test($compare)) {
+ return "Identical expectation [" . $dumper->describeValue($this->_getValue()) . "]";
+ } else {
+ return "Identical expectation [" . $dumper->describeValue($this->_getValue()) .
+ "] fails with [" .
+ $dumper->describeValue($compare) . "] " .
+ $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
+ }
+ }
+}
+
+/**
+ * Test for non-identity.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class NotIdenticalExpectation extends IdenticalExpectation {
+
+ /**
+ * Sets the value to compare against.
+ * @param mixed $value Test value to match.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function NotIdenticalExpectation($value, $message = '%s') {
+ $this->IdenticalExpectation($value, $message);
+ }
+
+ /**
+ * Tests the expectation. True if it differs from the
+ * held value.
+ * @param mixed $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return ! parent::test($compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ if ($this->test($compare)) {
+ return "Not identical expectation passes " .
+ $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
+ } else {
+ return "Not identical expectation [" . $dumper->describeValue($this->_getValue()) . "] matches";
+ }
+ }
+}
+
+/**
+ * Test for a pattern using Perl regex rules.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class PatternExpectation extends SimpleExpectation {
+ var $_pattern;
+
+ /**
+ * Sets the value to compare against.
+ * @param string $pattern Pattern to search for.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function PatternExpectation($pattern, $message = '%s') {
+ $this->SimpleExpectation($message);
+ $this->_pattern = $pattern;
+ }
+
+ /**
+ * Accessor for the pattern.
+ * @return string Perl regex as string.
+ * @access protected
+ */
+ function _getPattern() {
+ return $this->_pattern;
+ }
+
+ /**
+ * Tests the expectation. True if the Perl regex
+ * matches the comparison value.
+ * @param string $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return (boolean)preg_match($this->_getPattern(), $compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ if ($this->test($compare)) {
+ return $this->_describePatternMatch($this->_getPattern(), $compare);
+ } else {
+ $dumper = &$this->_getDumper();
+ return "Pattern [" . $this->_getPattern() .
+ "] not detected in [" .
+ $dumper->describeValue($compare) . "]";
+ }
+ }
+
+ /**
+ * Describes a pattern match including the string
+ * found and it's position.
+ * @param string $pattern Regex to match against.
+ * @param string $subject Subject to search.
+ * @access protected
+ */
+ function _describePatternMatch($pattern, $subject) {
+ preg_match($pattern, $subject, $matches);
+ $position = strpos($subject, $matches[0]);
+ $dumper = $this->_getDumper();
+ return "Pattern [$pattern] detected at character [$position] in [" .
+ $dumper->describeValue($subject) . "] as [" .
+ $matches[0] . "] in region [" .
+ $dumper->clipString($subject, 100, $position) . "]";
+ }
+}
+
+/**
+ * @package SimpleTest
+ * @subpackage UnitTester
+ * @deprecated
+ */
+class WantedPatternExpectation extends PatternExpectation {
+}
+
+/**
+ * Fail if a pattern is detected within the
+ * comparison.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class NoPatternExpectation extends PatternExpectation {
+
+ /**
+ * Sets the reject pattern
+ * @param string $pattern Pattern to search for.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function NoPatternExpectation($pattern, $message = '%s') {
+ $this->PatternExpectation($pattern, $message);
+ }
+
+ /**
+ * Tests the expectation. False if the Perl regex
+ * matches the comparison value.
+ * @param string $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return ! parent::test($compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param string $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ if ($this->test($compare)) {
+ $dumper = &$this->_getDumper();
+ return "Pattern [" . $this->_getPattern() .
+ "] not detected in [" .
+ $dumper->describeValue($compare) . "]";
+ } else {
+ return $this->_describePatternMatch($this->_getPattern(), $compare);
+ }
+ }
+}
+
+/**
+ * @package SimpleTest
+ * @subpackage UnitTester
+ * @deprecated
+ */
+class UnwantedPatternExpectation extends NoPatternExpectation {
+}
+
+/**
+ * Tests either type or class name if it's an object.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class IsAExpectation extends SimpleExpectation {
+ var $_type;
+
+ /**
+ * Sets the type to compare with.
+ * @param string $type Type or class name.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function IsAExpectation($type, $message = '%s') {
+ $this->SimpleExpectation($message);
+ $this->_type = $type;
+ }
+
+ /**
+ * Accessor for type to check against.
+ * @return string Type or class name.
+ * @access protected
+ */
+ function _getType() {
+ return $this->_type;
+ }
+
+ /**
+ * Tests the expectation. True if the type or
+ * class matches the string value.
+ * @param string $compare Comparison value.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ if (is_object($compare)) {
+ return SimpleTestCompatibility::isA($compare, $this->_type);
+ } else {
+ return (strtolower(gettype($compare)) == $this->_canonicalType($this->_type));
+ }
+ }
+
+ /**
+ * Coerces type name into a gettype() match.
+ * @param string $type User type.
+ * @return string Simpler type.
+ * @access private
+ */
+ function _canonicalType($type) {
+ $type = strtolower($type);
+ $map = array(
+ 'bool' => 'boolean',
+ 'float' => 'double',
+ 'real' => 'double',
+ 'int' => 'integer');
+ if (isset($map[$type])) {
+ $type = $map[$type];
+ }
+ return $type;
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ return "Value [" . $dumper->describeValue($compare) .
+ "] should be type [" . $this->_type . "]";
+ }
+}
+
+/**
+ * Tests either type or class name if it's an object.
+ * Will succeed if the type does not match.
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class NotAExpectation extends IsAExpectation {
+ var $_type;
+
+ /**
+ * Sets the type to compare with.
+ * @param string $type Type or class name.
+ * @param string $message Customised message on failure.
+ * @access public
+ */
+ function NotAExpectation($type, $message = '%s') {
+ $this->IsAExpectation($type, $message);
+ }
+
+ /**
+ * Tests the expectation. False if the type or
+ * class matches the string value.
+ * @param string $compare Comparison value.
+ * @return boolean True if different.
+ * @access public
+ */
+ function test($compare) {
+ return ! parent::test($compare);
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ return "Value [" . $dumper->describeValue($compare) .
+ "] should not be type [" . $this->_getType() . "]";
+ }
+}
+
+/**
+ * Tests for existance of a method in an object
+ * @package SimpleTest
+ * @subpackage UnitTester
+ */
+class MethodExistsExpectation extends SimpleExpectation {
+ var $_method;
+
+ /**
+ * Sets the value to compare against.
+ * @param string $method Method to check.
+ * @param string $message Customised message on failure.
+ * @access public
+ * @return void
+ */
+ function MethodExistsExpectation($method, $message = '%s') {
+ $this->SimpleExpectation($message);
+ $this->_method = &$method;
+ }
+
+ /**
+ * Tests the expectation. True if the method exists in the test object.
+ * @param string $compare Comparison method name.
+ * @return boolean True if correct.
+ * @access public
+ */
+ function test($compare) {
+ return (boolean)(is_object($compare) && method_exists($compare, $this->_method));
+ }
+
+ /**
+ * Returns a human readable test message.
+ * @param mixed $compare Comparison value.
+ * @return string Description of success
+ * or failure.
+ * @access public
+ */
+ function testMessage($compare) {
+ $dumper = &$this->_getDumper();
+ if (! is_object($compare)) {
+ return 'No method on non-object [' . $dumper->describeValue($compare) . ']';
+ }
+ $method = $this->_method;
+ return "Object [" . $dumper->describeValue($compare) .
+ "] should contain method [$method]";
+ }
+}
+?> \ No newline at end of file