-- FileTestImpl.mesa
-- written by Bill Paxton, April 1981
-- last edit by Bill Paxton, 15-Oct-81 15:00:51

-- This package provides random testing for filing Text nodes

DIRECTORY
EditTest,
TextEdit,
TextFind,
TextLooks,
TextLooksSupport,
RopeEdit,
TextNode,
NodeProps,
PutGet,
GetTree,
RunReader,
RopeReader,
Rope,
RopeInline,
CheckNode,
TreeCheck,
FileByteStream;

FileTestImpl: PROGRAM
	IMPORTS EditTest, TextEdit, RopeEdit,
		PutGet, GetTree, RunReader, RopeReader, Rope,
		NodeProps, TextNode, TreeCheck,
		CheckNode, FileByteStream
	EXPORTS EditTest =
BEGIN
OPEN
	rI:Rope,
	editI:TextEdit,
	findI:TextFind,
	looksI:TextLooks,
	looksSI:TextLooksSupport,
	ropeI:RopeEdit,
	nodeI:TextNode,
	propsI:NodeProps,
	runrdrI:RunReader,
	roperdrI:RopeReader,
	pgI:PutGet,
	checkI:CheckNode,
	streamI:FileByteStream,
	EditTest;

-- ***** Filing operations

fileNameA: Rope _ rI.FromString["file1.tioga"];
fileNameB: Rope _ rI.FromString["file2.tioga"];
fileName: Rope _ fileNameA;

PutGet: PUBLIC PROC = {
	newAlpha, newBeta: Node;
	fromFile, child: editI.Ref;
	oldAlphaSize, oldBetaSize, endAlpha: Offset;
	oldAlphaRope, newAlphaRope, oldBetaRope, newBetaRope: Rope;
	oldAlphaRuns, newAlphaRuns, oldBetaRuns, newBetaRuns: Runs;
	IF TRUE --OneInN[4]-- THEN RETURN;
	oldAlphaSize _ editI.Size[alpha];
	oldBetaSize _ editI.Size[beta];
	oldAlphaRope _ editI.GetRope[alpha];
	oldAlphaRuns _ editI.GetRuns[alpha];
	oldBetaRope _ editI.GetRope[beta];
	oldBetaRuns _ editI.GetRuns[beta];
	endAlpha _ pgI.ToFile[fileName,alpha];
--temp	[] _ pgI.ToFile[fileName,beta,endAlpha];
	fromFile _ pgI.FromFile[fileName,0,endAlpha];
	IF(child _ nodeI.FirstChild[fromFile]) # NIL THEN fromFile _ child;
	WITH n:fromFile SELECT FROM text => newAlpha _ @n; ENDCASE => ERROR;
	newAlphaRope _ editI.GetRope[newAlpha];
	newAlphaRuns _ editI.GetRuns[newAlpha];
	checkI.CheckTextNode[newAlpha];
	CheckSize[newAlpha,oldAlphaSize];
	CheckRopes[newAlphaRope,0,oldAlphaRope,0,oldAlphaSize];
	CheckRuns[newAlphaRuns,0,oldAlphaRuns,0,oldAlphaSize];
	IF newAlpha.typename # alpha.typename THEN ERROR;
	RETURN; --temp
	fromFile _ pgI.FromFile[fileName,endAlpha];
	IF(child _ nodeI.FirstChild[fromFile]) # NIL THEN fromFile _ child;
	WITH n:fromFile SELECT FROM text => newBeta _ @n; ENDCASE => ERROR;
	newBetaRope _ editI.GetRope[newBeta];
	newBetaRuns _ editI.GetRuns[newBeta];
	checkI.CheckTextNode[newBeta];
	CheckSize[newBeta,oldBetaSize];
	CheckRopes[newBetaRope,0,oldBetaRope,0,oldBetaSize];
	CheckRuns[newBetaRuns,0,oldBetaRuns,0,oldBetaSize];
	IF newBeta.typename # beta.typename THEN ERROR;
	fileName _ IF fileName=fileNameA THEN fileNameB ELSE fileNameA;
	};

PutGetToRope: PUBLIC PROC = {
	newAlpha, newBeta: Node;
	oldAlphaSize, oldBetaSize, endAlpha: Offset;
	outputAlpha, outputBeta, output: Rope;
	fromRope: editI.Ref;
	oldAlphaRope, newAlphaRope, oldBetaRope, newBetaRope: Rope;
	oldAlphaRuns, newAlphaRuns, oldBetaRuns, newBetaRuns: Runs;
	IF TRUE --OneInN[4]-- THEN RETURN;
	oldAlphaSize _ editI.Size[alpha];
	oldBetaSize _ editI.Size[beta];
	oldAlphaRope _ editI.GetRope[alpha];
	oldAlphaRuns _ editI.GetRuns[alpha];
	oldBetaRope _ editI.GetRope[beta];
	oldBetaRuns _ editI.GetRuns[beta];
	outputAlpha _ pgI.ToRope[alpha];
	endAlpha _ ropeI.Size[outputAlpha];
	outputBeta _ pgI.ToRope[beta];
	output _ ropeI.Concat[outputAlpha,outputBeta];
	fromRope _ pgI.FromRope[output,0,endAlpha];
	WITH n:fromRope SELECT FROM text => newAlpha _ @n; ENDCASE => ERROR;
	newAlphaRope _ editI.GetRope[newAlpha];
	newAlphaRuns _ editI.GetRuns[newAlpha];
	checkI.CheckTextNode[newAlpha];
	CheckSize[newAlpha,oldAlphaSize];
	CheckRopes[newAlphaRope,0,oldAlphaRope,0,oldAlphaSize];
	CheckRuns[newAlphaRuns,0,oldAlphaRuns,0,oldAlphaSize];
	IF newAlpha.typename # alpha.typename THEN ERROR;
	fromRope _ pgI.FromRope[output,endAlpha];
	WITH n:fromRope SELECT FROM text => newBeta _ @n; ENDCASE => ERROR;
	newBetaRope _ editI.GetRope[newBeta];
	newBetaRuns _ editI.GetRuns[newBeta];
	checkI.CheckTextNode[newBeta];
	CheckSize[newBeta,oldBetaSize];
	CheckRopes[newBetaRope,0,oldBetaRope,0,oldBetaSize];
	CheckRuns[newBetaRuns,0,oldBetaRuns,0,oldBetaSize];
	IF newBeta.typename # beta.typename THEN ERROR;
	};

PutGetToStream: PUBLIC PROC = {
	stream: streamI.Handle;
	newAlpha, newBeta: Node;
	oldAlphaSize, oldBetaSize, alphaChars, betaChars: Offset;
	fromStream: editI.Ref;
	oldAlphaRope, newAlphaRope, oldBetaRope, newBetaRope: Rope;
	oldAlphaRuns, newAlphaRuns, oldBetaRuns, newBetaRuns: Runs;
	IF TRUE --OneInN[4]-- THEN RETURN;
	stream _ streamI.Open[fileName,write];
	streamI.SetLength[stream,0];
	oldAlphaSize _ editI.Size[alpha];
	oldBetaSize _ editI.Size[beta];
	oldAlphaRope _ editI.GetRope[alpha];
	oldAlphaRuns _ editI.GetRuns[alpha];
	oldBetaRope _ editI.GetRope[beta];
	oldBetaRuns _ editI.GetRuns[beta];
	streamI.PutChar[stream,'1];
	alphaChars _ pgI.ToStream[stream,alpha];
	streamI.PutChar[stream,'2];
	betaChars _ pgI.ToStream[stream,beta];
	streamI.PutChar[stream,'3];
	streamI.Close[stream,TRUE];
	stream _ streamI.Open[fileName,read];
	IF streamI.GetChar[stream] # '1 THEN ERROR;
	fromStream _ pgI.FromStream[stream,alphaChars];
	WITH n:fromStream SELECT FROM text => newAlpha _ @n; ENDCASE => ERROR;
	newAlphaRope _ editI.GetRope[newAlpha];
	newAlphaRuns _ editI.GetRuns[newAlpha];
	checkI.CheckTextNode[newAlpha];
	CheckSize[newAlpha,oldAlphaSize];
	CheckRopes[newAlphaRope,0,oldAlphaRope,0,oldAlphaSize];
	CheckRuns[newAlphaRuns,0,oldAlphaRuns,0,oldAlphaSize];
	IF newAlpha.typename # alpha.typename THEN ERROR;
	IF streamI.GetChar[stream] # '2 THEN ERROR;
	fromStream _ pgI.FromStream[stream,betaChars];
	WITH n:fromStream SELECT FROM text => newBeta _ @n; ENDCASE => ERROR;
	newBetaRope _ editI.GetRope[newBeta];
	newBetaRuns _ editI.GetRuns[newBeta];
	checkI.CheckTextNode[newBeta];
	CheckSize[newBeta,oldBetaSize];
	CheckRopes[newBetaRope,0,oldBetaRope,0,oldBetaSize];
	CheckRuns[newBetaRuns,0,oldBetaRuns,0,oldBetaSize];
	IF newBeta.typename # beta.typename THEN ERROR;
	IF streamI.GetChar[stream] # '3 THEN ERROR;
	IF ~streamI.EndOf[stream] THEN ERROR;
	streamI.Close[stream,TRUE];
	fileName _ IF fileName=fileNameA THEN fileNameB ELSE fileNameA;
	};

PutGetRope: PUBLIC PROC = {
	newAlpha, newBeta: Node;
	fromFile: editI.Ref;
	oldAlphaRope, newAlphaRope, oldBetaRope, newBetaRope: Rope;
	oldAlphaSize, oldBetaSize, endAlpha: Offset;
	IF TRUE --OneInN[4]-- THEN RETURN;
	oldAlphaSize _ editI.Size[alpha];
	oldBetaSize _ editI.Size[beta];
	oldAlphaRope _ editI.GetRope[alpha];
	oldBetaRope _ editI.GetRope[beta];
	endAlpha _ oldAlphaSize;
	ropeI.ToFile[fileName,oldAlphaRope];
--temp	ropeI.ToFile[fileName,oldBetaRope,endAlpha];
	fromFile _ pgI.FromFile[fileName,0,endAlpha];
	fromFile _ nodeI.FirstChild[fromFile];
	WITH x:fromFile SELECT FROM text => newAlpha _ @x; ENDCASE => ERROR;
	newAlphaRope _ editI.GetRope[newAlpha];
	IF editI.GetRuns[newAlpha] # NIL THEN ERROR;
	checkI.CheckTextNode[newAlpha];
	CheckSize[newAlpha,oldAlphaSize];
	CheckRopes[newAlphaRope,0,oldAlphaRope,0,oldAlphaSize];
	newAlphaRope _ ropeI.FromFile[fileName,0,endAlpha];
	IF ropeI.Size[newAlphaRope] # oldAlphaSize THEN ERROR;
	CheckRopes[newAlphaRope,0,oldAlphaRope,0,oldAlphaSize];
	RETURN; --temp
	fromFile _ pgI.FromFile[fileName,endAlpha];
	fromFile _ nodeI.FirstChild[fromFile];
	WITH x:fromFile SELECT FROM text => newBeta _ @x; ENDCASE => ERROR;
	newBetaRope _ editI.GetRope[newBeta];
	IF editI.GetRuns[newBeta] # NIL THEN ERROR;
	checkI.CheckTextNode[newBeta];
	CheckSize[newBeta,oldBetaSize];
	CheckRopes[newBetaRope,0,oldBetaRope,0,oldBetaSize];
	newBetaRope _ ropeI.FromFile[fileName,endAlpha];
	IF ropeI.Size[newBetaRope] # oldBetaSize THEN ERROR;
	CheckRopes[newBetaRope,0,oldBetaRope,0,oldBetaSize];
	fileName _ IF fileName=fileNameA THEN fileNameB ELSE fileNameA;
	};

treeFileFlag: BOOLEAN _ FALSE;	
treeFileName: Rope _ rI.FromString["TestTree.Text"];
PutGetTree: PUBLIC PROC = {
	node: Node;
	new: Node;
	fromFile: editI.Ref;
	IF TRUE --treeFileFlag-- THEN RETURN;
	treeFileFlag _ TRUE; -- only do this test once
	node _ GetTree.ReadIndent[treeFileName];
	TreeCheck.Verify[node];
	[] _ pgI.ToFile[fileName,node];
	fromFile _ pgI.FromFile[fileName];
	TreeCheck.Verify[fromFile];
	WITH n:fromFile SELECT FROM text => new _ @n; ENDCASE => ERROR;
	CheckTrees[node,new];
	fileName _ IF fileName=fileNameA THEN fileNameB ELSE fileNameA;
	};

CheckTrees: PROC [t1,t2: editI.Ref] = { -- ERROR if trees not equal
	x1, x2: editI.Ref;
	WITH n1:t1 SELECT FROM
		text => WITH n2:t2 SELECT FROM
			text => { -- must have same text&looks
				size: Offset _ editI.Size[@n1];
				IF editI.Size[@n2] # size THEN ERROR;
				CheckRopes[n1.rope,0,n2.rope,0,size]; 
				CheckRuns[n1.runs,0,n2.runs,0,size] };
			ENDCASE => ERROR;
		other => WITH n2:t2 SELECT FROM
			other => NULL;
			ENDCASE => ERROR;
		ENDCASE => ERROR;
	IF t1.typename # t2.typename THEN ERROR;
	IF (t1.hasprefix OR t2.hasprefix) AND
		propsI.GetPrefixObject[t1]#propsI.GetPrefixObject[t2]
			THEN ERROR;
	IF (t1.haspostfix OR t2.haspostfix) AND
		propsI.GetPostfixObject[t1]#propsI.GetPostfixObject[t2]
			THEN ERROR;
	x1 _ t1.child; x2 _ t2.child;
	DO -- check children
		IF x1=NIL THEN IF x2=NIL THEN RETURN ELSE ERROR;
		IF x2=NIL THEN ERROR;
		CheckTrees[x1,x2];
		x1 _ nodeI.Next[x1]; x2 _ nodeI.Next[x2];
		ENDLOOP };

bigFileFlag: BOOLEAN _ FALSE;	
GetBigFile: PUBLIC PROC = {
	rope: Rope;
	IF TRUE --bigFileFlag-- THEN RETURN; -- only do this once or will fill up VM
	rope _ ropeI.FromFile[rI.FromString["bigfile.text"],0,LAST[Offset],TRUE];
	checkI.CheckRope[rope];
	bigFileFlag _ TRUE
	};
	
END.