Assert::notSame() - Code Metrics - Inspection of "phing: removed unnecessary configuration for codes..." - konecnyjakub/mytester - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 08298d...dff84c )

by Jakub

created 2020-09-27 16:14 UTC

Assert::notSame() A

↳ Parent: Assert

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

Metric	Value
cc	2
eloc	4
c	5
b	0
f	0
nc	2
nop	2
dl	0
loc	6
rs	10

<?php
declare(strict_types=1);

namespace MyTester;

/**
 * Assertions
 *
 * @author Jakub Konečný
 * @deprecated Create test cases
 */
final class Assert {
  use \Nette\StaticClass;

  /**
   * @param string|array $variable
   */
  private static function showStringOrArray($variable): string {
    return (is_string($variable) ? $variable : "(array)");
  }

  private static function isSuccess(bool $success): bool {
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    return $success;
  }
  
  /**
   * Tries an assertion
   * 
   * @param mixed $code Assertion to try
   * @param string $failureText Text to print on failure
   * @deprecated
   * @see TAssertions::assert()
   */
  public static function tryAssertion($code, string $failureText = ""): void {
    $success = static::isSuccess($code == true);
    if(!$success) {
      $message = ($failureText === "") ? "Assertion \"$code\" is not true." : $failureText;
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Are both values same?
   * 
   * @param mixed $expected
   * @param mixed $actual
   * @deprecated
   * @see TAssertions::assertSame()
   */
  public static function same($expected, $actual): void {
    $success = static::isSuccess($expected == $actual);
    if(!$success) {
      $message = "The value is not $expected but $actual.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Are not both values same?
   * 
   * @param mixed $expected
   * @param mixed $actual
   * @deprecated
   * @see TAssertions::assertNotSame()
   */
  public static function notSame($expected, $actual): void {
    $success = static::isSuccess($expected !== $actual);
    if(!$success) {
      $message = "The value is $expected.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is the expression true?
   * 
   * @param mixed $actual
   * @deprecated
   * @see TAssertions::assertTruthy()
   */
  public static function true($actual): void {
    $success = static::isSuccess($actual == true);
    if(!$success) {
      $message = "The expression is not true.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is the expression false?
   * 
   * @param mixed $actual
   * @deprecated
   * @see TAssertions::assertFalsey()
   */
  public static function false($actual): void {
    $success = static::isSuccess($actual == false);
    if(!$success) {
      $message = "The expression is not false.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is the value null?
   * 
   * @param mixed $actual
   * @deprecated
   * @see TAssertions::assertNull()
   */
  public static function null($actual): void {
    $success = static::isSuccess($actual == null);
    if(!$success) {
      $message = "The value is not null.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is not the value null?
   * 
   * @param mixed $actual
   * @deprecated
   * @see TAssertions::assertNotNull()
   */
  public static function notNull($actual): void {
    $success = static::isSuccess($actual !== null);
    if(!$success) {
      $message = "The value is null.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Does $actual contain $needle?
   * 
   * @param string|array $needle
   * @param string|array $actual
   * @deprecated
   * @see TAssertions::assertContains()
   */
  public static function contains($needle, $actual): void {
    if(!is_string($needle) && !is_array($needle)) {
      Environment::testResult("The variable is not string or array.", false);
    } elseif(is_string($actual) && is_string($needle)) {
      $success = static::isSuccess($needle !== "" && strpos($actual, $needle) !== false);
      if($success) {
        Environment::testResult("");
      } else {
        Environment::testResult("$needle is not in the variable.", false);
      }
    } elseif(is_array($actual)) {
      $success = static::isSuccess(in_array($needle, $actual));
      if($success) {
        Environment::testResult("");
      } else {
        Environment::testResult(static::showStringOrArray($needle) . " is not in the variable.", false);
      }
    } else {
      Environment::testResult(static::showStringOrArray($needle) . " is not in the variable.", false);
    }
  }
  
  /**
   * Does $actual not contain $needle?
   * 
   * @param string|array $needle
   * @param string|array $actual
   * @deprecated
   * @see TAssertions::assertNotContains()
   */
  public static function notContains($needle, $actual): void {
    if(!is_string($needle) && !is_array($needle)) {
      Environment::testResult("The variable is not string or array.", false);
    } elseif(is_string($actual) && is_string($needle)) {
      $success = static::isSuccess($needle === "" || strpos($actual, $needle) === false);
      if($success) {
        Environment::testResult("");
      } else {
        Environment::testResult("$needle is in the variable.", false);
      }
    } elseif(is_array($actual)) {
      $success = static::isSuccess(!in_array($needle, $actual));
      if($success) {
        Environment::testResult("");
      } else {
        Environment::testResult(static::showStringOrArray($needle) . " is in the variable.", false);
      }
    } else {
      Environment::testResult(static::showStringOrArray($needle) . " is not in the variable.", false);
    }
  }
  
  /**
   * Does $value contain $count items?
   *
   * @param string|array|\Countable $value
   * @deprecated
   * @see TAssertions::assertCount()
   */
  public static function count(int $count, $value): void {
    if(!is_array($value) && !$value instanceof \Countable) {
      Environment::testResult("The variable is not array or countable object.", false);
      return;
    }
    $success = static::isSuccess(count($value) === $count);
    if($success) {
      Environment::testResult("");
    } else {
      $actual = count($value);
      Environment::testResult("Count of the variable is $actual.", false);
    }
  }
  
  /**
   * Does $value not contain $count items?
   *
   * @param string|array|\Countable $value
   * @deprecated
   * @see TAssertions::assertNotCount()
   */
  public static function notCount(int $count, $value): void {
    if(!is_array($value) && !$value instanceof \Countable) {
      Environment::testResult("The variable is not array or countable object.", false);
      return;
    }
    $success = static::isSuccess(count($value) !== $count);
    if($success) {
      Environment::testResult("");
    } else {
      $actual = count($value);
      Environment::testResult("Count of the variable is $actual.", false);
    }
  }
  
  /**
   * Is $value of type $type?
   * 
   * @param string|object $type
   * @param mixed $value
   * @deprecated
   * @see TAssertions::assertType()
   */
  public static function type($type, $value): void {
    if(!is_object($type) && !is_string($type)) {
      Environment::testResult("Type must be string or object.", false);
      return;
    }
    if(in_array($type, ["array", "bool", "callable", "float",
      "int", "integer", "null", "object", "resource", "scalar", "string"], true)) {
      $success = static::isSuccess(call_user_func("is_$type", $value));
      if(!$success) {
        Environment::testResult("The variable is " . gettype($value) . ".", false);
      } else {
        Environment::testResult("");
      }
      return;
    }
    $success = static::isSuccess($value instanceof $type);
    if(!$success) {
      $actual = get_debug_type($value);
      Environment::testResult("The variable is instance of $actual.", false);
    } else {
      Environment::testResult("");
    }
  }
}
?>

1			<?php
2			declare(strict_types=1);
3
4			namespace MyTester;
5
6			/**
7			* Assertions
8			*
9			* @author Jakub Konečný
10			* @deprecated Create test cases
11			*/
12			final class Assert {
13			use \Nette\StaticClass;
14
15			/**
16			* @param string\|array $variable
17			*/
18			private static function showStringOrArray($variable): string {
19			return (is_string($variable) ? $variable : "(array)");
20			}
21
22			private static function isSuccess(bool $success): bool {
23			if(Environment::getShouldFail()) {
24			$success = !$success;
25			}
26			return $success;
27			}
28
29			/**
30			* Tries an assertion
31			*
32			* @param mixed $code Assertion to try
33			* @param string $failureText Text to print on failure
34			* @deprecated
35			* @see TAssertions::assert()
36			*/
37			public static function tryAssertion($code, string $failureText = ""): void {
38			$success = static::isSuccess($code == true);
39			if(!$success) {
40			$message = ($failureText === "") ? "Assertion \"$code\" is not true." : $failureText;
41			}
42			Environment::testResult($message ?? "", $success);
43			}
44
45			/**
46			* Are both values same?
47			*
48			* @param mixed $expected
49			* @param mixed $actual
50			* @deprecated
51			* @see TAssertions::assertSame()
52			*/
53			public static function same($expected, $actual): void {
54			$success = static::isSuccess($expected == $actual);
55			if(!$success) {
56			$message = "The value is not $expected but $actual.";
57			}
58			Environment::testResult($message ?? "", $success);
59			}
60
61			/**
62			* Are not both values same?
63			*
64			* @param mixed $expected
65			* @param mixed $actual
66			* @deprecated
67			* @see TAssertions::assertNotSame()
68			*/
69			public static function notSame($expected, $actual): void {
70			$success = static::isSuccess($expected !== $actual);
71			if(!$success) {
72			$message = "The value is $expected.";
73			}
74			Environment::testResult($message ?? "", $success);
75			}
76
77			/**
78			* Is the expression true?
79			*
80			* @param mixed $actual
81			* @deprecated
82			* @see TAssertions::assertTruthy()
83			*/
84			public static function true($actual): void {
85			$success = static::isSuccess($actual == true);
86			if(!$success) {
87			$message = "The expression is not true.";
88			}
89			Environment::testResult($message ?? "", $success);
90			}
91
92			/**
93			* Is the expression false?
94			*
95			* @param mixed $actual
96			* @deprecated
97			* @see TAssertions::assertFalsey()
98			*/
99			public static function false($actual): void {
100			$success = static::isSuccess($actual == false);
101			if(!$success) {
102			$message = "The expression is not false.";
103			}
104			Environment::testResult($message ?? "", $success);
105			}
106
107			/**
108			* Is the value null?
109			*
110			* @param mixed $actual
111			* @deprecated
112			* @see TAssertions::assertNull()
113			*/
114			public static function null($actual): void {
115			$success = static::isSuccess($actual == null);
116			if(!$success) {
117			$message = "The value is not null.";
118			}
119			Environment::testResult($message ?? "", $success);
120			}
121
122			/**
123			* Is not the value null?
124			*
125			* @param mixed $actual
126			* @deprecated
127			* @see TAssertions::assertNotNull()
128			*/
129			public static function notNull($actual): void {
130			$success = static::isSuccess($actual !== null);
131			if(!$success) {
132			$message = "The value is null.";
133			}
134			Environment::testResult($message ?? "", $success);
135			}
136
137			/**
138			* Does $actual contain $needle?
139			*
140			* @param string\|array $needle
141			* @param string\|array $actual
142			* @deprecated
143			* @see TAssertions::assertContains()
144			*/
145			public static function contains($needle, $actual): void {
146			if(!is_string($needle) && !is_array($needle)) {
147			Environment::testResult("The variable is not string or array.", false);
148			} elseif(is_string($actual) && is_string($needle)) {
149			$success = static::isSuccess($needle !== "" && strpos($actual, $needle) !== false);
150			if($success) {
151			Environment::testResult("");
152			} else {
153			Environment::testResult("$needle is not in the variable.", false);
154			}
155			} elseif(is_array($actual)) {
156			$success = static::isSuccess(in_array($needle, $actual));
157			if($success) {
158			Environment::testResult("");
159			} else {
160			Environment::testResult(static::showStringOrArray($needle) . " is not in the variable.", false);
161			}
162			} else {
163			Environment::testResult(static::showStringOrArray($needle) . " is not in the variable.", false);
164			}
165			}
166
167			/**
168			* Does $actual not contain $needle?
169			*
170			* @param string\|array $needle
171			* @param string\|array $actual
172			* @deprecated
173			* @see TAssertions::assertNotContains()
174			*/
175			public static function notContains($needle, $actual): void {
176			if(!is_string($needle) && !is_array($needle)) {
177			Environment::testResult("The variable is not string or array.", false);
178			} elseif(is_string($actual) && is_string($needle)) {
179			$success = static::isSuccess($needle === "" \|\| strpos($actual, $needle) === false);
180			if($success) {
181			Environment::testResult("");
182			} else {
183			Environment::testResult("$needle is in the variable.", false);
184			}
185			} elseif(is_array($actual)) {
186			$success = static::isSuccess(!in_array($needle, $actual));
187			if($success) {
188			Environment::testResult("");
189			} else {
190			Environment::testResult(static::showStringOrArray($needle) . " is in the variable.", false);
191			}
192			} else {
193			Environment::testResult(static::showStringOrArray($needle) . " is not in the variable.", false);
194			}
195			}
196
197			/**
198			* Does $value contain $count items?
199			*
200			* @param string\|array\|\Countable $value
201			* @deprecated
202			* @see TAssertions::assertCount()
203			*/
204			public static function count(int $count, $value): void {
205			if(!is_array($value) && !$value instanceof \Countable) {
206			Environment::testResult("The variable is not array or countable object.", false);
207			return;
208			}
209			$success = static::isSuccess(count($value) === $count);
210			if($success) {
211			Environment::testResult("");
212			} else {
213			$actual = count($value);
214			Environment::testResult("Count of the variable is $actual.", false);
215			}
216			}
217
218			/**
219			* Does $value not contain $count items?
220			*
221			* @param string\|array\|\Countable $value
222			* @deprecated
223			* @see TAssertions::assertNotCount()
224			*/
225			public static function notCount(int $count, $value): void {
226			if(!is_array($value) && !$value instanceof \Countable) {
227			Environment::testResult("The variable is not array or countable object.", false);
228			return;
229			}
230			$success = static::isSuccess(count($value) !== $count);
231			if($success) {
232			Environment::testResult("");
233			} else {
234			$actual = count($value);
235			Environment::testResult("Count of the variable is $actual.", false);
236			}
237			}
238
239			/**
240			* Is $value of type $type?
241			*
242			* @param string\|object $type
243			* @param mixed $value
244			* @deprecated
245			* @see TAssertions::assertType()
246			*/
247			public static function type($type, $value): void {
248			if(!is_object($type) && !is_string($type)) {
249			Environment::testResult("Type must be string or object.", false);
250			return;
251			}
252			if(in_array($type, ["array", "bool", "callable", "float",
253			"int", "integer", "null", "object", "resource", "scalar", "string"], true)) {
254			$success = static::isSuccess(call_user_func("is_$type", $value));
255			if(!$success) {
256			Environment::testResult("The variable is " . gettype($value) . ".", false);
257			} else {
258			Environment::testResult("");
259			}
260			return;
261			}
262			$success = static::isSuccess($value instanceof $type);
263			if(!$success) {
264			$actual = get_debug_type($value);
265			Environment::testResult("The variable is instance of $actual.", false);
266			} else {
267			Environment::testResult("");
268			}
269			}
270			}
271			?>

konecnyjakub / mytester

Push — master ( 08298d...dff84c )

Assert::notSame() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like