Assertions

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.

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

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.

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:

OP      ASSERT = (VECTOR [] CHAR assertion,BOOL valid) VOID:
IF      NOT valid
THEN    type line on terminal(assertion);
        terminal error( 661 {invalid assertion } )
FI;

And can be "USEd" as follows:

PROGRAM assertions CONTEXT VOID
USE standard,environment
BEGIN
  INT a := 43;
  "Oops!" ASSERT ( a = 42 )
END
FINISH

AutoHotkey

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

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

  return 0;

}</lang>

C#

<lang csharp>using System.Diagnostics;

Debug.Assert(a == 42);</lang>

Common Lisp

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

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

D

<lang d>import std.string; void main() {

 int a = readln().chomp().atoi();
 assert(a == 42, "You did not input 42!");

} </lang>

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>

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>

Groovy

<lang groovy>def doSomething = { x, f ->

  assert f != null : "f was null!"
  assert f instanceof Closure : "f was not a closure! f: ${f}"
  f(x)

}</lang>

Test program: <lang groovy>println doSomething(-1) { x -> -2*Math.asin(x) } try { println doSomething(-1, 50) } catch (Throwable t) { println t.message } try { println doSomething(-1, null) } catch (Throwable t) { println t.message }</lang>

Output:

3.141592653589793
f was not a closure! f: 50. Expression: (f instanceof groovy.lang.Closure). Values: f = 50
f was null!. Expression: (f != null). Values: f = null

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>

Java

<lang java5>public static void main(String[] args){

  int a;
  //...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 non-void expression

}</lang>

J

   assert n = 42

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

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

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

Modula-3

ASSERT is a pragma, that creates a run-time error if it returns FALSE. <lang modula3><*ASSERT a = 42*></lang>

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

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 NSCAssert or NSCAssertN instead.

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>

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. <lang perl>open FH, ">file" or die "Cannot open file: $!\n"; # $! contains the error message from the last error

my $a;

1. ...input or change a here

$a == 42 or die "Error message\n";</lang>

Some third-party modules might provide more detailed assertion ability.

Python

<lang python>a = 5

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

Ruby

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

n = 5 begin

 assert_equal(42, n)

rescue AssertionFailedError

 puts "assertion failed: expected 42, got #{n}"

end</lang>

Tcl

Library: tcllib

<lang tcl>package require control

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

assertion failed: $x == 42