mktests

<B>Digital的Unix操作系统VAX 4.2源码</B>

p2 (from_main)
int from_main;
{
    printf("in p2(%d)\n", from_main);
    global = 9;
}

p3 (s)
char s[];
{
    printf("in p3(%s)\n", s);
    global = 10;
}
'endcat'

echo tests/cc/nested.c
rm -f tests/cc/nested.c
cat > tests/cc/nested.c <<'endcat'
/*
 * Test of nested blocks.
 */
 
int i;

main ()
{
    i = 3;
    sub();
}

sub ()
{
    int i, j;

    for (i = 1; i <= 10; i++) {
	int j;

	j = j + i;
    }
    j = 0;
    for (i = 11; i <= 20; i++) {
	j = j + i;
    }
}

after ()
{
    int a;

    a = 3;
}
'endcat'

echo tests/cc/sleep.out
rm -f tests/cc/sleep.out
cat > tests/cc/sleep.out <<'endcat'
reading symbolic information ...
about to sleepdone

execution completed, exit code is 0

'endcat'

echo tests/cc/nested.in
rm -f tests/cc/nested.in
cat > tests/cc/nested.in <<'endcat'
stop at 20
run
where
print sub.i, sub.j
delete 1
stop at 24
cont
where
print sub.i, sub.j
print .i
'endcat'

echo tests/cc/strings.c
rm -f tests/cc/strings.c
cat > tests/cc/strings.c <<'endcat'
/*
 * Test of displaying strings compiled into the text segment via -R.
 */

char str[] = "this is a test";

main ()
{
    f("parameter test");
}

f (s)
char *s;
{
    abort();
}
'endcat'

echo tests/cc/strings.in
rm -f tests/cc/strings.in
cat > tests/cc/strings.in <<'endcat'
where
print str
'endcat'

echo tests/cc/arrays.c
rm -f tests/cc/arrays.c
cat > tests/cc/arrays.c <<'endcat'
/*
 * Test of debugging arrays in C.
 */

int a[10], *b;

p (i, a, j)
int i, a[], j;
{
    a[3] = i;
    a[4] = j;
}

main ()
{
    int i;

    b = a;
    for (i = 0; i < 10; i++) {
	a[i] = i;
    }
    p(4, a, 5);
}
'endcat'

echo tests/cc/strings.out
rm -f tests/cc/strings.out
cat > tests/cc/strings.out <<'endcat'
reading symbolic information ...
abort at 0x9f
f(s = "parameter test"), line 15 in "strings.c"
main(0x1, 0x7fffed74, 0x7fffed7c), line 9 in "strings.c"
"this is a test" 

'endcat'

echo tests/cc/arrays.in
rm -f tests/cc/arrays.in
cat > tests/cc/arrays.in <<'endcat'
whatis p.a
stop at 10
run
print .a
step
print a[3], a[4], a[5]
step
print .a
'endcat'

echo tests/cc/call.in
rm -f tests/cc/call.in
cat > tests/cc/call.in <<'endcat'
call printf("starting")
stop at 15
run
call p1()
call p2(3)
call p3("blah")
call printf("main_local = %d", main_local)
print main_local
call call
call call()
call p1(3)
call p2("blah")
'endcat'

echo tests/cc/call.out
rm -f tests/cc/call.out
cat > tests/cc/call.out <<'endcat'
reading symbolic information ...
starting
printf returns successfully
[2] stop at 15
in p1
in p2(3)
in p3(blah)
main_local = 19[2] stopped in main at line 15
   15       p1();

p1 returns successfully

p2 returns successfully

p3 returns successfully

printf returns successfully
19 
call call
         ^ syntax error
"call" not call-able
too many parameters in call to p1
type mismatch for from_main in call to p2

'endcat'

echo tests/mod/Makefile
rm -f tests/mod/Makefile
cat > tests/mod/Makefile <<'endcat'
#
# Makefile for testing dbx.
#

.SUFFIXES:

.SUFFIXES: .mod .def .pcd .s .o .x .t .in .tst .out

MOD = mod
TESTDBX = ../../tdbx
TESTS = imports.t arrays.t records.t procvars.t sets.t \
    nested.t reals.t call.t assign.t recur.t jsb.t stkcmds.t

PROGS = imports.x arrays.x records.x procvars.x sets.x \
    nested.x reals.x call.x assign.x recur.x jsb.x stkcmds.x

#
# Suffix conventions:
#
#	.mod	Modula-2 source
#	.def	Modula-2 definitions file
#	.pcd	P-code intermediate source
#	.s	assembly code file
#	.o	object file
#	.x	executable file
#	.t	dummy file represented last time tested
#	.in	input for testing
#	.tst	test output
#	.out	expected output
#

.mod.x:
	${MOD} -g $*.mod -o tmp
	mv tmp $*.x

.mod.o:
	${MOD} -c -g $*.mod

.def.mod:
	touch $*.mod

.in.tst:
	csh -f -c "${TESTDBX} $*.x < $*.in |& tail +3 >! $*.tst"

.x.t:
	@echo "    $*"
	@rm -f tmp
	@csh -f -c "${TESTDBX} $*.x < $*.in |& tail +3 > tmp"
	@check tmp $*.out
	@rm -f tmp
	@rm -f $*.t
	@touch $*.t

passed: ${PROGS} beforemsg ${TESTS}
	@echo "passed Modula-2 tests"

beforemsg:
	@echo ""
	@echo "Modula-2 tests:"

IMPORTSOBJ = imports.o imported.o imptypes.o

imports.x: ${IMPORTSOBJ}
	${MOD} -g ${IMPORTSOBJ} -o tmp
	mv tmp imports.x

jsb.x: jsb.mod
	${MOD} -O -g jsb.mod -o tmp
	mv tmp jsb.x

imports.t: imports.x ${TESTDBX}
arrays.t: arrays.x ${TESTDBX}
records.t: records.x ${TESTDBX}
procvars.t: procvars.x ${TESTDBX}
sets.t: sets.x ${TESTDBX}
nested.t: nested.x ${TESTDBX}
reals.t: reals.x ${TESTDBX}
call.t: call.x ${TESTDBX}
assign.t: assign.x ${TESTDBX}
recur.t: recur.x ${TESTDBX}
jsb.t: jsb.x ${TESTDBX}
stkcmds.t: stkcmds.x ${TESTDBX}
'endcat'

echo tests/mod/check
rm -f tests/mod/check
cat > tests/mod/check <<'endcat'
#! /bin/csh -f

#
# check <test output> <expected output>
#
# Check to see if test output matches expected output.
# If not, run diff and ask if differences are "ok".  If so,
# install new output as expected output.
#

cmp -s $1 $2
if ($status != 0) then
    diff $1 $2
    echo -n "ok? "
    if ($< != y) then
	exit 1
    endif
    mv $1 $2
endif
exit 0
'endcat'

echo tests/mod/imports.in
rm -f tests/mod/imports.in
cat > tests/mod/imports.in <<'endcat'
whereis v
whereis p
whatis main.p
whatis main.T
whatis main.OT
whatis imported.p
stop in imported.Blah
run
where
'endcat'

echo tests/mod/records.mod
rm -f tests/mod/records.mod
cat > tests/mod/records.mod <<'endcat'
module main;
type
    Rec = record
	charValue : char;
	intValue : integer;
	subrange : [0..1000];
	realValue : real;
    end;
var
    r : Rec;
begin
    r.charValue := 'c';
    r.intValue := 3;
    r.subrange := 10;
    r.realValue := 3.4;
end main.
'endcat'

echo tests/mod/records.in
rm -f tests/mod/records.in
cat > tests/mod/records.in <<'endcat'
whatis Rec
whatis r
run
print r
print r.realValue, r.subrange, r.intValue, r.charValue
'endcat'

echo tests/mod/imports.mod
rm -f tests/mod/imports.mod
cat > tests/mod/imports.mod <<'endcat'
module main;
from imptypes import RT;
import imported;
type
    RT = pointer to record
	i, j : integer;
    end;
var
    p : imported.T;
    q : imported.OT;
    r : RT;
begin
    new(r);
    r^.i := 3;
    r^.j := 4;
    imported.Blah;
end main.
'endcat'

echo tests/mod/imported.def
rm -f tests/mod/imported.def
cat > tests/mod/imported.def <<'endcat'
definition module imported;
export qualified Blah, T, OT;
export v;

type
    OT;
    T = record
	a, b : integer;
    end;

var v : integer;

procedure Blah ;

end imported.
'endcat'

echo tests/mod/imported.mod
rm -f tests/mod/imported.mod
cat > tests/mod/imported.mod <<'endcat'
implementation module imported;

type
    OT = integer;
var
    p : OT;

procedure Blah;
begin
    p := 3;
end Blah;

end imported.
'endcat'

echo tests/mod/imports.out
rm -f tests/mod/imports.out
cat > tests/mod/imports.out <<'endcat'
reading symbolic information ...
.v
mem.modmalloc.p mem.Storage_DEALLOCATE.p mem.Storage_ALLOCATE.p imported.p main.p
var p : main.T;
type T = record
    a : integer;
    b : integer;
end;
type OT = integer;
var p : integer;
[1] stop in Blah
[1] stopped in Blah at line 8 in file "imported.mod"
    8   procedure Blah;
Blah, line 8 in "imported.mod"
_init(0x1, 0x7fffed74, 0x7fffed7c), line 16 in "imports.mod"

'endcat'

echo tests/mod/records.out
rm -f tests/mod/records.out
cat > tests/mod/records.out <<'endcat'
reading symbolic information ...
type Rec = record
    charValue : char;
    intValue : integer;
    subrange : 0..1000;
    realValue : real;
end;
var r : Rec;

execution completed, exit code is 0
(charValue = 'c', intValue = 3, subrange = 10, realValue = 3.4) 
3.4 10 3 'c' 

'endcat'

echo tests/mod/arrays.mod
rm -f tests/mod/arrays.mod
cat > tests/mod/arrays.mod <<'endcat'
module main;
type
    Color = (RED, BLUE, GREEN);
var
    a : array [1..10] of integer;
    i : integer;
    b : array Color of integer;
    c : Color;

procedure p (i : integer; var a : array of integer; j : integer);
begin
    a[3] := i;
    a[4] := j;
end p;

begin
    for i := 1 to 10 do
	a[i] := i;
    end;
    p(4, a, 5);
    b[BLUE] := 3;
    c := RED;
end main.
'endcat'

echo tests/mod/sets.in
rm -f tests/mod/sets.in
cat > tests/mod/sets.in <<'endcat'
whatis Color
whatis ColorSet
stop in p
run
step
where
step
print sets.s
step
step
where
print sets.s
'endcat'

echo tests/mod/arrays.in
rm -f tests/mod/arrays.in
cat > tests/mod/arrays.in <<'endcat'
whatis p.a
stop at 12
run
print a
print a[3], a[4], a[5]
step
step
where
print b, c
'endcat'

echo tests/mod/arrays.out
rm -f tests/mod/arrays.out
cat > tests/mod/arrays.out <<'endcat'
reading symbolic information ...
(var parameter) a : array[integer] of integer;
[1] stop at "arrays.mod":12
[1] stopped in p at line 12 in file "arrays.mod"
   12       a[3] := i;
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 
4 5 6 
stopped in p at line 13 in file "arrays.mod"
   13       a[4] := j;
stopped in _init at line 21 in file "arrays.mod"
   21       b[BLUE] := 3;
_init(0x1, 0x7fffed74, 0x7fffed7c), line 21 in "arrays.mod"
(0, 0, 0) RED 

'endcat'

echo tests/mod/sets.mod
rm -f tests/mod/sets.mod
cat > tests/mod/sets.mod <<'endcat'
module sets;
type
    Color = (RED, BLUE, GREEN);
    ColorSet = set of Color;
var
    s : ColorSet;

procedure p (var s : ColorSet);
begin
    s := ColorSet{RED, BLUE};
end p;

begin
    p(s);
    if BLUE in s then
	s := s - ColorSet{BLUE};
    end;
end sets.
'endcat'

echo tests/mod/variants.mod
rm -f tests/mod/variants.mod
cat > tests/mod/variants.mod <<'endcat'
module main;
type
    ElementType = (CHAR, INT, REAL);
    VR = record
	case tag : ElementType of
	    CHAR:
		charValue : char;|
	    INT:
		intValue : integer;|
	    REAL:
		realValue : real;
	end;
    end;
var
    vr : VR;
begin
    vr.tag := CHAR;
    vr.charValue := 'c';
    vr.tag := INT;
    vr.intValue := 3;
    vr.tag := REAL;
    vr.realValue := 3.4;
end main.
'endcat'

echo tests/mod/stkcmds.mod
rm -f tests/mod/stkcmds.mod
cat > tests/mod/stkcmds.mod <<'endcat'
module main;
var
    i : integer;

procedure p2 (i : integer);
begin
    if i < 5 then
	p2(i+1);
    end;
end p2;

procedure p1 (i : integer);
begin
    p2(i+1);
end p1;

begin
    i := 0;
    p1(i+1);
end main.
'endcat'

echo tests/mod/procvars.in
rm -f tests/mod/procvars.in
cat > tests/mod/procvars.in <<'endcat'
whatis q.t
stop in p
stop in q
run
step
step
print t
cont
where
step
step
print j
'endcat'

echo tests/mod/nested.mod
rm -f tests/mod/nested.mod
cat > tests/mod/nested.mod <<'endcat'
(*
 * Test of nested procedures and modules.
 *)

module main;
var
    i : integer;

procedure p (var i : integer);
var
    j : integer;

    procedure nestedp (var j : integer);
    var
	i : integer;
    begin
	i := j + 2;
	j := i;
    end nestedp;

begin
    j := i + 1;
    nestedp(j);
    i := j;
end p;

begin
    i := 3;
    p(i);
end main.
'endcat'

echo tests/mod/procvars.mod
rm -f tests/mod/procvars.mod
cat > tests/mod/procvars.mod <<'endcat'
(*
 * Test of procedure variables.
 *)

module main;

procedure p (var i : integer);
begin
    i := 3;
end p;

procedure q ;
var
    t : procedure(var integer);
    j : integer;
begin
    t := p;
    t(j);
    j := j + 1;
end q;

begin
    q;
end main.
'endcat'

echo tests/mod/procvars.out
rm -f tests/mod/procvars.out
cat > tests/mod/procvars.out <<'endcat'
reading symbolic information ...
var t : (class 23);
[1] stop in p
[2] stop in q
[2] stopped in q at line 12 in file "procvars.mod"
   12   procedure q ;
stopped in q at line 17 in file "procvars.mod"
   17       t := p;
stopped in q at line 18 in file "procvars.mod"
   18       t(j);
p 
[1] stopped in p at line 7 in file "procvars.mod"
    7   procedure p (var i : integer);
p(i = 0), line 7 in "procvars.mod"
q, line 18 in "procvars.mod"
_init(0x1, 0x7fffed74, 0x7fffed7c), line 23 in "procvars.mod"
stopped in p at line 9 in file "procvars.mod"
    9       i := 3;
stopped in q at line 19 in file "procvars.mod"
   19       j := j + 1;
3 

'endcat'

echo tests/mod/sets.out
rm -f tests/mod/sets.out
cat > tests/mod/sets.out <<'endcat'
reading symbolic information ...
type Color = (RED, BLUE, GREEN);
type ColorSet = set of Color;
[1] stop in p
[1] stopped in p at line 8 in file "sets.mod"
    8   procedure p (var s : ColorSet);
stopped in p at line 10 in file "sets.mod"
   10       s := ColorSet{RED, BLUE};
p(s = {}), line 10 in "sets.mod"
_init(0x1, 0x7fffed78, 0x7fffed80), line 14 in "sets.mod"
stopped in _init at line 15 in file "sets.mod"
   15       if BLUE in s then
{RED, BLUE} 
stopped in _init at line 16 in file "sets.mod"
   16   	s := s - ColorSet{BLUE};

execution completed, exit code is 0
exit(0x0) at 0x1602
_init(0x1, 0x7fffed78, 0x7fffed80), line 16 in "sets.mod"
{RED} 

'endcat'

echo tests/mod/imptypes.def
rm -f tests/mod/imptypes.def
cat > tests/mod/imptypes.def <<'endcat'
definition module imptypes;
export qualified RT;

type
    RT;

end imptypes.
'endcat'

echo tests/mod/imptypes.mod
rm -f tests/mod/imptypes.mod
cat > tests/mod/imptypes.mod <<'endcat'
implementation module imptypes;
end imptypes.
'endcat'

echo tests/mod/jsb.out
rm -f tests/mod/jsb.out
cat > tests/mod/jsb.out <<'endcat'
reading symbolic information ...
[1] stop in p
in p(3, blah, 4)
[1] stopped in p at line 7 in file "jsb.mod"
    7   procedure p (i : integer; s : array of char; j : integer);
p(i = 3, s = 'blah', j = 4), line 7 in "jsb.mod"
_init(0x1, 0x7fffed78, 0x7fffed80), line 15 in "jsb.mod"
3 

execution completed, exit code is 0

'endcat'

echo tests/mod/nested.in
rm -f tests/mod/nested.in
cat > tests/mod/nested.in <<'endcat'
whereis i
whereis j
stop at 18
run
print i, j, main.i, p.i, p.j
step
print i, j, main.i
cont
print main.i
'endcat'

echo tests/mod/jsb.mod
rm -f tests/mod/jsb.mod
cat > tests/mod/jsb.mod <<'endcat'
module main;

from io import Writef, output;

var global : integer;

procedure p (i : integer; s : array of char; j : integer);
begin
    Writef(output, "in p(%d, %s, %d)\n", i, s, j);
    global := 10;
end p;

begin
    global := 3;
    p(3, "blah", 4);
end main.
'endcat'

echo tests/mod/nested.out
rm -f tests/mod/nested.out
cat > tests/mod/nested.out <<'endcat'
reading symbolic information ...
main.p.i main.p.nestedp.i main.i
main.p.j main.p.nestedp.j
[1] stop at "nested.mod":18
[1] stopped in nestedp at line 18 in file "nested.mod"
   18   	j := i;
6 4 3 3 4 
stopped in main.p at line 24 in file "nested.mod"
   24       i := j;
3 6 3