changed ASSERT to Assert and NEW to New

diff --git a/lib/obnc/FilesTest.obn b/lib/obnc/FilesTest.obn
index d0712d5439854991e4c3bee5987bef5a92b57273..9b37be0d5706d6849987821a34c88786e8b3d0cf 100644 (file)
--- a/lib/obnc/FilesTest.obn
+++ b/lib/obnc/FilesTest.obn
@@ -23,8 +23,8 @@ module FilesTest;
                var f: Files.File;
        begin
                f := Files.Old("FilesTest.obn");
-               ASSERT(f # nil);
-               ASSERT(f is Files.File)
+               Assert(f # nil);
+               Assert(f is Files.File)
        end TestOld;
 
 
@@ -32,8 +32,8 @@ module FilesTest;
                var f: Files.File;
        begin
                f := Files.New("NewTest");
-               ASSERT(f # nil);
-               ASSERT(f is Files.File)
+               Assert(f # nil);
+               Assert(f is Files.File)
        end TestNew;
 
 
@@ -47,28 +47,28 @@ module FilesTest;
                end IsRider;
        begin
                f := Files.New("RegisterTest");
-               ASSERT(f # nil);
-               ASSERT(IsRider(r));
+               Assert(f # nil);
+               Assert(IsRider(r));
                Files.Register(f);
 
                f := Files.Old("RegisterTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.Delete("RegisterTest", res);
-               ASSERT(res = 0);
+               Assert(res = 0);
 
                f := Files.New("RegisterTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
                Files.Write(r, 37);
                Files.Close(f);
                Files.Register(f);
-               ASSERT(Files.Length(f) = 1);
+               Assert(Files.Length(f) = 1);
 
                f := Files.Old("RegisterTest");
-               ASSERT(f # nil);
-               ASSERT(Files.Length(f) = 1);
+               Assert(f # nil);
+               Assert(Files.Length(f) = 1);
                Files.Delete("RegisterTest", res);
-               ASSERT(res = 0)
+               Assert(res = 0)
        end TestRegister;
 
 
@@ -77,12 +77,12 @@ module FilesTest;
                        r: Files.Rider;
        begin
                f := Files.New("CloseTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
                Files.Write(r, 65);
-               ASSERT(Files.Length(f) <= 1);
+               Assert(Files.Length(f) <= 1);
                Files.Close(f);
-               ASSERT(Files.Length(f) = 1)
+               Assert(Files.Length(f) = 1)
        end TestClose;
 
 
@@ -91,11 +91,11 @@ module FilesTest;
                        r: Files.Rider;
        begin
                f := Files.New("PurgeTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
                Files.Write(r, 65);
                Files.Purge(f);
-               ASSERT(Files.Length(f) = 0)
+               Assert(Files.Length(f) = 0)
        end TestPurge;
 
 
@@ -104,14 +104,14 @@ module FilesTest;
                        res: Int;
        begin
                f := Files.New("DeleteTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.Register(f);
                f := Files.Old("DeleteTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.Delete("DeleteTest", res);
-               ASSERT(res = 0);
+               Assert(res = 0);
                f := Files.Old("DeleteTest");
-               ASSERT(f = nil)
+               Assert(f = nil)
        end TestDelete;
 
 
@@ -120,21 +120,21 @@ module FilesTest;
                        res: Int;
        begin
                f := Files.New("RenameTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.Register(f);
                f := Files.Old("RenameTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.Rename("RenameTest", "RenameTest1", res);
-               ASSERT(res = 0);
+               Assert(res = 0);
 
                f := Files.Old("RenameTest");
-               ASSERT(f = nil);
+               Assert(f = nil);
                f := Files.Old("RenameTest1");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.Delete("RenameTest1", res);
-               ASSERT(res = 0)
+               Assert(res = 0)
        end TestRename;
 
 
@@ -143,11 +143,11 @@ module FilesTest;
                        res: Int;
        begin
                f := Files.New("LengthTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.Register(f);
-               ASSERT(Files.Length(f) = 0);
+               Assert(Files.Length(f) = 0);
                Files.Delete("LengthTest", res);
-               ASSERT(res = 0)
+               Assert(res = 0)
        end TestLength;
 
 
@@ -157,25 +157,25 @@ module FilesTest;
                        hour, minute, second, year, month, day: Int;
        begin
                f := Files.Old("FilesTest.obn");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.GetDate(f, t, d);
                hour := t div 4096;
-               ASSERT(hour >= 0);
-               ASSERT(hour < 24);
+               Assert(hour >= 0);
+               Assert(hour < 24);
                minute := t div 64 mod 64;
-               ASSERT(minute >= 0);
-               ASSERT(minute < 60);
+               Assert(minute >= 0);
+               Assert(minute < 60);
                second := t mod 64;
-               ASSERT(second >= 0);
-               ASSERT(second < 60);
+               Assert(second >= 0);
+               Assert(second < 60);
                year := d div 512;
-               ASSERT(year >= 0);
+               Assert(year >= 0);
                month := d div 32 mod 16;
-               ASSERT(month >= 1);
-               ASSERT(month <= 12);
+               Assert(month >= 1);
+               Assert(month <= 12);
                day := d mod 32;
-               ASSERT(day >= 1);
-               ASSERT(day <= 31)
+               Assert(day >= 1);
+               Assert(day <= 31)
        end TestDate;
 
 
@@ -184,9 +184,9 @@ module FilesTest;
                        r: Files.Rider;
        begin
                f := Files.New("SetTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
-               ASSERT(~r.eof)
+               Assert(~r.eof)
        end TestSetPos;
 
 
@@ -195,9 +195,9 @@ module FilesTest;
                        r: Files.Rider;
        begin
                f := Files.New("PosTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
-               ASSERT(Files.Pos(r) = 0)
+               Assert(Files.Pos(r) = 0)
        end TestPos;
 
 
@@ -206,9 +206,9 @@ module FilesTest;
                        r: Files.Rider;
        begin
                f := Files.New("BaseTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
-               ASSERT(Files.Base(r) = f)
+               Assert(Files.Base(r) = f)
        end TestBase;
 
 
@@ -218,16 +218,16 @@ module FilesTest;
                        b: Byte;
        begin
                f := Files.New("ReadWriteTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
                Files.SetPos(r, f, 0);
                Files.Write(r, 65);
                Files.Close(f);
-               ASSERT(Files.Length(f) = 1);
+               Assert(Files.Length(f) = 1);
                Files.SetPos(r, f, 0);
                Files.Read(r, b);
-               ASSERT(~r.eof);
-               ASSERT(b = 65);
-               ASSERT(Files.Pos(r) = 1)
+               Assert(~r.eof);
+               Assert(b = 65);
+               Assert(Files.Pos(r) = 1)
        end TestReadWrite;
 
 
@@ -237,7 +237,7 @@ module FilesTest;
                        i: Int;
        begin
                f := Files.New("ReadWriteIntTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteInt(r, 100);
@@ -246,13 +246,13 @@ module FilesTest;
 
                Files.SetPos(r, f, 0);
                Files.ReadInt(r, i);
-               ASSERT(~r.eof);
-               ASSERT(i = 100);
+               Assert(~r.eof);
+               Assert(i = 100);
                Files.ReadInt(r, i);
-               ASSERT(~r.eof);
-               ASSERT(i = -1000);
+               Assert(~r.eof);
+               Assert(i = -1000);
                Files.ReadInt(r, i);
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteInt;
 
 
@@ -262,7 +262,7 @@ module FilesTest;
                        x: Real;
        begin
                f := Files.New("ReadWriteRealTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteReal(r, 3.14);
@@ -271,13 +271,13 @@ module FilesTest;
 
                Files.SetPos(r, f, 0);
                Files.ReadReal(r, x);
-               ASSERT(~r.eof);
-               ASSERT(ABS(x - 3.14) < 1.0E-6);
+               Assert(~r.eof);
+               Assert(ABS(x - 3.14) < 1.0E-6);
                Files.ReadReal(r, x);
-               ASSERT(~r.eof);
-               ASSERT(ABS(x - (-3.14)) < 1.0E-6);
+               Assert(~r.eof);
+               Assert(ABS(x - (-3.14)) < 1.0E-6);
                Files.ReadReal(r, x);
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteReal;
 
 
@@ -287,7 +287,7 @@ module FilesTest;
                        i: Int;
        begin
                f := Files.New("ReadWriteNumTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteNum(r, 100);
@@ -296,13 +296,13 @@ module FilesTest;
 
                Files.SetPos(r, f, 0);
                Files.ReadNum(r, i);
-               ASSERT(~r.eof);
-               ASSERT(i = 100);
+               Assert(~r.eof);
+               Assert(i = 100);
                Files.ReadNum(r, i);
-               ASSERT(~r.eof);
-               ASSERT(i = -1000);
+               Assert(~r.eof);
+               Assert(i = -1000);
                Files.ReadNum(r, i);
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteNum;
 
 
@@ -312,7 +312,7 @@ module FilesTest;
                        s: array 32 of Char;
        begin
                f := Files.New("ReadWriteStringTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteString(r, "hello");
@@ -322,16 +322,16 @@ module FilesTest;
 
                Files.SetPos(r, f, 0);
                Files.ReadString(r, s);
-               ASSERT(~r.eof);
-               ASSERT(s = "hello");
+               Assert(~r.eof);
+               Assert(s = "hello");
                Files.ReadString(r, s);
-               ASSERT(~r.eof);
-               ASSERT(s = "there");
+               Assert(~r.eof);
+               Assert(s = "there");
                Files.ReadString(r, s);
-               ASSERT(~r.eof);
-               ASSERT(s = "");
+               Assert(~r.eof);
+               Assert(s = "");
                Files.ReadString(r, s);
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteString;
 
 
@@ -341,7 +341,7 @@ module FilesTest;
                        s: Set;
        begin
                f := Files.New("ReadWriteSetTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteSet(r, {});
@@ -351,16 +351,16 @@ module FilesTest;
 
                Files.SetPos(r, f, 0);
                Files.ReadSet(r, s);
-               ASSERT(~r.eof);
-               ASSERT(s = {});
+               Assert(~r.eof);
+               Assert(s = {});
                Files.ReadSet(r, s);
-               ASSERT(~r.eof);
-               ASSERT(s = {0});
+               Assert(~r.eof);
+               Assert(s = {0});
                Files.ReadSet(r, s);
-               ASSERT(~r.eof);
-               ASSERT(s = {0, 1});
+               Assert(~r.eof);
+               Assert(s = {0, 1});
                Files.ReadSet(r, s);
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteSet;
 
 
@@ -370,7 +370,7 @@ module FilesTest;
                        b: Bool;
        begin
                f := Files.New("ReadWriteBoolTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteBool(r, true);
@@ -379,13 +379,13 @@ module FilesTest;
 
                Files.SetPos(r, f, 0);
                Files.ReadBool(r, b);
-               ASSERT(~r.eof);
-               ASSERT(b);
+               Assert(~r.eof);
+               Assert(b);
                Files.ReadBool(r, b);
-               ASSERT(~r.eof);
-               ASSERT(~b);
+               Assert(~r.eof);
+               Assert(~b);
                Files.ReadBool(r, b);
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteBool;
 
 
@@ -398,7 +398,7 @@ module FilesTest;
                for i := 0 to LEN(buf) - 1 do buf[i] := i + 1 end;
 
                f := Files.New("ReadWriteBytesTest");
-               ASSERT(f # nil);
+               Assert(f # nil);
 
                Files.SetPos(r, f, 0);
                Files.WriteBytes(r, buf, LEN(buf));
@@ -410,19 +410,19 @@ module FilesTest;
                Files.SetPos(r, f, 0);
 
                Files.ReadBytes(r, buf, LEN(buf));
-               ASSERT(~r.eof);
+               Assert(~r.eof);
                for i := 0 to LEN(buf) - 1 do
-                       ASSERT(buf[i] = i + 1)
+                       Assert(buf[i] = i + 1)
                end;
 
                Files.ReadBytes(r, buf, LEN(buf));
-               ASSERT(~r.eof);
+               Assert(~r.eof);
                for i := 0 to LEN(buf) - 1 do
-                       ASSERT(buf[i] = i + 1)
+                       Assert(buf[i] = i + 1)
                end;
 
                Files.ReadBytes(r, buf, LEN(buf));
-               ASSERT(r.eof)
+               Assert(r.eof)
        end TestReadWriteBytes;
 
 begin

diff --git a/lib/obnc/InTest.obn b/lib/obnc/InTest.obn
index 23581b718ad83cf3c990d27da876cd53b4a35965..7bca02f059b38451f6a83dc5c6790e878329f9ae 100644 (file)
--- a/lib/obnc/InTest.obn
+++ b/lib/obnc/InTest.obn
@@ -30,51 +30,51 @@ module InTest;
 
 begin
        In.Character(ch);
-       ASSERT(In.Done);
-       ASSERT(ch = "a");
+       Assert(In.Done);
+       Assert(ch = "a");
 
        In.Integer(n);
-       ASSERT(In.Done);
-       ASSERT(n = 37);
+       Assert(In.Done);
+       Assert(n = 37);
 
        In.Integer(n);
-       ASSERT(In.Done);
-       ASSERT(n = 37H);
+       Assert(In.Done);
+       Assert(n = 37H);
 
        In.RealNum(x);
-       ASSERT(In.Done);
-       ASSERT(x >= 3.14 - eps);
-       ASSERT(x <= 3.14 + eps);
+       Assert(In.Done);
+       Assert(x >= 3.14 - eps);
+       Assert(x <= 3.14 + eps);
 
        In.String(s);
-       ASSERT(In.Done);
-       ASSERT(s = "");
+       Assert(In.Done);
+       Assert(s = "");
 
        In.String(s);
-       ASSERT(In.Done);
-       ASSERT(s = "foo bar");
+       Assert(In.Done);
+       Assert(s = "foo bar");
 
        In.String(s);
-       ASSERT(In.Done);
-       ASSERT(s = 0X);
+       Assert(In.Done);
+       Assert(s = 0X);
 
        In.String(s);
-       ASSERT(In.Done);
-       ASSERT(s = 1FX);
+       Assert(In.Done);
+       Assert(s = 1FX);
 
        In.String(s);
-       ASSERT(In.Done);
-       ASSERT(s = 0FFX);
+       Assert(In.Done);
+       Assert(s = 0FFX);
 
        In.Name(s);
-       ASSERT(In.Done);
-       ASSERT(s = "foo/bar");
+       Assert(In.Done);
+       Assert(s = "foo/bar");
 
        In.Line(s);
-       ASSERT(In.Done);
-       ASSERT(s = "");
+       Assert(In.Done);
+       Assert(s = "");
 
        In.Line(s);
-       ASSERT(In.Done);
-       ASSERT(s = "foo bar")
+       Assert(In.Done);
+       Assert(s = "foo bar")
 end InTest.

diff --git a/lib/obnc/Input.obn b/lib/obnc/Input.obn
index 77f53390aad4fd8be8ef9473313ed3a5a295a904..8f4f6da6a4cc43e2a5b0f9698bd9107109fcabc6 100644 (file)
--- a/lib/obnc/Input.obn
+++ b/lib/obnc/Input.obn
@@ -38,5 +38,5 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
        end Time;
 
 begin
-       ASSERT(Input0.TimeUnit > 0) (*silence "Input0 unused" compiler note*)
+       Assert(Input0.TimeUnit > 0) (*silence "Input0 unused" compiler note*)
 end Input.

diff --git a/lib/obnc/Input0Test.obn b/lib/obnc/Input0Test.obn
index 1e8764f5cacb0f87350fcb2012dcabe6c921d1d7..b6bd0a446da6d67827accbd102a0d3d934f4d0b2 100644 (file)
--- a/lib/obnc/Input0Test.obn
+++ b/lib/obnc/Input0Test.obn
@@ -28,11 +28,11 @@ module Input0Test;
                        n := Input.Available()
                until n >= 3;
                Input.Read(ch);
-               ASSERT(ch = "a");
+               Assert(ch = "a");
                Input.Read(ch);
-               ASSERT(ch = "b");
+               Assert(ch = "b");
                Input.Read(ch);
-               ASSERT(ch = "c");
+               Assert(ch = "c");
                Out.String("OK");
                Out.Ln;
        end TestAvailable;
@@ -44,14 +44,14 @@ module Input0Test;
                Out.String("Press space ... ");
                Out.Ln;
                Input.Read(ch);
-               ASSERT(ch = " ");
+               Assert(ch = " ");
                Out.String("OK");
                Out.Ln;
 
                Out.String("Press $ ... ");
                Out.Ln;
                Input.Read(ch);
-               ASSERT(ch = "$");
+               Assert(ch = "$");
                Out.String("OK");
                Out.Ln
        end TestRead;
@@ -59,8 +59,8 @@ module Input0Test;
 
        procedure TestTime;
        begin
-               ASSERT(Input.TimeUnit > 0);
-               ASSERT(Input.Time() > 0)
+               Assert(Input.TimeUnit > 0);
+               Assert(Input.Time() > 0)
        end TestTime;
 
 

diff --git a/lib/obnc/InputTest.obn b/lib/obnc/InputTest.obn
index 67d53597bbf96a97f85bc350a07f019a2d6356d3..1d274701c6757aeaf7c7e3be406ba4cd54524039 100644 (file)
--- a/lib/obnc/InputTest.obn
+++ b/lib/obnc/InputTest.obn
@@ -27,7 +27,7 @@ module InputTest;
                repeat
                        n := Input.Available()
                until n # 0;
-               ASSERT(n > 0);
+               Assert(n > 0);
                Out.String("OK");
                Out.Ln;
                Input.Read(ch)
@@ -40,14 +40,14 @@ module InputTest;
                Out.String("Press space ... ");
                Out.Ln;
                Input.Read(ch);
-               ASSERT(ch = " ");
+               Assert(ch = " ");
                Out.String("OK");
                Out.Ln;
 
                Out.String("Press $ ... ");
                Out.Ln;
                Input.Read(ch);
-               ASSERT(ch = "$");
+               Assert(ch = "$");
                Out.String("OK");
                Out.Ln
        end TestRead;
@@ -67,9 +67,9 @@ module InputTest;
                repeat
                        Input.Mouse(buttons, x, y);
                until buttons # {};
-               ASSERT(button in buttons);
-               ASSERT(x >= 0);
-               ASSERT(y >= 0);
+               Assert(button in buttons);
+               Assert(x >= 0);
+               Assert(y >= 0);
                Out.String("OK");
                Out.Ln;
                repeat (*wait until button has been released*)
@@ -88,8 +88,8 @@ module InputTest;
 
        procedure TestTime;
        begin
-               ASSERT(Input.TimeUnit > 0);
-               ASSERT(Input.Time() > 0)
+               Assert(Input.TimeUnit > 0);
+               Assert(Input.Time() > 0)
        end TestTime;
 
 

diff --git a/lib/obnc/MathTest.obn b/lib/obnc/MathTest.obn
index caf5a5426ff64912b02570b4c35635fd72f39b77..d192ffd338043a350472211cc6e475f4d0ccb03a 100644 (file)
--- a/lib/obnc/MathTest.obn
+++ b/lib/obnc/MathTest.obn
@@ -23,72 +23,72 @@ module MathTest;
                eps = 0.01;
 
 begin
-       ASSERT(ABS(Math.sqrt(1.0) - 1.0) < eps);
-       ASSERT(ABS(Math.sqrt(4.0) - 2.0) < eps);
+       Assert(ABS(Math.sqrt(1.0) - 1.0) < eps);
+       Assert(ABS(Math.sqrt(4.0) - 2.0) < eps);
 
-       ASSERT(ABS(Math.power(0.0, 1.0) - 0.0) < eps);
-       ASSERT(ABS(Math.power(1.0, 0.0) - 1.0) < eps);
-       ASSERT(ABS(Math.power(2.0, 3.0) - 8.0) < eps);
-       ASSERT(ABS(Math.power(2.0, -3.0) - 1.0 / 8.0) < eps);
+       Assert(ABS(Math.power(0.0, 1.0) - 0.0) < eps);
+       Assert(ABS(Math.power(1.0, 0.0) - 1.0) < eps);
+       Assert(ABS(Math.power(2.0, 3.0) - 8.0) < eps);
+       Assert(ABS(Math.power(2.0, -3.0) - 1.0 / 8.0) < eps);
 
-       ASSERT(ABS(Math.exp(0.0) - 1.0) < eps);
-       ASSERT(ABS(Math.exp(1.0) - Math.e) < eps);
-       ASSERT(ABS(Math.exp(2.0) - Math.e * Math.e) < eps);
-       ASSERT(ABS(Math.exp(-2.0) - 1.0 / Math.e / Math.e) < eps);
+       Assert(ABS(Math.exp(0.0) - 1.0) < eps);
+       Assert(ABS(Math.exp(1.0) - Math.e) < eps);
+       Assert(ABS(Math.exp(2.0) - Math.e * Math.e) < eps);
+       Assert(ABS(Math.exp(-2.0) - 1.0 / Math.e / Math.e) < eps);
 
-       ASSERT(ABS(Math.ln(1.0) - 0.0) < eps);
-       ASSERT(ABS(Math.ln(Math.e) - 1.0) < eps);
-       ASSERT(ABS(Math.ln(Math.e * Math.e) - 2.0) < eps);
+       Assert(ABS(Math.ln(1.0) - 0.0) < eps);
+       Assert(ABS(Math.ln(Math.e) - 1.0) < eps);
+       Assert(ABS(Math.ln(Math.e * Math.e) - 2.0) < eps);
 
-       ASSERT(ABS(Math.log(1.0, 2.0) - 0.0) < eps);
-       ASSERT(ABS(Math.log(Math.e, Math.e) - 1.0) < eps);
-       ASSERT(ABS(Math.log(100.0, 10.0) - 2.0) < eps);
+       Assert(ABS(Math.log(1.0, 2.0) - 0.0) < eps);
+       Assert(ABS(Math.log(Math.e, Math.e) - 1.0) < eps);
+       Assert(ABS(Math.log(100.0, 10.0) - 2.0) < eps);
 
-       ASSERT(ABS(Math.round(0.4) - 0.0) < eps);
-       ASSERT(ABS(Math.round(-0.4) - 0.0) < eps);
-       ASSERT(ABS(Math.round(0.6) - 1.0) < eps);
-       ASSERT(ABS(Math.round(-0.6) - (-1.0)) < eps);
+       Assert(ABS(Math.round(0.4) - 0.0) < eps);
+       Assert(ABS(Math.round(-0.4) - 0.0) < eps);
+       Assert(ABS(Math.round(0.6) - 1.0) < eps);
+       Assert(ABS(Math.round(-0.6) - (-1.0)) < eps);
 
-       ASSERT(ABS(Math.sin(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.sin(Math.pi / 6.0) - 0.5) < eps);
-       ASSERT(ABS(Math.sin(Math.pi / 2.0) - 1.0) < eps);
+       Assert(ABS(Math.sin(0.0) - 0.0) < eps);
+       Assert(ABS(Math.sin(Math.pi / 6.0) - 0.5) < eps);
+       Assert(ABS(Math.sin(Math.pi / 2.0) - 1.0) < eps);
 
-       ASSERT(ABS(Math.cos(0.0) - 1.0) < eps);
-       ASSERT(ABS(Math.cos(Math.pi / 3.0) - 0.5) < eps);
-       ASSERT(ABS(Math.cos(Math.pi / 2.0) - 0.0) < eps);
+       Assert(ABS(Math.cos(0.0) - 1.0) < eps);
+       Assert(ABS(Math.cos(Math.pi / 3.0) - 0.5) < eps);
+       Assert(ABS(Math.cos(Math.pi / 2.0) - 0.0) < eps);
 
-       ASSERT(ABS(Math.tan(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.tan(Math.pi / 4.0) - 1.0) < eps);
+       Assert(ABS(Math.tan(0.0) - 0.0) < eps);
+       Assert(ABS(Math.tan(Math.pi / 4.0) - 1.0) < eps);
 
-       ASSERT(ABS(Math.arcsin(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arcsin(0.5) - Math.pi / 6.0) < eps);
-       ASSERT(ABS(Math.arcsin(1.0) - Math.pi / 2.0) < eps);
+       Assert(ABS(Math.arcsin(0.0) - 0.0) < eps);
+       Assert(ABS(Math.arcsin(0.5) - Math.pi / 6.0) < eps);
+       Assert(ABS(Math.arcsin(1.0) - Math.pi / 2.0) < eps);
 
-       ASSERT(ABS(Math.arccos(1.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arccos(0.5) - Math.pi / 3.0) < eps);
-       ASSERT(ABS(Math.arccos(0.0) - Math.pi / 2.0) < eps);
+       Assert(ABS(Math.arccos(1.0) - 0.0) < eps);
+       Assert(ABS(Math.arccos(0.5) - Math.pi / 3.0) < eps);
+       Assert(ABS(Math.arccos(0.0) - Math.pi / 2.0) < eps);
 
-       ASSERT(ABS(Math.arctan(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arctan(1.0) - Math.pi / 4.0) < eps);
+       Assert(ABS(Math.arctan(0.0) - 0.0) < eps);
+       Assert(ABS(Math.arctan(1.0) - Math.pi / 4.0) < eps);
 
-       ASSERT(ABS(Math.arctan2(0.0, 2.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arctan2(2.0, 2.0) - Math.pi / 4.0) < eps);
+       Assert(ABS(Math.arctan2(0.0, 2.0) - 0.0) < eps);
+       Assert(ABS(Math.arctan2(2.0, 2.0) - Math.pi / 4.0) < eps);
 
-       ASSERT(ABS(Math.sinh(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.sinh(1.0) - (Math.e - 1.0 / Math.e) / 2.0) < eps);
+       Assert(ABS(Math.sinh(0.0) - 0.0) < eps);
+       Assert(ABS(Math.sinh(1.0) - (Math.e - 1.0 / Math.e) / 2.0) < eps);
 
-       ASSERT(ABS(Math.cosh(0.0) - 1.0) < eps);
-       ASSERT(ABS(Math.cosh(1.0) - (Math.e + 1.0 / Math.e) / 2.0) < eps);
+       Assert(ABS(Math.cosh(0.0) - 1.0) < eps);
+       Assert(ABS(Math.cosh(1.0) - (Math.e + 1.0 / Math.e) / 2.0) < eps);
 
-       ASSERT(ABS(Math.tanh(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.tanh(1.0) - (Math.e - 1.0 / Math.e) / (Math.e + 1.0 / Math.e)) < eps);
+       Assert(ABS(Math.tanh(0.0) - 0.0) < eps);
+       Assert(ABS(Math.tanh(1.0) - (Math.e - 1.0 / Math.e) / (Math.e + 1.0 / Math.e)) < eps);
 
-       ASSERT(ABS(Math.arcsinh(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arcsinh((Math.e - 1.0 / Math.e) / 2.0) - 1.0) < eps);
+       Assert(ABS(Math.arcsinh(0.0) - 0.0) < eps);
+       Assert(ABS(Math.arcsinh((Math.e - 1.0 / Math.e) / 2.0) - 1.0) < eps);
 
-       ASSERT(ABS(Math.arccosh(1.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arccosh((Math.e + 1.0 / Math.e) / 2.0) - 1.0) < eps);
+       Assert(ABS(Math.arccosh(1.0) - 0.0) < eps);
+       Assert(ABS(Math.arccosh((Math.e + 1.0 / Math.e) / 2.0) - 1.0) < eps);
 
-       ASSERT(ABS(Math.arctanh(0.0) - 0.0) < eps);
-       ASSERT(ABS(Math.arctanh((Math.e - 1.0 / Math.e) / (Math.e + 1.0 / Math.e)) - 1.0) < eps)
+       Assert(ABS(Math.arctanh(0.0) - 0.0) < eps);
+       Assert(ABS(Math.arctanh((Math.e - 1.0 / Math.e) / (Math.e + 1.0 / Math.e)) - 1.0) < eps)
 end MathTest.

diff --git a/lib/obnc/Strings.obn b/lib/obnc/Strings.obn
index 30a10ab901013caf0be415d73b86090f20f54c13..ba95fd624a247a61096a665a5a800ad1efadf43e 100644 (file)
--- a/lib/obnc/Strings.obn
+++ b/lib/obnc/Strings.obn
@@ -33,8 +33,8 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
                        i, lim: Int;
        begin
                destLength := Length(dest);
-               ASSERT(pos >= 0);
-               ASSERT(pos <= destLength);
+               Assert(pos >= 0);
+               Assert(pos <= destLength);
 
                sourceLength := Length(source);
                newLength := Min(destLength + sourceLength, LEN(dest) - 1);
@@ -73,9 +73,9 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
                var length, n1, i: Int;
        begin
                length := Length(s);
-               ASSERT(pos >= 0);
-               ASSERT(pos <= length);
-               ASSERT(n >= 0);
+               Assert(pos >= 0);
+               Assert(pos <= length);
+               Assert(n >= 0);
 
                n1 := Min(n, length - pos); (*actual number of characters to delete*)
                for i := pos to length - n1 do
@@ -89,8 +89,8 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
                var destLength, n, i: Int;
        begin
                destLength := Length(dest);
-               ASSERT(pos >= 0);
-               ASSERT(pos <= destLength);
+               Assert(pos >= 0);
+               Assert(pos <= destLength);
 
                n := Min(Length(source), LEN(dest) - 1 - pos); (*actual number of characters to replace*)
 
@@ -110,8 +110,8 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
                var sourceLength, n1, i: Int;
        begin
                sourceLength := Length(source);
-               ASSERT(pos >= 0);
-               ASSERT(pos <= sourceLength);
+               Assert(pos >= 0);
+               Assert(pos <= sourceLength);
 
                n1 := Min(n, Min(sourceLength - pos, LEN(dest) - 1)); (*actual number of characters to extract*)
                for i := 0 to n1 - 1 do
@@ -125,8 +125,8 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
 (**Pos(pat, s, pos) returns the position of the first occurrence of pat in s. Searching starts at position pos (0 <= pos <= Length(s)). If pat is not found, -1 is returned.*)
                var idxs, idxp, result: Int;
        begin
-               ASSERT(pos >= 0);
-               ASSERT(pos < LEN(s));
+               Assert(pos >= 0);
+               Assert(pos < LEN(s));
                
                idxs := pos - 1;
                repeat
@@ -143,7 +143,7 @@ Implements the basic library module from "The Oakwood Guidelines for Oberon-2 Co
                        result := -1
                end;
 
-               ASSERT((result = -1) or (result >= 0) & (result + idxp < LEN(s)))
+               Assert((result = -1) or (result >= 0) & (result + idxp < LEN(s)))
        return result
        end Pos;
 

diff --git a/lib/obnc/StringsTest.obn b/lib/obnc/StringsTest.obn
index 1958cc4c8fc00e84ac0570d9ad2d5502f9bf4191..f3933fadc3fc1b2072478f12483963172594d3ba 100644 (file)
--- a/lib/obnc/StringsTest.obn
+++ b/lib/obnc/StringsTest.obn
@@ -25,93 +25,93 @@ module StringsTest;
 
 begin
        (*test Length*)
-       ASSERT(Strings.Length("") = 0);
+       Assert(Strings.Length("") = 0);
        shortStr := "";
-       ASSERT(Strings.Length(shortStr) = 0);
+       Assert(Strings.Length(shortStr) = 0);
        shortStr := 22X;
-       ASSERT(Strings.Length(shortStr) = 1);
+       Assert(Strings.Length(shortStr) = 1);
        shortStr := "123";
-       ASSERT(Strings.Length(shortStr) = 3);
+       Assert(Strings.Length(shortStr) = 3);
 
        (*test Insert*)
        s := "cde";
        Strings.Insert("ab", 0, s);
-       ASSERT(s = "abcde");
+       Assert(s = "abcde");
        s := "adef";
        Strings.Insert("bc", 1, s);
-       ASSERT(s = "abcdef");
+       Assert(s = "abcdef");
        shortStr := "ade";
        Strings.Insert("bc", 1, shortStr);
-       ASSERT(shortStr = "abc");
+       Assert(shortStr = "abc");
        shortStr := "aef";
        Strings.Insert("bcd", 1, shortStr);
-       ASSERT(shortStr = "abc");
+       Assert(shortStr = "abc");
        s := "foo bar";
        Strings.Insert(" baz", Strings.Length(s), s);
-       ASSERT(s = "foo bar baz");
+       Assert(s = "foo bar baz");
        Strings.Insert(" qux qux qux qux qux", Strings.Length(s), s);
-       ASSERT(s = "foo bar baz q");
+       Assert(s = "foo bar baz q");
 
        (*test Append*)
        s := "";
        Strings.Append("foo", s);
-       ASSERT(s = "foo");
+       Assert(s = "foo");
        Strings.Append(" bar", s);
-       ASSERT(s = "foo bar");
+       Assert(s = "foo bar");
        Strings.Append(" baz qux", s);
-       ASSERT(s = "foo bar baz q");
+       Assert(s = "foo bar baz q");
 
        (*test Delete*)
        s := "foo bar baz";
        Strings.Delete(s, 11, 4);
-       ASSERT(s = "foo bar baz");
+       Assert(s = "foo bar baz");
        Strings.Delete(s, 7, 4);
-       ASSERT(s = "foo bar");
+       Assert(s = "foo bar");
        Strings.Delete(s, 0, 4);
-       ASSERT(s = "bar");
+       Assert(s = "bar");
        Strings.Delete(s, 1, 10);
-       ASSERT(s = "b");
+       Assert(s = "b");
        Strings.Delete(s, 0, 0);
-       ASSERT(s = "b");
+       Assert(s = "b");
        Strings.Delete(s, 0, 1);
-       ASSERT(s = "");
+       Assert(s = "");
 
        (*test Replace*)
        s := "foo bar baz";
        Strings.Replace("qux", 4, s);
-       ASSERT(s = "foo qux baz");
+       Assert(s = "foo qux baz");
        s := "foo bar";
        Strings.Replace("qux qux qux", 5, s);
-       ASSERT(s = "foo bqux qux ");
+       Assert(s = "foo bqux qux ");
        s := "foo";
        Strings.Replace(" bar", 3, s);
-       ASSERT(s = "foo bar");
+       Assert(s = "foo bar");
 
        (*test Extract*)
        Strings.Extract("foo bar", 4, 3, shortStr);
-       ASSERT(shortStr = "bar");
+       Assert(shortStr = "bar");
        Strings.Extract("foo bar", 4, 10, shortStr);
-       ASSERT(shortStr = "bar");
+       Assert(shortStr = "bar");
        Strings.Extract("foo bar", 0, 6, shortStr);
-       ASSERT(shortStr = "foo");
+       Assert(shortStr = "foo");
        Strings.Extract("foo bar", 7, 4, shortStr);
-       ASSERT(shortStr = "");
+       Assert(shortStr = "");
 
        (*test Pos*)
-       ASSERT(Strings.Pos("", "", 0) = 0);
-       ASSERT(Strings.Pos("", "foo", 0) = 0);
-       ASSERT(Strings.Pos("", "foo", 1) = 1);
-       ASSERT(Strings.Pos("", "foo", 3) = 3);
-       ASSERT(Strings.Pos("foo", "foo", 0) = 0);
-       ASSERT(Strings.Pos("foo", "fool", 0) = 0);
-       ASSERT(Strings.Pos("ool", "fool", 0) = 1);
-       ASSERT(Strings.Pos("oo", "fool", 0) = 1);
-       ASSERT(Strings.Pos("fools", "fool", 0) = -1);
-       ASSERT(Strings.Pos("ools", "fool", 0) = -1);
-       ASSERT(Strings.Pos("ol", "fool", 1) = 2);
+       Assert(Strings.Pos("", "", 0) = 0);
+       Assert(Strings.Pos("", "foo", 0) = 0);
+       Assert(Strings.Pos("", "foo", 1) = 1);
+       Assert(Strings.Pos("", "foo", 3) = 3);
+       Assert(Strings.Pos("foo", "foo", 0) = 0);
+       Assert(Strings.Pos("foo", "fool", 0) = 0);
+       Assert(Strings.Pos("ool", "fool", 0) = 1);
+       Assert(Strings.Pos("oo", "fool", 0) = 1);
+       Assert(Strings.Pos("fools", "fool", 0) = -1);
+       Assert(Strings.Pos("ools", "fool", 0) = -1);
+       Assert(Strings.Pos("ol", "fool", 1) = 2);
 
        (*test Cap*)
        s := "foo Bar BAZ";
        Strings.Cap(s);
-       ASSERT(s = "FOO BAR BAZ")
+       Assert(s = "FOO BAR BAZ")
 end StringsTest.

diff --git a/lib/obnc/XYplane.obn b/lib/obnc/XYplane.obn
index 4c88ee8403ec77a408459f8d30db7cd6dc05d6a0..04fe889ce5d12ad27781ff76dfa3cf3584aeac09 100644 (file)
--- a/lib/obnc/XYplane.obn
+++ b/lib/obnc/XYplane.obn
@@ -81,5 +81,5 @@ end drawpixels.
 *)
 
 begin
-       ASSERT(Input.TimeUnit > 0) (*silence "Input unused" compiler note*)
+       Assert(Input.TimeUnit > 0) (*silence "Input unused" compiler note*)
 end XYplane.

diff --git a/lib/obnc/XYplaneTest.obn b/lib/obnc/XYplaneTest.obn
index 1d2ef372560030d420db330c9cb9e3d3c0cc2247..c24111403c86ace608a8d96c63cd04a3620a641d 100644 (file)
--- a/lib/obnc/XYplaneTest.obn
+++ b/lib/obnc/XYplaneTest.obn
@@ -26,10 +26,10 @@ module XYplaneTest;
                        & (y >= 0) & (y < XYplane.H);
                XYplane.Clear;
                XYplane.Dot(x, y, XYplane.draw);
-               ASSERT(withinBounds & XYplane.IsDot(x, y)
+               Assert(withinBounds & XYplane.IsDot(x, y)
                        or ~withinBounds & ~XYplane.IsDot(x, y));
                XYplane.Dot(x, y, XYplane.erase);
-               ASSERT(~XYplane.IsDot(x, y))
+               Assert(~XYplane.IsDot(x, y))
        end TestPosition;
 
 
@@ -73,18 +73,18 @@ module XYplaneTest;
                (*test SetSize*)
                XYplane.SetSize(640, 480);
                XYplane.Open;
-               ASSERT(XYplane.W = 640);
-               ASSERT(XYplane.H = 480);
+               Assert(XYplane.W = 640);
+               Assert(XYplane.H = 480);
 
                (*test UseColor and Color*)
                XYplane.UseColor(00FF3FH);
                XYplane.Dot(100, 100, XYplane.draw);
-               ASSERT(XYplane.Color(100, 100) = 00FF3FH);
-               ASSERT(XYplane.IsDot(100, 100));
+               Assert(XYplane.Color(100, 100) = 00FF3FH);
+               Assert(XYplane.IsDot(100, 100));
                XYplane.UseColor(0);
                XYplane.Dot(100, 100, XYplane.draw);
-               ASSERT(XYplane.Color(100, 100) = 0);
-               ASSERT(~XYplane.IsDot(100, 100))
+               Assert(XYplane.Color(100, 100) = 0);
+               Assert(~XYplane.IsDot(100, 100))
        end Run;
 
 begin

diff --git a/src/.Oberon.y.swp b/src/.Oberon.y.swp
new file mode 100644 (file)
index 0000000..0627e87
Binary files /dev/null and b/src/.Oberon.y.swp differ

diff --git a/src/Oberon.y b/src/Oberon.y
index e9d7ea977d470f720a15367dfe0b9223e62446bb..a8290f46e84639dffb977845c72cc41466acbd5b 100644 (file)
--- a/src/Oberon.y
+++ b/src/Oberon.y
@@ -3590,7 +3590,7 @@ static Trees_Node PredeclaredProcedureAST(const char procName[], Trees_Node expL
        static const struct { const char *name; int symbol; } symbols[] = {
                {"ABS", TREES_ABS_PROC},
                {"ASR", TREES_ASR_PROC},
-               {"ASSERT", TREES_ASSERT_PROC},
+               {"Assert", TREES_ASSERT_PROC},
                {"CHR", TREES_CHR_PROC},
                {"DEC", TREES_DEC_PROC},
                {"EXCL", TREES_EXCL_PROC},
@@ -3600,8 +3600,7 @@ static Trees_Node PredeclaredProcedureAST(const char procName[], Trees_Node expL
                {"INCL", TREES_INCL_PROC},
                {"LEN", TREES_LEN_PROC},
                {"LSL", TREES_LSL_PROC},
-               {"NEW", TREES_NEW_PROC},
-               {"ODD", TREES_ODD_PROC},
+               {"New", TREES_NEW_PROC},
                {"ORD", TREES_ORD_PROC},
                {"PACK", TREES_PACK_PROC},
                {"ROR", TREES_ROR_PROC},

diff --git a/src/Table.c b/src/Table.c
index a3b0f2db99442f79a53795da982d594a2ae81955..f375689303875c6b25106151d89743b89aa747d5 100644 (file)
--- a/src/Table.c
+++ b/src/Table.c
@@ -81,7 +81,7 @@ void Table_Init(void)
        static const struct { const char *name; int kind, type; } predecIdents[] = {
                {"ABS", TREES_PROCEDURE_KIND, TREES_ABS_PROC},
                {"ASR", TREES_PROCEDURE_KIND, TREES_ASR_PROC},
-               {"ASSERT", TREES_PROCEDURE_KIND, TREES_ASSERT_PROC},
+               {"Assert", TREES_PROCEDURE_KIND, TREES_ASSERT_PROC},
                {"Bool", TREES_TYPE_KIND, TREES_BOOLEAN_TYPE},
                {"Byte", TREES_TYPE_KIND, TREES_BYTE_TYPE},
                {"CHR", TREES_PROCEDURE_KIND, TREES_CHR_PROC},
@@ -95,7 +95,7 @@ void Table_Init(void)
                {"Int", TREES_TYPE_KIND, TREES_INTEGER_TYPE},
                {"LEN", TREES_PROCEDURE_KIND, TREES_LEN_PROC},
                {"LSL", TREES_PROCEDURE_KIND, TREES_LSL_PROC},
-               {"NEW", TREES_PROCEDURE_KIND, TREES_NEW_PROC},
+               {"New", TREES_PROCEDURE_KIND, TREES_NEW_PROC},
                {"ORD", TREES_PROCEDURE_KIND, TREES_ORD_PROC},
                {"PACK", TREES_PROCEDURE_KIND, TREES_PACK_PROC},
                {"ROR", TREES_PROCEDURE_KIND, TREES_ROR_PROC},

diff --git a/src/y.tab.c b/src/y.tab.c
index c754de49043bc345694cedafccfdd1b893a176fe..aaab518878b0e67c1cc3440eb67352d4ede5c77b 100644 (file)
--- a/src/y.tab.c
+++ b/src/y.tab.c
@@ -5568,7 +5568,7 @@ static Trees_Node PredeclaredProcedureAST(const char procName[], Trees_Node expL
        static const struct { const char *name; int symbol; } symbols[] = {
                {"ABS", TREES_ABS_PROC},
                {"ASR", TREES_ASR_PROC},
-               {"ASSERT", TREES_ASSERT_PROC},
+               {"Assert", TREES_ASSERT_PROC},
                {"CHR", TREES_CHR_PROC},
                {"DEC", TREES_DEC_PROC},
                {"EXCL", TREES_EXCL_PROC},
@@ -5578,8 +5578,7 @@ static Trees_Node PredeclaredProcedureAST(const char procName[], Trees_Node expL
                {"INCL", TREES_INCL_PROC},
                {"LEN", TREES_LEN_PROC},
                {"LSL", TREES_LSL_PROC},
-               {"NEW", TREES_NEW_PROC},
-               {"ODD", TREES_ODD_PROC},
+               {"New", TREES_NEW_PROC},
                {"ORD", TREES_ORD_PROC},
                {"PACK", TREES_PACK_PROC},
                {"ROR", TREES_ROR_PROC},

diff --git a/subword b/subword
new file mode 100755 (executable)
index 0000000..6cda803
--- /dev/null
+++ b/subword
@@ -0,0 +1,2 @@
+#!/bin/sh
+find . -type f -name "*$3*" -exec sed -i -e "s/\\b$1\\b/$2/g" {} \;

diff --git a/tests/obnc/failing-at-compile-time/T7ActualVarParamImported1.obn b/tests/obnc/failing-at-compile-time/T7ActualVarParamImported1.obn
index 06797e02d24e1d7918cffcdffa8763217502027a..dd44ca75ae4e5de94a37ee85ae2bbbbaf185dfc9 100644 (file)
--- a/tests/obnc/failing-at-compile-time/T7ActualVarParamImported1.obn
+++ b/tests/obnc/failing-at-compile-time/T7ActualVarParamImported1.obn
@@ -20,5 +20,5 @@ module T7ActualVarParamImported1;
        import A;
 
 begin
-       NEW(A.p)
+       New(A.p)
 end T7ActualVarParamImported1.

diff --git a/tests/obnc/passing/T2TypeDeclarations.obn b/tests/obnc/passing/T2TypeDeclarations.obn
index 4de46c6f664765698438eff06b2112d1088f10f0..7ba35de316df4ece7d415a4f5fff549f578bfb52 100644 (file)
--- a/tests/obnc/passing/T2TypeDeclarations.obn
+++ b/tests/obnc/passing/T2TypeDeclarations.obn
@@ -91,13 +91,13 @@ module T2TypeDeclarations;
                                proc: procedure
                        end;
        begin
-               NEW(x);
-               ASSERT(x.ptr = nil);
-               NEW(y);
-               ASSERT(y.proc = nil);
-               NEW(z);
-               ASSERT(z.ptr = nil);
-               ASSERT(z.proc = nil)
+               New(x);
+               Assert(x.ptr = nil);
+               New(y);
+               Assert(y.proc = nil);
+               New(z);
+               Assert(z.ptr = nil);
+               Assert(z.proc = nil)
        end TestMemoryAllocation;
 
 
@@ -116,7 +116,7 @@ module T2TypeDeclarations;
                var x: P;
                        y: T;
        begin
-               NEW(x);
+               New(x);
                x.i := 1;
                y.f := 1
        end TestScope;
@@ -125,16 +125,16 @@ begin
        TestMemoryAllocation;
        s1 := s;
        table[0] := nil;
-       NEW(t);
-       NEW(i);
+       New(t);
+       New(i);
        t.content := i;
        t.content(IntegerNode).value := 1;
        t.proc := TreeProc;
-       NEW(e);
+       New(e);
        n.elem := left;
        n.next := nil;
        n.p := NodeProc;
-       NEW(p);
+       New(p);
        a[0].f := nil;
        TestScope
 end T2TypeDeclarations.

diff --git a/tests/obnc/passing/T3VariableDeclarations.obn b/tests/obnc/passing/T3VariableDeclarations.obn
index 9b06f43075ce4ba3d40ae093bcbf7719b8536fc2..fcfb2d6cd6a654badaa451fcdc371304edc39cd1 100644 (file)
--- a/tests/obnc/passing/T3VariableDeclarations.obn
+++ b/tests/obnc/passing/T3VariableDeclarations.obn
@@ -39,7 +39,7 @@ module T3VariableDeclarations;
 
                procedure AssertVector(var v: Vector);
                begin
-                       ASSERT(v is Vector)
+                       Assert(v is Vector)
                end AssertVector;
 
        begin
@@ -49,8 +49,8 @@ module T3VariableDeclarations;
                AssertVector(rs[0].pos);
                AssertVector(rs[0].size);
 
-               NEW(rp);
-               ASSERT(rp is Rectangle);
+               New(rp);
+               Assert(rp is Rectangle);
                AssertVector(rp.pos);
                AssertVector(rp.size);
        end TestInitialization;

diff --git a/tests/obnc/passing/T4Expressions.obn b/tests/obnc/passing/T4Expressions.obn
index d700b0b1112d2fd356aa13004b7859838778f157..35b9162ab1b00dc85d0a6b46ac25d0be578b3179 100644 (file)
--- a/tests/obnc/passing/T4Expressions.obn
+++ b/tests/obnc/passing/T4Expressions.obn
@@ -48,21 +48,21 @@ module T4Expressions;
 
        begin
                s := "hello";
-               ASSERT(s[1] = "e");
+               Assert(s[1] = "e");
 
                A[1, 2] := 1;
-               ASSERT(A[1, 2] = A[1][2]);
+               Assert(A[1, 2] = A[1][2]);
                i := 0;
                j := 0;
                A[0, 0] := ABS(A[IncReturnZero(i), IncReturnZero(j)]);
-               ASSERT(i = 1);
-               ASSERT(j = 1);
+               Assert(i = 1);
+               Assert(j = 1);
 
-               NEW(a[0]);
+               New(a[0]);
                a[0].a[0] := 1;
-               ASSERT(a[0].a[0] = 1);
+               Assert(a[0].a[0] = 1);
                a[0]^.f := F;
-               ASSERT(a[0].f() = 1);
+               Assert(a[0].f() = 1);
        end TestDesignators;
 
 
@@ -76,13 +76,13 @@ module T4Expressions;
 Out.Integer(ORD({1, 2, a, 5, b, 8}), 0); Out.Ln;
 Out.Integer(ORD({1, 2, a..b, 8}), 0); Out.Ln;
 Out.Integer(ORD({1, 2, a, 5, b, 8} = {1, 2, a..b, 8}), 0); Out.Ln;
-               ASSERT({1, 2, a, 5, b, 8} = {1, 2, a..b, 8});
+               Assert({1, 2, a, 5, b, 8} = {1, 2, a..b, 8});
                i := 0;
                j := 0;
                A := {IncReturnZero(i)..IncReturnZero(j)};
-               ASSERT(A = {0});
-               ASSERT(i = 1);
-               ASSERT(j = 1)
+               Assert(A = {0});
+               Assert(i = 1);
+               Assert(j = 1)
        end TestSetConstructors;
 
 
@@ -103,147 +103,147 @@ Out.Integer(ORD({1, 2, a, 5, b, 8} = {1, 2, a..b, 8}), 0); Out.Ln;
                        t1: T1;
        begin
                (*booleans*)
-               ASSERT(true = true);
-               ASSERT(true # false);
+               Assert(true = true);
+               Assert(true # false);
                b := true;
                b1 := false;
-               ASSERT(b = true);
-               ASSERT(b1 # true);
+               Assert(b = true);
+               Assert(b1 # true);
 
                (*characters / single-character strings*)
                ch := 0X;
                ch1 := "a";
-               ASSERT(ch = 0X);
-               ASSERT(ch # "a");
-               ASSERT(ch < ch1);
-               ASSERT(ch <= 0X);
-               ASSERT(ch <= "a");
-               ASSERT(ch1 > ch);
-               (*ASSERT(ch >= 0X);*)
-               ASSERT("a" >= ch);
+               Assert(ch = 0X);
+               Assert(ch # "a");
+               Assert(ch < ch1);
+               Assert(ch <= 0X);
+               Assert(ch <= "a");
+               Assert(ch1 > ch);
+               (*Assert(ch >= 0X);*)
+               Assert("a" >= ch);
                ch := 7FX;
                ch1 := 80X;
-               ASSERT(ch < ch1);
+               Assert(ch < ch1);
 
                (*integers*)
-               ASSERT(0 = 0);
-               ASSERT(0 # 1);
-               ASSERT(0 < 1);
-               ASSERT(0 <= 0);
-               ASSERT(0 <= 1);
-               ASSERT(1 > 0);
-               ASSERT(0 >= 0);
-               ASSERT(1 >= 0);
-               ASSERT(0 in {0});
-               ASSERT(~(1 in {0}));
+               Assert(0 = 0);
+               Assert(0 # 1);
+               Assert(0 < 1);
+               Assert(0 <= 0);
+               Assert(0 <= 1);
+               Assert(1 > 0);
+               Assert(0 >= 0);
+               Assert(1 >= 0);
+               Assert(0 in {0});
+               Assert(~(1 in {0}));
                n := 0;
-               ASSERT(n = 0);
-               ASSERT(n # 1);
-               ASSERT(n < 1);
-               ASSERT(n <= 0);
-               ASSERT(n <= 1);
-               ASSERT(n < 1);
-               ASSERT(n >= 0);
-               ASSERT(n >= -1);
-               ASSERT(n in {0});
-               ASSERT(~(1 in {n}));
+               Assert(n = 0);
+               Assert(n # 1);
+               Assert(n < 1);
+               Assert(n <= 0);
+               Assert(n <= 1);
+               Assert(n < 1);
+               Assert(n >= 0);
+               Assert(n >= -1);
+               Assert(n in {0});
+               Assert(~(1 in {n}));
                i := 0;
                j := 0;
                b := IncReturnZero(i) in IncReturnEmpty(j);
-               ASSERT(i = 1);
-               ASSERT(j = 1);
+               Assert(i = 1);
+               Assert(j = 1);
 
                (*real numbers*)
-               ASSERT(0.0 = 0.0);
-               ASSERT(0.0 # 1.0);
-               ASSERT(0.0 < 1.0);
-               ASSERT(0.0 <= 0.0);
-               ASSERT(0.0 <= 1.0);
-               ASSERT(1.0 > 0.0);
-               ASSERT(0.0 >= 0.0);
-               ASSERT(1.0 >= 0.0);
+               Assert(0.0 = 0.0);
+               Assert(0.0 # 1.0);
+               Assert(0.0 < 1.0);
+               Assert(0.0 <= 0.0);
+               Assert(0.0 <= 1.0);
+               Assert(1.0 > 0.0);
+               Assert(0.0 >= 0.0);
+               Assert(1.0 >= 0.0);
                x := 0.0;
-               ASSERT(x = 0.0);
-               ASSERT(x # 1.0);
-               ASSERT(x < 1.0);
-               ASSERT(x <= 0.0);
-               ASSERT(x <= 1.0);
-               ASSERT(1.0 > x);
-               ASSERT(x >= 0.0);
-               ASSERT(x >= -1.0);
+               Assert(x = 0.0);
+               Assert(x # 1.0);
+               Assert(x < 1.0);
+               Assert(x <= 0.0);
+               Assert(x <= 1.0);
+               Assert(1.0 > x);
+               Assert(x >= 0.0);
+               Assert(x >= -1.0);
 
                (*bytes*)
                y := 0;
-               ASSERT(y = 0);
-               ASSERT(y < 1);
-               ASSERT(y <= 0);
-               ASSERT(y <= 1);
-               ASSERT(1 > y);
-               (*ASSERT(y >= 0);*)
-               ASSERT(y in {0});
-               ASSERT(~(1 in {y}));
+               Assert(y = 0);
+               Assert(y < 1);
+               Assert(y <= 0);
+               Assert(y <= 1);
+               Assert(1 > y);
+               (*Assert(y >= 0);*)
+               Assert(y in {0});
+               Assert(~(1 in {y}));
 
                (*sets*)
-               ASSERT({0, 1} = {1, 0});
-               ASSERT({0} # {0, 1});
-               ASSERT({1 .. 0} = {});
+               Assert({0, 1} = {1, 0});
+               Assert({0} # {0, 1});
+               Assert({1 .. 0} = {});
                n := 1;
-               ASSERT({n .. 0} = {});
+               Assert({n .. 0} = {});
                A := {0};
                B := {0, 1};
-               ASSERT(A = {0});
-               ASSERT(B # {0});
-               ASSERT(A # B);
+               Assert(A = {0});
+               Assert(B # {0});
+               Assert(A # B);
 
                (*strings / characters / character arrays*)
-               ASSERT("foo" = "foo");
-               ASSERT("foo" # "bar");
-               ASSERT("bar" < "foo");
-               ASSERT("foo" <= "foo");
-               ASSERT("bar" <= "foo");
-               ASSERT("foo" > "bar");
-               ASSERT("foo" >= "foo");
-               ASSERT("foo" >= "bar");
+               Assert("foo" = "foo");
+               Assert("foo" # "bar");
+               Assert("bar" < "foo");
+               Assert("foo" <= "foo");
+               Assert("bar" <= "foo");
+               Assert("foo" > "bar");
+               Assert("foo" >= "foo");
+               Assert("foo" >= "bar");
                ch := "b";
-               ASSERT("b" = ch);
-               ASSERT("f" # ch);
-               ASSERT(ch < "c");
-               ASSERT("b" <= ch);
-               ASSERT("a" <= ch);
-               ASSERT("c" > ch);
-               ASSERT("b" >= ch);
-               ASSERT("c" >= ch);
+               Assert("b" = ch);
+               Assert("f" # ch);
+               Assert(ch < "c");
+               Assert("b" <= ch);
+               Assert("a" <= ch);
+               Assert("c" > ch);
+               Assert("b" >= ch);
+               Assert("c" >= ch);
                str := "foo";
-               ASSERT("foo" = str);
-               ASSERT("fool" # str);
-               ASSERT("fo" # str);
-               ASSERT("bar" # str);
-               ASSERT("bar" < str);
-               ASSERT("fo" < str);
-               ASSERT("foo" <= str);
-               ASSERT("bar" <= str);
-               ASSERT("qux" > str);
-               ASSERT("foo" >= str);
-               ASSERT("qux" >= str);
+               Assert("foo" = str);
+               Assert("fool" # str);
+               Assert("fo" # str);
+               Assert("bar" # str);
+               Assert("bar" < str);
+               Assert("fo" < str);
+               Assert("foo" <= str);
+               Assert("bar" <= str);
+               Assert("qux" > str);
+               Assert("foo" >= str);
+               Assert("qux" >= str);
                strs[0] := "";
                strs[1] := "bar";
-               ASSERT(~(str = strs[1]));
-               ASSERT(str # strs[1]);
-               ASSERT(~(str < strs[1]));
-               ASSERT(~(str <= strs[1]));
-               ASSERT(str > strs[1]);
-               ASSERT(str >= strs[1]);
+               Assert(~(str = strs[1]));
+               Assert(str # strs[1]);
+               Assert(~(str < strs[1]));
+               Assert(~(str <= strs[1]));
+               Assert(str > strs[1]);
+               Assert(str >= strs[1]);
                str[0] := 7FX; str[1] := 0X;
                strs[1][0] := 80X; strs[1][1] := 0X;
-               ASSERT(str < strs[1]);
+               Assert(str < strs[1]);
 
                (*pointers*)
-               NEW(t1);
+               New(t1);
                t := t1;
-               ASSERT(t = t1);
-               ASSERT(t1 = t);
+               Assert(t = t1);
+               Assert(t1 = t);
                t := nil;
-               ASSERT((t is T) or ~(t is T)) (*The value of nil is T is undefined.*)
+               Assert((t is T) or ~(t is T)) (*The value of nil is T is undefined.*)
        end TestRelationalOperations;
 
 
@@ -256,62 +256,62 @@ Out.Integer(ORD({1, 2, a, 5, b, 8} = {1, 2, a..b, 8}), 0); Out.Ln;
                        A: Set;
        begin
                (*booleans*)
-               ASSERT(true or true);
-               ASSERT(true or false);
-               ASSERT(false or true);
+               Assert(true or true);
+               Assert(true or false);
+               Assert(false or true);
                b := true;
-               ASSERT(b or true);
-               ASSERT(b or false);
-               ASSERT(false or b);
+               Assert(b or true);
+               Assert(b or false);
+               Assert(false or b);
 
                (*integers*)
-               ASSERT(1 + 1 = 2);
-               ASSERT(1 - 1 = 0);
+               Assert(1 + 1 = 2);
+               Assert(1 - 1 = 0);
                n := 1;
-               ASSERT(+n = +1);
-               ASSERT(-n = -1);
-               ASSERT(n + 1 = 2);
-               ASSERT(n - 1 = 0);
-               ASSERT(-n + 1 = 0);
-               ASSERT(-n - 1 = -2);
+               Assert(+n = +1);
+               Assert(-n = -1);
+               Assert(n + 1 = 2);
+               Assert(n - 1 = 0);
+               Assert(-n + 1 = 0);
+               Assert(-n - 1 = -2);
 
                (*reals*)
-               ASSERT(1.0 + 1.0 >= 2.0 - eps);
-               ASSERT(1.0 + 1.0 <= 2.0 + eps);
-               ASSERT(1.0 - 1.0 >= -eps);
-               ASSERT(1.0 - 1.0 <= eps);
+               Assert(1.0 + 1.0 >= 2.0 - eps);
+               Assert(1.0 + 1.0 <= 2.0 + eps);
+               Assert(1.0 - 1.0 >= -eps);
+               Assert(1.0 - 1.0 <= eps);
                x := 1.0;
-               ASSERT(+x = +1.0);
-               ASSERT(-x = -1.0);
-               ASSERT(x + 1.0 >= 2.0 - eps);
-               ASSERT(x + 1.0 <= 2.0 + eps);
-               ASSERT(x - 1.0 >= -eps);
-               ASSERT(x - 1.0 <= eps);
-               ASSERT(-x + 1.0 >= - eps);
-               ASSERT(-x + 1.0 <= eps);
-               ASSERT(-x - 1.0 >= -2.0 - eps);
-               ASSERT(-x - 1.0 <= -2.0 + eps);
+               Assert(+x = +1.0);
+               Assert(-x = -1.0);
+               Assert(x + 1.0 >= 2.0 - eps);
+               Assert(x + 1.0 <= 2.0 + eps);
+               Assert(x - 1.0 >= -eps);
+               Assert(x - 1.0 <= eps);
+               Assert(-x + 1.0 >= - eps);
+               Assert(-x + 1.0 <= eps);
+               Assert(-x - 1.0 >= -2.0 - eps);
+               Assert(-x - 1.0 <= -2.0 + eps);
                if SYSTEM.SIZE(Real) > 8 then
                        x := 2.0E+308; (*greater than maximum value of binary64*)
-                       ASSERT(x > 1.0E+308);
-                       ASSERT(x < 3.0E+308)
+                       Assert(x > 1.0E+308);
+                       Assert(x < 3.0E+308)
                end;
 
                (*bytes*)
                y := 1;
-               ASSERT(+y = +1);
-               ASSERT(-y = -1);
-               ASSERT(y + 1= 2);
-               ASSERT(1 - y = 0);
+               Assert(+y = +1);
+               Assert(-y = -1);
+               Assert(y + 1= 2);
+               Assert(1 - y = 0);
 
                (*sets*)
-               ASSERT({0, 1} + (-{0, 1}) = -{});
-               ASSERT({0, 1} + {0, 2} = {0 .. 2});
-               ASSERT({0, 1} - {0, 2} = {1});
+               Assert({0, 1} + (-{0, 1}) = -{});
+               Assert({0, 1} + {0, 2} = {0 .. 2});
+               Assert({0, 1} - {0, 2} = {1});
                A := {0, 1};
-               ASSERT(A + (-{0, 1}) = -{});
-               ASSERT(A + {0, 2} = {0 .. 2});
-               ASSERT(A - {0, 2} = {1})
+               Assert(A + (-{0, 1}) = -{});
+               Assert(A + {0, 2} = {0 .. 2});
+               Assert(A - {0, 2} = {1})
        end TestAdditiveOperations;
 
 
@@ -324,54 +324,54 @@ Out.Integer(ORD({1, 2, a, 5, b, 8} = {1, 2, a..b, 8}), 0); Out.Ln;
                        A: Set;
        begin
                (*booleans*)
-               ASSERT(true & true);
+               Assert(true & true);
                b := true;
-               ASSERT(b & true);
+               Assert(b & true);
 
                (*integers*)
-               ASSERT(9 * 2 = 18);
-               ASSERT(9 div 4 = 2);
-               ASSERT((-9) div 4 = -3);
-               ASSERT(9 mod 4 = 1);
-               ASSERT((-9) mod 4 = 3);
+               Assert(9 * 2 = 18);
+               Assert(9 div 4 = 2);
+               Assert((-9) div 4 = -3);
+               Assert(9 mod 4 = 1);
+               Assert((-9) mod 4 = 3);
                n := -9;
                y := 4;
-               ASSERT(n * y = -36);
-               ASSERT(n div y = -3);
-               ASSERT(n mod y = 3);
+               Assert(n * y = -36);
+               Assert(n div y = -3);
+               Assert(n mod y = 3);
                i := 1;
                j := 1;
                n := (IncReturnZero(i) + 3) div (IncReturnZero(j) + 2);
-               ASSERT(n = 1);
-               ASSERT(i = 2);
-               ASSERT(j = 2);
+               Assert(n = 1);
+               Assert(i = 2);
+               Assert(j = 2);
                n := IncReturnZero(i) mod (IncReturnZero(j) + 1);
-               ASSERT(i = 3);
-               ASSERT(j = 3);
+               Assert(i = 3);
+               Assert(j = 3);
 
                (*reals*)
-               ASSERT(9.0 * 2.0 >= 18.0 - eps);
-               ASSERT(9.0 * 2.0 <= 18.0 + eps);
-               ASSERT(9.0 / 2.0 >= 4.5 - eps);
-               ASSERT(9.0 / 2.0 <= 4.5 + eps);
+               Assert(9.0 * 2.0 >= 18.0 - eps);
+               Assert(9.0 * 2.0 <= 18.0 + eps);
+               Assert(9.0 / 2.0 >= 4.5 - eps);
+               Assert(9.0 / 2.0 <= 4.5 + eps);
                x := 9.0;
-               ASSERT(x * 2.0 >= 18.0 - eps);
-               ASSERT(x * 2.0 <= 18.0 + eps);
-               ASSERT(x / 2.0 >= 4.5 - eps);
-               ASSERT(x / 2.0 <= 4.5 + eps);
+               Assert(x * 2.0 >= 18.0 - eps);
+               Assert(x * 2.0 <= 18.0 + eps);
+               Assert(x / 2.0 >= 4.5 - eps);
+               Assert(x / 2.0 <= 4.5 + eps);
 
                (*bytes*)
                y := 9;
-               ASSERT(y * 2 = 18);
-               (*ASSERT(y div 4 = 2);
-               ASSERT(y mod 4 = 1);*)
+               Assert(y * 2 = 18);
+               (*Assert(y div 4 = 2);
+               Assert(y mod 4 = 1);*)
 
                (*sets*)
-               ASSERT({0, 1} * {1, 2} = {1});
-               ASSERT({0, 1} / {1, 2} = {0, 2});
+               Assert({0, 1} * {1, 2} = {1});
+               Assert({0, 1} / {1, 2} = {0, 2});
                A := {0, 1};
-               ASSERT(A * {1, 2} = {1});
-               ASSERT(A / {1, 2} = {0, 2})
+               Assert(A * {1, 2} = {1});
+               Assert(A / {1, 2} = {0, 2})
        end TestMultiplicativeOperations;
 
 
@@ -395,82 +395,82 @@ Out.Integer(ORD({1, 2, a, 5, b, 8} = {1, 2, a..b, 8}), 0); Out.Ln;
                        x: Byte;
                        s: Set;
        begin
-               ASSERT(ABS(-1) = 1);
-               ASSERT(ABS(0) = 0);
-               ASSERT(ABS(1) = 1);
-               ASSERT(ABS(-1.0) = 1.0);
-               ASSERT(ABS(0.0) = 0.0);
-               ASSERT(ABS(1.0) = 1.0);
+               Assert(ABS(-1) = 1);
+               Assert(ABS(0) = 0);
+               Assert(ABS(1) = 1);
+               Assert(ABS(-1.0) = 1.0);
+               Assert(ABS(0.0) = 0.0);
+               Assert(ABS(1.0) = 1.0);
                i := 0;
                j := ABS(IncReturnZero(i) - 1);
-               ASSERT(j = 1);
-               ASSERT(i = 1);
+               Assert(j = 1);
+               Assert(i = 1);
 
                a := "";
-               ASSERT(LEN(a) = 10);
+               Assert(LEN(a) = 10);
 
-               ASSERT(LSL(0, 0) = 0);
-               ASSERT(LSL(0, 1) = 0);
-               ASSERT(LSL(1, 0) = 1);
-               ASSERT(LSL(1, 1) = 2);
+               Assert(LSL(0, 0) = 0);
+               Assert(LSL(0, 1) = 0);
+               Assert(LSL(1, 0) = 1);
+               Assert(LSL(1, 1) = 2);
 
-               ASSERT(ASR(0, 0) = 0);
-               ASSERT(ASR(0, 1) = 0);
-               ASSERT(ASR(1, 0) = 1);
-               ASSERT(ASR(1, 1) = 0);
+               Assert(ASR(0, 0) = 0);
+               Assert(ASR(0, 1) = 0);
+               Assert(ASR(1, 0) = 1);
+               Assert(ASR(1, 1) = 0);
 
-               ASSERT(ROR(0, 1) = 0);
-               ASSERT(ROR(2, 1) = 1);
+               Assert(ROR(0, 1) = 0);
+               Assert(ROR(2, 1) = 1);
                i := 0;
                j := 0;
                k := ROR(IncReturnZero(i) + 2, IncReturnZero(j) + 1);
-               ASSERT(k = 1);
-               ASSERT(i = 1);
-               ASSERT(j = 1);
+               Assert(k = 1);
+               Assert(i = 1);
+               Assert(j = 1);
 
-               ASSERT(FLOOR(-1.5) = -2);
-               ASSERT(FLOOR(0.0) = 0);
-               ASSERT(FLOOR(1.5) = 1);
+               Assert(FLOOR(-1.5) = -2);
+               Assert(FLOOR(0.0) = 0);
+               Assert(FLOOR(1.5) = 1);
                i := 0;
                j := FLOOR(FLT(IncReturnZero(i)) + 1.5);
-               ASSERT(j = 1);
-               ASSERT(i = 1);
+               Assert(j = 1);
+               Assert(i = 1);
 
-               ASSERT(FLT(-1) = -1.0);
-               ASSERT(FLT(0) = 0.0);
-               ASSERT(FLT(1) = 1.0);
+               Assert(FLT(-1) = -1.0);
+               Assert(FLT(0) = 0.0);
+               Assert(FLT(1) = 1.0);
 
-               ASSERT(ORD(0X) = 0);
+               Assert(ORD(0X) = 0);
                ch := 0X;
-               ASSERT(ORD(ch) = 0);
-               ASSERT(ORD("A") = 41H);
+               Assert(ORD(ch) = 0);
+               Assert(ORD("A") = 41H);
                ch := "A";
-               ASSERT(ORD(ch) = 41H);
-               ASSERT(ORD(0FFX) = 0FFH);
+               Assert(ORD(ch) = 41H);
+               Assert(ORD(0FFX) = 0FFH);
                ch := 0FFX;
-               ASSERT(ORD(ch) = 0FFH);
+               Assert(ORD(ch) = 0FFH);
 
-               ASSERT(ORD(false) = 0);
+               Assert(ORD(false) = 0);
                b := false;
-               ASSERT(ORD(b) = 0);
-               ASSERT(ORD(true) = 1);
+               Assert(ORD(b) = 0);
+               Assert(ORD(true) = 1);
                b := true;
-               ASSERT(ORD(b) = 1);
+               Assert(ORD(b) = 1);
 
-               ASSERT(ORD({}) = 0);
+               Assert(ORD({}) = 0);
                s := {};
-               ASSERT(ORD(s) = 0);
-               ASSERT(ORD({8}) = 256);
+               Assert(ORD(s) = 0);
+               Assert(ORD({8}) = 256);
                s := {8};
-               ASSERT(ORD(s) = 256);
+               Assert(ORD(s) = 256);
 
-               ASSERT(CHR(0) = 0X);
-               ASSERT(CHR(1) = 1X);
-               ASSERT(CHR(7FH) = 7FX);
+               Assert(CHR(0) = 0X);
+               Assert(CHR(1) = 1X);
+               Assert(CHR(7FH) = 7FX);
                ch := 7FX;
-               ASSERT(CHR(7FH) = ch);
+               Assert(CHR(7FH) = ch);
                x := 1;
-               ASSERT(CHR(x) = 1X);
+               Assert(CHR(x) = 1X);
 
                i := absConst;
                i := lslConst;

diff --git a/tests/obnc/passing/T5Statements.obn b/tests/obnc/passing/T5Statements.obn
index db6d9247fa0244fe087559892fff46380e044adf..3b89f4490198aeb60cf19cca745485e92c0651dd 100644 (file)
--- a/tests/obnc/passing/T5Statements.obn
+++ b/tests/obnc/passing/T5Statements.obn
@@ -52,30 +52,30 @@ module T5Statements;
                b := true;
                b1 := false;
                b := b1;
-               ASSERT(b = b1);
+               Assert(b = b1);
                ch := "a";
                ch1 := 22X;
                ch := ch1;
-               ASSERT(ch = ch1);
+               Assert(ch = ch1);
                n := 0;
                n1 := -1;
                n := n1;
-               ASSERT(n = n1);
+               Assert(n = n1);
                x := 0.0;
                x1 := -1.0;
                x := x1;
-               ASSERT(x = x1);
+               Assert(x = x1);
                y := 0;
                y1 := 255;
                y := y1;
-               ASSERT(y = y1);
+               Assert(y = y1);
                n := 0;
                y := n;
-               ASSERT(y = n);
+               Assert(y = n);
                A := {};
                A1 := {0, 1};
                A := A1;
-               ASSERT(A = A1);
+               Assert(A = A1);
        end TestBasicAssignments;
 
 
@@ -93,38 +93,38 @@ module T5Statements;
                        var t: array 128 of Char;
                begin
                        t := s;
-                       ASSERT(t = s)
+                       Assert(t = s)
                end AssignOpenArray;
 
                procedure AssignMultiDimOpenArray(s: array of array of String);
                        var t: array 2 of String;
                begin
                        t := s[0];
-                       ASSERT(t[0] = s[0, 0]);
-                       ASSERT(t[1] = s[0, 1])
+                       Assert(t[0] = s[0, 0]);
+                       Assert(t[1] = s[0, 1])
                end AssignMultiDimOpenArray;
 
        begin
                str := "testing, testing...";
                str1 := "more testing...";
                str := str1;
-               ASSERT(str = str1);
+               Assert(str = str1);
                AssignString(str);
-               ASSERT(str = "hello");
+               Assert(str = "hello");
                AssignOpenArray("hello");
                
                strs[0] := "foo";
-               ASSERT(strs[0] = "foo");
+               Assert(strs[0] = "foo");
                strs[1] := "bar";
-               ASSERT(strs[1] = "bar");
+               Assert(strs[1] = "bar");
                strs[1] := strs[0];
-               ASSERT(strs[1] = "foo");
+               Assert(strs[1] = "foo");
                
                strs[0] := "foo";
                strs[1] := "bar";
                strs1 := strs;
-               ASSERT(strs1[0] = "foo");
-               ASSERT(strs1[1] = "bar");
+               Assert(strs1[0] = "foo");
+               Assert(strs1[1] = "bar");
                
                AssignMultiDimOpenArray(strs2)
        end TestArrayAssignments;
@@ -140,7 +140,7 @@ module T5Statements;
 
                procedure P(var s: ShapeDesc);
                begin
-                       ASSERT(s is CircleDesc);
+                       Assert(s is CircleDesc);
                        s(CircleDesc) := s(CircleDesc);
                        s(CircleDesc).r := 1.0
                end P;
@@ -153,17 +153,17 @@ module T5Statements;
        begin
                foo.i := 37;
                bar := foo;
-               ASSERT(bar.i = 37);
+               Assert(bar.i = 37);
 
                s.x := 0.0;
                s.y := 0.0;
                r.x := 0.0;
                P(c);
-               ASSERT(ABS(c.r - 1.0) < eps);
+               Assert(ABS(c.r - 1.0) < eps);
 
                r.x := 1.0;
                s := r;
-               ASSERT(s.x = r.x);
+               Assert(s.x = r.x);
 
                P(a[9]);
 
@@ -178,14 +178,14 @@ module T5Statements;
                        r: pointer to RectangleDesc;
                        r1: pointer to RectangleDesc;
        begin
-               NEW(x);
+               New(x);
                y := x;
-               ASSERT(y is Rectangle);
-               NEW(r);
+               Assert(y is Rectangle);
+               New(r);
                s := r;
-               ASSERT(s is RectangleDesc);
+               Assert(s is RectangleDesc);
                r1 := r;
-               ASSERT(r1 is RectangleDesc)
+               Assert(r1 is RectangleDesc)
        end TestPointerAssignments;
 
 
@@ -274,7 +274,7 @@ module T5Statements;
 
                procedure P7(var t: T0);
                begin
-                       ASSERT(t is T1)
+                       Assert(t is T1)
                end P7;
 
        begin
@@ -287,7 +287,7 @@ module T5Statements;
                P6("test");
                s := "test";
                P6(s);
-               NEW(p1);
+               New(p1);
                p0 := p1;
                P7(p0^)
        end TestProcedureCalls;
@@ -311,60 +311,60 @@ module T5Statements;
        begin
                n := 0;
                INC(n);
-               ASSERT(n = 1);
+               Assert(n = 1);
 
                n := 0;
                INC(n, 10);
-               ASSERT(n = 10);
+               Assert(n = 10);
 
                n := 0;
                DEC(n);
-               ASSERT(n = -1);
+               Assert(n = -1);
 
                n := 0;
                DEC(n, 10);
-               ASSERT(n = -10);
+               Assert(n = -10);
 
                A := {};
                INCL(A, 0);
-               ASSERT(A = {0});
+               Assert(A = {0});
 
                A := {0};
                EXCL(A, 0);
-               ASSERT(A = {});
+               Assert(A = {});
 
-               NEW(v);
-               ASSERT(v # nil);
+               New(v);
+               Assert(v # nil);
                v.f := 1;
-               ASSERT(v.f = 1);
+               Assert(v.f = 1);
 
                x := 1.0;
                PACK(x, 2);
-               ASSERT(x >= 4.0 - eps);
-               ASSERT(x <= 4.0 + eps);
+               Assert(x >= 4.0 - eps);
+               Assert(x <= 4.0 + eps);
                a[0] := 1.0;
                i := 0;
                j := 0;
                PACK(a[IncReturnZero(i)], IncReturnZero(j) + 2);
-               ASSERT(a[0] >= 4.0 - eps);
-               ASSERT(a[0] <= 4.0 + eps);
-               ASSERT(i = 1);
-               ASSERT(j = 1);
+               Assert(a[0] >= 4.0 - eps);
+               Assert(a[0] <= 4.0 + eps);
+               Assert(i = 1);
+               Assert(j = 1);
 
                x := 4.0;
                UNPK(x, n);
-               ASSERT(x >= 1.0);
-               ASSERT(x < 2.0);
-               ASSERT(n = 2);
+               Assert(x >= 1.0);
+               Assert(x < 2.0);
+               Assert(n = 2);
                a[0] := 4.0;
                i := 0;
                j := 0;
                UNPK(a[IncReturnZero(i)], b[IncReturnZero(j)]);
-               ASSERT(a[0] >= 1.0);
-               ASSERT(a[0] < 2.0);
-               ASSERT(b[0] = 2);
-               ASSERT(i = 1);
-               ASSERT(j = 1)
+               Assert(a[0] >= 1.0);
+               Assert(a[0] < 2.0);
+               Assert(b[0] = 2);
+               Assert(i = 1);
+               Assert(j = 1)
        end TestPredeclaredProperProcedures;
 
 
@@ -375,14 +375,14 @@ module T5Statements;
                if n = 0 then
                        n := 1
                end;
-               ASSERT(n = 1);
+               Assert(n = 1);
                n := 1;
                if n = 0 then
                        n := 1
                else
                        n := 2
                end;
-               ASSERT(n = 2);
+               Assert(n = 2);
                n := 2;
                if n = 0 then
                        n := 1
@@ -391,7 +391,7 @@ module T5Statements;
                else
                        n := 3
                end;
-               ASSERT(n = 3)
+               Assert(n = 3)
        end TestIfStatements;
 
 
@@ -432,7 +432,7 @@ module T5Statements;
                        | 10, 12 .. 20:
                                n := 0
                end;
-               ASSERT(n = 0);
+               Assert(n = 0);
                ch := "u";
                case ch of
                        | 0X:
@@ -442,8 +442,8 @@ module T5Statements;
                        | "l", "m" .. "z":
                                ch := 0X
                end;
-               ASSERT(ch = 0X);
-               NEW(rp);
+               Assert(ch = 0X);
+               New(rp);
                sp := rp;
                case sp of
                          (*Shape:
@@ -454,10 +454,10 @@ module T5Statements;
                        | Circle:
                                sp.r := 1.0
                end;
-               ASSERT(sp(Rectangle).w = 1.0);
-               ASSERT(sp(Rectangle).h = 2.0);
+               Assert(sp(Rectangle).w = 1.0);
+               Assert(sp(Rectangle).h = 2.0);
                P(c);
-               ASSERT(c.r = 1.0);
+               Assert(c.r = 1.0);
        end TestCaseStatements;
 
 
@@ -470,7 +470,7 @@ module T5Statements;
                        n := n + 1;
                        i := i + 1
                end;
-               ASSERT(n = 10);
+               Assert(n = 10);
                n := 4;
                n1 := 6;
                while n > n1 do
@@ -478,8 +478,8 @@ module T5Statements;
                elsif n1 > n do
                        n1 := n1 - n
                end;
-               ASSERT(n = 2);
-               ASSERT(n1 = 2);
+               Assert(n = 2);
+               Assert(n1 = 2);
                n := 5;
                n1 := 6;
                while n > n1 do
@@ -487,8 +487,8 @@ module T5Statements;
                elsif n1 > n do
                        n1 := n1 - n
                end;
-               ASSERT(n = 1);
-               ASSERT(n1 = 1);
+               Assert(n = 1);
+               Assert(n1 = 1);
        end TestWhileStatements;
 
 
@@ -501,7 +501,7 @@ module T5Statements;
                        INC(n);
                        INC(i)
                until i = 11;
-               ASSERT(n = 10);
+               Assert(n = 10);
        end TestRepeatStatements;
 
 
@@ -520,22 +520,22 @@ module T5Statements;
                for i := 1 to 10 do
                        n := n + 1
                end;
-               ASSERT(n = 10);
+               Assert(n = 10);
                n := 0;
                for i := 1 to 20 by 2 do
                        n := n + 1
                end;
-               ASSERT(n = 10);
+               Assert(n = 10);
                n := 0;
                for i := 20 to 1 by -2 do
                        n := n + 1
                end;
-               ASSERT(n = 10);
+               Assert(n = 10);
                globalInteger := 0;
                for i := 0 to IncGlobalIntegerReturnOne() do (*make sure the limit function is called three times*)
                        x := x + 1.0
                end;
-               ASSERT(globalInteger = 3)
+               Assert(globalInteger = 3)
        end TestForStatements;
 
 begin

diff --git a/tests/obnc/passing/T5SystemStatements.obn b/tests/obnc/passing/T5SystemStatements.obn
index 32c8d2a23b69123eecd006d291a24903543e82c9..847eccc58248ad6f84c88b7c6b4efad82bcd5596 100644 (file)
--- a/tests/obnc/passing/T5SystemStatements.obn
+++ b/tests/obnc/passing/T5SystemStatements.obn
@@ -33,60 +33,60 @@ module T5SystemStatements;
                        a, a1: Array;
                        a2: array SYSTEM.SIZE(Array) + 1 of Int;
        begin
-               ASSERT(SYSTEM.SIZE(Int) = SYSTEM.SIZE(Pointer));
+               Assert(SYSTEM.SIZE(Int) = SYSTEM.SIZE(Pointer));
 
                (*ADR, PUT, GET*)
                b := true;
                SYSTEM.GET(SYSTEM.ADR(b), b1);
-               ASSERT(b1 = b);
+               Assert(b1 = b);
                SYSTEM.PUT(SYSTEM.ADR(b), false);
-               ASSERT(~b);
+               Assert(~b);
                ch := "a";
                SYSTEM.GET(SYSTEM.ADR(ch), ch1);
-               ASSERT(ch1 = ch);
+               Assert(ch1 = ch);
                SYSTEM.PUT(SYSTEM.ADR(ch), "b");
-               ASSERT(ch = "b");
+               Assert(ch = "b");
                SYSTEM.PUT(SYSTEM.ADR(ch), ch1);
-               ASSERT(ch = ch1);
+               Assert(ch = ch1);
                i := 1;
                SYSTEM.GET(SYSTEM.ADR(i), i1);
-               ASSERT(i1 = i);
+               Assert(i1 = i);
                SYSTEM.PUT(SYSTEM.ADR(i), 0);
-               ASSERT(i = 0);
+               Assert(i = 0);
                r := 1.0;
                SYSTEM.GET(SYSTEM.ADR(r), r1);
-               ASSERT(r1 = r);
+               Assert(r1 = r);
                SYSTEM.PUT(SYSTEM.ADR(r), 0.0);
-               ASSERT(r = 0.0);
+               Assert(r = 0.0);
                x := 1;
                SYSTEM.GET(SYSTEM.ADR(x), x1);
-               ASSERT(x1 = x);
+               Assert(x1 = x);
                SYSTEM.PUT(SYSTEM.ADR(x), 0);
-               ASSERT(x = 0);
+               Assert(x = 0);
                s := {0};
                SYSTEM.GET(SYSTEM.ADR(s), s1);
-               ASSERT(s1 = s);
+               Assert(s1 = s);
                SYSTEM.PUT(SYSTEM.ADR(s), {});
-               ASSERT(s = {});
+               Assert(s = {});
 
                (*BIT*)
                i := 1;
-               ASSERT(SYSTEM.BIT(SYSTEM.ADR(i), 0));
+               Assert(SYSTEM.BIT(SYSTEM.ADR(i), 0));
                i := 2;
-               ASSERT(~SYSTEM.BIT(SYSTEM.ADR(i), 0));
-               ASSERT(SYSTEM.BIT(SYSTEM.ADR(i), 1));
+               Assert(~SYSTEM.BIT(SYSTEM.ADR(i), 0));
+               Assert(SYSTEM.BIT(SYSTEM.ADR(i), 1));
 
                (*COPY*)
                a[0] := 1; a[1] := 2;
                SYSTEM.COPY(SYSTEM.ADR(a), SYSTEM.ADR(a1), 2);
-               ASSERT(a1[0] = 1);
-               ASSERT(a1[1] = 2);
+               Assert(a1[0] = 1);
+               Assert(a1[1] = 2);
 
                (*VAL*)
                xs[0] := 1; xs[1] := 2;
                SYSTEM.PUT(SYSTEM.ADR(xs), SYSTEM.VAL(Byte, 37));
-               ASSERT(xs[0] = 37);
-               ASSERT(xs[1] = 2);
+               Assert(xs[0] = 37);
+               Assert(xs[1] = 2);
 
                (*silence "unused" compiler notifications*)
                x := byte;

diff --git a/tests/obnc/passing/T6ProcedureDeclarations.obn b/tests/obnc/passing/T6ProcedureDeclarations.obn
index f6c113a7e94b16a5bfd968edbcab69e6b76491cf..268d0fd90f678afef5cf81ecba1da84ec9a89fac 100644 (file)
--- a/tests/obnc/passing/T6ProcedureDeclarations.obn
+++ b/tests/obnc/passing/T6ProcedureDeclarations.obn
@@ -51,8 +51,8 @@ module T6ProcedureDeclarations;
 
                procedure P3(A: Matrix);
                begin
-                       ASSERT(LEN(A) = 10);
-                       ASSERT(LEN(A[0]) = 20)
+                       Assert(LEN(A) = 10);
+                       Assert(LEN(A[0]) = 20)
                end P3;
 
                procedure P4(A: array of Row);
@@ -60,7 +60,7 @@ module T6ProcedureDeclarations;
 
        begin
                P(0);
-               NEW(ptr);
+               New(ptr);
                P1(ptr);
                P2(proc);
                P3(A);
@@ -75,14 +75,14 @@ module T6ProcedureDeclarations;
 
                procedure Alloc(var p: Ptr);
                begin
-                       NEW(p);
+                       New(p);
                        p.f := 1
                end Alloc;
 
                procedure P(var A: Matrix);
                begin
-                       ASSERT(LEN(A) = 10);
-                       ASSERT(LEN(A[0]) = 20)
+                       Assert(LEN(A) = 10);
+                       Assert(LEN(A[0]) = 20)
                end P;
 
                procedure Q(var x: T0);
@@ -96,7 +96,7 @@ module T6ProcedureDeclarations;
 
        begin
                Alloc(x);
-               ASSERT(x.f = 1);
+               Assert(x.f = 1);
                P(A);
                y.f := 0;
                Q(y)
@@ -114,7 +114,7 @@ module T6ProcedureDeclarations;
                        var i: Int;
                begin
                        for i := 0 to LEN(a) - 1 do
-                               ASSERT(a[i] = i + 1)
+                               Assert(a[i] = i + 1)
                        end
                end P;
 
@@ -127,7 +127,7 @@ module T6ProcedureDeclarations;
                                c := 0;
                                for i := 0 to LEN(M) - 1 do
                                        for j := 0 to LEN(M[0]) - 1 do
-                                               ASSERT(M[i, j] = c);
+                                               Assert(M[i, j] = c);
                                                INC(c)
                                        end
                                end;
@@ -138,7 +138,7 @@ module T6ProcedureDeclarations;
                        begin
                                c := LEN(row);
                                for j := 0 to LEN(row) - 1 do
-                                       ASSERT(row[j] = c);
+                                       Assert(row[j] = c);
                                        INC(c)
                                end
                        end Inner1;
@@ -156,7 +156,7 @@ module T6ProcedureDeclarations;
                        for i := 0 to LEN(T) - 1 do
                                for j := 0 to LEN(T[0]) - 1 do
                                        for k := 0 to LEN(T[0, 0]) - 1 do
-                                               ASSERT(T[i, j, k] = c);
+                                               Assert(T[i, j, k] = c);
                                                INC(c)
                                        end
                                end
@@ -199,7 +199,7 @@ module T6ProcedureDeclarations;
                        type PtrExt = pointer to record (Ptr) end;
                        var y: PtrExt;
                begin
-                       NEW(y)
+                       New(y)
                return y
                end P;
 
@@ -229,7 +229,7 @@ module T6ProcedureDeclarations;
 
        begin
                s := Sum(10);
-               ASSERT(s = 55)
+               Assert(s = 55)
        end TestLocalProcedures;
 
 

diff --git a/tests/obnc/passing/T7Modules.obn b/tests/obnc/passing/T7Modules.obn
index 09b9526f2a70e417385677898902c46aea46d97d..9fc125ff827b057827ea77dd9160b2a577a38cd6 100644 (file)
--- a/tests/obnc/passing/T7Modules.obn
+++ b/tests/obnc/passing/T7Modules.obn
@@ -44,41 +44,41 @@ module T7Modules;
                p1: ListExt;
 
 begin
-       ASSERT(A.boolConst);
-       ASSERT(A.charConst = CHR(22H));
-       ASSERT(A.intConst = 1);
-       ASSERT(A.realConst = 2.3);
-       ASSERT(A.strConst = "hello there");
-       ASSERT(A.nul = 0X);
-       ASSERT(A.lf = 0AX);
-       ASSERT(A.charMax = 0FFX);
-       ASSERT(A.setConst = {0, 2, 3, 5});
+       Assert(A.boolConst);
+       Assert(A.charConst = CHR(22H));
+       Assert(A.intConst = 1);
+       Assert(A.realConst = 2.3);
+       Assert(A.strConst = "hello there");
+       Assert(A.nul = 0X);
+       Assert(A.lf = 0AX);
+       Assert(A.charMax = 0FFX);
+       Assert(A.setConst = {0, 2, 3, 5});
 
-       ASSERT(A.boolVar = A.boolConst);
-       ASSERT(A.charVar = A.charConst);
-       ASSERT(A.intVar = A.intConst);
-       ASSERT(ABS(A.realVar - A.realConst) < 1.0E-6);
-       ASSERT(A.strVar = A.strConst);
-       ASSERT(A.setVar = A.setConst);
-       ASSERT(A.recVar.f = 1);
+       Assert(A.boolVar = A.boolConst);
+       Assert(A.charVar = A.charConst);
+       Assert(A.intVar = A.intConst);
+       Assert(ABS(A.realVar - A.realConst) < 1.0E-6);
+       Assert(A.strVar = A.strConst);
+       Assert(A.setVar = A.setConst);
+       Assert(A.recVar.f = 1);
 
        intVar := A.intVar;
        A.procVar(A.strVar);
-       NEW(y.f);
+       New(y.f);
        y.f.f := 1;
        w := x;
        A.Q(x);
-       NEW(list);
+       New(list);
        A.R(matrix);
        x0 := x1;
        A.S(t);
        A.S1(p);
        
-       ASSERT(D.b);
-       ASSERT(E.b);
-       ASSERT(T7Modules.b);
-       ASSERT(lib1M.b);
-       ASSERT(OBNC.b);
+       Assert(D.b);
+       Assert(E.b);
+       Assert(T7Modules.b);
+       Assert(lib1M.b);
+       Assert(OBNC.b);
        p1 := nil
 end T7Modules.