Assertions: Difference between revisions

{{trans|Python}}

 

assert(a == 42)

assert(a == 42, ‘Error message’)</syntaxhighlight>

 

=={{header|68000 Assembly}}==

BEQ continue

ILLEGAL ;causes an immediate jump to the illegal instruction vector.

=={{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:

...

Assert (A = 42, "Oops!");</syntaxhighlight>

The procedure Assert propagates Assertion_Error when condition is false.

Since Ada 2012 one may also specify preconditions and post-conditions for a subprogram.

(List : in Array_Type;

Value : in Integer;

 

=={{header|Aime}}==

 

x = 41;

 

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

IF NOT valid

THEN type line on terminal(assertion);

FI;</syntaxhighlight>

And can be "USEd" as follows:

USE standard,environment

BEGIN

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;

=={{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);

 

=={{header|Arturo}}==

ensure [a = 42]</syntaxhighlight>

 

=== Exceptions ===

{{works with|AutoHotkey_L}}

Assert(a > 10)

Assert(a < 42) ; throws exception

}</syntaxhighlight>

=== Legacy versions ===

{

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

AWK doesn't have a built-in assert statement. It could be simulated using a user-defined assert() function defined as below. The BEGIN section shows some examples of successful and failed "assertions".

 

BEGIN {

meaning = 6 * 7

 

=={{header|Axe}}==

 

answer = assertion(42)

PRINT "The ultimate answer is indeed ", answer

41</pre>

 

{{works with|BASIC256|2.0.0.11}}

subroutine assert (condition, message)

if not condition then print "ASSERTION FAIED: ";message: throwerror 1

</syntaxhighlight>

 

END

 

=={{header|Brat}}==

 

assert_equal 42 42

 

=={{header|C}}==

 

int main(){

 

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.

 

Calls to methods of the Debug class are only compiled when the DEBUG compiler constant is defined, and so are intended for asserting invariants in internal code that could only be broken because of logic errors. Calls to methods of the Trace class similarly require the TRACE constant, which, however, is defined by default for both debug and release builds in Visual Studio projects—trace assertions can thus be used for various logging purposes in production code.

 

 

static class Program

}</syntaxhighlight>

 

' Note: VB Visual Studio projects have System.Diagnostics imported by default,

' along with several other namespaces.

 

Subscribing an instance involves adding the following line to the beginning of Main() (with a semicolon in C#, of course ;)

 

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

{{trans|C}}

 

int main()

 

=={{header|Clojure}}==

(let [i 42]

(assert (= i 42)))

 

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

(assert (and (integerp x) (= 42 x)) (x)))</syntaxhighlight>

 

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

Works with BlackBox Component Builder

MODULE Assertions;

VAR

Crystal doesn't have an assert statement. the <code>spec</code> module provides a testing DSL, but a simple assert can be created with a function or macro.

 

end

 

 

=={{header|D}}==

 

int foo(in bool condition) pure nothrow

=={{header|Dart}}==

=== Assert ===

main() {

var i = 42;

=== Expect ===

Testing assertions can be done using the test and expect functions in the test package

 

main() {

=={{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}

=={{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;

Dyalect has a built-in "assert" function:

 

assert(42, x)</syntaxhighlight>

 

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

 

=={{header|ECL}}==

 

ASSERT(a = 42,'A is not 42!',FAIL);</syntaxhighlight>

 

=={{header|Eiffel}}==

 

File called main.e:

creation main

feature main is

end</syntaxhighlight>

Another file called test.e:

feature assert(val: INTEGER) is

require

 

=={{header|Elixir}}==

 

defmodule AssertionTest do

 

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

(let ((x 41))

(cl-assert (= x 42) t "This shouldn't happen"))</syntaxhighlight>

=={{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.

 

=={{header|Euphoria}}==

return i = 42

end type

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

F# provides an ''assert'' function that is only enabled when the program is compiled with ''DEBUG'' defined. When an assertion fails, a dialog box is shown with the option to enter the debugger.

assert (x = 42)

 

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

 

42 assert=</syntaxhighlight>

 

 

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

 

DECLARE asserter

 

=={{header|Forth}}==

: assert a @ 42 <> throw ;

 

 

=={{header|FreeBASIC}}==

' requires compilation with -g switch

 

 

=={{header|GAP}}==

 

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

=={{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() {

 

=={{header|Groovy}}==

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

}</syntaxhighlight>

 

Test program:

checkTheAnswer(42)

println "before 'Hello Universe'..."

 

=={{header|Haskell}}==

 

main = let a = someValue in

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

 

runerr(n,( expression ,"Assertion/error - message.")) # Throw (and possibly trap) an error number n 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

 

 

=={{header|J}}==

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

function check() {

try {

 

'''assert.jq'''

def m: $msg | if type == "string" then . else [.[]] | join(":") end;

if env.JQ_ASSERT then

</syntaxhighlight>

'''Example'''

# File: example.jq

# This example assumes the availability of the $__loc__ function

 

=={{header|Julia}}==

# @assert macro checks the supplied conditional expression, with the expression

Kotlin supports Jva-style assertions. These need to be enabled using java's -ea option for an <code>AssertionError</code> to be thrown when the condition is false. An assertion should generally never fire, and throws an <code>Error</code>. <code>Error</code>s are seldom used in Kotlin (and much less assertions), as they represent catastrophic issues with the program, such as classes failing to load. These are usually only ever raised by the JVM itself, rather than actual user code.

 

val a = 42

assert(a == 43)

A more Kotlin idiomatic approach to checks are the <code>require</code> (and <code>requireNotNull</code>) to check arguments, and the <code>check</code> (and <code>checkNotNull</code>), and <code>error</code> to check state. The former is mostly meant for checking input, and will throw <code>IllegalArgumentException</code>s, whereas the later is meant for state-checking, and will throw <code>IllegalStateException</code>s

 

require(names.isNotEmpty()) { "Please pass a non-empty names map" } // IllegalArgumentException

val lastName = requireNotNull(names[name]) { "names is expected to contain name" } // IllegalArgumentException

 

=={{header|Lasso}}==

fail_if(

#a != 42,

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

=={{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

 

=={{header|Lisaac}}==

 

=={{header|Lua}}==

assert (a == 42)

assert (a == 42,'\''..a..'\' is not the answer to life, the universe, and everything')</syntaxhighlight>

Trapping error may leave current stack of values with values so if we have above try {} a block of Stack New {} then we get old stack after exit of Stack New {} (this statement hold current stack, attach a new stack of value, and at the exit restore old stack). Another way is to use Flush which clear stack. Statement Flush Error clear all level of error information.

 

Module Assert {

\\ This is a global object named Rec

}

Module SaveIt {

Save.Doc .doc$,.lastfilename$

}

Try {

Report "Run this"

Error "Hello"

}

Assert

</syntaxhighlight>

 

=={{header|Maple}}==

(Taken from Lua, above.)

ASSERT( a = 42 );

ASSERT( a = 42, "a is not the answer to life, the universe, and everything" );</syntaxhighlight>

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

 

 

=={{header|MATLAB}} / {{header|Octave}}==

 

 

Sample Output:

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

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

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);

message "ok";</syntaxhighlight>

=={{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|Nanoquery}}==

assert (a = 42)</syntaxhighlight>

 

=={{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

* it is a pattern, numbers match themselves exactly, other patterns that would match: <tt>Int</tt>, <tt>0..100</tt>, <tt>Any</tt>

 

 

assert(a==42)

=={{header|Nim}}==

In Nim there are two main ways to check assertions.

assert(a == 42, "Not 42!")</syntaxhighlight>

This first kind of assertion may be disabled by compiling with --assertions:off or -d:danger.

doAssert(a == 42, "Not 42!")</syntaxhighlight>

This second kind of assertion cannot be disabled.

 

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

Oxford Oberon-2

MODULE Assertions;

VAR

=={{header|Objeck}}==

If variable is not equal to 42 a stack trace is generated and the program is halts.

function : Main(args : String[]) ~ Nil {

if(args->Size() = 1) {

=={{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 *)

(* evaluate stuff to return here when a is 42 *)</syntaxhighlight>

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

 

assert: [ n isInteger ]

assert: [ n 42 == ]

 

=={{header|Ol}}==

(define i 24)

 

(assert i ===> 42)

</syntaxhighlight>

{{Out}}

assertion error:

i must be 42

</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

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

{{trans|C}}

#include <pari/pari.h>

 

 

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

 

=={{header|Pascal}}==

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 = <>);

 

 

This idiom is typically used during file operations:

or die "Cannot open file: $!\n"; # $! contains the error message from the last error</syntaxhighlight>

It is not needed whith the "autodie" pragma:

open my $fh, '<', 'file'; # automatically throws an exception on failure</syntaxhighlight>

 

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

assert($a == 42);</syntaxhighlight>

 

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';

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

can be disabled using the "without type_check" directive:

<span style="color: #008080;">type</span> <span style="color: #000000;">int42</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">42</span>

 

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

<span style="color: #008080;">global</span> <span style="color: #008080;">constant</span> <span style="color: #000000;">DEBUG</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span> <span style="color: #000080;font-style:italic;">-- (or any other identifier name can be used)</span>

<span style="color: #008080;">global</span> <span style="color: #008080;">procedure</span> <span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">flag</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">msg</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- see also assert() below</span>

first line terminates with a divide by zero, whereas the second and third produce a

slightly more user-friendly, and therefore potentially less developer-friendly message:

<span style="color: #008080;">if</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">42</span> <span style="color: #008080;">then</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">9</span><span style="color: #0000FF;">/</span><span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">42</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"i is not 42!!"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

 

=={{header|PHP}}==

$a = 5

#...input or change $a here

 

The predicate/function that is tested but be "escaped" by <code>$</code> in order to not be evaluated before the test.

 

%

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

...</syntaxhighlight>

Other possibilities are either to break into an error handler:

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

41 -- Incorrect N

?</syntaxhighlight>

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

 

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

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

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

{{works with|SWI Prolog}}

 

test(A):-

assertion(A==42).

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)

 

A implementation as defined above could be;

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

A=42-1

 

=={{header|Python}}==

#...input or change a here

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

 

=={{header|QB64}}==

DO

 

=={{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

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

 

 

(define x 80)

=={{header|Raku}}==

(formerly Perl 6)

$a == 42 or die '$a ain\'t 42';</syntaxhighlight>

 

=={{header|REXX}}==

===version 1===

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

* 10.08.2012 Walter Pachl

<br>possible actions. &nbsp; Here, it just returns to the next REXX statement after the

'''call assert'''.

a = 1 /*assign a value to the A variable.*/

b = -2 /* " " " " " B " */

 

=={{header|Ring}}==

x = 42

assert( x = 42 )

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

}

</syntaxhighlight>

 

=={{header|Ruby}}==

This uses test/unit from the standard library.

 

include Test::Unit::Assertions

 

 

=={{header|Rust}}==

let x = 42;

assert!(x == 42);

 

=={{header|Sather}}==

main is

i ::= 41;

=={{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.

require(a == 42, "a isn't equal to 42")</syntaxhighlight>

 

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))

 

{{trans|Common Lisp}}

(assert (and (integer? x) (= x 42))))</syntaxhighlight>

 

=={{header|SETL}}==

 

=={{header|Sidef}}==

assert_eq(num, 42); # dies when "num" is not 42</syntaxhighlight>

{{out}}

 

=={{header|Slate}}==

define: #n -> 7.

assert: n = 42 &description: 'That is not the Answer.'.</syntaxhighlight>

 

=={{header|Smalltalk}}==

...

self assert: (foo == 42).</syntaxhighlight>

 

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

self should:[ some code ] raise: someException "ensures that an exception is raised</syntaxhighlight>

 

{{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 *;

--# pre X = 42;</syntaxhighlight>

:or as a postcondition on an operation:

--# derives X from *;

--# post X = 42;</syntaxhighlight>

Example:

--# check X = 42;</syntaxhighlight>

produces the following output:

=={{header|Standard ML}}==

Using exceptions:

if cond then () else raise Fail "assert"

 

For instance, if a dataset contains two variables x, y, z, one can check if x<y for all data lines for which z>0, with:

 

 

There is another command, '''[http://www.stata.com/help.cgi?confirm confirm]''', that can be used to check existence and type of program arguments or files. For instance, to check that the file titanium.dta exists:

 

 

If the file does not exist, an error is thrown with return code 601.

It's also possible to use '''[http://www.stata.com/help.cgi?error error]''' to throw an error if some condition is satisfied. However, this command can only print predefined error messages: it takes the error number as an argument. For instance:

 

* Will print "no dataset in use"</syntaxhighlight>

 

To print a more sensible message, one would do instead:

 

display as error "The correct answer is not 42."

exit 54

 

=={{header|Swift}}==

//...input or change a here

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

=={{header|Tcl}}==

{{tcllib|control}}

 

set x 5

<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

 

=={{header|Vala}}==

int b = 33;

assert (a == 42);

 

=={{header|VBA}}==

Dim a As Integer

a = 41

=={{header|VBScript}}==

====Definition====

if not boolExpr then

Err.Raise vbObjectError + 99999, , strOnFail

</syntaxhighlight>

====Invocation====

i = 43

Assert i=42, "There's got to be more to life than this!"</syntaxhighlight>

====Output====

C:\foo\assert.vbs(3, 3) (null): There's got to be more to life than this!</syntaxhighlight>

 

=={{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|Visual Basic .NET}}==

See [[#C# and Visual Basic .NET]].

 

=={{header|Wren}}==

Wren does not have assertions as such though we can write something similar.

 

var assert = Fn.new { |cond|

[./assertion line 12] in (script)

</pre>

 

 

{{out}}

<pre>

</pre>

 

synthesized something like this.

 

char Str;

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

 

=={{header|Yabasic}}==

if not a then

error "Assertion failed"

 

=={{header|Zig}}==

 

pub fn main() void {

}</syntaxhighlight>

 

There is no hardware support for error handling, but the programmer can do this the same way they would create any other <code>if</code> statement:

 

cp 42

jp nz,ErrorHandler</syntaxhighlight>

 

=={{header|zkl}}==

n=41; (n==42) or throw(Exception.AssertionError("I wanted 42!"));</syntaxhighlight>

{{out}}

 

=={{header|zonnon}}==

module Assertions;

var

end Assertions.

</syntaxhighlight>