Assertions: Difference between revisions

From Rosetta Code
Content added Content deleted
(Added 11l)
No edit summary
Line 16: Line 16:
assert(a == 42)
assert(a == 42)
assert(a == 42, ‘Error message’)</lang>
assert(a == 42, ‘Error message’)</lang>
=={{header|68000 Assembly}}==
The <code>TRAP</code> instruction is used for error handling. Execution jumps to a specified memory address stored in the "trap table."

<lang 68000devpac>CMP.L #42,D0
BEQ continue
ILLEGAL ;jumps to Trap 4.
continue:
; rest of program</lang>


=={{header|Ada}}==
=={{header|Ada}}==
Line 431: Line 439:
// Error: function assertions.foo no return exp;
// Error: function assertions.foo no return exp;
// or assert(0); at end of function
// or assert(0); at end of function
assert(false, "This can't happen.");
assert(false, "This can't ha
}

void main() pure {
int x = foo(true);

// A regular assertion, it throws an error.
// Use -release to disable it.
// It can be used in nothrow functions.
assert(x == 42, "x is not 42");

// This throws an exception and it can't be disabled.
// There are some different versions of this lazy function.
enforce(x == 42, "x is not 42");
}</lang>

=={{header|Dart}}==
=== Assert ===
<lang javascript>
main() {
var i = 42;
assert( i == 42 );
}
</lang>

=== Expect ===
Testing assertions can be done using the test and expect functions in the test package
<lang d>import 'package:test/test.dart';

main() {
int i=42;
int j=41;

test('i equals 42?', (){
expect( i, equals(42) );
});

test('j equals 42?', (){
expect( j, equals(42) );
});
}</lang>

=={{header|Delphi}}==

<lang Delphi>Assert(a = 42);</lang>

If an assertion fails, EAssertionFailed exception is raised.

The generation of assertion code can be disabled by compiler directive

<lang Delphi>{$ASSERTIONS OFF}</lang>

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

<lang Delphi>program TestAssert;

{$APPTYPE CONSOLE}

{.$ASSERTIONS OFF} // remove '.' to disable assertions

uses
SysUtils;

var
a: Integer;

begin
try
Assert(a = 42);
except
on E:Exception do
Writeln(E.Classname, ': ', E.Message);
end;
Readln;
end.</lang>

=={{header|DWScript}}==
Simple assertion, with a custom (optional) message
<lang Delphi>Assert(a = 42, 'Not 42!');</lang>
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
<lang Delphi>procedure UniversalAnswer(var a : Integer);
require
a = 42;
begin
// code here
ensure
a = 42;
end;</lang>

=={{header|Dyalect}}==
Dyalect has a built-in "assert" function:

<lang dyalect>var x = 42
assert(42, x)</lang>

This function throws an exception if assertion fails.

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

<lang e>require(a == 42) # default message, "Required condition failed"

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

require(a == 42, fn { `Off by ${a - 42}.` }) # computed only on failure</lang>

=={{header|EchoLisp}}==
<lang lisp>
(assert (integer? 42)) → #t ;; success returns true

;; error and return to top level if not true;
(assert (integer? 'quarante-deux))
⛔ error: assert : assertion failed : (#integer? 'quarante-deux)

;; assertion with message (optional)
(assert (integer? 'quarante-deux) "☝️ expression must evaluate to the integer 42")
💥 error: ☝️ expression must evaluate to the integer 42 : assertion failed : (#integer? 'quarante-deux)
</lang>

=={{header|ECL}}==

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

=={{header|Eiffel}}==
{{works with|SmartEiffel}} version 2.4

There are many assertion types in Eiffel, one is the following:

File called main.e:
<lang eiffel>class MAIN
creation main
feature main is
local
test: TEST;
do
create test;

io.read_integer;
test.assert(io.last_integer);
end
end</lang>
Another file called test.e:
<lang eiffel>class TEST
feature assert(val: INTEGER) is
require
val = 42;
do
print("Thanks for the 42!%N");
end
end</lang>

=={{header|Elixir}}==
<lang elixir>ExUnit.start

defmodule AssertionTest do
use ExUnit.Case
def return_5, do: 5
test "not equal" do
assert 42 == return_5
end
end</lang>

{{out}}
<pre>
1) test not equal (AssertionTest)
test.exs:8
Assertion with == failed
code: 42 == return_5
lhs: 42
rhs: 5
stacktrace:
test.exs:9: (test)



Finished in 0.1 seconds (0.1s on load, 0.01s on tests)
1 test, 1 failure

Randomized with seed 869000
</pre>

=={{header|Emacs Lisp}}==
Assertion can be loaded from cl.el:
<lang lisp>(require 'cl)
(let ((x 41))
(assert (= x 42) t "the answer is not right"))</lang>

=={{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.
<lang erlang>1> N = 42.
42
2> N = 43.
** exception error: no match of right hand side value 43
3> N = 42.
42
4> 44 = N.
** exception error: no match of right hand side value 42
5> 42 = N.
42</lang>

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

=={{header|Euphoria}}==
<lang euphoria>type fourty_two(integer i)
return i = 42
end type

fourty_two i

i = 41 -- type-check failure</lang>

=={{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.
<lang fsharp>let test x =
assert (x = 42)

test 43</lang>

For additional information about assertions in .NET, see [[#C# and Visual Basic .NET]]

=={{header|Factor}}==
Throw an exception if the value on the top of the stack is not equal to 42:

<lang factor>USING: kernel ;
42 assert=</lang>

=={{header|FBSL}}==
One needs to DECLARE the asserter variable at the top of script.

This implementation evaluates the expression given to the function and displays a message if it evaluates to false.
<lang qbasic>#APPTYPE CONSOLE

DECLARE asserter

FUNCTION Assert(expression)
DIM cmd AS STRING = "DIM asserter AS INTEGER = (" & expression & ")"
EXECLINE(cmd, 1)
IF asserter = 0 THEN PRINT "Assertion: ", expression, " failed"
END FUNCTION

Assert("1<2")
Assert("1>2")

PAUSE</lang>
Output
<pre>Assertion: 1>2 failed

Press any key to continue...</pre>

=={{header|Forth}}==
<lang fsharp>variable a
: assert a @ 42 <> throw ;

41 a ! assert</lang>

=={{header|FreeBASIC}}==
<lang freebasic>' FB 1.05.0 Win64
' requires compilation with -g switch

Dim a As Integer = 5
Assert(a = 6)
'The rest of the code will not be executed
Print a
Sleep</lang>

{{out}}
<pre>
assert.bas(5): assertion failed at __FB_MAINPROC__: a =6
</pre>

=={{header|GAP}}==
<lang gap># See section 7.5 of reference manual

# GAP has assertions levels. An assertion is tested if its level
# is less then the global level.

# Set global level
SetAssertionLevel(10);

a := 1;
Assert(20, a > 1, "a should be greater than one");
# nothing happens

a := 1;
Assert(4, a > 1, "a should be greater than one");
# error

# Show current global level
AssertionLevel();
# 10</lang>

=={{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.
<lang go>package main

func main() {
x := 43
if x != 42 {
panic(42)
}
}</lang>
Output:
<pre>
panic: 42

panic PC=0x2b772d1a1048
runtime.panic+0xa7 /pool/go/src/pkg/runtime/proc.c:1032
runtime.panic(0x40e820, 0x2a)
main.main+0x48 /pool/test.go:8
main.main()
runtime.mainstart+0xf /pool/go/src/pkg/runtime/amd64/asm.s:77
runtime.mainstart()
runtime.goexit /pool/go/src/pkg/runtime/proc.c:148
runtime.goexit()
</pre>

=={{header|Groovy}}==
<lang groovy>def checkTheAnswer = {
assert it == 42 : "This: " + it + " is not the answer!"
}</lang>

Test program:
<lang groovy>println "before 42..."
checkTheAnswer(42)
println "before 'Hello Universe'..."
checkTheAnswer("Hello Universe")</lang>

Output:
<pre>before 42...
before 'Hello Universe'...
java.lang.AssertionError: This: Hello Universe is not the answer!. Expression: (it == 42). Values: it = Hello Universe
at ConsoleScript80$_run_closure1.doCall(ConsoleScript80:2)
at ConsoleScript80.run(ConsoleScript80:8)</pre>

=={{header|Haskell}}==
<lang haskell>import Control.Exception

main = let a = someValue in
assert (a == 42) -- throws AssertionFailed when a is not 42
somethingElse -- what to return when a is 42</lang>

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

<lang Icon>...
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.
...</lang>

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:

<lang Icon>
$define DEBUG 1 # this allows the assertions to go through

procedure check (a)
if DEBUG then stop (42 = a, " is invalid value for 'a'")
write (a)
end

procedure main ()
check (10)
check (42)
check (12)
end
</lang>

This produces the output:
<pre>
10
42 is invalid value for 'a'
</pre>

Changing the define to: <code>$define DEBUG &fail</code> turns off the assertion checking.

=={{header|J}}==
<lang j> assert n = 42</lang>

=={{header|Java}}==
<lang java5>public class Assertions {

public static void main(String[] args) {
int a = 13;

// ... some real code 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.
// The error message can be any non-void expression.
}
}</lang>

Note: assertion checking is disabled by default when you run your program with the <tt>java</tt> command. You must provide the <tt>-ea</tt> (short for <tt>-enableassertions</tt>) flag in order to enable them.

=={{header|JavaScript}}==
<lang javaScript>
function check() {
try {
if (isNaN(answer)) throw '$answer is not a number';
if (answer != 42) throw '$answer is not 42';
}
catch(err) {
console.log(err);
answer = 42;
}
finally { console.log(answer); }
}

console.count('try'); // 1
let answer;
check();

console.count('try'); // 2
answer = 'fourty two';
check();

console.count('try'); // 3
answer = 23;
check();
</lang>

{{out}}<pre>
try: 1
$answer is not a number
42

try: 2
$answer is not a number
42

try: 3
$answer is not 42
42
</pre>

=={{header|Julia}}==
<lang julia>const x = 5
# @assert macro checks the supplied conditional expression, with the expression
# returned in the failed-assertion message
@assert x == 42
# ERROR: LoadError: AssertionError: x == 42
# Julia also has type assertions of the form, x::Type which can be appended to
# variable for type-checking at any point
x::String
# ERROR: LoadError: TypeError: in typeassert, expected String, got Int64
</lang>

=={{header|Kotlin}}==
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.

<lang kotlin>fun main() {
val a = 42
assert(a == 43)
}</lang>

{{out}}
<pre>
Exception in thread "main" java.lang.AssertionError: Assertion failed
at AssertKt.main(assert.kt:5)
</pre>

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

<lang kotlin>fun findName(names: Map<String, String>, firstName: String) {
require(names.isNotEmpty()) { "Please pass a non-empty names map" } // IllegalArgumentException
val lastName = requireNotNull(names[name]) { "names is expected to contain name" } // IllegalArgumentException

val fullName = "$firstName $lastName"
check(fullName.contains(" ")) { "fullname was expected to have a space...?" } // IllegalStateException
return fullName
}</lang>

=={{header|Lasso}}==
<lang lasso>local(a) = 8
fail_if(
#a != 42,
error_code_runtimeAssertion,
error_msg_runtimeAssertion + ": #a is not 42"
)</lang>
{{out}}
<pre>-9945 Runtime assertion: #a is not 42</pre>

=={{header|Liberty BASIC}}==
Liberty BASIC has no exceptions or user-defined error messages,
but we could break program if condition is not met.
We can even make it spell "AssertionFailed". In a way.
<lang lb>
a=42
call assert a=42
print "passed"

a=41
call assert a=42
print "failed (we never get here)"
end

sub assert cond
if cond=0 then 'simulate error, mentioning "AssertionFailed"
AssertionFailed(-1)=0
end if
end sub
</lang>

{{out}}
<pre>
passed
</pre>

Stops with error message
{{out}}
<pre>
RuntimeError: Subscript out of range: -1, AssertionFailed()
</pre>

=={{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:
<lang lingo>-- in a movie script
on assert (ok, message)
if not ok then
if not voidP(message) then _player.alert(message)
abort -- exits from current call stack, i.e. also from the caller function
end if
end

-- anywhere in the code
on test
x = 42
assert(x=42, "Assertion 'x=42' failed")
put "this shows up"
x = 23
assert(x=42, "Assertion 'x=42' failed")
put "this will never show up"
end</lang>

=={{header|Lisaac}}==
<lang Lisaac>? { n = 42 };</lang>

=={{header|Lua}}==
<lang lua>a = 5
assert (a == 42)
assert (a == 42,'\''..a..'\' is not the answer to life, the universe, and everything')</lang>

=={{header|M2000 Interpreter}}==
M2000 use Error to produce error, Try variable {} and Try {} to capture errors, and return a number from a function when function called as module (zero means no error).

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.


<lang M2000 Interpreter>
Module Assert {
\\ This is a global object named Rec
Global Group Rec {
Private:
document doc$="Error List at "+date$(today)+" "+time$(now)+{
}
Public:
lastfilename$="noname.err"
Module Error(a$) {
if a$="" then exit
.doc$<=" "+a$+{
}
flush error
}
Module Reset {
Clear .doc$
}
Module Display {
Report .doc$
}
Module SaveIt {
.lastfilename$<=replace$("/", "-","Err"+date$(today)+time$(now)+".err")
Save.Doc .doc$,.lastfilename$
}
}
Module Checkit {
Function Error1 (x) {
if x<10 then Print "Normal" : exit
=130 ' error code
}
Call Error1(5)
Try ok {
Call Error1(100)
}
If not Ok then Rec.Error Error$ : Flush Error
Test "breakpoint A" ' open Control form, show code as executed, press next or close it
Try {
Report "Run this"
Error "Hello"
Report "Not run this"
}
Rec.Error Error$
Module Error1 (x) {
if x<10 then Print "Normal" : exit
Error "Big Error"
}
Try ok {
Error1 100
}
If Error then Rec.Error Error$
}
Checkit
Rec.Display
Rec.SaveIt
win "notepad.exe", dir$+Rec.lastfilename$
}
Assert
</lang>

=={{header|Maple}}==
(Taken from Lua, above.)
<lang Maple>a := 5:
ASSERT( a = 42 );
ASSERT( a = 42, "a is not the answer to life, the universe, and everything" );</lang>

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

<lang Mathematica>Assert[var===42]</lang>

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

<lang MATLAB>assert(x == 42,'x = %d, not 42.',x);</lang>

Sample Output:
<lang MATLAB>x = 3;
assert(x == 42,'Assertion Failed: x = %d, not 42.',x);
??? Assertion Failed: x = 3, not 42.
</lang>

=={{header|Metafont}}==

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

<lang metafont>def assert(expr t) = if not (t): errmessage("assertion failed") fi enddef;</lang>

This <code>assert</code> macro uses the <code>errmessage</code> built in to show the "error". The
<code>errmessage</code> gives the error message and asks the user what to do.

Usage example:

<lang metafont>n := 41;
assert(n=42);
message "ok";</lang>

Output (failed assertion):

<pre>This is METAFONT, Version 2.71828 (Web2C 7.5.5)
(./assert.mf
! assertion failed.
<to be read again>
;
l.4 assert(n=42);
?</pre>

=={{header|Modula-3}}==
<code>ASSERT</code> is a pragma, that creates a run-time error if it returns <code>FALSE</code>.
<lang modula3><*ASSERT a = 42*></lang>

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

=={{header|Nanoquery}}==
<lang Nanoquery>a = 5
assert (a = 42)</lang>

=={{header|Nemerle}}==
A basic assertion uses the <tt>assert</tt> keyword:
<lang Nemerle>assert (foo == 42, $"foo == $foo, not 42.")</lang>
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:
<lang Nemerle>using Nemerle.Assertions;

class SampleClass
{
public SomeMethod (input : list[int]) : int
requires input.Length > 0 // requires keyword indicates precondition,
// there can be more than one condition per method
{ ... }

public AnotherMethod (input : string) : list[char]
ensures value.Length > 0 // ensures keyword indicates postcondition
{ ... } // value is a special symbol that indicates the method's return value
}</lang>
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}}==
In Nim there are two main ways to check assertions.
<lang Nim>var a = 42
assert(a == 42, "Not 42!")</lang>
This first kind of assertion may be disabled by compiling with --assertions:off or -d:danger.
<lang Nim>var a = 42
doAssert(a == 42, "Not 42!")</lang>
This second kind of assertion cannot be disabled.

=={{header|Oberon-2}}==
Oxford Oberon-2
<lang oberon2>
MODULE Assertions;
VAR
a: INTEGER;
BEGIN
a := 40;
ASSERT(a = 42);
END Assertions.
</lang>
Output:
<pre>
Runtime error: assertion failed (0) on line 6 in module Assertions
In procedure Assertions.%main
called from MAIN
</pre>

=={{header|Objeck}}==
If variable is not equal to 42 a stack trace is generated and the program is halts.
<lang objeck>class Test {
function : Main(args : String[]) ~ Nil {
if(args->Size() = 1) {
a := args[0]->ToInt();
Runtime->Assert(a = 42);
};
}
}
</lang>

=={{header|Objective-C}}==
For use within an Objective-C method:
<lang objc>NSAssert(a == 42, @"Error message");</lang>

If you want to use formatting arguments, you need to use the assertion macro corresponding to your number of formatting arguments:
<lang objc>NSAssert1(a == 42, @"a is not 42, a is actually %d", a); # has 1 formatting arg, so use NSAssert"1"</lang>

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

To turn off assertions, define the <tt>NS_BLOCK_ASSERTIONS</tt> macro.

=={{header|OCaml}}==
<lang ocaml>let a = get_some_value () in
assert (a = 42); (* throws Assert_failure when a is not 42 *)
(* evaluate stuff to return here when a is 42 *)</lang>

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

=={{header|Oforth}}==

In Oforth, assertions are handled as tests.

Assertions are checked only if oforth is launched using --a command line. Default value is to not check assertions.

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

<lang Oforth>: testInteger(n, m)
assert: [ n isInteger ]
assert: [ n 42 == ]

System.Out "Assertions are ok, parameters are : " << n << ", " << m << cr ;</lang>

{{out}}
<pre>
testInteger(41, 43)
[1:interpreter] ExRuntime : Assertion failed into <#testInteger>

testInteger(42, 43)
Assertions are ok, parameters are : 42, 43
</pre>

=={{header|Ol}}==
<lang scheme>
(define i 24)

(assert i ===> 42)
</lang>
{{Out}}
<pre>
Welcome to Otus Lisp 2.1-2486-481fd919
type ',help' to help, ',quit' to end session.
> (define i 24)
;; Defined i
> (assert i ===> 42)
assertion error:
i must be 42
>
</pre>

=={{header|Oz}}==
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).

<lang oz>declare
proc {PrintNumber N}
N=42 %% assert
{Show N}
end
in
{PrintNumber 42} %% ok
{PrintNumber 11} %% throws </lang>

Output:
<pre>%***************************** failure **************************
%**
%** Tell: 11 = 42
%**
%** Call Stack:
%** procedure 'PrintNumber' in file "Oz<8>", line 3, column 0, PC = 18600220
%**--------------------------------------------------------------
</pre>

=={{header|PARI/GP}}==
PARI can use any of the usual C methods for making assertions. GP has no built-in assertions.
{{trans|C}}
<lang C>#include <assert.h>
#include <pari/pari.h>

void
test()
{
GEN a;
// ... input or change a here

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

More common is the use of <code>pari_err_BUG</code> in such cases:
<lang C>if (!equalis(a, 42)) pari_err_BUG("this_function_name (expected a = 42)");</lang>

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

<lang perl>print "Give me a number: ";
chomp(my $a = <>);

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

# Alternatives
die "Error message\n" unless $a == 42;
die "Error message\n" if not $a == 42;
die "Error message\n" if $a != 42;</lang>

This idiom is typically used during file operations:
<lang perl>open my $fh, '<', 'file'
or die "Cannot open file: $!\n"; # $! contains the error message from the last error</lang>
It is not needed whith the "autodie" pragma:
<lang perl>use autodie;
open my $fh, '<', 'file'; # automatically throws an exception on failure</lang>

Some third-party modules provide other ways of using assertions in Perl:
<lang perl>use Carp::Assert;
assert($a == 42);</lang>

There is also a number of ways to test assertions in test suites, for example:
<lang perl>is $a, 42;
ok $a == 42;
cmp_ok $a, '==', 42, 'The answer should be 42';
# etc.</lang>

=={{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:
<lang Phix>type int42(object i)
return i=42
end type

int42 i

i = 41 -- type-check failure</lang>
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.

Note that, under "without type_check", the run-time reserves the right to continue to
perform limited type checking, for example were the type declared as int42(integer i)
then ensuring that i is an integer may allow subsequent optimisations to be applied,
and therefore, despite the compiler directive, integer() could still be enforced even
though "=42" would not.

You can also use constants to reduce code output on release versions:
<lang Phix>global constant DEBUG = 0 -- (or any other identifier name can be used)
global procedure assert(integer flag, string msg)
if DEBUG then
if not flag then
{} = message_box(msg,"failed assertion",MB_OK) -- or
puts(1,msg) -- , and/or
crash(msg) -- crash/ex.err report -- or
trace(1) -- start debugging
end if
end if
end function

assert(i=42,"i is not 42!!")</lang>
Note that while the body of assert() and the call to it are suppressed, the calculation
of the expression (i=42) may still generate code; sometimes further improvements to the
compiler may be possible, sometimes the asserts may need "if DEBUG" around them. Also
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
compiler from being enhanced to avoid emitting such unnecessary values, one day.

Lastly, I find the following trivial idioms to be spectacularly effective in Phix, the
first line terminates with a divide by zero, whereas the second produces a slightly more
user-friendly, and therefore potentially less developer-friendly message:
<lang Phix>if i!=42 then ?9/0 end if
if i!=42 then crash("i is not 42!!") end if</lang>
Again, if the application was run from Edita, on error it automatically jumps to the
offending file and line.

=={{header|PHP}}==
<lang php><?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()
?></lang>

=={{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:
<lang PicoLisp>...
~(assert (= N 42)) # Exists only in debug mode
...</lang>
Other possibilities are either to break into an error handler:
<lang PicoLisp>(let N 41
(unless (= N 42) (quit "Incorrect N" N)) ) # 'quit' throws an error
41 -- Incorrect N
?</lang>
or to stop at a debug break point, allowing to continue with the program:
<lang PicoLisp>(let N 41
(unless (= N 42) (! setq N 42)) ) # '!' is a breakpoint
(setq N 42) # Manually fix the value
! # Hit ENTER to leave the breakpoint
-> 42</lang>

=={{header|PL/I}}==
<lang>
/* PL/I does not have an assert function as such, */
/* but it is something that can be implemented in */
/* any of several ways. A straight-forward way */
/* raises a user-defined interrupt. */

on condition (assert_failure) snap
put skip list ('Assert failure');
....
if a ^= b then signal condition(assert_failure);

/* Another way is to use the preprocessor, thus: */
%assert: procedure (a, b) returns (character);
return ('if ' || a || '^=' || b ||
' then signal condition(assert_failure);');
%end assert;
%activate assert;

assert(a, 42);
</lang>

=={{header|Prolog}}==
{{works with|SWI Prolog}}

<lang prolog>
test(A):-
assertion(A==42).
</lang>

=={{header|PureBasic}}==
PureBasic does not have a native function for assertion, but allows for the definition of one.

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.

<lang PureBasic>Macro Assert(TEST,MSG="Assert: ")
CompilerIf #PB_Compiler_Debugger
If Not (TEST)
Debug MSG+" Line="+Str(#PB_Compiler_Line)+" in "+#PB_Compiler_File
CallDebugger
EndIf
CompilerEndIf
EndMacro</lang>

A implementation as defined above could be;
<lang PureBasic>A=42
Assert(A=42,"Assert that A=42")
A=42-1
Assert(A=42)</lang>
Where the second test would fail resulting in a message to the programmer with cause (if given by programmer), code line & file.

=={{header|Python}}==
<lang python>a = 5
#...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
# the error message can be any expression</lang>
It is possible to turn off assertions by running Python with the <tt>-O</tt> (optimizations) flag.

=={{header|QB64}}==
<lang vb>$ASSERTS:CONSOLE
DO
a = INT(RND * 10)
b$ = myFunc$(a)
PRINT a, , b$
_LIMIT 3
LOOP UNTIL _KEYHIT
FUNCTION myFunc$ (value AS SINGLE)
_ASSERT value > 0, "Value cannot be zero"
_ASSERT value <= 10, "Value cannot exceed 10"
IF value > 1 THEN plural$ = "s"
myFunc$ = STRING$(value, "*") + STR$(value) + " star" + plural$ + " :-)"
END FUNCTION</lang>

=={{header|R}}==
<lang R>stopifnot(a==42)</lang>

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

<lang Racket>#lang racket

(define/contract x
(=/c 42) ; make sure x = 42
42)

(define/contract f
(-> number? (or/c 'yes 'no)) ; function contract
(lambda (x)
(if (= 42 x) 'yes 'no)))

(f 42) ; succeeds
(f "foo") ; contract error!
</lang>

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

<lang Racket>#lang racket

(define x 80)
(unless (= x 42)
(error "a is not 42")) ; will error
</lang>

=={{header|Raku}}==
(formerly Perl 6)
<lang perl6>my $a = (1..100).pick;
$a == 42 or die '$a ain\'t 42';</lang>

{{works with|pugs}}
''Note: This example uses an experimental feature, and does not work in the primary Perl 6 compiler, Rakudo.''
<lang perl6># with a (non-hygienic) macro
macro assert ($x) { "$x or die 'assertion failed: $x'" }
assert('$a == 42');</lang>

=={{header|REXX}}==
===version 1===
<lang REXX>/* REXX ***************************************************************
* There's no assert feature in Rexx. That's how I'd implement it
* 10.08.2012 Walter Pachl
**********************************************************************/
x.=42
x.2=11
Do i=1 By 1
Call assert x.i,42
End
Exit
assert:
Parse Arg assert_have,assert_should_have
If assert_have\==assert_should_have Then Do
Say 'Assertion fails in line' sigl
Say 'expected:' assert_should_have
Say ' found:' assert_have
Say sourceline(sigl)
Say 'Look around'
Trace ?R
Nop
Signal Syntax
End
Return
Syntax: Say 'program terminated'</lang>
Output:
<pre>
Assertion fails in line 8
expected: 42
found: 11
Call assert x.i,42
Look around
Here I enter Say i
2
and then I press just enter
program terminated
</pre>

===version 2===
Programming note: &nbsp; this simple version will work better when the &nbsp; '''ASSERT''' &nbsp; be on one line,
<br>and be without other REXX statements.

The clauses don't require parentheses, but are used here for clarity.

The &nbsp; '''ASSERT''' &nbsp; function could be programmed to '''exit''' as one of many
<br>possible actions. &nbsp; Here, it just returns to the next REXX statement after the
'''call assert'''.
<lang rexx>/*REXX program implements a simple ASSERT function; the expression can be compound. */
a = 1 /*assign a value to the A variable.*/
b = -2 /* " " " " " B " */
gee = 7.00 /* " " " " " GEE " */
zee = 26 /* " " " " " ZEE " */

call assert (a = 1)
call assert (b > 0)
call assert (gee = 7)
call assert (zee = a & zee>b)
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
assert: if arg(1)=1 then return; parse value sourceline(sigl) with x; say
say '===== ASSERT failure in REXX line' sigl", the statement is:"; say '=====' x
say; return</lang>
{{out|output|text=&nbsp; when using the internal defaults:}}
<pre>
===== ASSERT failure in REXX line 8, the statement is:
===== call assert (b > 0)


===== ASSERT failure in REXX line 10, the statement is:
===== call assert (zee = a & zee>b)
</pre>

=={{header|Ring}}==
<lang ring>
x = 42
assert( x = 42 )
assert( x = 100 )
</lang>

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

<lang RLaB>
// test if 'a' is 42, and if not stop the execution of the code and print
// some error message
if (a != 42)
{
stop("a is not 42 as expected, therefore I stop until this issue is resolved!");
}
</lang>

=={{header|Ruby}}==
This uses test/unit from the standard library.

<lang ruby>require "test/unit/assertions"
include Test::Unit::Assertions

n = 5
begin
assert_equal(42, n)
rescue Exception => e
# Ruby 1.8: e is a Test::Unit::AssertionFailedError
# Ruby 1.9: e is a MiniTest::Assertion
puts e
end</lang>

Output: <pre><42> expected but was
<5>.</pre>

=={{header|Rust}}==
<lang rust>
let x = 42;
assert!(x == 42);
assert_eq!(x, 42);
</lang>

=={{header|Sather}}==
<lang sather>class MAIN is
main is
i ::= 41;
assert i = 42; -- fatal
-- ...
end;
end;</lang>

(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>:
<lang scala>assert(a == 42)
assert(a == 42, "a isn't equal to 42")
assume(a == 42)
assume(a == 42, "a isn't equal to 42")</lang>

The next one does the same thing as above, but it is not tagged. Often used as a pre-condition
checker on class constructors.
<lang scala>require(a == 42)
require(a == 42, "a isn't equal to 42")</lang>

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.
<lang scala>println(a.ensuring(a == 42))
println(a.ensuring(a == 42, "a isn't equal to 42"))
println(a.ensuring(_ == 42))
println(a.ensuring(_ == 42, "a isn't equal to 42"))</lang>

=={{header|Scheme}}==
{{Works with|Scheme|R<math>^6</math>RS}}

{{trans|Common Lisp}}
<lang scheme>(let ((x 42))
(assert (and (integer? x) (= x 42))))</lang>

=={{header|SETL}}==
<lang ada>assert( n = 42 );</lang>

=={{header|Sidef}}==
<lang ruby>var num = pick(0..100);
assert_eq(num, 42); # dies when "num" is not 42</lang>
{{out}}
<pre>
assert_eq: 26 == 42 is false at assertions.sf line 2.
</pre>

=={{header|Slate}}==
<lang slate>load: 'src/lib/assert.slate'.
define: #n -> 7.
assert: n = 42 &description: 'That is not the Answer.'.</lang>
raises an <tt>AssertionFailed</tt> condition (an <tt>Error</tt>).

=={{header|Smalltalk}}==
<lang smalltalk>foo := 41.
...
self assert: (foo == 42).</lang>

In TestCase and subclasses, a number of check methods are inherited; among them:
<lang smalltalk>self assert: (... somethingMustEvaluateToTrue.. )
self should:[ some code ] raise: someException "ensures that an exception is raised</lang>

{{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):
<lang smalltalk>self assert: (... somethingMustEvaluateToTrue.. ) "implemented in Object"</lang>
the implementation in Object raises an AssertionFailedError exception, which usually opens a debugger when in the IDE, but can be caught in deployed apps.

=={{header|SPARK}}==
Works with SPARK GPL 2010

Assertions are analysed statically, before compilation or execution. They can appear in various places:
:inline in the code, either
<lang ada>-# check X = 42;</lang>
::or
<lang ada>-# assert X = 42;</lang>
:as a precondition on an operation:
<lang ada>procedure P (X : in out Integer);
--# derives X from *;
--# pre X = 42;</lang>
:or as a postcondition on an operation:
<lang ada>procedure P (X : in out Integer);
--# derives X from *;
--# post X = 42;</lang>
Example:
<lang ada>X := 7;
--# check X = 42;</lang>
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|Standard ML}}==
Using exceptions:
<lang sml>fun assert cond =
if cond then () else raise Fail "assert"

val () = assert (x = 42)</lang>

=={{header|Stata}}==
Assertions in Stata are limited to checking a property on the observations of a dataset. See '''[http://www.stata.com/help.cgi?assert assert]''' in Stata help.

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:

<lang stata>assert x<y if z>0</lang>

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:

<lang stata>confirm file titanium.dta</lang>

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:

<lang stata>if (`n'==42) error 3
* Will print "no dataset in use"</lang>

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

<lang stata>if (`n'==42) {
display as error "The correct answer is not 42."
exit 54
}</lang>

Then, if '''[http://www.stata.com/help.cgi?capture capture]''' is used to trap the error, the return code (here 54) can be retrieved in '''[http://www.stata.com/help.cgi?_variables _rc]'''.

=={{header|Swift}}==
<lang swift>var a = 5
//...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
// the error message must be a static string</lang>
In release mode assertion checks are turned off.

=={{header|Tcl}}==
{{tcllib|control}}
<lang tcl>package require control

set x 5
control::assert {$x == 42}</lang>
Produces the output:
<pre>assertion failed: $x == 42</pre>

{{omit from|gnuplot}}
{{omit from|NSIS}}

=={{header|UNIX Shell}}==
{{works with|bash}}
Assertions are not builtin commands, but we can add a function easily.
<lang bash>assert() {
if test ! $1; then
[[ $2 ]] && echo "$2" >&2
exit 1
fi
}
x=42
assert "$x -eq 42" "that's not the answer"
((x--))
assert "$x -eq 42" "that's not the answer"
echo "won't get here"</lang>

=={{header|Vala}}==
<lang vala>int a = 42;
int b = 33;
assert (a == 42);
assert (b == 42); // will break the program with "assertion failed" error</lang>

=={{header|VBA}}==
<lang vb>Sub test()
Dim a As Integer
a = 41
Debug.Assert a = 42
End Sub</lang>
{{out}}
When run in the development area executing halts and highlights with yellow background the debug.assert line.

=={{header|VBScript}}==
====Definition====
<lang vb>sub Assert( boolExpr, strOnFail )
if not boolExpr then
Err.Raise vbObjectError + 99999, , strOnFail
end if
end sub
</lang>
====Invocation====
<lang vb>dim i
i = 43
Assert i=42, "There's got to be more to life than this!"</lang>
====Output====
<lang VBScript>>cscript "C:\foo\assert.vbs"
C:\foo\assert.vbs(3, 3) (null): There's got to be more to life than this!</lang>

=={{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.
<lang vb>Debug.Assert i = 42</lang>

=={{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.
<lang ecmascript>var assertEnabled = true

var assert = Fn.new { |cond|
if (assertEnabled && !cond) Fiber.abort("Assertion failure")
}

var x = 42
assert.call(x == 42) // fine
assertEnabled = false
assert.call(x > 42) // no error
assertEnabled = true
assert.call(x > 42) // error</lang>

{{out}}
<pre>
$ wren assertion.wren
Assertion failure
[./assertion line 4] in new(_) block argument
[./assertion line 12] in (script)
</pre>

=={{header|XPL0}}==
XPL0 does not have an assert command. The equivalent is usually
synthesized something like this.

<lang XPL0>proc Fatal(Str); \Display error message and terminate program
char Str;
[\return; uncomment this if "assertions" are to be disabled
SetVid(3); \set normal text display if program uses graphics
Text(0, Str); \display error message
ChOut(0, 7); \sound the bell
exit 1; \terminate the program; pass optional error code to DOS
];

if X#42 then Fatal("X#42");</lang>

=={{header|Yabasic}}==
<lang Yabasic>sub assert(a)
if not a then
error "Assertion failed"
end if
end sub

assert(myVar = 42)</lang>

=={{header|Zig}}==
<lang zig>const assert = @import("std").debug.assert;

pub fn main() void {
assert(1 == 0); // On failure, an `unreachable` is reached
}</lang>

Zig's assert gives a stack trace for debugging on failure.

=={{header|zkl}}==
<lang zkl>n:=42; (n==42) or throw(Exception.AssertionError);
n=41; (n==42) or throw(Exception.AssertionError("I wanted 42!"));</lang>
{{out}}
<pre>
Stack trace for VM#1 ():
Cmd.__constructor addr:38 args(0) reg(1)
startup.__constructor addr:2242 args(0) reg(1) ER
startup.__constructor addr:2178 args(0) reg(22)
Exception thrown: AssertionError(I wanted 42!)
</pre>

=={{header|zonnon}}==
<lang zonnon>
module Assertions;
var
a: integer;
begin
a := 40;
assert(a = 42,100)
end Assertions.
</lang>

Revision as of 10:23, 13 September 2021

Task
Assertions
You are encouraged to solve this task according to the task description, using any language you may know.

Assertions are a way of breaking out of code when there is an error or an unexpected input.

Some languages throw exceptions and some treat it as a break point.


Task

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

11l

Translation of: Python

<lang 11l>V a = 5 assert(a == 42) assert(a == 42, ‘Error message’)</lang>

68000 Assembly

The TRAP instruction is used for error handling. Execution jumps to a specified memory address stored in the "trap table."

<lang 68000devpac>CMP.L #42,D0 BEQ continue 

   ILLEGAL    ;jumps to Trap 4.

continue:

rest of program</lang>

Ada

Using pragma Assert: <lang ada>pragma Assert (A = 42, "Oops!");</lang> The behavior of pragma is controlled by pragma Assertion_Policy. Another way is to use the predefined package Ada.Assertions: <lang ada>with Ada.Assertions; use Ada.Assertions; ... Assert (A = 42, "Oops!");</lang> The procedure Assert propagates Assertion_Error when condition is false. Since Ada 2012 one may also specify preconditions and post-conditions for a subprogram. <lang ada>procedure Find_First 

    (List     : in     Array_Type;
     Value    : in     Integer;
     Found    :    out Boolean;
     Position :    out Positive) with
     Depends => ((Found, Position) => (List, Value)),
     Pre     => (List'Length > 0),
     Post    =>
     (if Found then Position in List'Range and then List (Position) = Value
      else Position = List'Last);</lang>

The precondition identified with "Pre =>" is an assertion that the length of the parameter List must be greater than zero. The post-condition identified with "Post =>" asserts that, upon completion of the procedure, if Found is true then Position is a valid index value in List and the value at the array element List(Position) equals the value of the Value parameter. If Found is False then Position is set to the highest valid index value for List.

Aime

<lang aime>integer x;

x = 41; if (x != 42) { 

   error("x is not 42");

}</lang> Executing the program will produce on standard error: 

aime: assert: 5: x is not 42

ALGOL 68

The "Revised Report on the Algorithmic Language - ALGOL 68" suggest that ASSERT may be made available by a particular implementation, quote: "Pragmats may ... convey to the implementation some piece of information affecting some aspect of the meaning of the program which is not defined by this Report,..."

Example given[1]: 

INT a, b; read((a, b)) PR ASSERT a >= 0 & b > 0 PR;

This works with neither ELLA ALGOL 68 nor ALGOL 68G.

The standard alternative would be to implement the assertions as an exception as per the Exceptions sample code.

In ELLA ALGOL 68 the ASSERT is implemented as an operator in the environment prelude: <lang algol68>OP ASSERT = (VECTOR [] CHAR assertion,BOOL valid) VOID: IF NOT valid THEN type line on terminal(assertion); 

       terminal error( 661 {invalid assertion } )

FI;</lang> And can be "USEd" as follows: <lang algol68>PROGRAM assertions CONTEXT VOID USE standard,environment BEGIN 

 INT a := 43;
 "Oops!" ASSERT ( a = 42 )

END FINISH</lang>

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.

<lang algolw>begin 

   integer a;
   a := 43;
   assert a = 42;
   write( "this won't appear" )

end.</lang>

Apex

Asserts that the specified condition is true. If it is not, a fatal error is returned that causes code execution to halt. <lang apex> String myStr = 'test; System.assert(myStr == 'something else', 'Assertion Failed Message'); </lang>

Asserts that the first two arguments are the same. If they are not, a fatal error is returned that causes code execution to halt. <lang apex> Integer i = 5; System.assertEquals(6, i, 'Expected 6, received ' + i); </lang>

Asserts that the first two arguments are different. If they are the same, a fatal error is returned that causes code execution to halt. <lang apex> Integer i = 5; System.assertNotEquals(5, i, 'Expected different value than ' + i); </lang>

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

Arturo

<lang rebol>a: 42 ensure [a = 42]</lang>

AutoHotkey

Exceptions

Works with: AutoHotkey_L

<lang AHK>a := 42 Assert(a > 10) Assert(a < 42) ; throws exception

Assert(bool){ 

   If !bool
       throw Exception("Expression false", -1)

}</lang>

Legacy versions

<lang AutoHotkey>if (a != 42) { 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 }</lang>

AWK

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".

<lang awk> BEGIN { meaning = 6 * 7 assert(meaning == 42, "Integer mathematics failed") assert(meaning == 42) meaning = strtonum("42 also known as forty-two") assert(meaning == 42, "Built-in function failed") meaning = "42" assert(meaning == 42, "Dynamic type conversion failed") meaning = 6 * 9 assert(meaning == 42, "Ford Prefect's experiment failed") print "That's all folks" exit }

  1. Errormsg is optional, displayed if assertion fails

function assert(cond, errormsg){ if (!cond) { if (errormsg != "") print errormsg exit 1 } } </lang>

The above example produces the output below, and sets the program's exit code to 1 (the default is 0) 

Ford Prefect's experiment failed

Axe

<lang axe>A=42??Returnʳ</lang>

BaCon

<lang qbasic>' Assertions answer = assertion(42) PRINT "The ultimate answer is indeed ", answer

PRINT "Now, expect a failure, unless NDEBUG defined at compile time" answer = assertion(41) PRINT answer END

' Ensure the given number is the ultimate answer FUNCTION assertion(NUMBER i) 

   ' BaCon can easily be intimately integrated with C
   USEH
       #include <assert.h>
   END USEH

   ' If the given expression is not true, abort the program
   USEC
       assert(i == 42);
   END USEC

   RETURN i

END FUNCTION</lang>

Output:
prompt$ bacon -q assertion.bac && ./assertion
Converting 'assertion.bac'... done, 24 lines were processed in 0.006 seconds.
Compiling 'assertion.bac'... cc  -c assertion.bac.c
cc -o assertion assertion.bac.o -lbacon -lm 
Done, program 'assertion' ready.
The ultimate answer is indeed 42
Now, expect a failure, unless NDEBUG defined at compile time
assertion: assertion.assertion.h:16: assertion: Assertion `i == 42' failed.
ERROR: signal ABORT received - internal error. Try to compile the program with TRAP LOCAL to find the cause.

prompt$ bacon -q -o '-DNDEBUG' assertion.bac && ./assertion
Converting 'assertion.bac'... done, 24 lines were processed in 0.003 seconds.
Compiling 'assertion.bac'... cc  -DNDEBUG -c assertion.bac.c
cc -o assertion assertion.bac.o -lbacon -lm 
Done, program 'assertion' ready.
The ultimate answer is indeed 42
Now, expect a failure, unless NDEBUG defined at compile time
41

BASIC256

Works with: BASIC256 version 2.0.0.11

<lang BASIC256> subroutine assert (condition, message) 

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

end subroutine

call assert(1+1=2, "but I don't expect this assertion to fail"): rem Does not throw an error rem call assert(1+1=3, "and rightly so"): rem Throws an error </lang>

BBC BASIC

<lang bbcbasic> PROCassert(a% = 42) 

     END
     
     DEF PROCassert(bool%)
     IF NOT bool% THEN ERROR 100, "Assertion failed"
     ENDPROC</lang>

Brat

<lang brat>squish import :assert :assertions

assert_equal 42 42 assert_equal 13 42 #Raises an exception</lang>

C

<lang c>#include <assert.h>

int main(){ 

  int a;
  /* ...input or change a here */
  assert(a == 42); /* aborts program when a is not 42, unless the NDEBUG macro was defined */

  return 0;

}</lang> To turn off assertions, simply define the NDEBUG macro before where <assert.h> 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: <lang c>assert(a == 42 && "Error message");</lang> 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.


C# and Visual Basic .NET

.NET provides the Debug.Assert and Trace.Assert methods, which notify TraceListener instances subscribed to the program's trace output if the specified condition is false. Both methods also have overloads that allow a specified string to be added to the default message of the assertion, which consists of "Assertion Failed" and a stack trace for the location of the assertion.

The behavior of a failed assertion is controlled by the listeners in the TraceListeners collection shared by the Debug and Trace classes. By default, the collection contains an instance of the DefaultTraceListener class, which uses functions in the Windows API that notify attached debuggers, if any. Additional behavior depends on the framework version that the application is running in:

  • In .NET Core applications, if no debuggers are attached, failed Debug.Assert assertions for non-UI applications terminate the program and write the assertion message to the console, while failed Trace.Assert assertions do not affect execution. In this respect, a failed Debug assertion behaves similarly to an exception.
  • In .NET Framework applications, for both types of assertions, a special instance of the Abort-Retry-Ignore message box containing the assertion message is displayed (even with a debugger attached). "Abort" terminates the program; "Retry" switches to the location of the assertion in source code if the application is running in a debugger, or, if none are attached, prompts to launch a just-in-time debugger; and "Ignore" continues execution past the assertion.

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.

<lang csharp>using System.Diagnostics; // Debug and Trace are in this namespace.

static class Program { 

   static void Main()
   {
       int a = 0;

       Console.WriteLine("Before");

       // Always hit.
       Trace.Assert(a == 42, "Trace assertion failed");

       Console.WriteLine("After Trace.Assert");

       // Only hit in debug builds.        
       Debug.Assert(a == 42, "Debug assertion failed");

       Console.WriteLine("After Debug.Assert");
   }

}</lang>

<lang vbnet>Imports System.Diagnostics ' Note: VB Visual Studio projects have System.Diagnostics imported by default, ' along with several other namespaces.

Module Program 

   Sub Main()
       Dim a As Integer = 0

       Console.WriteLine("Before")

       ' Always hit.
       Trace.Assert(a = 42, "Trace assertion failed: The Answer was incorrect")

       Console.WriteLine("After Trace.Assert")

       ' Only hit in debug builds.        
       Debug.Assert(a = 42, "Debug assertion failed: The Answer was incorrect")

       Console.WriteLine("After Debug.Assert")
   End Sub

End Module</lang>

Output (for .NET Core debug builds when outside of a debugger):
Before
After Trace.Assert
Assertion Failed
Debug assertion failed

   at Program.Main() in FILENAME:line 21
Output:

In .NET Core applications, this is the output

  • when a debugger is attached and is used to continue past both assertions when they fail, or
  • in release builds of the program, where the call to Debug.Assert is removed and the Trace.Assert assertion is hit but has no visible effects.

In .NET Framework applications, assertions never show up in the console and so the output is this when a debugger or the "Ignore" option used to continue past the assertions. 

Before
After Trace.Assert
After Debug.Assert

Displaying Trace assertions in console:

To "see" the Trace.Assert assertion, additional TraceListener instances must be subscribed by the program. In the .NET Framework, there are several built-in subclasses of TraceListener, including ConsoleTraceListener, which writes trace messages to the console. In .NET Core, these classes are available starting from .NET Core 3.0.

Subscribing an instance involves adding the following line to the beginning of Main() (with a semicolon in C#, of course ;) <lang vbnet>Trace.Listeners.Add(new ConsoleTraceListener())</lang>

C++

Translation of: C

<lang cpp>#include <cassert> // assert.h also works

int main() { 

 int a;
 // ... input or change a here

 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

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

Clojure

<lang Clojure> (let [i 42] 

    (assert (= i 42)))

</lang>

Common Lisp

<lang lisp>(let ((x 42)) 

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

Component Pascal

Works with BlackBox Component Builder <lang oberon2> MODULE Assertions; VAR x: INTEGER; PROCEDURE DoIt*; BEGIN x := 41; ASSERT(x = 42); END DoIt; END Assertions.

Assertions.DoIt </lang> Output: 

TRAP 0

 Assertions.DoIt   [0000001DH] 
 Kernel.Call   [00001A7CH] 
	.adr	INTEGER	1685454913
	.kind	INTEGER	0
	.n	INTEGER	0
	.p	INTEGER	0
	.par	ARRAY 256 OF INTEGER	elements
	.r	REAL	8.70603013185328E+175
	.sig	POINTER	[64760018H]
	.size	INTEGER	2287288
	.sp	INTEGER	256
	.typ	POINTER	NIL
 Meta.Item.ParamCallVal   [00002B5EH] 
	.adr	INTEGER	1685454913
	.data	ARRAY 256 OF INTEGER	elements

Crystal

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

<lang ruby>class AssertionError < Exception end

def assert(predicate : Bool, msg = "The asserted condition was false") 

 raise AssertionError.new(msg) unless predicate

end

assert(12 == 42, "It appears that 12 doesn't equal 42")</lang>

D

<lang d>import std.exception: enforce;

int foo(in bool condition) pure nothrow in { 

   // Assertions are used in contract programming.
   assert(condition);

} out(result) { 

   assert(result > 0);

} body { 

   if (condition)
       return 42;

   // assert(false) is never stripped from the code, it generates an
   // error in debug builds, and it becomes a HALT instruction in
   // -release mode.
   //
   // It's used as a mark by the D type system. If you remove this
   // line the compiles gives an error:
   //
   // Error: function assertions.foo no return exp;
   //   or assert(0); at end of function
   assert(false, "This can't ha
Retrieved from "https://rosettacode.org/wiki/Assertions?oldid=98807"