Assertions: Difference between revisions

Show an assertion in your language by asserting that an integer variable is equal to '''42'''.

<br><br>

 

=={{header|Ada}}==

Using pragma Assert:

The behavior of pragma is controlled by pragma Assertion_Policy. Another way is to use the predefined package Ada.Assertions:

...

The procedure Assert propagates Assertion_Error when condition is false.

 

=={{header|Aime}}==

 

x = 41;

if (x != 42) {

error("x is not 42");

Executing the program will produce on standard error:

<pre>aime: assert: 5: x is not 42</pre>

 

In [[ELLA ALGOL 68]] the ASSERT is implemented as an operator in the ''environment'' prelude:

IF NOT valid

THEN type line on terminal(assertion);

terminal error( 661 {invalid assertion } )

And can be "USEd" as follows:

USE standard,environment

BEGIN

"Oops!" ASSERT ( a = 42 )

END

 

=={{header|ALGOL W}}==

Assertions were added to the 1972 version of Algol W. If the tested condition is false, the program terminates. In the following, the write does not get executed.

 

integer a;

a := 43;

assert a = 42;

write( "this won't appear" )

 

=={{header|Apex}}==

Asserts that the specified condition is true. If it is not, a fatal error is returned that causes code execution to halt.

String myStr = 'test;

System.assert(myStr == 'something else', 'Assertion Failed Message');

 

Asserts that the first two arguments are the same. If they are not, a fatal error is returned that causes code execution to halt.

Integer i = 5;

System.assertEquals(6, i, 'Expected 6, received ' + i);

 

Asserts that the first two arguments are different. If they are the same, a fatal error is returned that causes code execution to halt.

Integer i = 5;

System.assertNotEquals(5, i, 'Expected different value than ' + i);

 

'''You can’t catch an assertion failure using a try/catch block even though it is logged as an exception.'''

 

=={{header|AutoHotkey}}==

=== Exceptions ===

{{works with|AutoHotkey_L}}

Assert(a > 10)

Assert(a < 42) ; throws exception

If !bool

throw Exception("Expression false", -1)

=== Legacy versions ===

{

OutputDebug, "a != 42" ; sends output to a debugger if connected

ListVars ; lists values of local and global variables

Pause ; pauses the script, use ExitApp to exit instead

 

=={{header|Axe}}==

 

END

DEF PROCassert(bool%)

IF NOT bool% THEN ERROR 100, "Assertion failed"

 

=={{header|Brat}}==

 

assert_equal 42 42

 

=={{header|C}}==

 

int main(){

 

return 0;

To turn off assertions, simply define the <tt>NDEBUG</tt> macro before where <tt><assert.h></tt> is included.

 

There is no mechanism to add a custom "message" with your assertion, like in other languages. However, there is a "trick" to do this, by simply logical-AND-ing your condition with a string constant message, like in the following. Since a string constant is guaranteed to be non-NULL (and hence evaluated as True), and since AND-ing with True is an identity operation for a boolean, it will not alter the behavior of the assertion, but it will get captured in the debug message that is printed:

This trick only works with messages written directly in the source code (i.e. cannot be a variable or be computed), however, since the assertion message is captured by the macro at compile-time.

 

 

 

 

=={{header|C++}}==

{{trans|C}}

 

int main()

assert(a == 42); // Aborts program if a is not 42, unless the NDEBUG macro was defined

// when including <cassert>, in which case it has no effect

Note that assert does ''not'' get a <code>std::</code> prefix because it's a macro.

 

=={{header|Clojure}}==

(let [i 42]

(assert (= i 42)))

 

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

 

=={{header|Component Pascal}}==

Works with BlackBox Component Builder

MODULE Assertions;

VAR

 

Assertions.DoIt

Output:

<pre>

.data ARRAY 256 OF INTEGER elements

</pre>

 

=={{header|D}}==

 

int foo(in bool condition) pure nothrow

// There are some different versions of this lazy function.

enforce(x == 42, "x is not 42");

 

=={{header|Dart}}==

int i=42;

int j=41;

 

 

=={{header|Delphi}}==

 

 

If an assertion fails, EAssertionFailed exception is raised.

The generation of assertion code can be disabled by compiler directive

 

 

Here is a simple console demo app which raises and handles assertion exception:

 

 

{$APPTYPE CONSOLE}

end;

Readln;

 

=={{header|DWScript}}==

Simple assertion, with a custom (optional) message

Other specialized assertions can be used in contracts, for instance this function check that the parameter (passed by reference ofr the purpose of illustration) is 42 when entering the function and when leaving the function

require

a = 42;

ensure

a = 42;

 

=={{header|E}}==

E does not have the specific feature of assertions which may be disabled by a global option. But it does have a utility to throw an exception if a condition is false:

 

 

require(a == 42, "The Answer is Wrong.") # supplied message

 

 

=={{header|EchoLisp}}==

(assert (integer? 42)) → #t ;; success returns true

 

(assert (integer? 'quarante-deux) "☝️ expression must evaluate to the integer 42")

💥 error: ☝️ expression must evaluate to the integer 42 : assertion failed : (#integer? 'quarante-deux)

 

=={{header|ECL}}==

 

 

=={{header|Eiffel}}==

 

File called main.e:

creation main

feature main is

test.assert(io.last_integer);

end

Another file called test.e:

feature assert(val: INTEGER) is

require

print("Thanks for the 42!%N");

end

 

=={{header|Elixir}}==

 

defmodule AssertionTest do

assert 42 == return_5

end

 

{{out}}

 

=={{header|Emacs Lisp}}==

(let ((x 41))

 

=={{header|Erlang}}==

Erlang doesn't have an assert statement. However, it is single assignment, and its assignment operator won't complain if you reassign the exact same value to an existing variable but will throw an exception otherwise.

42

2> N = 43.

** exception error: no match of right hand side value 42

5> 42 = N.

 

As such, the behavior of Erlang's assignment operator is extremely similar to a regular <tt>assert</tt> in other languages.

 

=={{header|Euphoria}}==

return i = 42

end type

fourty_two i

 

 

=={{header|Factor}}==

Throw an exception if the value on the top of the stack is not equal to 42:

 

 

=={{header|FBSL}}==

 

This implementation evaluates the expression given to the function and displays a message if it evaluates to false.

 

DECLARE asserter

Assert("1>2")

 

Output

<pre>Assertion: 1>2 failed

 

=={{header|Forth}}==

: assert a @ 42 <> throw ;

 

 

=={{header|FreeBASIC}}==

' requires compilation with -g switch

 

'The rest of the code will not be executed

Print a

 

{{out}}

assert.bas(5): assertion failed at __FB_MAINPROC__: a =6

</pre>

 

=={{header|GAP}}==

 

# GAP has assertions levels. An assertion is tested if its level

# Show current global level

AssertionLevel();

 

=={{header|Go}}==

Assertions are a feature [http://golang.org/doc/go_faq.html#assertions consciously omitted] from Go. For cases where you want feedback during development, the following code should provide a similar purpose. While it is simply an if statement and a panic, the technique does have some properties typical of assertions. For one, the predicate of an if statement in Go is required to be of boolean type. Specifically, ints are not tacitly tested for zero, pointers are not tested for nil: the expression must be boolean, as the WP article mentions is typical of assertions. Also, it provides a good amount of information should the predicate evaluate to true. First, a value of any type can be passed to the panic, and by default is displayed, followed by a stack trace which includes the location of the panic in the source code&mdash;function name, file name, and line number.

 

func main() {

panic(42)

}

Output:

<pre>

 

=={{header|Groovy}}==

assert it == 42 : "This: " + it + " is not the answer!"

 

Test program:

checkTheAnswer(42)

println "before 'Hello Universe'..."

 

Output:

 

=={{header|Haskell}}==

 

main = let a = someValue in

assert (a == 42) -- throws AssertionFailed when a is not 42

 

=={{header|Icon}} and {{header|Unicon}}==

 

runerr(n,( expression ,"Assertion/error - message.")) # Throw (and possibly trap) an error number n if expression succeeds.

...

stop(( expression ,"Assertion/stop - message.")) # Terminate program if expression succeeds.

 

There are no 'assertions', which can be turned on/off by the compiler. We can emulate them by prefixing a stop statement with a check on a global variable:

 

$define DEBUG 1 # this allows the assertions to go through

 

check (12)

end

 

This produces the output:

 

=={{header|J}}==

 

=={{header|Java}}==

 

=={{header|Julia}}==

 

=={{header|Lasso}}==

fail_if(

#a != 42,

error_code_runtimeAssertion,

error_msg_runtimeAssertion + ": #a is not 42"

{{out}}

<pre>-9945 Runtime assertion: #a is not 42</pre>

but we could break program if condition is not met.

We can even make it spell "AssertionFailed". In a way.

a=42

call assert a=42

end if

end sub

 

{{out}}

=={{header|Lingo}}==

Lingo has no assert statement, but the abort command (that exits the full call stack) allows to implement something like it as global function:

on assert (ok, message)

if not ok then

assert(x=42, "Assertion 'x=42' failed")

put "this will never show up"

 

=={{header|Lisaac}}==

 

=={{header|Lua}}==

assert (a == 42)

 

=={{header|Maple}}==

(Taken from Lua, above.)

ASSERT( a = 42 );

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

 

 

 

Sample Output:

assert(x == 42,'Assertion Failed: x = %d, not 42.',x);

??? Assertion Failed: x = 3, not 42.

 

=={{header|Metafont}}==

Metafont has no really an assert built in, but it can easily created:

 

 

This <code>assert</code> macro uses the <code>errmessage</code> built in to show the "error". The

Usage example:

 

assert(n=42);

 

Output (failed assertion):

=={{header|Modula-3}}==

<code>ASSERT</code> is a pragma, that creates a run-time error if it returns <code>FALSE</code>.

 

Assertions can be ignored in the compiler by using the <code>-a</code> switch.

 

=={{header|Nemerle}}==

A basic assertion uses the <tt>assert</tt> keyword:

Assertion violations throw an <tt>AssertionException</tt> with the line number where the assertion failed and the message provided as the second parameter to assert.

 

Nemerle also provides macros in the <tt>Nemerle.Assertions</tt> namespace to support preconditions, postconditions and class invariants:

 

class SampleClass

ensures value.Length > 0 // ensures keyword indicates postcondition

{ ... } // value is a special symbol that indicates the method's return value

The design by contract macros throw <tt>Nemerle.AssertionException</tt>'s unless another Exception is specified using the <tt>otherwise</tt> keyword after the <tt>requires/ensures</tt> statement.

For further details on design by contract macros, see [http://nemerle.org/wiki/index.php?title=Design_by_contract_macros here].

 

=={{header|Nim}}==

 

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE Assertions;

VAR

ASSERT(a = 42);

END Assertions.

Output:

<pre>

called from MAIN

</pre>

 

=={{header|Objective-C}}==

For use within an Objective-C method:

 

If you want to use formatting arguments, you need to use the assertion macro corresponding to your number of formatting arguments:

 

Within a regular C function you should use <code>NSCAssert</code> or <code>NSCAssert''N''</code> instead.

 

=={{header|OCaml}}==

assert (a = 42); (* throws Assert_failure when a is not 42 *)

 

It is possible to compile with the parameter <code>-noassert</code> then the compiler won't compile the assertion checks.

If an assertion is ko (and if oforth is launched using --a), an exception is raised.

 

assert: [ n isInteger ]

assert: [ n 42 == ]

 

 

{{out}}

testInteger(42, 43)

Assertions are ok, parameters are : 42, 43

</pre>

 

Oz does not have an assert statement. But if different values are assigned to the same dataflow variable, an exception will be thrown (similar to Erlang).

 

proc {PrintNumber N}

N=42 %% assert

in

{PrintNumber 42} %% ok

 

Output:

PARI can use any of the usual C methods for making assertions. GP has no built-in assertions.

{{trans|C}}

#include <pari/pari.h>

 

 

assert(equalis(a, 42)); /* Aborts program if a is not 42, unless the NDEBUG macro was defined */

 

More common is the use of <code>pari_err_BUG</code> in such cases:

 

=={{header|Pascal}}==

See [[Assertions#Delphi | Delphi]]

 

=={{header|Perl}}==

While not exactly an assertion, a common Perl idiom is to use <code>or die</code> to throw an exception when a certain statement is false.

 

chomp(my $a = <>);

 

die "Error message\n" unless $a == 42;

die "Error message\n" if not $a == 42;

 

This idiom is typically used during file operations:

It is not needed whith the "autodie" pragma:

 

Some third-party modules provide other ways of using assertions in Perl:

 

There is also a number of ways to test assertions in test suites, for example:

ok $a == 42;

cmp_ok $a, '==', 42, 'The answer should be 42';

 

=={{header|Phix}}==

User defined types allow the value to be automatically tested whenever it changes, and

can be disabled using the "without type_check" directive:

When a type check occurs, program execution halts and if the program was run from the

editor, it automatically jumps to the offending source file and line.

 

You can also use constants to reduce code output on release versions:

of the expression (i=42) may still generate code; sometimes further improvements to the

note that, as things stand, the constants 42 and "i is not 42!!" will be created in the

executable file whatever DEBUG is set to, though again there is nothing to prevent the

 

Lastly, I find the following trivial idioms to be spectacularly effective in Phix, the

offending file and line.

 

=={{header|PHP}}==

$a = 5

#...input or change $a here

assert($a == 42) # when $a is not 42, take appropriate actions,

# which is set by assert_options()

 

=={{header|PicoLisp}}==

The '[http://software-lab.de/doc/refA.html#assert assert]' function, in

combination with the tilde read macro, generates code only in debug mode:

~(assert (= N 42)) # Exists only in debug mode

Other possibilities are either to break into an error handler:

(unless (= N 42) (quit "Incorrect N" N)) ) # 'quit' throws an error

41 -- Incorrect N

or to stop at a debug break point, allowing to continue with the program:

(unless (= N 42) (! setq N 42)) ) # '!' is a breakpoint

(setq N 42) # Manually fix the value

! # Hit ENTER to leave the breakpoint

 

=={{header|PL/I}}==

/* PL/I does not have an assert function as such, */

/* but it is something that can be implemented in */

 

assert(a, 42);

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

 

test(A):-

assertion(A==42).

 

=={{header|PureBasic}}==

The Macro below will only be included in the code if is compiled in debug mode, if so it will test the condition and if it fails it will inform with the message defined by the programmer, the line where it happened and in which source code file.

 

CompilerIf #PB_Compiler_Debugger

If Not (TEST)

EndIf

CompilerEndIf

 

A implementation as defined above could be;

Assert(A=42,"Assert that A=42")

A=42-1

Where the second test would fail resulting in a message to the programmer with cause (if given by programmer), code line & file.

 

=={{header|Python}}==

#...input or change a here

assert a == 42 # throws an AssertionError when a is not 42

assert a == 42, "Error message" # throws an AssertionError

# when a is not 42 with "Error message" for the message

It is possible to turn off assertions by running Python with the <tt>-O</tt> (optimizations) flag.

 

=={{header|R}}==

 

=={{header|Racket}}==

Racket has higher-order assertions known as ''contracts'' that can protect any values including functions and objects. Contracts are typically applied on the imports or exports of a module.

 

 

(define/contract x

(f 42) ; succeeds

(f "foo") ; contract error!

 

If typical assertion checking (i.e. error unless some boolean condition holds) is needed, that is also possible:

 

 

(define x 80)

(unless (= x 42)

(error "a is not 42")) ; will error

 

=={{header|REXX}}==

* There's no assert feature in Rexx. That's how I'd implement it

* 10.08.2012 Walter Pachl

End

Return

Output:

<pre>

program terminated

</pre>

 

=={{header|RLaB}}==

RLaB does not have a special function to deal with assertions. The following workaround will do the trick:

 

// test if 'a' is 42, and if not stop the execution of the code and print

// some error message

stop("a is not 42 as expected, therefore I stop until this issue is resolved!");

}

 

 

=={{header|Ruby}}==

This uses test/unit from the standard library.

 

include Test::Unit::Assertions

 

# Ruby 1.9: e is a MiniTest::Assertion

puts e

 

Output: <pre><42> expected but was

 

=={{header|Rust}}==

let x = 42;

assert!(x == 42);

assert_eq!(x, 42);

 

=={{header|Sather}}==

main is

i ::= 41;

-- ...

end;

 

(The current GNU Sather compiler v1.2.3 I am using to test the code seems to ignore the assertion and no fatal error is raised, despite Sather should, see e.g. [http://www.gnu.org/software/sather/docs-1.2/tutorial/safety2208.html here]).

=={{header|Scala}}==

These two are the same thing, and are tagged <code>@elidable(ASSERTION)</code>:

assert(a == 42, "a isn't equal to 42")

assume(a == 42)

 

The next one does the same thing as above, but it is not tagged. Often used as a pre-condition

checker on class constructors.

 

This one checks a value and returns it for further use (here shown being printed). It

uses <code>assert</code>, which, as explained, gets tagged.

println(a.ensuring(a == 42, "a isn't equal to 42"))

println(a.ensuring(_ == 42))

 

=={{header|Scheme}}==

 

{{trans|Common Lisp}}

 

=={{header|Sidef}}==

{{out}}

<pre>

 

=={{header|Slate}}==

define: #n -> 7.

raises an <tt>AssertionFailed</tt> condition (an <tt>Error</tt>).

 

=={{header|Smalltalk}}==

...

 

In TestCase and subclasses, a number of check methods are inherited; among them:

 

{{works with|Smalltalk/X}}

Object also implements assert:; these are evaluated dynamically, but can be disabled via a flag setting. Also the compiler can be instructed to ignore them for production code (which is not normally done; disabled instead by default):

the implementation in Object raises an AssertionFailedError exception, which usually opens a debugger when in the IDE, but can be caught in deployed apps.

 

Assertions are analysed statically, before compilation or execution. They can appear in various places:

:inline in the code, either

::or

:as a precondition on an operation:

--# derives X from *;

:or as a postcondition on an operation:

--# derives X from *;

Example:

produces the following output:

<pre>H1: true .

C1: false .</pre>

which is an unprovable theorem that tells you that there is a guaranteed failure.

 

=={{header|Swift}}==

//...input or change a here

assert(a == 42) // aborts program when a is not 42

assert(a == 42, "Error message") // aborts program

// when a is not 42 with "Error message" for the message

In release mode assertion checks are turned off.

 

=={{header|Tcl}}==

{{tcllib|control}}

 

set x 5

Produces the output:

<pre>assertion failed: $x == 42</pre>

 

 

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

{{works with|bash}}

Assertions are not builtin commands, but we can add a function easily.

if test ! $1; then

[[ $2 ]] && echo "$2" >&2

((x--))

assert "$x -eq 42" "that's not the answer"

 

=={{header|Vala}}==

int b = 33;

assert (a == 42);

 

=={{header|VBScript}}==

====Definition====

if not boolExpr then

Err.Raise vbObjectError + 99999, , strOnFail

end if

end sub

====Invocation====

i = 43

====Output====

 

=={{header|Visual Basic}}==

VB's <code>Assert</code> only fires when run from within the IDE. When compiled, all <code>Debug</code> lines are ignored.

 

 

=={{header|XPL0}}==

synthesized something like this.

 

char Str;

[\return; uncomment this if "assertions" are to be disabled

];

 

 

=={{header|zkl}}==

{{out}}

<pre>

Exception thrown: AssertionError(I wanted 42!)

</pre>