DIRECTORY
IO,
Process USING[CheckForAbort],
RMTWTestSubject USING[],
Rope USING[ActionType, Equal, Index, Length, Map, ROPE, Substr],
StackCirio USING[InterpretTextLine, Stack, WalkStack];

RMTWTestSubjectImpl: CEDAR PROGRAM IMPORTS IO, Process, StackCirio, Rope EXPORTS RMTWTestSubject =
BEGIN


TestDescriptor: TYPE = RECORD[
expression: Rope.ROPE,
expectedResult: Rope.ROPE,
compareNCharsOnly: CARD ¬ 0,
validity: Validity ¬ valid];

Validity: TYPE = {valid, proc, uninitializedVar, WRONG};

ExamineSubjectStack: PUBLIC PROC[stack: StackCirio.Stack, local: BOOLEAN, reports: IO.STREAM] =
BEGIN
nUnexpectedResults: CARD ¬ 0;

BEGIN
frame2Tests: LIST OF TestDescriptor ¬ LIST[
	["c", "'a"],
	["quit", "FALSE"],
	["bool1", "FALSE"],
	["bool2", "TRUE"],
	["charA", "'A"],
	["charB", "'b"],
	["array1", "(7)[6, 8, 10, 12, 14, 16, 18]"],
	["array2", "(6)[11, 13, 15, 17, 19, 21]"],
	["refR", "^[a:7, b:8]"],
	["bb", "[ref:^[ref:NIL, a:45, b:46], a:47, b:48]"],
	["refSeq", "^[x:10, (5)[3, 7, 11, 15, 19]]"],
	["refSeq2", "^[y:45, (7)[TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE]]"],
	["ref2Seq2", "^[y:77, (32)[TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, ...]]"],
	["b", "[a:6, b:7]"],
	["w", "[x:[a:4, b:5], y:[u:6, v:7]]"],
	["y", "failure due to illegal operation: y undefined"],
	["action", "RMTWTestSubjectImpl.bar.action(pc=137CE78h, descr at 2BF10Ch, src=8557)", 29, proc],
	["foo", "RMTWTestSubjectImpl.(no name)(pc=137CCE0h, descr at 139B880h, src=8208)", 28, proc],
	["bar", "RMTWTestSubjectImpl.bar(pc=137CCF4h, descr at 139B878h, src=8228)", 24, proc],
	["x", "10", 6, proc],
	["veryBad", "RMTWTestSubjectImpl(pc=1379868h, descr at 139B898h, src=372)", 18, proc],
	["CallDebugger", "failure due to illegal operation: CallDebugger undefined"]];
nUnexpectedResults ¬ ExamineOneFrame[stack, frame2Tests, reports] + nUnexpectedResults;
END;

[] ¬ StackCirio.WalkStack[stack, 2, reports];


BEGIN
frame3Tests: LIST OF TestDescriptor ¬ LIST[
	["deep", "1606016"],
	["rope", "^[(text)[..., (3)[[...]]]]"],
	["arg1", "1234"],
	["arg2", "5678"],
	["res1", "2468"],
	["res2", "22712"],
	["z", "8518320"],
	["yy", "3807"],
	["ll", "x"],
	["mm", "f"],
	["q", "RMTWTestSubjectImpl.bar.q(pc=137D8F0h, descr at 2BF104h, src=9735)", 24, proc],
	["b", "[a:6, b:7]"],
	["w", "[x:[a:4, b:5], y:[u:6, v:7]]"],
	["y", "failure due to illegal operation: y undefined"],
	["action", "RMTWTestSubjectImpl.bar.action(pc=137CE78h, descr at 2BF10Ch, src=8557)", 29, proc],
	["foo", "RMTWTestSubjectImpl.(no name)(pc=137CCE0h, descr at 139B880h, src=8208)", 28, proc],
	["bar", "RMTWTestSubjectImpl.bar(pc=137CCF4h, descr at 139B878h, src=8228)", 22, proc],
	["x", "10"],
	["veryBad", "RMTWTestSubjectImpl(pc=1379868h, descr at 139B898h, src=372)", 18, proc],
	["CallDebugger", "failure due to illegal operation: CallDebugger undefined"],
	["r", ""],
	["rData", "3456"],
	["rData _ 34", "34"],
	["rData", "34"]];
frame3LocalTests: LIST OF TestDescriptor ¬ LIST[
	["rData", "34"],
	["r[4567]", "34"],
	["rData", "4567"]];
nUnexpectedResults ¬ ExamineOneFrame[stack, frame3Tests, reports] + nUnexpectedResults;
IF local THEN
nUnexpectedResults ¬ ExamineOneFrame[stack, frame3LocalTests, reports] + nUnexpectedResults;
END;

IF nUnexpectedResults = 0 THEN IO.PutRope[reports, "\N\NThere were NO unexpected results\N\N"]
  ELSE IO.PutF1[reports, "\N\NThere were %g unexpected results\N\N", IO.card[nUnexpectedResults]];
END;

ExamineOneFrame: PROC[stack: StackCirio.Stack, tryThis: LIST OF TestDescriptor, reports: IO.STREAM] RETURNS[--nUnexpectedResults-- CARD] =
BEGIN
ResultDescriptor: TYPE = RECORD[
expression: Rope.ROPE,
expectedResult: Rope.ROPE,
actualResult: Rope.ROPE];
deltas: LIST OF ResultDescriptor ¬ NIL;
lastDelta: LIST OF ResultDescriptor ¬ NIL;
news: LIST OF TestDescriptor ¬ NIL;
lastNew: LIST OF TestDescriptor ¬ NIL;
nUnexpectedResults: CARD ¬ 0;

FOR tests: LIST OF TestDescriptor ¬ tryThis, tests.rest WHILE tests # NIL DO
result: Rope.ROPE ¬ StackCirio.InterpretTextLine[stack, tests.first.expression, reports];
new: LIST OF TestDescriptor ¬ LIST[[tests.first.expression, result, tests.first.compareNCharsOnly, tests.first.validity]];
nChars: CARD ¬ IF tests.first.compareNCharsOnly > 0 THEN tests.first.compareNCharsOnly ELSE Rope.Length[tests.first.expectedResult];
Process.CheckForAbort[];
IF news = NIL THEN news ¬ new ELSE lastNew.rest ¬ new;
lastNew ¬ new;
IO.PutF[reports, "for expression: %g we get\N\T%g\N", IO.rope[tests.first.expression], IO.rope[result]];
IF (tests.first.validity # uninitializedVar) AND NOT Rope.Equal[Rope.Substr[result, 0, nChars], Rope.Substr[tests.first.expectedResult, 0, nChars]] THEN
BEGIN
delta: LIST OF ResultDescriptor ¬ LIST[[tests.first.expression, tests.first.expectedResult, result]];
IO.PutF1[reports, "  THIS IS WRONG, we expected\N\T%g\N\N", IO.rope[tests.first.expectedResult]];
IF deltas = NIL THEN deltas ¬ delta ELSE lastDelta.rest ¬ delta;
lastDelta ¬ delta;
nUnexpectedResults ¬ nUnexpectedResults + 1;
END;
ENDLOOP;

IO.PutRope[reports, "\N\Nhere is a list of expressions with their actual results\N"];
FOR items: LIST OF TestDescriptor ¬ news, items.rest WHILE items # NIL DO
IO.PutF[reports, "\T[\"%g\", \"%g\"", IO.rope[items.first.expression], IO.rope[items.first.expectedResult]];
SELECT items.first.validity FROM
valid =>
IF items.first.compareNCharsOnly > 0 THEN
IO.PutF1[reports, ", %g", IO.card[items.first.compareNCharsOnly]]
 ELSE NULL;
proc =>
BEGIN
nChars: CARD ¬ Rope.Index[items.first.expectedResult, 0, "(pc="]+4;
IO.PutF1[reports, ", %g, proc", IO.card[nChars]];
END;
uninitializedVar =>
IO.PutRope[reports, ", 0, uninitializedVar"];
WRONG =>
IO.PutRope[reports, ", 0, WRONG"];
ENDCASE => ERROR;
IO.PutRope[reports, "],\N"];
ENDLOOP;

IF deltas # NIL THEN
BEGIN
IO.PutRope[reports, "\N\Nthere were unexpected results\N"];
FOR items: LIST OF ResultDescriptor ¬ deltas, items.rest WHILE items # NIL DO
IO.PutF1[reports, "\Texpression: %g\N", IO.rope[items.first.expression]];
IO.PutF1[reports, "\Texpected result: %g\N", IO.rope[items.first.expectedResult]];
IO.PutF1[reports, "\Tactual result: %g\N", IO.rope[items.first.actualResult]];
ENDLOOP;
END
 ELSE IO.PutRope[reports, "\N\Nthere were NO unexpected results\N\N"];
RETURN[nUnexpectedResults];
END;


R: TYPE = RECORD[a, b: INT];
S: TYPE = RECORD[x: R, y: RECORD[u: INT, v: CARD]];

b: R ¬ [6, 7];
w: S ¬ [[4, 5], [6, 7]];

Subject: PUBLIC PROC[local: BOOLEAN, inner: PROC[CARD32]] =
{[] ¬ bar[1234, 5678, inner]};

foo: PROC ¬ {NULL};
bar: PROC[arg1: INT, arg2: INT, debug: PROC[key: CARD32]] RETURNS[res1: INT, res2: INT] =
BEGIN
z: INT ¬ 8518320;  -- should be placed in the frame extension because it is referenced from q
yy: INT ¬ 3807;
LL: TYPE = {w, x, y, z};
ll: LL ¬ x;
MM: TYPE = MACHINE DEPENDENT { a (0), b (1), c(2), d(3), f(5), end (25)};
mm: MM ¬ f;
action: Rope.ActionType =
BEGIN
bool1: BOOLEAN ¬ FALSE;
bool2: BOOLEAN ¬ TRUE;
charA: CHAR ¬ 'A;
charB: CHARACTER ¬ 'b;
array1: ARRAY [3..9] OF INT;
array2: PACKED ARRAY [5..10] OF INT[0..128);
refR: REF R ¬ NEW[R¬[7, 8]];
B: TYPE = RECORD[ref: REF B, a, b: INT];
bb: B ¬ [NEW[B¬[NIL, 45, 46]], 47, 48];
Seq: TYPE =  RECORD[x: INT, fields: SEQUENCE nFields: CARD16 OF INT];
refSeq: REF Seq ¬ NEW[Seq[5]];
Seq2: TYPE = RECORD[y: INT, fields: PACKED SEQUENCE nFields: [0..45) OF BOOLEAN];
refSeq2: REF Seq2 ¬ NEW[Seq2[7]];
ref2Seq2: REF Seq2 ¬ NEW[Seq2[32]];
FOR I: INT IN [3..9] DO array1[I] ¬ 2*I ENDLOOP;
FOR I: INT IN [5..10] DO array2[I] ¬ 2*I+1 ENDLOOP;
refSeq.x ¬ 10;
FOR I: INT IN [0..5) DO refSeq.fields[I] ¬ 4*I+3 ENDLOOP;
refSeq2.y ¬ 45;
FOR I: INT IN [0..7) DO refSeq2.fields[I] ¬ SELECT I FROM
0 => TRUE,
1 => TRUE,
2 => FALSE,
3 => TRUE,
4 => FALSE,
5 => FALSE,
6 => TRUE,
ENDCASE => ERROR
 ENDLOOP;
ref2Seq2.y ¬ 77;
FOR I: INT IN [0..32) DO
x: CARD ¬ (I/4)+1;
bit: CARD ¬ I MOD 4;

ref2Seq2.fields[I] ¬ SELECT bit FROM
0 => (x MOD 2) = 1,
1 => (x/2 MOD 2) = 1,
2 => (x/4 MOD 2) = 1,
3 => (x/8 MOD 2) = 1,
ENDCASE => ERROR
 ENDLOOP;
debug[444444];
RETURN[FALSE];
END;
q: PROC[a: INT] = 
BEGIN
deep: INT ¬ 1606016;
rope: Rope.ROPE ¬ "abc";
[] ¬ Rope.Map[rope, 0, Rope.Length[rope], action];
debug[8511261];
x ¬ z-9;
END;
rData: INT ¬ 3456;
r: PROC[a: INT] RETURNS[INT] =
{res: INT ¬ rData; rData ¬ a; RETURN[res]};
res1 ¬ arg1*2; res2 ¬ arg2*4;
foo[!veryBad => 
BEGIN
q[33333];
x ¬ x+11
END];
BEGIN
fluff: INT ¬ 45;
q[22222];
END;
END;

x: INT ¬ 10;
veryBad: SIGNAL[y: INT] RETURNS[BOOLEAN] = CODE;


END..

 
X
RMTWTestSubjectImpl.mesa
Copyright Σ 1992 by Xerox Corporation.  All rights reserved.
Sturgis, March 13, 1990 2:53 pm PST
Willie-s, May 15, 1992 2:42 pm PDT
Subject Stack Examination
now we examine the located frame
(commented out until we can show the global frame in less than n-squared time)
BEGIN
frameText: Rope.ROPE _ StackCirio.ShowCurrentFrame[stack, reports];
IO.PutF[reports, "\n\n%g\n\n", IO.rope[frameText]];
END;

now we perform the individual expression tests
lets skip a frame and look at the following frame
and examine
(commented out until we can show the global frame in less than n-squared time)
BEGIN
frameText: Rope.ROPE _ StackCirio.ShowCurrentFrame[stack, reports];
IO.PutF[reports, "\n\n%g\n\n", IO.rope[frameText]];
END;
now we perform the individual expression tests
overall result:
Test Subject
ENABLE UNWIND => NULL;
we use CARD16 so that this will compile on a D-machine.
we need to compile on a D-Machine because our companion code, ExamineOneFrame, will be executed on a D-machine.  It would be better if we could test with CARD.
ENABLE UNWIND => NULL;
inner block of bar

Κ
j–
(cedarcode) style•NewlineDelimiter

™š
œ™Jšœ
Οe
œ1™<Jš
œ#™#J™"—Icode˜š
Οk	˜	Kšžœ
˜Kšœžœ˜Kšœžœ˜Kšœžœ(žœ
˜@Kšœžœ&˜6K˜—šΟnœžœ
žœ
žœ
žœžœ˜bKš
ž˜K˜™K˜šœžœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜K˜—K˜Kšœ
žœ#žœ˜8K˜šŸœžœ
žœ!žœžœ
žœ˜_Kš
ž˜Kšœžœ˜K˜™ J™NJš
ž™Jšœžœ/™CJšžœžœ™3Jšžœ
™—J™™.Kš
ž˜šœ
žœ
žœžœ
˜+Kš
œΣ	˜Σ	—K˜WKšžœ
˜—K˜™1K˜-—K˜™J™NJš
ž™Jšœžœ/™CJšžœžœ™3Jšžœ
™—K˜™.Kš
ž˜šœ
žœ
žœžœ
˜+Kš
œ³˜³—šœžœ
žœžœ
˜0K˜:—K˜Wšžœž˜
K˜\—Kšžœ
˜—K˜™Kšžœžœ
žœ=˜^Kšœžœ
žœ<žœ˜b—Kšžœ
˜K˜—šŸœžœ#žœ
žœžœ
žœžœ
Οcœ
žœ˜Š
Kš
ž˜šœžœžœ
˜ Kšœžœ
˜Kšœžœ
˜Kšœžœ˜—Kšœžœ
žœžœ
˜'Kšœžœ
žœžœ
˜*Kšœžœ
žœžœ
˜#Kšœ	žœ
žœžœ
˜&šœžœ˜K˜—šžœžœ
žœ&žœ	žœ
ž˜LKšœ
žœH˜YKšœžœ
žœžœX˜zKš	œžœžœ#žœžœ)˜„
Kš
œ˜Kšžœžœ
žœžœ˜6K˜Kšžœ4žœžœ˜hšžœ+žœ
žœ`ž˜˜
Kš
ž˜Kšœžœ
žœžœ?˜eKšžœ:žœ#˜aKšžœ
žœ
žœžœ˜@K˜K˜,Kšžœ
˜—Kšžœ
˜—K˜KšžœS˜Ušžœžœ
žœ#žœ	žœ
ž˜IKšžœ$žœžœ#˜lšžœž˜ ˜šžœ#ž˜)Kšžœžœ%˜A—Kšœ
žœ
žœ
˜—˜Kš
ž˜Kšœžœ7˜CKšžœžœ˜1Kšžœ
˜—š
œ˜Kšžœ+˜-—šžœ˜Kšžœ ˜"—Kšžœžœ
˜—Kšžœ˜Kšžœ
˜—K˜šžœ
žœ
ž˜Kš
ž˜Kšžœ9˜;šžœžœ
žœ'žœ	žœ
ž˜MKšžœ&žœ˜IKšžœ+žœ#˜RKšžœ)žœ!˜NKšžœ
˜—Kš
ž˜—Kšœ
žœ
žœ>˜FKšžœ˜Kšžœ
˜——K˜™K˜Kšœžœžœžœ˜Kšœžœžœ
žœžœžœ˜3K˜K˜K˜K˜šŸœžœ
žœžœ	žœ
žœ˜;K˜—K˜Kšœžœžœ˜šœžœžœžœ	žœžœžœžœžœ˜YKš
ž˜Jšžœ
žœžœ
™Kšœžœ
 J˜]Kšœžœ˜Kšžœžœ˜Kšœžœ˜Kšžœžœžœ
ž	œ-˜IKšœžœ˜˜Kš
ž˜Kšœžœžœ
˜Kšœžœžœ
˜Kšœžœ˜Kšœž	œ˜Kšœžœžœ
žœ
˜Kš	œžœ
žœ	žœ
žœ	˜,Kšœžœžœ˜Kš	œžœžœžœ
žœ˜(Kšœ	žœžœ˜'šœžœžœžœ
žœ
žœ
žœ
žœ˜EJšœžœ*™7Jš
œŸ
™Ÿ
—Kšœžœžœ	˜Kšœžœžœžœ
žœ
žœžœ
žœ˜QKšœ	žœžœ
˜!Kšœ
žœžœ˜#Kšžœ
Ÿ
œžœ
žœžœžœ
˜0Kšžœ
Ÿ
œžœ
žœ	žœžœ
˜3K˜Kšžœ
Ÿ
œžœ
žœžœžœ
˜9K˜š
žœ
Ÿ
œžœ
žœžœžœž˜9Kšœžœ
˜
Kšœžœ
˜
Kšœžœ
˜Kšœžœ
˜
Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜
Kšžœž˜Kšœ
žœ
˜	—K˜š	žœ
Ÿ
œžœ
žœ	ž˜Kšœžœ˜Kšœžœžœ˜K˜Kšœžœž˜$Kšœžœ˜Kšœ
žœ˜Kšœ
žœ˜Kšœ
žœ˜Kšžœž˜Kšœ
žœ
˜	—Kš
œ˜Kšžœ
žœ˜Kšžœ
˜—šœžœžœ˜Kš
ž˜Jšžœ
žœžœ
™Kšœžœ˜Kšœžœ	˜K˜2Kš
œ˜K˜Kšžœ
˜—Kšœžœ˜š	œžœžœžœ
žœ˜Kšœžœžœ˜+—K˜˜Kš
ž˜K˜	K˜Kšžœ˜—™Kš
ž˜Kšœžœ˜K˜	Kšžœ
˜—Kšžœ
˜—K˜Kšœžœ˜Kšœ	žœžœžœ
žœžœ
˜0K™—˜K˜—Kšžœ˜——…—!~0@