Eiffel

{{works with|SmartEiffel}} version 2.4

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

File called main.e:

class MAIN
    creation main
    feature main is
        local
            test: TEST;
        do
            create test;

            io.read_integer;
            test.assert(io.last_integer);
        end
end

Another file called test.e:

class TEST
    feature assert(val: INTEGER) is
        require
            val = 42;
        do
            print("Thanks for the 42!%N");
        end
end

Elixir

ExUnit.start

defmodule AssertionTest do
  use ExUnit.Case

  def return_5, do: 5

  test "not equal" do
    assert 42 == return_5
  end
end

{{out}}

  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

Emacs Lisp

Assertion can be loaded from cl.el:

(require 'cl)
(let ((x 41))
  (assert (= x 42) t "the answer is not right"))

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.

 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

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

Euphoria

type fourty_two(integer i)
    return i = 42
end type

fourty_two i

i = 41 -- type-check failure

Factor

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

USING: kernel ;
42 assert=

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.

#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

Output

Assertion: 1>2 failed

Press any key to continue...

Forth

variable a
: assert   a @ 42 <> throw ;

41 a ! assert

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

{{out}}

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

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

let test x =
  assert (x = 42)

test 43

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

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

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—function name, file name, and line number.

package main

func main() {
    x := 43
    if x != 42 {
        panic(42)
    }
}

Output:

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

Groovy

def checkTheAnswer = {
   assert it == 42 : "This: " + it + " is not the answer!"
}

Test program:

println "before 42..."
checkTheAnswer(42)
println "before 'Hello Universe'..."
checkTheAnswer("Hello Universe")

Output:

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)

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

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

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

This produces the output:

10
42 is invalid value for 'a'

Changing the define to: $define DEBUG &fail turns off the assertion checking.

J

## Java


```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.
    }
}

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

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

Kotlin

Assertions need to be enabled using java's -ea option for an AssertionError to be thrown when the condition is false.

// version 1.0.6 (assert.kt)

fun main(args: Array<String>) {
   val a = 42
   assert(a == 43)
}

{{out}}

Exception in thread "main" java.lang.AssertionError: Assertion failed
        at AssertKt.main(assert.kt:5)

Lasso

local(a) = 8
fail_if(
    #a != 42,
    error_code_runtimeAssertion,
    error_msg_runtimeAssertion + ": #a is not 42"
)

{{out}}

-9945 Runtime assertion: #a is not 42

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.

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

{{out}}

passed

Stops with error message {{out}}

RuntimeError: Subscript out of range: -1, AssertionFailed()

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:

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

Lisaac

? { n = 42 };

Lua

a = 5
assert (a == 42)
assert (a == 42,'\''..a..'\' is not the answer to life, the universe, and everything')

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.

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

Maple

(Taken from Lua, above.)

a := 5:
ASSERT( a = 42 );
ASSERT( a = 42, "a is not the answer to life, the universe, and everything" );

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

Assert[var===42]

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

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

Sample Output:

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

Metafont

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

def assert(expr t) = if not (t): errmessage("assertion failed") fi enddef;

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

Usage example:

n := 41;
assert(n=42);
message "ok";

Output (failed assertion):

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

?

=={{header|Modula-3}}== ASSERT is a pragma, that creates a run-time error if it returns FALSE.

<*ASSERT a = 42*>

Assertions can be ignored in the compiler by using the -a switch.

Nemerle

A basic assertion uses the assert keyword:

assert (foo == 42, $"foo == $foo, not 42.")

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

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

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
}

The design by contract macros throw Nemerle.AssertionException's unless another Exception is specified using the otherwise keyword after the requires/ensures statement. For further details on design by contract macros, see [http://nemerle.org/wiki/index.php?title=Design_by_contract_macros here].

Nim

var a = 42
assert(a == 42, "Not 42!")

Assertions may be disabled by compiling with --assertions:off.

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

MODULE Assertions;
VAR
	a: INTEGER;
BEGIN
	a := 40;
	ASSERT(a = 42);
END Assertions.

Output:

Runtime error: assertion failed (0) on line 6 in module Assertions
In procedure Assertions.%main
   called from MAIN

Objeck

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

class Test {
  function : Main(args : String[]) ~ Nil {
    if(args->Size() = 1) {
      a := args[0]->ToInt();
      Runtime->Assert(a = 42);
    };
  }
}

=={{header|Objective-C}}== For use within an Objective-C method:

NSAssert(a == 42, @"Error message");

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

NSAssert1(a == 42, @"a is not 42, a is actually %d", a); # has 1 formatting arg, so use NSAssert"1"

Within a regular C function you should use NSCAssert or NSCAssert''N'' instead.

To turn off assertions, define the NS_BLOCK_ASSERTIONS macro.

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

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

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.

: testInteger(n, m)
   assert: [ n isInteger ]
   assert: [ n 42 == ]

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

{{out}}

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

testInteger(42, 43)
Assertions are ok, parameters are : 42, 43

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

declare
  proc {PrintNumber N}
     N=42  %% assert
     {Show N}
  end
in
  {PrintNumber 42} %% ok
  {PrintNumber 11} %% throws

Output:

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

PARI/GP

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

#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 */
}

More common is the use of pari_err_BUG in such cases:

if (!equalis(a, 42)) pari_err_BUG("this_function_name (expected a = 42)");

Pascal

See [[Assertions#Delphi | Delphi]]

Perl

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

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;

This idiom is typically used during file operations:

open my $fh, '<', 'file'
    or die "Cannot open file: $!\n"; # $! contains the error message from the last error

It is not needed whith the "autodie" pragma:

use autodie;
open my $fh, '<', 'file'; # automatically throws an exception on failure

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

use Carp::Assert;
assert($a == 42);

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

is $a, 42;
ok $a == 42;
cmp_ok $a, '==', 42, 'The answer should be 42';
# etc.

Perl 6

my $a = (1..100).pick;
$a == 42 or die '$a ain\'t 42';

{{works with|pugs}} ''Note: This example uses an experimental feature, and does not work in the primary Perl 6 compiler, Rakudo.''

# with a (non-hygienic) macro
macro assert ($x) { "$x or die 'assertion failed: $x'" }
assert('$a == 42');

Phix

User defined types allow the value to be automatically tested whenever it changes, and can be disabled using the "without type_check" directive:

type int42(object i)
    return i=42
end type

int42 i

i = 41 -- type-check failure

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:

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

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:

if i!=42 then ?9/0 end if
if i!=42 then crash("i is not 42!!") end if

Again, if the application was run from Edita, on error it automatically jumps to the offending file and line.

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

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:

(let N 41
   (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:

(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

PL/I

## Prolog

{{works with|SWI Prolog}}


```prolog

test(A):-
    assertion(A==42).

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

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

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

stopifnot(a==42)

#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 racket

(define x 80)
(unless (= x 42)
  (error "a is not 42")) ; will error

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

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

// 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!");
}

x = 42
assert( x = 42 )
assert( x = 100 )

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

<42> expected but was
<5>.

let x = 42;
assert!(x == 42);
assert_eq!(x, 42);

class MAIN is
  main is
    i ::= 41;
    assert i = 42; -- fatal
    -- ...
  end;
end;

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

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

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

(let ((x 42))
  (assert (and (integer? x) (= x 42))))

assert( n = 42 );

var num = pick(0..100);
assert_eq(num, 42);         # dies when "num" is not 42

assert_eq: 26 == 42 is false at assertions.sf line 2.

load: 'src/lib/assert.slate'.
define: #n -> 7.
assert: n = 42 &description: 'That is not the Answer.'.

foo := 41.
...
self assert: (foo == 42).

self assert: (... somethingMustEvaluateToTrue.. )
self should:[ some code ] raise: someException "ensures that an exception is raised

self assert: (... somethingMustEvaluateToTrue.. ) "implemented in Object"

-# check X = 42;

-# assert X = 42;

procedure P (X : in out Integer);
--# derives X from *;
--# pre  X = 42;

procedure P (X : in out Integer);
--# derives X from *;
--# post X = 42;

X := 7;
--# check X = 42;

H1:    true .
       ->
C1:    false .

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:


```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:


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

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

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

package require control

set x 5
control::assert {$x == 42}

assertion failed: $x == 42

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"

int a = 42;
int b = 33;
assert (a == 42);
assert (b == 42); // will break the program with "assertion failed" error

Sub test()
    Dim a As Integer
    a = 41
    Debug.Assert a = 42
End Sub

sub Assert( boolExpr, strOnFail )
	if not boolExpr then
		Err.Raise vbObjectError + 99999, , strOnFail
	end if
end sub

dim i
i = 43
Assert i=42, "There's got to be more to life than this!"

cscript "C:\foo\assert.vbs"
C:\foo\assert.vbs(3, 3) (null): There's got to be more to life than this!

## Visual Basic .NET

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


## XPL0

XPL0 does not have an assert command. The equivalent is usually
synthesized something like this.


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

sub assert(a)
	if not a then
		error "Assertion failed"
	end if
end sub

assert(myVar = 42)

const assert = @import("std").debug.assert;

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

n:=42; (n==42) or throw(Exception.AssertionError);
n=41;  (n==42) or throw(Exception.AssertionError("I wanted 42!"));

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

module Assertions;
var
	a: integer;
begin
	a := 40;
	assert(a = 42,100)
end Assertions.