Test a function: Difference between revisions

 

=={{header|ACL2}}==

Using [http://www.ccs.neu.edu/home/cce/acl2/doublecheck.html DoubleCheck]:

 

(if (zp i)

(mv xs ys)

(defproperty palindrome-test

(p :value (random-palindrome))

 

=={{header|Ada}}==

 

For normal use there is pragma Assert, functioning the same as many other languages.<br>

 

 

procedure Test_Function is

Ada.Text_IO.Put_Line("Test Passed!");

end;

 

Ada 2012 introduced a new way to specify functions and test their correctness: Pre- and Postoconditions.

 

with Post => Palindrome'Result =

(Text'Length < 2 or else

 

=={{header|AutoHotkey}}==

there is no "well known" testing library, but here is a simple testing framework: <br>

test library: assert.ahk

;; assert(a, b, test=2)

assert(a, b="blank", test=0)

 

return 1

test example:

, "palindrome test")

assert(broken("in girum imus nocte et consumimur igni"), "works"

 

#Include assert.ahk

 

=={{header|Brat}}==

 

palindrome? = { str |

assert { palindrome? "blah blah" }

}

 

Output:

 

4 tests, 4 assertions, 1 failures.</pre>

 

=={{header|C}}==

 

int IsPalindrome(char *Str);

 

assert(IsPalindrome("alice"));

}

 

=={{header|C sharp}}==

First, using the VisualStudio TestTools for unit tests. I'm testing both of the methods for palindrome detection created in the article.

 

using Microsoft.VisualStudio.TestTools.UnitTesting;

using PalindromeDetector.ConsoleApp;

}

}

 

Second, NUnit tests. Couldn't test these because of namespace issues with NUnit, but I'm sure they work.

using NUnit.Framework;

using PalindromeDetector.ConsoleApp;

}

}

 

=={{header|Clojure}}==

(use 'clojure.test)

 

(deftest test-palindrome?

 

(run-tests)

 

=={{header|Common Lisp}}==

(defpackage :rosetta

(:use :cl

NIL

|#

 

=={{header|Crystal}}==

 

 

describe "palindrome" do

def palindrome(s)

s == s.reverse

 

<pre>

 

=={{header|D}}==

assert(isPalindrome("racecar"));

assert(isPalindrome("bob"));

assert(!isPalindrome("alice"));

 

=={{header|Delphi}}==

Using built in assertions.

 

Assert(IsPalindrome('Ingirumimusnocteetconsumimurigni'), 'Ingirumimusnocteetconsumimurigni is a valid palindrome');

 

Using [[wp:DUnit|DUnit]], an open source unit testing framework that is bundled with Delphi.

 

Check(IsPalindrome('Ingirumimusnocteetconsumimurigni'), 'Ingirumimusnocteetconsumimurigni is a valid palindrome');

 

=={{header|E}}==

The standard testing tool in E is Updoc, a system which takes test scripts formatted in the same style as a [[REPL]] session and verifies that executing them produces the specified result values.

 

 

? def isPalindrome(string :String) {

 

? (x + xreversed).size()

 

=={{header|EchoLisp}}==

EchoLisp provides (assert <true-value?> ["fail-message"]) and (check-expect <expression> <expected-result>).

(assert (palindrome? "aba")) → #t

(assert (palindrome? "abbbca") "palindrome fail")

😐 warning: #t : check failed : (palindrome? abcda) → #f

(assert (palindrome? "un roc lamina l animal cornu")) → #t

 

=={{header|Erlang}}==

This is a unit test so I use Eunit. For system tests "Common Test" would be used. Both are built in.

-module( palindrome_tests ).

-compile( export_all ).

 

abcdef_test() -> ?assertNot( palindrome:is_palindrome("abcdef") ).

{{out}}

<pre>

=={{header|Euphoria}}==

 

--unittest in standard library 4.0+

include std/unittest.e

test_report()

 

 

=={{header|F_Sharp|F#}}==

{{libheader|NUnit}}

let a = s.ToUpper().ToCharArray()

Array.rev a = a

[<Test>]

member x.Test02() =

 

=={{header|Factor}}==

''palindrome/palindrome.factor''

 

IN: palindrome

 

 

''palindrome/palindrome-tests.factor''

 

IN: palindrome.tests

 

[ t ] [ "racecar" palindrome? ] unit-test

 

To run these tests from the listener:

 

 

Factor's tutorial, [http://docs.factorcode.org/content/article-first-program.html Your first program], uses ''palindrome?'' as its example. The tutorial shows how to create tests for ''palindrome?'' and how to fix a failing test.

To use the built-in test library, the program must be compiled into a pod. The layout for a simple pod and its build file is given in the [http://fantom.org/doc/docIntro/HelloWorld.html#pod documentation], and also information for adding and running the [http://fantom.org/doc/docTools/Fant.html test files].

 

class TestPalindrome : Test

{

}

}

 

=={{header|Fortran}}==

There is no standard or popular facility. Compilers usually do not even check that a function or subroutine is invoked with the correct number of parameters let alone the correct types. Testing that a function returns expected values is entirely a matter for the programmer and whatever tools that may be devised, either directly for the function in question or adapted from some other project where this had been done.

 

=={{header|Go}}==

Using Go's standard command, go test.

 

import "testing"

}

}

Output of go test:

<pre>

A notable testing library for Haskell is QuickCheck. It works in a way particularly supported by Haskell's type inference: you provide a function return a boolean, the test, and QuickCheck automatically generates random values for the function's parameters and checks that it returns <code>True</code> for all of them.

 

 

isPalindrome :: String -> Bool

putStr "Odd palindromes: " >> quickCheck (\s -> not (null s) ==> isPalindrome (s ++ (tail.reverse) s))

putStr "Non-palindromes: " >> quickCheck (\i s -> not (null s) && 0 <= i && i < length s && i*2 /= length s

 

The <code>==&gt;</code> operator is used to constrain the randomly-generated values: the second test needs a nonempty string, and the third needs an index into the string that is not the exact middle.

for failure. There is no standard framework, but the following example shows

how these tests might be handled.

s := "ablewasiereisawelba"

assert{"test1",palindrome(s)}

procedure assertFailure(A)

if @A[2] then write(@A[1],": failed")

 

Which outputs:

->

</pre>

 

=={{header|J}}==

 

Tests are contained in a test script <tt>c:\mypath\palindrome_test.ijs</tt> with the following contents:

 

NB. Basic testing

test_palinB=: monad define

assert isPalin0 'ab'

 

Example Usage:

unittest 'c:\mypath\palindrome_test.ijs'

Test: c:\mypath\palindrome_test.ijs

palinA .................................. OK

 

=={{header|Java}}==

{{works with|Java|5}}<br>

{{libheader|JUnit}}

import static ExampleClass.rPali; // or from wherever it is defined

import org.junit.*;

//some code that should throw a WhateverException

}

Most [[IDE]]s that support Java will have JUnit built in or will have an easy-to-use plugin for it. For those that don't use these IDEs, test classes can be run from a normal main method and their results will print to standard output:

public static main(String[] args){

org.junit.runner.JUnitCore.runClasses(PalindromeTest.class/*, other classes here if you have more*/);

}

 

=={{header|JavaScript}}==

{{works with|Browserify}}

 

 

describe('palindrome', () => {

});

})

 

Output:

 

Here is an example of a file with four test case triplets:

.

1

def factorial: if . <= 0 then 1 else . * ((. - 1) | factorial) end; factorial

3

 

If the file is named, say, test.txt, then the tests can be run by executing: jq --run-tests < test.txt

 

jq 1.4 produces very verbose output because an execution trace is included. In this article, only the key output lines are shown. The output that results from running the four test cases above is, in abbreviated form, as follows:

 

Testing '.' at line number 3

Testing 'def factorial: if . <= 0 then 1 else . * ((. - 1) | factorial) end; factorial' at line number 18

3 of 4 tests passed (0 malformed)

===Testing jq Libraries===

 

For example, suppose the file library.jq contains the following definitions:

 

 

 

and that the file test-library.txt contains the two test triplets:

 

3

6

import "library" as lib; lib::palindrome

"salàlas"

 

Then the tests can be run by invoking jq in the usual way:

 

=={{header|Jsish}}==

Given the [[Palindrome detection]] solution of

 

function isPalindrome(str:string, exact:boolean=true) {

if (!exact) {

}

return str === str.split('').reverse().join('');

 

''jsish'' allows adding ''echo mode'' lines, (which are lines with a semi-colon ; in column 1 followed by an expression, with a closing semi-colon)

Ok, looks good so far. ''jsish'' also has a run unit tests mode, <code>-u</code>. Along with running basic "did the program crash", -u also handles special comment sections for expectations.

 

function isPalindrome(str:string, exact:boolean=true) {

if (!exact) {

isPalindrome('CUB') ==> false

=!EXPECTEND!=

 

Giving

CUB is not an exact palindrome. Putting that back to pass again, and adding a few other tests, in particular for exercising the ''exact palindrome'' flag that ignores case and punctuation when set to false. (A false palindrome so to speak).

 

function isPalindrome(str:string, exact:boolean=true) {

if (!exact) {

isPalindrome('CUB') ==> false

=!EXPECTEND!=

 

That's all good, but after looking at --U output, it'll mean an extra edit to the file to add the expectations. ''jsish'' to the rescue, and automatically updating the expectation block:

Which now looks like

 

function isPalindrome(str:string, exact:boolean=true) {

if (!exact) {

isPalindrome('A man, a plan, a canal; Panama!', true) ==> false

=!EXPECTEND!=

 

Easy peasy. ''Maybe too easy'', auto update of unit tests should not be run until you know you have valid tests and known results. If there is a bug in the expression, <code>-u -update true</code> will gladly update a script with invalid results. The <code>-update true</code> feature should be treated as a helper, not a "turn off brain now" crutch. Very handy on initial create, or when messaging changes in code under test, but to be treated with respect and care.

Echo lines are not the only thing captured by <code>jsish -u</code> mode. All outputs are captured and can be compared in the EXPECT block. It even allows for sample input testing.

 

var trial = console.input();

puts(trial.replace(/a/g, 'b'));

bbccbb

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

include("Palindrome_detection.jl")

 

@test !palindrome("a11")

@test !palindrome("012")

 

{{out}}

=={{header|Kotlin}}==

Kotlin can use various JVM testing frameworks including its own kotlin-test module. However, for simple cases, it is easier to use the 'assert' function built into its standard library which will throw an AssertionError if the condition is false and assertions are enabled using java's -ea option when the application is run:

 

fun isPalindrome(s: String) = (s == s.reversed())

}

}

 

{{out}}

The following example uses the [https://bitbucket.org/bfad/lspec/ LSpec Library]:

 

define isPalindrome(text::string) => {

// Run the tests and get the summary

// (This normally isn't in the code as the test suite is run via command-line.)

 

{{out}}

 

=={{header|Lua}}==

 

<pre>Assert::asrtf: Assertion y>5 failed.

0.841471</pre>

=={{header|NetRexx}}==

{{libheader|JUnit}}

 

options replace format comments java crossref savelog symbols binary

 

return

;Output

<pre>

 

=={{header|Nim}}==

result = newString(s.len)

result[s.high - i] = c

 

 

when isMainModule:

assert(not isPalindrome("ba_ ab"))

assert(isPalindrome("ba _ ab"))

 

 

result = newString(s.len)

result[s.high - i] = c

 

 

when isMainModule:

 

test "no palindrome":

<pre>[OK] empty string

 

ocaml unix.cma -I +oUnit oUnit.cma palindrome.cmo palindrome_tests.ml

 

open Palindrome

 

"test_palindrome_5" >:: test_palindrome_5]

let _ =

 

=={{header|Oforth}}==

Unit tests are a built-in functionality. If Oforth is run using --t option, all tests are checked. Otherwise, tests are not checked :

test: ["abba" isPalindrome ]

 

=={{header|PARI/GP}}==

{{trans|Raku}}

 

use strict;

use warnings;

ok palindrome_r == $expect, 1, "palindrome_r: $note";

ok palindrome_e == $expect, 1, "palindrome_e: $note";

 

The program produces TAP output.

 

=={{header|Phix}}==

 

 

 

 

<pre>

palindromes:

4 tests run, 3 passed, 1 failed, 75% success

Press any key to continue...

</pre>

 

The '[http://software-lab.de/doc/refT.html#test test]' function is

built into PicoLisp.

(= (setq S (chop S)) (reverse S)) )

 

(test T (palindrome? "racecar"))

 

=={{header|Prolog}}==

It can also be run by using the run_tests predicate.

 

 

:- begin_tests(palindrome).

test(invalid_palindrome, [fail]) :- palindrome('this is not a palindrome').

 

 

=={{header|PureBasic}}==

PureBasic allows for definition of Assert() and other tools & the debugger is integrated into the native editor.

; Needed for the Assert-Macro below

" ; " second dlbquote to prevent Rosettas misshighlighting of following code. Remove comment before execution!

text2$="wisconsin"

Assert(IsPalindrome(text1$), "Catching this would be a fail")

 

=={{header|Python}}==

This uses the [[wp:doctest|doctest]] module from the Python standard library. This allows copies of tests run in an interactive session to be re-used as tests.

 

'''

>>> is_palindrome('')

 

if __name__ == "__main__":

When run in the form as shown above there is no output as all tests pass. If the alternative doctest.testmod line is used with verbose=True, then the following output is produced:

 

14 passed and 0 failed.

Test passed.</pre>

 

=={{header|R}}==

 

See also the functions defineTestSuite and runTestSuite.

checkTrue(!palindroc("ab")) # TRUE

checkException(palindroc()) # TRUE

 

=={{header|Racket}}==

Racket has a built-in unit testing library. Tests can be specified next to function implementations or in a testing submodule.

 

#lang racket

(module+ test (require rackunit))

(check-true (palindromb "avoova"))

(check-false (palindromb "potato")))

 

=={{header|Raku}}==

(formerly Perl 6)

 

sub palin( Str $string) { so $string.lc.comb(/\w/) eq $string.flip.lc.comb(/\w/) }

 

'A man, a plan, a canal: Panama.' => True,

'My dog has fleas' => False,

'1 on 1' => False,

'In girum imus nocte et consumimur igni' => True,

is palin($test), $expected-result,

"\"$test\" is {$expected-result??''!!'not '}a palindrome.";

 

<pre>1..6

ok 1 - "1 on 1" is not a palindrome.

Retro includes a library for creating automated tests. This is used for checking the standard libraries shipped with Retro.

 

needs hash'

 

: t1 ( - ) "ingirumimusnocteetconsumimurigni" palindrome? -1 assert= ; assertion

: test ( - ) t0 t1 ;

 

=={{header|REXX}}==

===stress REXX keywords (used as variables)===

{This was originally written in some form of FORTRAN.}

<pre>

1

===stress test some REXX BIFs===

This stress tests some of the REXX built-in functions (BIFs).

say

say z.32

<pre>

 

 

=={{header|Ring}}==

assert(IsPalindrome("racecar"))

assert(IsPalindrome("alice"))

 

=={{header|Ruby}}==

Ruby comes with a unit testing package. All you have to do is to create a subclass of Test::Unit::Testcase that contains methods that begin with "test_". The package will create a test suite and run it for you.

 

s == s.reverse

end

assert(palindrome?("ab"), "this test case fails on purpose")

end

 

<pre>$ ruby palindrome.rb

This example uses Minitest, which comes with Ruby 1.9. (But if you have Ruby 1.8, then you can still install Minitest as a gem, using [[:Category:RubyGems|RubyGems]].)

 

def palindrome?(s)

s == s.reverse

palindrome?("ab").must_equal true, "this test case fails on purpose"

end

 

<pre>$ ruby19 palindrome.rb

 

Test run options: --seed 40770</pre>

 

=={{header|Scala}}==

shown here, being similar to Haskell's QuickCheck.

 

import Prop._

import Gen._

forAll { (s: String) => s.take(s.length / 2) == s.drop((s.length + 1) / 2).reverse || !isPalindrome(s) }

 

Output:

SRFI 64 is a popular test library.

 

(import (srfi 64))

(test-begin "palindrome-tests")

(test-equal #t (palindrome? "ingirumimusnocteetconsumimurigni")) ; another of several test functions

(test-end)

 

The library reports the number of pass/fail tests at the end; the report may be customised.

{{works with|Db2 LUW}}

{{libheader|db2unit}}

CREATE OR REPLACE PROCEDURE TEST_MY_TEST()

BEGIN

CALL DB2UNIT.ASSERT_INT_EQUALS('Same value', EXPECTED, ACTUAL);

END @

Output:

<pre>

 

=={{header|Swift}}==

import XCTest

 

}

}

 

=={{header|Tcl}}==

 

{{libheader|tcltest}}

source palindrome.tcl; # Assume that this is what loads the implementation of ‘palindrome’

 

} -returnCodes error -result "wrong # args: should be \"palindrome s\""

 

If placed in a file called <tt>palindrome.test</tt>, the following output is produced when it is executed:

Note that only a small fraction of the features of the testing framework are demonstrated here. In particular, it does not show off management of conditional execution, the application of setup and cleanup code, and how these things are assembled into a whole test suite for a large system.

 

=={{header|UNIX Shell}}==

 

is_palindrome() {

fi

}

 

is_palindrome "A man, a plan, a canal, Panama!"

=={{header|VBA}}==

Using the StrReverse function after deleted spaces

Option Explicit

 

IsPalindrome = (tempTxt = StrReverse(tempTxt))

End Function

{{out}}

<pre>abba is a palidrome ? True

wombat is a palidrome ? False

in girum imus nocte et consumimur igni is a palidrome ? True</pre>

 

=={{header|zkl}}==

if (text.len()<2) return(False);

text==text.reverse();

// spaces make this not a palindrome

Need to create a closure (.fp) so the unit test is what runs the test function and can catch any errors the test function throws.

{{output}}

</pre>

A test file:

fcn pali(text){

if (text.len()<2) return(False);

 

tester.stats();

{{output}}

<pre>

</pre>

If you had a collection of files to test:

{{output}}

<pre>