33. Testovací script (JS) a křížová kontrola

Ilustrační obrázek k článku: Testovací script (JS) a křížová kontrola
V minulém díle jsme postavili PHP část testovacího scriptu. Dnes doplníme JavaScriptovou část a dokončíme mechanismus pro křížové porovnávání výsledků – tedy páteř spolehlivosti CombiScriptu.

V minulém díle jsme vytvořili PHP část testovacího scriptu, která vygenerovala tabulku s výsledky testů na serveru. Dnes napíšeme JavaScriptovou část, která tytéž testy spustí v prohlížeči a porovná výsledky. To je klíčové pro ověření, že náš CombiScript opravdu vrací stejné hodnoty v obou jazycích.

Funkce tst_ToHTML v JavaScriptu

Začneme funkcí tst_ToHTML. Musíme ji napsat stejně jako v PHP, kde vypadala takto:

  1. function tst_ToHtml($x)
  2. {
  3. return nl2br(htmlspecialchars($x));
  4. }

JavaScript nemá vestavěnou funkci htmlspecialchars, takže si ji musíme naprogramovat sami. Když se podíváme do PHP manuálu, vidíme přesně, jaké znaky se konvertují. V JS použijeme několikanásobné nahrazení. Pořadí je důležité - ampersand musí být první, jinak bychom převáděli i ampersandy z již převedených entit.

Stejným způsobem nahradíme konce řádků za <br />. Carriage return považujeme za volitelný (proto regex \n\r?).

  1. function tst_ToHtml(x)
  2. {
  3. x = x.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
  4. x = x.replace(/\r?\n/g, '<br />\n');
  5. return x;
  6. }

Funkce Out bez statických proměnných

Dále vytvoříme JS variantu funkce Out. V PHP jsme využívali statickou proměnnou, ale JavaScript statické proměnné nemá. Musíme se tedy poradit jinak.

Řešení je překvapivě elegantní: každá JS funkce je objekt a může mít vlastnosti. Text si tedy schováme přímo do vlastnosti Out._buffer. To je užitečný trik, který se hodí i mimo CombiScript - zapamatujte si ho.

PHP verze pro srovnání:

  1. // Definice jednoznačných instancí
  2. define('TST_OUT_RESET', new stdClass());
  3. define('TST_OUT_GET', new stdClass());
  4. function Out($x)
  5. {
  6. static $buffer = '';
  7. if ($x === TST_OUT_RESET) return $buffer = '';
  8. if ($x === TST_OUT_GET) return $buffer;
  9. if (is_string($x) || is_int($x) || is_float($x) || is_bool($x) || is_null($x))
  10. {
  11. $buffer .= tst_ToHtml(json_encode($x, JSON_UNESCAPED_UNICODE));
  12. return;
  13. }
  14. if ($x instanceof Exception)
  15. {
  16. $s = ($x instanceof cs_Error) ? '#Err:' : '?Err:';
  17. $s .= $x->getMessage();
  18. if ($x instanceof cs_Error)
  19. {
  20. $data = $x->getData();
  21. if ($data && is_array($data) && count($data))
  22. {
  23. $s .= ' ' . json_encode($data, JSON_UNESCAPED_UNICODE);
  24. }
  25. }
  26. $buffer .= $s;
  27. return;
  28. }
  29. $buffer .= 'Out-UnknownType';
  30. }

A nyní JS implementace využívající vlastnosti funkce:

  1. const TST_OUT_RESET = {};
  2. const TST_OUT_GET = {};
  3. function Out(x)
  4. {
  5. if (Out._buffer === undefined) Out._buffer = '';
  6. if (x === TST_OUT_RESET) return Out._buffer = '';
  7. if (x === TST_OUT_GET) return Out._buffer;
  8. if (typeof x === "string" || typeof x === "number" || typeof x === "boolean" || x === null)
  9. {
  10. Out._buffer += JSON.stringify(x);
  11. return;
  12. }
  13. if (x instanceof Error)
  14. {
  15. let s = (x instanceof cs_Error) ? '#Err:' : '?Err:';
  16. s += x.message;
  17. const data = x.getData();
  18. if (Array.isArray(data) && data.length > 0)
  19. {
  20. s += ' ' + JSON.stringify(data);
  21. }
  22. Out._buffer += s
  23. return;
  24. }
  25. Out._buffer += 'Out-UnknownType';
  26. }

Spuštění jednotlivých testů

Nakonec vytvoříme funkci tst_RunTest, která spustí jednu anonymní testovací funkci. V PHP vypadá takto:

  1. function tst_RunTest($test)
  2. {
  3. Out(TST_OUT_RESET);
  4. try
  5. {
  6. $test();
  7. }
  8. catch (Exception $e)
  9. {
  10. Out($e);
  11. }
  12. return Out(TST_OUT_GET);
  13. }

Přepis do JavaScriptu je přímočarý - jen změníme způsob zachytávání výjimek:

  1. function tst_RunTest($test)
  2. {
  3. Out(TST_OUT_RESET);
  4. try
  5. {
  6. $test();
  7. }
  8. catch (error)
  9. {
  10. Out(error)
  11. }
  12. return Out(TST_OUT_GET);
  13. }

Automatické spuštění všech testů

A zcela na závěr vytvoříme kód, který po načtení stránky automaticky spustí všechny testy v JavaScriptu. Logika je následující:

  1. Projdeme všechny testovací soubory, funkce a jednotlivé testy
  2. Pro každý test najdeme odpovídající řádek tabulky (vygenerovaný v PHP)
  3. Spustíme test a výsledek zapíšeme do buňky s indexem 3
  4. Porovnáme výsledek PHP (buňka 2) s výsledkem JS (buňka 3)
  5. Do buňky 4 zapíšeme "OK" nebo "Err" a obarvíme podle očekávání
  1. window.onload = function()
  2. {
  3. for (var $File in $Tests)
  4. for (var $Func in $Tests[$File])
  5. for (var $TestId=0; $TestId<$Tests[$File][$Func].length; $TestId++)
  6. {
  7. var $TestArr = $Tests[$File][$Func][$TestId];
  8. var trEl = document.getElementById($File+'-'+$Func+'-'+$TestId);
  9. if (!trEl) continue;
  10. trEl.cells[3].innerHTML = tst_ToHtml(tst_RunTest($TestArr[1]));
  11. trEl.cells[4].innerHTML = (trEl.cells[2].innerHTML===trEl.cells[3].innerHTML) ? 'OK' : 'Err';
  12. if ($TestArr[0]===1)
  13. {
  14. trEl.cells[4].style.color = (trEl.cells[4].innerText==='OK') ? 'green' : 'red';
  15. }
  16. }
  17. }

Kompletní testovací framework

Nyní máme hotovo. Celý testovací script včetně obou částí (PHP i JS) vypadá takto:

    
  1. <!DOCTYPE html>
  2. <HTML lang="cs">
  3. <HEAD>
  4. <META charset="UTF-8"/>
  5. <META name="viewport" content="width=device-width, initial-scale=1.0">
  6. <LINK rel="shortcut icon" href="./favicon.ico"/>
  7. <TITLE>CombiScript Tests</TITLE>
  8. <STYLE>
  9. BODY {
  10. background-color:#EEE;
  11. font-family:sans-serif;
  12. }
  13. .Tests {
  14. border-collapse: collapse;
  15. width:100%;
  16. }
  17. .Tests TD, .Tests TH {
  18. border:1px solid black;
  19. position:relative;
  20. }
  21. .tst_Source {
  22. white-space:pre;
  23. font-family:monospace;
  24. }
  25. </STYLE>
  26. </HEAD>
  27. <BODY>
  28. <?php
  29. $Libs = ['cs_Util', 'nm_Util'];
  30. $TestLibs = ['nm_Util_Test'];
  31. foreach ($Libs AS $Nr => $Lib)
  32. include('./cs_src/'.$Lib.'.php.js');
  33. foreach ($TestLibs AS $Nr => $Lib)
  34. include('./cs_tests/'.$Lib.'.php.js');
  35. ?>
  36. </BODY>
  37. <?php
  38. foreach ($Libs AS $Nr => $Lib)
  39. echo '<SCRIPT src="./cs_src/'.$Lib.'.php.js?'.date('YmdHis').'"></SCRIPT>';
  40. foreach ($TestLibs AS $Nr => $Lib)
  41. echo '<SCRIPT src="./cs_tests/'.$Lib.'.php.js?'.date('YmdHis').'"></SCRIPT>';
  43. function tst_ToHtml($x)
  44. {
  45. return nl2br(htmlspecialchars($x));
  46. }
  48. // Definice jednoznačných instancí
  49. define('TST_OUT_RESET', new stdClass());
  50. define('TST_OUT_GET', new stdClass());
  52. function Out($x)
  53. {
  54. static $buffer = '';
  55. if ($x === TST_OUT_RESET) return $buffer = '';
  56. if ($x === TST_OUT_GET) return $buffer;
  57. if (is_string($x) || is_int($x) || is_float($x) || is_bool($x) || is_null($x))
  58. {
  59. $buffer .= json_encode($x, JSON_UNESCAPED_UNICODE);
  60. return;
  61. }
  62. if ($x instanceof Exception)
  63. {
  64. $s = ($x instanceof cs_Error) ? '#Err:' : '?Err:';
  65. $s .= $x->getMessage();
  66. if ($x instanceof cs_Error)
  67. {
  68. $data = $x->getData();
  69. if ($data && is_array($data) && count($data))
  70. {
  71. $s .= ' ' . json_encode($data, JSON_UNESCAPED_UNICODE);
  72. }
  73. }
  74. $buffer .= $s;
  75. return;
  76. }
  77. $buffer .= 'Out-UnknownType';
  78. }
  80. function tst_RunTest($test)
  81. {
  82. Out(TST_OUT_RESET);
  83. try
  84. {
  85. $test();
  86. }
  87. catch (Exception $e)
  88. {
  89. Out($e);
  90. }
  91. return Out(TST_OUT_GET);
  92. }
  94. function tst_GetClosureCode($func)
  95. {
  96. static $cache = [];
  97. $ref = new ReflectionFunction($func);
  98. if (!$ref->isUserDefined()) return null;
  99. $file = $ref->getFileName();
  100. if (!isset($cache[$file]))
  101. $cache[$file] = file($file);
  102. $start = $ref->getStartLine() - 1;
  103. $end = $ref->getEndLine();
  104. $ret = implode('', array_slice($cache[$file], $start, $end - $start)); //\n uz je soucasti kazdy line ziskane pomoci funkce file()
  105. if (preg_match('/function\s*\(/i', $ret, $matches, PREG_OFFSET_CAPTURE)) $Begin = $matches[0][1]; //Pocitam s tim ze je to prvni "function (" na radku kde zacina deklarace funkce
  106. $End = strrpos($ret, '}'); //Pocitam s tim ze je to posledni "}" na radku kde konci deklarace funkce
  107. $ret = substr($ret, $Begin, $End-$Begin+1);
  108. return $ret;
  109. }
  111. foreach ($Tests AS $File=>$FileArr)
  112. {
  113. foreach ($FileArr AS $Func=>$FuncArr)
  114. {
  115. echo '<H3>'.$Func.'</H3>';
  116. echo '<TABLE class=Tests><TR><TH>Popis</TH><TH>Zdroj</TH><TH>PHP</TH><TH>JS</TH><TH>Vysledek</TH></TR>';
  117. foreach ($FuncArr AS $TestId=>$TestArr)
  118. {
  119. echo '<TR id="'.$File.'-'.$Func.'-'.$TestId.'">';
  120. echo '<TD>'.tst_ToHtml($TestArr[2]).'</TD>';
  121. echo '<TD style="white-space:pre; font-family:monospace">'.htmlspecialchars(tst_GetClosureCode($TestArr[1])).'</TD>';
  122. echo '<TD>'.tst_ToHtml(tst_RunTest($TestArr[1])).'</TD>';
  123. echo '<TD></TD>';
  124. echo '<TD></TD>';
  125. echo '</TR>';
  126. }
  127. echo '</TABLE>';
  128. }
  129. }
  131. ?>
  132. </BODY>
  133. <SCRIPT>
  134. "use strict";
  135. var $Tests = {};
  136. </SCRIPT>
  138. <?php
  139. foreach ($Libs AS $Nr => $Lib)
  140. echo '<SCRIPT src="./cs_src/'.$Lib.'.php.js?'.date('YmdHis').'"></SCRIPT>';
  141. foreach ($TestLibs AS $Nr => $Lib)
  142. echo '<SCRIPT src="./cs_tests/'.$Lib.'.php.js?'.date('YmdHis').'"></SCRIPT>';
  143. ?>
  145. <SCRIPT>
  146. "use strict";
  148. function tst_ToHtml(x)
  149. {
  150. x = x.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
  151. x = x.replace(/\r?\n/g, '<br />\n');
  152. return x;
  153. }
  155. const TST_OUT_RESET = {};
  156. const TST_OUT_GET = {};
  158. function Out(x)
  159. {
  160. if (Out._buffer === undefined) Out._buffer = '';
  161. if (x === TST_OUT_RESET) return Out._buffer = '';
  162. if (x === TST_OUT_GET) return Out._buffer;
  163. if (typeof x === "string" || typeof x === "number" || typeof x === "boolean" || x === null)
  164. {
  165. Out._buffer += JSON.stringify(x);
  166. return;
  167. }
  168. if (x instanceof Error)
  169. {
  170. let s = (x instanceof cs_Error) ? '#Err:' : '?Err:';
  171. s += x.message;
  172. const data = x.getData();
  173. if (Array.isArray(data) && data.length > 0)
  174. {
  175. s += ' ' + JSON.stringify(data);
  176. }
  177. Out._buffer += s
  178. return;
  179. }
  180. Out._buffer += 'Out-UnknownType';
  181. }
  183. function tst_RunTest($test)
  184. {
  185. Out(TST_OUT_RESET);
  186. try
  187. {
  188. $test();
  189. }
  190. catch (error)
  191. {
  192. Out(error)
  193. }
  194. return Out(TST_OUT_GET);
  195. }
  197. window.onload = function()
  198. {
  199. for (var $File in $Tests)
  200. for (var $Func in $Tests[$File])
  201. for (var $TestId=0; $TestId<$Tests[$File][$Func].length; $TestId++)
  202. {
  203. var $TestArr = $Tests[$File][$Func][$TestId];
  204. var trEl = document.getElementById($File+'-'+$Func+'-'+$TestId);
  205. if (!trEl) continue;
  206. trEl.cells[3].innerHTML = tst_ToHtml(tst_RunTest($TestArr[1]));
  207. trEl.cells[4].innerHTML = (trEl.cells[2].innerHTML===trEl.cells[3].innerHTML) ? 'OK' : 'Err';
  208. if ($TestArr[0]===1)
  209. {
  210. trEl.cells[4].style.color = (trEl.cells[4].innerText==='OK') ? 'green' : 'red';
  211. }
  212. }
  213. }
  215. </SCRIPT>
  216. </HTML>
  1. <!-- --><?php /*
  2. "use strict";
  3. //*/
  4. function nm_IsNumber($num)
  5. {
  6. 0&&0<!--$_;/*
  7. return typeof $num === 'number'
  8. /*/
  9. return is_int($num) OR is_float($num);
  10. //*/
  11. }
  13. function nm_Abs($num)
  14. {
  15. if (!nm_IsNumber($num)) throw new cs_Error('nm_Abs-$num-NotNumber', [cs_Type($num)]);
  16. 0&&0<!--$_;/*
  17. return Math.abs($num);
  18. /*/
  19. return abs($num);
  20. //*/
  21. }
  23. function nm_Sign($num)
  24. {
  25. if (!nm_IsNumber($num)) throw new cs_Error('nm_Sign-$num-NotNumber', [cs_Type($num)]);
  26. 0&&0<!--$_;/*
  27. return Math.sign($num);
  28. /*/
  29. return ($num > 0) - ($num < 0);
  30. //*/
  31. }
  33. function nm_IsAsInt($num)
  34. {
  35. 0&&0<!--$_;/*
  36. return Number.isInteger($num);
  37. /*/
  38. if (is_int($num)) return true;
  39. return (is_float($num) && floor($num) === $num);
  40. //*/
  41. }
  43. function nm_Pi()
  44. {
  45. 0&&0<!--$_;/*
  46. return Math.PI;
  47. /*/
  48. return Pi();
  49. //*/
  50. }
  52. function nm_Rad2Deg($rad)
  53. {
  54. if (!nm_IsNumber($rad)) throw new cs_Error('nm_Rad2Deg-$rad-NotNumber', [cs_Type($rad)]);
  55. 0&&0<!--$_;/*
  56. return $rad * (180/Math.PI);
  57. /*/
  58. return rad2deg($rad);
  59. //*/
  60. }
  62. function nm_Deg2Rad($deg)
  63. {
  64. if (!nm_IsNumber($deg)) throw new cs_Error('nm_Deg2Rad-$deg-NotNumber', [cs_Type($deg)]);
  65. 0&&0<!--$_;/*
  66. return $deg/180*Math.PI;
  67. /*/
  68. return deg2rad($deg);
  69. //*/
  70. }
  72. function nm_Sin($rad)
  73. {
  74. if (!nm_IsNumber($rad)) throw new cs_Error('nm_Sin-$rad-NotNumber', [cs_Type($rad)]);
  75. 0&&0<!--$_;/*
  76. return Math.sin($rad);
  77. /*/
  78. return sin($rad);
  79. //*/
  80. }
  82. function nm_Cos($rad)
  83. {
  84. if (!nm_IsNumber($rad)) throw new cs_Error('nm_Cos-$rad-NotNumber', [cs_Type($rad)]);
  85. 0&&0<!--$_;/*
  86. return Math.cos($rad);
  87. /*/
  88. return cos($rad);
  89. //*/
  90. }
  92. function nm_Tan($rad)
  93. {
  94. if (!nm_IsNumber($rad)) throw new cs_Error('nm_Tan-$rad-NotNumber', [cs_Type($rad)]);
  95. 0&&0<!--$_;/*
  96. return Math.tan($rad);
  97. /*/
  98. return tan($rad);
  99. //*/
  100. }
  102. function nm_ASin($num)
  103. {
  104. if (!nm_IsNumber($num)) throw new cs_Error('nm_ASin-$num-NotNumber', [cs_Type($num)]);
  105. if ($num>1 || $num<-1) throw new cs_Error('nm_ASin-$num-OutOfRange');
  106. 0&&0<!--$_;/*
  107. return Math.asin($num);
  108. /*/
  109. return asin($num);
  110. //*/
  111. }
  113. function nm_ACos($num)
  114. {
  115. if (!nm_IsNumber($num)) throw new cs_Error('nm_ACos-$num-NotNumber', [cs_Type($num)]);
  116. if ($num>1 || $num<-1) throw new cs_Error('nm_ACos-$num-OutOfRange');
  117. 0&&0<!--$_;/*
  118. return Math.acos($num);
  119. /*/
  120. return acos($num);
  121. //*/
  122. }
  124. function nm_ATan($num)
  125. {
  126. if (!nm_IsNumber($num)) throw new cs_Error('nm_ATan-$num-NotNumber', [cs_Type($num)]);
  127. 0&&0<!--$_;/*
  128. return Math.atan($num);
  129. /*/
  130. return atan($num);
  131. //*/
  132. }
  134. function nm_ATan2($y, $x)
  135. {
  136. if (!nm_IsNumber($y)) throw new cs_Error('nm_ATan2-$y-NotNumber', [cs_Type($y)]);
  137. if (!nm_IsNumber($x)) throw new cs_Error('nm_ATan2-$x-NotNumber', [cs_Type($x)]);
  138. 0&&0<!--$_;/*
  139. return Math.atan2($y, $x);
  140. /*/
  141. return atan2($y, $x);
  142. //*/
  143. }
  1. <!-- --><?php /*
  2. "use strict";
  3. class cs_Error extends Error
  4. {
  5. constructor($message, $data=[])
  6. {
  7. super($message);
  8. if (Error.captureStackTrace) Error.captureStackTrace(this, cs_Error);
  9. this.data = $data;
  10. }
  11. getData()
  12. {
  13. return this.data;
  14. }
  15. }
  16. /*/
  17. class cs_Error extends Exception
  18. {
  19. private $_data = '';
  20. public function __construct($message, $data=[])
  21. {
  22. $this->_data = $data;
  23. parent::__construct($message);
  24. }
  25. public function getData()
  26. {
  27. return $this->_data;
  28. }
  29. }
  30. //*/
  32. function cs_Type($var)
  33. {
  34. if ($var === null) return 'Null';
  35. if (nm_IsNumber($var)) return 'Number';
  36. //if (bl_IsBoolean($var)) return 'Boolean'; //TODO next
  37. //if (st_IsString($var)) return 'String';
  38. //if (ar_IsArray($var)) return 'Array';
  39. return 'Unknown';
  40. }
  1. <!-- --><?php
  2. "use strict";
  4. $Tests['nm_Util'] = [];
  6. $Tests['nm_Util']['nm_IsNumber'] = [
  7. [1, function()
  8. {
  9. Out(nm_IsNumber(5));
  10. },
  11. 'Ověřuje, že kladné celé číslo je číslo'],
  13. [1, function()
  14. {
  15. Out(nm_IsNumber(-5));
  16. },
  17. 'Ověřuje, že záporné celé číslo je číslo'],
  19. [1, function()
  20. {
  21. Out(nm_IsNumber(0));
  22. },
  23. 'Ověřuje, že nula je číslo'],
  25. [1, function()
  26. {
  27. Out(nm_IsNumber(2.5));
  28. },
  29. 'Ověřuje, že kladné desetinné číslo je číslo'],
  31. [1, function()
  32. {
  33. Out(nm_IsNumber(-2.5));
  34. },
  35. 'Ověřuje, že záporné desetinné číslo je číslo'],
  37. [1, function()
  38. {
  39. Out(nm_IsNumber(.5));
  40. },
  41. 'Ověřuje, že desetinné číslo s vynechanou úvodní nulou je číslo'],
  43. [1, function()
  44. {
  45. Out(nm_IsNumber(-.5));
  46. },
  47. 'Ověřuje, že záporné desetinné číslo s vynechanou úvodní nulou je číslo'],
  49. [1, function()
  50. {
  51. Out(nm_IsNumber(3.21E4));
  52. },
  53. 'Ověřuje, že číslo v exponenciálním tvaru je číslo'],
  56. [1, function()
  57. {
  58. Out(nm_IsNumber(-3.21E4));
  59. },
  60. 'Ověřuje, že záporné číslo v exponenciálním tvaru je číslo'],
  62. [1, function()
  63. {
  64. Out(nm_IsNumber(3.21E-4));
  65. },
  66. 'Ověřuje, že číslo s negativním exponentem je číslo'],
  68. [1, function()
  69. {
  70. Out(nm_IsNumber(-3.21E-4));
  71. },
  72. 'Ověřuje, že záporné číslo s negativním exponentem je číslo'],
  74. [1, function()
  75. {
  76. Out(nm_IsNumber(-3.21e-4));
  77. },
  78. 'Ověřuje, že se akceptuje malé "e" v exponenciálním tvaru'],
  80. [1, function()
  81. {
  82. Out(nm_IsNumber("123"));
  83. },
  84. 'Ověřuje, že string obsahující číslo není číslo'],
  86. [1, function()
  87. {
  88. Out(nm_IsNumber([1]));
  89. },
  90. 'Ověřuje, že pole není číslo']
  91. ];
  95. $Tests['nm_Util']['nm_IsAsInt'] = [
  96. [1, function()
  97. {
  98. Out(nm_IsAsInt(5));
  99. },
  100. 'Ověřuje, že kladné celé číslo je celé číslo'],
  102. [1, function()
  103. {
  104. Out(nm_IsAsInt(-5));
  105. },
  106. 'Ověřuje, že záporné celé číslo je celé číslo'],
  108. [1, function()
  109. {
  110. Out(nm_IsAsInt(5.0));
  111. },
  112. 'Ověřuje, že celočíselný float je celé číslo'],
  114. [1, function()
  115. {
  116. Out(nm_IsAsInt(-5.0));
  117. },
  118. 'Ověřuje, že záporný celočíselný float je celé číslo'],
  120. [1, function()
  121. {
  122. Out(nm_IsAsInt(0));
  123. },
  124. 'Ověřuje, že nula je celé číslo'],
  126. [1, function()
  127. {
  128. Out(nm_IsAsInt(-0));
  129. },
  130. 'Ověřuje, že minus nula je celé číslo'],
  132. [1, function()
  133. {
  134. Out(nm_IsAsInt(2.5));
  135. },
  136. 'Ověřuje, že kladné desetinné číslo není celé číslo'],
  138. [1, function()
  139. {
  140. Out(nm_IsAsInt(-2.5));
  141. },
  142. 'Ověřuje, že záporné desetinné číslo není celé číslo'],
  144. [1, function()
  145. {
  146. Out(nm_IsAsInt("123"));
  147. },
  148. 'Ověřuje, že string obsahující číslo není celé číslo'],
  150. [1, function()
  151. {
  152. Out(nm_IsAsInt(9007199254740991.5));
  153. },
  154. 'Ověřuje, že velké číslo s desetinnou částí se stále jeví jako integer (rozložení na číselné ose je už tak hrubé)'],
  156. [1, function()
  157. {
  158. Out(nm_IsAsInt(4.9999999999999995));
  159. },
  160. 'Toto ještě není 5'],
  162. [1, function()
  163. {
  164. Out(nm_IsAsInt(4.9999999999999996));
  165. },
  166. 'Toto už je 5']
  167. ];
  171. $Tests['nm_Util']['nm_Abs'] = [
  172. [1, function()
  173. {
  174. Out(nm_Abs(2.5));
  175. },
  176. 'Ověřuje, že absolutní hodnota kladného čísla je to samé číslo'],
  178. [1, function()
  179. {
  180. Out(nm_Abs(-2.5));
  181. },
  182. 'Ověřuje, že absolutní hodnota záporného čísla změní znaménko na kladné'],
  184. [1, function()
  185. {
  186. Out(nm_Abs(0));
  187. },
  188. 'Ověřuje, že absolutní hodnota nuly je nula'],
  190. [1, function()
  191. {
  192. Out(nm_Abs("123"));
  193. },
  194. 'Ověřuje, že pro nečíselný parametr se vyhodí chyba'],
  195. ];
  199. $Tests['nm_Util']['nm_Sign'] = [
  200. [1, function()
  201. {
  202. Out(nm_Sign(2.5));
  203. },
  204. 'Ověřuje, že signum kladného čísla je +1'],
  206. [1, function()
  207. {
  208. Out(nm_Sign(-2.5));
  209. },
  210. 'Ověřuje, že signum záporného čísla je -1'],
  212. [1, function()
  213. {
  214. Out(nm_Sign(0));
  215. },
  216. 'Ověřuje, že signum nuly je 0'],
  218. [1, function()
  219. {
  220. Out(nm_Sign(-0));
  221. },
  222. 'Ověřuje, že signum záporné nuly je také 0'],
  224. [1, function()
  225. {
  226. Out(nm_Sign("0"));
  227. },
  228. 'Ověřuje, že pro nečíselný parametr se vyhodí chyba'],
  229. ];

V živé ukázce výše vidíte tabulku se "zelenými" výsledky - podle toho se PHP a JS v námi definovaných a otestovaných funkcích zatím chovají stejně. To je páteř naší důvěry v CombiScript: pokud testy procházejí zeleně, můžeme nanich klidně stavět složitější funkce - až po návrh celého CADu.

V příštím díle se vrátíme k rozšiřování knihovny nm_Util a podíváme se na další matematické funkce, které budeme potřebovat pro geometrické výpočty v našem CADu.

Předchozí