/* Copyright (c) Microsoft Corporation.
   Licensed under the MIT License. */

/***************************************************************************
	Author: ShonK
	Project: Kauai test app
	Reviewed:
	Copyright (c) Microsoft Corporation

	Test code used in both ut and ft.

***************************************************************************/
#include "util.h"
ASSERTNAME

#ifdef DEBUG
extern void CheckForLostMem(BASE *po);
#else //!DEBUG
#define CheckForLostMem(po)
#endif //!DEBUG

void TestInt(void);
void TestMem(void);
void TestGl(void);
void TestFni(void);
void TestFil(void);
void TestGg(void);
void TestCfl(void);
void TestErs(void);
void TestCrf(void);


/******************************************************************************
	Test util code.
******************************************************************************/
void TestUtil(void)
{
	Bug("Assert Test");
	long lw = 0x12345678;
	BugVar("AssertVar test", &lw);

	TestInt();
	TestMem();
	TestErs();
	TestGl();
	TestGg();
	//TestFni();
	//TestFil();
	//TestCfl();
	TestCrf();
}


/***************************************************************************
	Test utilint stuff.
***************************************************************************/
void TestInt(void)
{
	AssertDo(SwHigh(0x12345678) == (short)0x1234, 0);
	AssertDo(SwHigh(0xABCDEF01) == (short)0xABCD, 0);
	AssertDo(SwLow(0x12345678) == (short)0x5678, 0);
	AssertDo(SwLow(0xABCDEF01) == (short)0xEF01, 0);

	AssertDo(LwHighLow(0x1234, 0x5678) == 0x12345678, 0);
	AssertDo(LwHighLow((short)0xABCD, (short)0xEF01) == 0xABCDEF01, 0);

	AssertDo(BHigh(0x1234) == 0x12, 0);
	AssertDo(BHigh((short)0xABCD) == 0xAB, 0);
	AssertDo(BLow(0x1234) == 0x34, 0);
	AssertDo(BLow((short)0xABCD) == 0xCD, 0);

	AssertDo(SwHighLow(0x12, 0x56) == (short)0x1256, 0);
	AssertDo(SwHighLow(0xAB, 0xEF) == (short)0xABEF, 0);

	AssertDo(SwMin(kswMax, kswMin) == kswMin, 0);
	AssertDo(SwMin(kswMin, kswMax) == kswMin, 0);
	AssertDo(SwMax(kswMax, kswMin) == kswMax, 0);
	AssertDo(SwMax(kswMin, kswMax) == kswMax, 0);

	AssertDo(SuMin(ksuMax, 0) == 0, 0);
	AssertDo(SuMin(0, ksuMax) == 0, 0);
	AssertDo(SuMax(ksuMax, 0) == ksuMax, 0);
	AssertDo(SuMax(0, ksuMax) == ksuMax, 0);

	AssertDo(LwMin(klwMax, klwMin) == klwMin, 0);
	AssertDo(LwMin(klwMin, klwMax) == klwMin, 0);
	AssertDo(LwMax(klwMax, klwMin) == klwMax, 0);
	AssertDo(LwMax(klwMin, klwMax) == klwMax, 0);

	AssertDo(LuMin(kluMax, 0) == 0, 0);
	AssertDo(LuMin(0, kluMax) == 0, 0);
	AssertDo(LuMax(kluMax, 0) == kluMax, 0);
	AssertDo(LuMax(0, kluMax) == kluMax, 0);

	AssertDo(SwAbs(kswMax) == kswMax, 0);
	AssertDo(SwAbs(kswMin) == -kswMin, 0);
	AssertDo(LwAbs(klwMax) == klwMax, 0);
	AssertDo(LwAbs(klwMin) == -klwMin, 0);

	AssertDo(LwMulSw(kswMax, kswMax) == 0x3FFF0001, 0);
	AssertDo(LwMulSw(kswMin, kswMin) == 0x3FFF0001, 0);
	AssertDo(LwMulSw(kswMax, kswMin) == -0x3FFF0001, 0);

	AssertDo(LwMulDiv(klwMax, klwMax, klwMin) == klwMin, 0);
	AssertDo(LwMulDiv(klwMax, klwMin, klwMax) == klwMin, 0);

	AssertDo(CbRoundToLong(0) == 0, 0);
	AssertDo(CbRoundToLong(1) == 4, 0);
	AssertDo(CbRoundToLong(2) == 4, 0);
	AssertDo(CbRoundToLong(3) == 4, 0);
	AssertDo(CbRoundToLong(4) == 4, 0);
	AssertDo(CbRoundToLong(5) == 8, 0);

	AssertDo(CbRoundToShort(0) == 0, 0);
	AssertDo(CbRoundToShort(1) == 2, 0);
	AssertDo(CbRoundToShort(2) == 2, 0);
	AssertDo(CbRoundToShort(3) == 4, 0);
	AssertDo(CbRoundToShort(4) == 4, 0);
	AssertDo(CbRoundToShort(5) == 6, 0);

	AssertDo(LwGcd(10000, 350) == 50, 0);
	AssertDo(LwGcd(10000, -560) == 80, 0);

	AssertDo(FcmpCompareFracs(50000, 30000, 300000, 200000) == fcmpGt, 0);
	AssertDo(FcmpCompareFracs(-50000, 30000, -300000, 200000) == fcmpLt, 0);
	AssertDo(FcmpCompareFracs(-50000, 30000, 300000, 200000) == fcmpLt, 0);
	AssertDo(FcmpCompareFracs(50000, 30000, -300000, 200000) == fcmpGt, 0);
	AssertDo(FcmpCompareFracs(50000, 30000, 500000, 300000) == fcmpEq, 0);
	AssertDo(FcmpCompareFracs(0x1FFF0000, 0x10, 0x11000000, 0x10) == fcmpGt, 0);
}


/***************************************************************************
	Test the memory manager.
***************************************************************************/
void TestMem(void)
{
	#define kchq 18
	static HQ rghq[kchq]; //static so it's initially zeros
	HQ hqT, hq;
	long cb, ihq;

	for (ihq = 0; ihq < kchq; ihq++)
		{
		cb = (1L << ihq) - 1 + ihq;
		if (!FAllocHq(&hq, cb, fmemNil, mprDebug))
			{
			BugVar("HqAlloc failed on size:", &cb);
			break;
			}
		rghq[ihq] = hq;
		AssertDo(CbOfHq(hq) == cb, 0);

		FillPb(QvFromHq(hq), cb, (byte)cb);
		if (cb > 0)
			{
			AssertDo(*(byte *)QvFromHq(hq) == (byte)cb, 0);
			AssertDo(*(byte *)PvAddBv(QvFromHq(hq), cb - 1) == (byte)cb, 0);
			}

		AssertDo(PvLockHq(hq) == QvFromHq(hq), 0);
		if (!FCopyHq(hq, &hqT, mprDebug))
			Bug("FCopyHq failed");
		else
			{
			AssertDo(CbOfHq(hqT) == cb, 0);
			if (cb > 0)
				{
				AssertDo(*(byte *)QvFromHq(hqT) == (byte)cb, 0);
				AssertDo(*(byte *)PvAddBv(QvFromHq(hqT), cb - 1) == (byte)cb, 0);
				}
			FreePhq(&hqT);
			}
		Assert(hqT == hqNil, 0);
		FreePhq(&hqT);

		UnlockHq(hq);
		}

	for (ihq = 0; ihq < kchq; ihq++)
		{
		hq = rghq[ihq];
		if (hqNil == hq)
			break;
		cb = CbOfHq(hq);
		if (!FResizePhq(&rghq[ihq], 2 * cb, fmemClear, mprDebug))
			{
			Bug("FResizePhq failed");
			break;
			}
		hq = rghq[ihq];
		if (cb > 0)
			{
			AssertDo(*(byte *)QvFromHq(hq) == (byte)cb, 0);
			AssertDo(*(byte *)PvAddBv(QvFromHq(hq), cb - 1) == (byte)cb, 0);
			AssertDo(*(byte *)PvAddBv(QvFromHq(hq), cb) == 0, 0);
			AssertDo(*(byte *)PvAddBv(QvFromHq(hq), 2 * cb - 1) == 0, 0);
			}
		}

	for (ihq = 0; ihq < kchq; ihq++)
		{
		if (hqNil != rghq[ihq])
			{
			cb = (1L << (kchq - 1 - ihq)) - 1 + (kchq - 1 - ihq);
			AssertDo(FResizePhq(&rghq[ihq], cb, fmemNil, mprDebug), "FResizePhq failed");
			}
		FreePhq(&rghq[ihq]);
		}
}


/***************************************************************************
	Test list code.
***************************************************************************/
void TestGl(void)
{
	short sw;
	long isw;
	short *qsw;
	PGL pglsw;

	pglsw = GL::PglNew(size(short));
	if (pvNil == pglsw)
		{
		Bug("PglNew failed");
		return;
		}

	for (sw = 0; sw < 10; sw++)
		{
		AssertDo(pglsw->FAdd(&sw, &isw), 0);
		AssertDo(isw == sw, 0);
		}
	AssertDo(pglsw->IvMac() == 10, 0);

	for (isw = 0; isw < 10; isw++)
		{
		qsw = (short *)pglsw->QvGet(isw);
		AssertDo(*qsw == isw, 0);
		pglsw->Get(isw, &sw);
		AssertDo(sw == isw, 0);
		}

	for (isw = 10; isw > 0; )
		pglsw->Delete(isw -= 2);
	AssertDo(pglsw->IvMac() == 5, 0);

	for (isw = 0; isw < 5; isw++)
		{
		pglsw->Get(isw, &sw);
		AssertDo(sw == isw * 2 + 1, 0);
		sw = (short)isw * 100;
		pglsw->Put(isw, &sw);
		qsw = (short *)pglsw->QvGet(isw);
		AssertDo(*qsw == isw * 100, 0);
		*qsw = (short)isw;
		}

	AssertDo(pglsw->IvMac() == 5, 0);
	AssertDo(pglsw->FEnsureSpace(0, fgrpShrink), 0);
	AssertDo(pglsw->IvMac() == 5, 0);

	for (isw = 5; isw-- != 0; )
		{
		sw = (short)isw;
		pglsw->FInsert(isw, &sw);
		}

	AssertDo(pglsw->IvMac() == 10, 0);
	for (isw = 10; isw-- != 0; )
		{
		pglsw->Get(isw, &sw);
		AssertDo(sw == isw / 2, 0);
		}

	ReleasePpo(&pglsw);
}


/***************************************************************************
	Test the fni code.
***************************************************************************/
void TestFni(void)
{
	FNI fni1, fni2;
	STN stn1, stn2, stn3;

	AssertDo(fni1.FGetTemp(), 0);
	AssertDo(fni1.Ftg() == vftgTemp, 0);
	AssertDo(!fni1.FDir(), 0);
	fni2 = fni1;
	fni1.GetLeaf(&stn3);
	fni2.GetLeaf(&stn2);
	AssertDo(stn3.FEqual(&stn2), 0);

	AssertDo(fni1.FSetLeaf(pvNil, kftgDir), 0);
	AssertDo(fni1.FDir(), 0);
	AssertDo(fni1.Ftg() == kftgDir, 0);

	AssertDo(fni1.FUpDir(&stn1, ffniNil), 0);
	AssertDo(fni1.FUpDir(&stn2, ffniMoveToDir), 0);
	AssertDo(stn1.FEqual(&stn2), 0);
	AssertDo(!fni1.FSameDir(&fni2), 0);
	AssertDo(!fni1.FEqual(&fni2), 0);
	AssertDo(fni1.Ftg() == kftgDir, 0);
	AssertDo(fni1.FDownDir(&stn1, ffniNil), 0);
	AssertDo(!fni1.FSameDir(&fni2), 0);
	AssertDo(fni1.FDownDir(&stn1, ffniMoveToDir), 0);
	AssertDo(fni1.FSameDir(&fni2), 0);
	AssertDo(fni1.FSetLeaf(&stn3, vftgTemp), 0);

	AssertDo(fni1.FEqual(&fni2), 0);
	AssertDo(fni1.TExists() == tNo, 0);
	AssertDo(fni2.FSetLeaf(pvNil, kftgDir), 0);
	AssertDo(fni2.FGetUnique(vftgTemp), 0);
	AssertDo(!fni1.FEqual(&fni2), 0);
}


/***************************************************************************
	File test code.
***************************************************************************/
void TestFil(void)
{
	PFIL pfil;
	FNI fni;

	while (FGetFniSaveMacro(&fni, 'TEXT', "\x9" "Save As: ", "\x4" "Junk",
			PszLit("All files\0*.*\0"), NULL))
		{
		AssertDo(fni.TExists() == tNo, 0);
		pfil = FIL::PfilCreate(&fni);
		AssertPo(pfil, 0);
		AssertDo(pfil->FSetFpMac(100), 0);
		AssertDo(pfil->FpMac() == 100, 0);
		AssertDo(pfil->FWriteRgb(&fni, size(fni), 0), 0);
		pfil->SetTemp(fTrue);
		pfil->Mark();
		ReleasePpo(&pfil);
		}

	FIL::CloseUnmarked();
	FIL::ClearMarks();
	FIL::CloseUnmarked();
}


/***************************************************************************
	Test the group api.
***************************************************************************/
void TestGg(void)
{
	PGG pgg;
	ulong grf;
	long cb, iv;
	byte *qb;
	PSZ psz = PszLit("0123456789ABCDEFG");
	achar rgch[100];

	AssertDo((pgg = GG::PggNew(0)) != pvNil, 0);
	for (iv = 0; iv < 10; iv++)
		{
		AssertDo(pgg->FInsert(iv / 2, iv + 1, psz), 0);
		}
	AssertDo(pgg->FAdd(16, &iv, psz), 0);
	AssertDo(iv == 10, 0);
	AssertDo(pgg->IvMac() == 11, 0);

	grf = 0;
	for (iv = pgg->IvMac(); iv--; )
		{
		cb = pgg->Cb(iv);
		qb = (byte *)pgg->QvGet(iv);
		AssertDo(FEqualRgb(psz, qb, cb), 0);
		grf |= 1L << cb;
		if (cb & 1)
			pgg->Delete(iv);
		}
	AssertDo(grf == 0x000107FE, 0);

	grf = 0;
	for (iv = pgg->IvMac(); iv--; )
		{
		cb = pgg->Cb(iv);
		AssertDo(!(cb & 1), 0);
		pgg->Get(iv, rgch);
		qb = (byte *)pgg->QvGet(iv);
		AssertDo(FEqualRgb(rgch, qb, cb), 0);
		AssertDo(FEqualRgb(rgch, psz, cb), 0);
		grf |= 1L << cb;
		CopyPb(psz, rgch + cb, cb);
		AssertDo(pgg->FPut(iv, cb + cb, rgch), 0);
		}
	AssertDo(grf == 0x00010554, 0);

	grf = 0;
	for (iv = pgg->IvMac(); iv--; )
		{
		cb = pgg->Cb(iv);
		AssertDo(!(cb & 3), 0);
		cb /= 2;
		grf |= 1L << cb;
		pgg->DeleteRgb(iv, LwMin(cb, iv), cb);

		qb = (byte *)pgg->QvGet(iv);
		AssertDo(FEqualRgb(psz, qb, cb), 0);
		}
	AssertDo(grf == 0x00010554, 0);
	ReleasePpo(&pgg);
}


/***************************************************************************
	Test the chunky file stuff.
***************************************************************************/
void TestCfl(void)
{
	enum
		{
		relPaul,
		relMarge,
		relTig,
		relCarl,
		relPriscilla,
		relGreg,
		relShon,
		relClaire,
		relMike,
		relStephen,
		relBaby,
		relCathy,
		relJoshua,
		relRachel,
		relLim
		};

	struct EREL
		{
		CTG ctg;
		CNO cno;
		PSZ psz;
		short relPar1, relPar2;
		};

	const CTG kctgLan = 0x41414141;
	const CTG kctgKatz = 0x42424242;
	const CTG kctgSandy = 0x43434343;
	EREL dnrel[relLim] =
		{
		{ kctgLan, 0, PszLit("Paul"), relLim, relLim },
		{ kctgLan, 0, PszLit("Marge"), relLim, relLim },
		{ kctgLan, 0, PszLit("Tig"), relPaul, relMarge },
		{ kctgKatz, 0, PszLit("Carl"), relLim, relLim },
		{ kctgKatz, 0, PszLit("Priscilla"), relLim, relLim },
		{ kctgKatz, 0, PszLit("Greg"), relCarl, relPriscilla },
		{ kctgKatz, 0, PszLit("Shon"), relCarl, relPriscilla },
		{ kctgKatz, 0, PszLit("Claire"), relPaul, relMarge },
		{ kctgKatz, 0, PszLit("Mike"), relCarl, relPriscilla },
		{ kctgKatz, 0, PszLit("Stephen"), relGreg, relLim },
		{ kctgKatz, 0, PszLit("Baby"), relShon, relClaire },
		{ kctgSandy, 0, PszLit("Cathy"), relCarl, relPriscilla },
		{ kctgSandy, 0, PszLit("Joshua"), relCathy, relLim },
		{ kctgSandy, 0, PszLit("Rachel"), relCathy, relLim },
		};


	FNI fni, fniDst;
	PCFL pcfl, pcflDst;
	BLCK blck;
	short rel;
	long icki;
	CNO cno;
	CKI cki;
	EREL *perel, *perelPar;
	STN stn;
	achar rgch[kcchMaxSz];

	while (FGetFniSaveMacro(&fni, 'TEXT', "\x9" "Save As: ", "\x4" "Junk",
			PszLit("All files\0*.*\0"), NULL))
		{
		AssertDo((pcfl = CFL::PcflCreate(&fni, fcflNil)) != pvNil, 0);
		AssertDo(fniDst.FGetTemp(), 0);
		AssertDo((pcflDst = CFL::PcflCreate(&fniDst, fcflNil)) != pvNil, 0);

		for (rel = 0; rel < relLim; rel++)
			{
			perel = &dnrel[rel];
			AssertDo(pcfl->FAddPv(perel->psz, CchSz(perel->psz), perel->ctg,
				&perel->cno), 0);
			stn = perel->psz;
			AssertDo(pcfl->FSetName(perel->ctg, perel->cno, &stn), 0);
			if (perel->relPar1 < relLim)
				{
				perelPar = &dnrel[perel->relPar1];
				AssertDo(pcfl->FAdoptChild(perelPar->ctg, perelPar->cno,
					perel->ctg, perel->cno), 0);
				}
			if (perel->relPar2 < relLim)
				{
				perelPar = &dnrel[perel->relPar2];
				AssertDo(pcfl->FAdoptChild(perelPar->ctg, perelPar->cno,
					perel->ctg, perel->cno), 0);
				}
			AssertDo(pcfl->FCopy(perel->ctg, perel->cno, pcflDst, &cno),
				"copy failed");
			}
		AssertDo(pcfl->Ccki() == 14, 0);
		for (rel = 0; rel < relLim; rel++)
			{
			perel = &dnrel[rel];
			pcfl->FGetName(perel->ctg, perel->cno, &stn);
			AssertDo(FEqualRgb(stn.Prgch(), perel->psz, stn.Cch()), 0);
			AssertDo(pcfl->FFind(perel->ctg, perel->cno, &blck), 0);
			AssertDo(blck.FRead(rgch), 0);
			AssertDo(FEqualRgb(rgch, perel->psz, CchSz(perel->psz) * size(achar)), 0);
			}

		// copy all the chunks - they should already be there, but this
		// should set up all the child links
		for (rel = 0; rel < relLim; rel++)
			{
			perel = &dnrel[rel];
			AssertDo(pcfl->FCopy(perel->ctg, perel->cno, pcflDst, &cno),
				"copy failed");
			}
		AssertPo(pcflDst, fcflFull);

		// this should delete relShon, but not relBaby
		perelPar = &dnrel[relCarl];
		perel = &dnrel[relShon];
		pcfl->DeleteChild(perelPar->ctg, perelPar->cno, perel->ctg, perel->cno);
		perelPar = &dnrel[relPriscilla];
		pcfl->DeleteChild(perelPar->ctg, perelPar->cno, perel->ctg, perel->cno);
		AssertDo(pcfl->Ccki() == 13, 0);

		// this should delete relGreg and relStephen
		perelPar = &dnrel[relCarl];
		perel = &dnrel[relGreg];
		pcfl->DeleteChild(perelPar->ctg, perelPar->cno, perel->ctg, perel->cno);
		perelPar = &dnrel[relPriscilla];
		pcfl->DeleteChild(perelPar->ctg, perelPar->cno, perel->ctg, perel->cno);
		AssertDo(pcfl->Ccki() == 11, 0);

		// this should delete relCarl, relPriscilla, relCathy, relJoshua,
		// relRachel and relMike
		pcfl->Delete(perelPar->ctg, perelPar->cno);
		perelPar = &dnrel[relCarl];
		pcfl->Delete(perelPar->ctg, perelPar->cno);
		AssertDo(pcfl->Ccki() == 5, 0);

		for (icki = 0; pcfl->FGetCki(icki, &cki); icki++)
			{
			AssertDo(pcfl->FGetName(cki.ctg, cki.cno, &stn), 0);
			AssertDo(pcfl->FFind(cki.ctg, cki.cno, &blck), 0);
			AssertDo(blck.FRead(rgch), 0);
			AssertDo(FEqualRgb(rgch, stn.Prgch(), stn.Cch() * size(achar)), 0);
			AssertDo(stn.Cch() * size(achar) == blck.Cb(), 0);
			}

		// copy all the chunks back
		for (icki = 0; pcflDst->FGetCki(icki, &cki); icki++)
			{
			AssertDo(pcflDst->FCopy(cki.ctg, cki.cno, pcfl, &cno),
				"copy failed");
			}
		AssertPo(pcfl, fcflFull);
		AssertDo(pcfl->Ccki() == 14, 0);
		ReleasePpo(&pcflDst);

		AssertDo(pcfl->FSave(BigLittle('JUNK', 'KNUJ'), pvNil), 0);
		ReleasePpo(&pcfl);
		}

	while (FGetFniOpenMacro(&fni, pvNil, 0, PszLit("All files\0*.*\0"), NULL))
		{
		AssertDo(fni.TExists() == tYes, 0);
		pcfl = CFL::PcflOpen(&fni, fcflNil);
		if (pcfl == pvNil)
			continue;
		AssertPo(pcfl, 0);
		if (FGetFniSaveMacro(&fni, 'TEXT', "\x9" "Save As: ", "\x4" "Junk",
				PszLit("All files\0*.*\0"), NULL))
			{
			AssertDo(pcfl->FSave(BigLittle('JUNK', 'KNUJ'), &fni), 0);
			}
		ReleasePpo(&pcfl);
		}

	CFL::CloseUnmarked();
	CFL::ClearMarks();
	CFL::CloseUnmarked();
}

/******************************************************************************
	Test the error registration code.
******************************************************************************/
void TestErs(void)
{
	const long cercTest = 30;
	long erc, ercT;

	vpers->Clear();
	Assert(vpers->Cerc() == 0, "bad count of error codes on stack");

	for (erc = 0; erc < cercTest; erc++)
		{
		Assert(vpers->Cerc() == LwMin(erc, kcerdMax),
			"bad count of error codes on stack");
		PushErc(erc);
		AssertVar(vpers->FIn(erc), "error code not found", &erc);
		}

	for (erc = cercTest - 1; vpers->FIn(erc); erc--)
		;
	AssertVar(erc == cercTest - kcerdMax - 1, "lost error code", &erc);

	for (erc = 0; erc < vpers->Cerc(); erc++)
		{
		AssertVar((ercT = vpers->ErcGet(erc)) == cercTest - kcerdMax + erc,
			"invalid error code", &ercT);
		}

	for (erc = cercTest - 1; vpers->FPop(&ercT); erc--)
		AssertVar(ercT == erc, "bogus error code returned", &ercT);
	AssertVar(erc == cercTest - kcerdMax - 1, "lost error code", &erc);

	for (erc = 0; erc < cercTest; erc++)
		{
		Assert(vpers->Cerc() == LwMin(erc, kcerdMax),
			"bad count of error codes on stack");
		PushErc(erc);
		AssertVar(vpers->FIn(erc), "error code not found", &erc);
		}
	vpers->Clear();
	Assert(vpers->Cerc() == 0, "bad count of error codes on stack");
}


/******************************************************************************
	Test chunky resource file
******************************************************************************/
void TestCrf(void)
{
	const CNO cnoLim = 10;
	FNI fni;
	CTG ctg = 'JUNK';
	CNO cno;
	PGHQ rgpghq[cnoLim];
	PCFL pcfl;
	PCRF pcrf;
	HQ hq;
	PGHQ pghq;

	if (!fni.FGetTemp() || pvNil == (pcfl = CFL::PcflCreate(&fni, fcflWriteEnable | fcflTemp)))
		{
		Bug("creating chunky file failed");
		return;
		}

	for (cno = 0; cno < cnoLim; cno++)
		{
		AssertDo(pcfl->FPutPv("Test string", 11, ctg, cno), 0);
		}

	if (pvNil == (pcrf = CRF::PcrfNew(pcfl, 50)))
		{
		Bug("creating CRF failed");
		ReleasePpo(&pcfl);
		return;
		}
	ReleasePpo(&pcfl);

	for (cno = 0; cno < cnoLim; cno++)
		pcrf->TLoad(ctg, cno, GHQ::FReadGhq, rscNil, 10);

	for (cno = 0; cno < cnoLim; cno++)
		pcrf->TLoad(ctg, cno, GHQ::FReadGhq, rscNil, 20);

	for (cno = 0; cno < cnoLim; cno++)
		pcrf->TLoad(ctg, cno, GHQ::FReadGhq, rscNil, 20 + cno);

	for (cno = 0; cno < cnoLim; cno++)
		{
		pghq = (PGHQ)pcrf->PbacoFetch(ctg, cno, GHQ::FReadGhq);
		if (pvNil == pghq)
			continue;
		hq = pghq->hq;
		Assert(CbOfHq(hq) == 11, "wrong length");
		Assert(FEqualRgb(QvFromHq(hq), "Test string", 11), "bad bytes");
		ReleasePpo(&pghq);
		}

	for (cno = 0; cno < cnoLim; cno++)
		{
		pghq = (PGHQ)pcrf->PbacoFetch(ctg, cno, GHQ::FReadGhq);
		rgpghq[cno] = pghq;
		if (pvNil == pghq)
			continue;
		hq = pghq->hq;
		Assert(CbOfHq(hq) == 11, "wrong length");
		Assert(FEqualRgb(QvFromHq(hq), "Test string", 11), "bad bytes");
		}

	for (cno = 0; cno < cnoLim; cno++)
		{
		ReleasePpo(&rgpghq[cno]);
		}

	ReleasePpo(&pcrf);
}