path: root/src/frontend/selftest.cpp

#include <FL/forms.H>
hd24fs* testfs;

void createimage_callback(void* y)
{
	cout << "." << endl;
	Fl::add_timeout(1.0,createimage_callback,y);	
	return;
}
int passcount;
int failcount;
#define MINSECTORS 1353964

//#define BITBIGGER (MINSECTORS+10000)
/* this gives for a bit over 5 minutes at 48k, 24 tracks: */
#define BITBIGGER (MINSECTORS+2073600)

/* constant is for pretty demo image. */
void pass()
{
	passcount++;
	cout << "......................................................PASS" << endl;
}
void fail()
{
	failcount++;
	cout << "......................................................FAIL" << endl;
}
void fail(const char* reason)
{
	failcount++;
	cout << "......................................................FAIL" << endl;
	cout << "Reason: "<<reason << endl;
}
void test_createimage()
{
	cout << "Test if creating too small drive images is prevented... " << endl;

	__uint32 lastsector=MINSECTORS-1;

	string* strtest=new string("testimage.h24");
	char message[2048];
	message[0]='\0';
   	Fl::add_timeout(1.0,createimage_callback,&message[0]);
	int result=hd24utils::newdriveimage(strtest,lastsector,&message[0],NULL);
	delete strtest;
	Fl::remove_timeout(&createimage_callback);
	if (result!=-1) fail(); else pass();
	////////////////////////////////////////////////////
	cout << "-----------------------------------------------" << endl;
	cout << "Create minimum size empty drive image... please wait" << endl;
	lastsector=MINSECTORS;

	strtest=new string("testimage.h24");
	result=hd24utils::newdriveimage(strtest,lastsector,&message[0],NULL);
	
	cout << "Image create messages=" << message << endl;
	if (result==0) pass(); else fail();
	// Check expected drive image contents.
	hd24fs* testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	/* we calculate free space based on 1 channel because it is much
	   more sensitive than free space based on 24 channels */
	string* freespace=testfs->freespace(48000,1); 
							
	cout << "Free space on drive: " << *freespace << endl;
	delete testfs;
	//////////////////////////////////////////////////////
	cout << "-----------------------------------------------" << endl;
	cout << "Creating somewhat larger size empty drive image... please wait" << endl;
	lastsector=BITBIGGER;
		
	string* strtest2=new string("testimage2.h24");
	result=hd24utils::newdriveimage(strtest2,lastsector,&message[0],NULL);
	
	cout << "Image create messages=" << message << endl;
	if (result==0) pass(); else fail();
	// Check expected drive image contents.
	hd24fs* testfs2=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest2,false);
	string* freespace2=testfs2->freespace(48000,1);
	cout << "Free space on drive: " << *freespace2 << endl;
	if (strcmp(freespace->c_str(),freespace2->c_str())==0)
	{
		fail("Images were supposed to have different sizes");
	} else {
		pass();
	}
	delete testfs2;
	delete freespace2;
	delete strtest2;
//*/
	delete freespace;
	delete strtest;
	return;
}

void test_useimage()
{
	char failmsg[64];
	cout << "Try to use empty drive image... " << endl;
	//false=force?
	string* strtest=new string("testimage2.h24");
	testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	delete strtest;
	strtest=NULL;

	// Let's see if all is as expected.
	if (!(testfs->isOpen())) fail(); else pass();
	string* freespace=testfs->freespace(48000,24);
	cout << "Free space on drive: " << *freespace << endl;
	delete freespace;
	hd24raw* rawfs=new hd24raw(testfs);
	/*
		These functions are only available through raw FS
	*/
	int songsondisk=rawfs->songsondisk();
	cout << "Songs on disk=" << songsondisk << endl;
	if (songsondisk!=0) fail(); else pass();

	__uint32 lastsector=rawfs->getlastsectornum();
	__uint32 expectedlastsector=BITBIGGER; 
	cout << "Last sectornum of drive image="<< lastsector << endl;
	
	
	if (lastsector!=expectedlastsector)
	{
		sprintf(failmsg,"Expected last sector was %ld but found %ld",expectedlastsector,lastsector);
		fail(failmsg);
	}
	else
	{
		pass();
	}

	string* devname=testfs->getdevicename(); 
	cout <<"Device name="<<*devname<<endl;
	if (*devname=="")
	{
		fail("Device name should always exist");
	} else pass();

	string* volname=testfs->volumename();
	cout <<"Volume name="<<*volname <<endl;
	if (*volname=="") fail("Volume name of freshly formatted drive must be nonempty"); else pass();

	// set volume name, commit, then test if change OK
	__uint32 projcount=testfs->projectcount();
	cout <<"Project count="<<projcount << endl;
	if (projcount!=1) fail("Newly formatted image must have exactly 1 project."); else pass();
	hd24project* currproj=NULL;
	if (projcount>0)
	{
		currproj=testfs->getproject(0); // must error
		cout << "Check protection against getting project 0" << endl;
		if (currproj!=NULL) fail(); else pass();

		delete currproj;
		currproj=testfs->getproject(1); // must not error
		cout << "Check zero songcount for supposedly empty project" << endl;
		__uint32 songcount=currproj->songcount();
		if (songcount!=0) fail(); else pass();

		cout << "Check getting nonexisting/invalid project numbers" << endl;
		int failed=0;
		for (int i=2; i<=100; i++)	
		{
			currproj=testfs->getproject(i); // must not error but must return null
			if (currproj!=NULL)
			{
				failed=1;
			}
		}
		if (failed!=0) fail(); else pass();
	}

	cout << "set volume name in drive image" << endl;	
	testfs->setvolumename("myvol"); // only in memory!!!
	// check if volume name has been set (in memory)
	cout << "reading back volume name to see if set was successful" << endl;

	volname=testfs->volumename();
	if (*volname!="myvol") fail(); else pass();

	cout << "set longer name in drive image" << endl;	
	testfs->setvolumename("mylongervolumename"); // only in memory!!!
	volname=testfs->volumename();
	if (*volname!="mylongervolumename") fail(); else pass();

	cout << "Test truncating too long volume name in drive image" << endl;
	testfs->setvolumename("myoverlylongvolumenamethemaximumissixtyfourcharactersbutwemakeitlongeranyway"); // only in memory!!!
	volname=testfs->volumename();
	if (strlen(volname->c_str())!=64) fail(); else pass();
	cout << "Try to clear volume name" <<endl;
	testfs->setvolumename("");
	volname=testfs->volumename();
	if (strlen(volname->c_str())!=0) fail(); else pass();
	cout << "Setting volume name " << endl;
	testfs->setvolumename("MyVolume");
	cout << "and commiting for later readback." << endl;	
	testfs->savedriveinfo(); // auto-commit
	cout << "Commit done." << endl;
	return;
}

void test_commit()
{
	string* strtest=new string("testimage2.h24");

	cout << "Delete testfs..." << endl;
	delete testfs;
	testfs=NULL;

	pass();

	testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	delete strtest;
	cout << "Reading back volume name" << endl;
	string* volname=testfs->volumename();
	cout << "Read back " << *volname << endl;
	if (*volname!="MyVolume") fail(); else pass();

	// after commit, drive size must be preserved.
	hd24raw* rawfs=new hd24raw(testfs);
	__uint32 lastsector=rawfs->getlastsectornum();
	__uint32 expectedlastsector=BITBIGGER;
 	cout << "Test if image has remained same size: "<< lastsector << endl;
	if (lastsector!=expectedlastsector) fail(); else pass();
	

	testfs->setvolumename("Drive Name");
	testfs->savedriveinfo(); // commit tested before-assume it succeeds.
}

void test_project()
{
	string* strtest=new string("testimage2.h24");

	cout << "Delete testfs..." << endl;
	delete testfs;
	testfs=NULL;
	
	pass();

	testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	delete strtest;
	hd24raw* rawfs=new hd24raw(testfs);
	cout << "Checking current project count... (should be 1): ";
	int pcount=testfs->projectcount();	
	cout << pcount << endl;
	if (pcount==1) pass(); else fail("Project count of formatted drive should be 1");

	cout << "Try to get project id 0 (should not be possible)" << endl;
	hd24project* proj=testfs->getproject(0);
	if (proj==NULL) pass(); else
	{
		delete proj;
		proj=NULL;
		fail("Project IDs should be 1 based but are not!");
	}

	cout << "Try to get project id 1 (first and only project on drive" << endl;
	proj=testfs->getproject(1);
	if (proj==NULL) fail("Cannot get only project on drive"); else
	{
		delete proj;
		proj=NULL;
		pass();
	}
	cout << "Try to get any but the first project on the drive" << endl;
	cout << "(using legal project numbers and one too high number)" << endl;
	int projsgot=0;
	int i=0;
	for (i=2; i<=100; i++)
	{
		if (proj!=NULL)
		{
			delete proj;
			proj=NULL;
		}
		proj=testfs->getproject(i);
		if (proj!=NULL)
		{
			projsgot++;
			fail("Managed to get project number:");
			cout << i << endl;
			delete proj;
			proj=NULL;
		}
	}
	if (proj!=NULL)
	{
		delete proj;
		proj=NULL;
	}

	if (projsgot==0) pass();

	cout << "Try if only project on drive is protected from deleting" << endl;
	testfs->deleteproject(1);
	pcount=testfs->projectcount();	
	cout << pcount << endl;
	if (pcount==1) pass(); else fail("Only project on drive should not be deletable");

	cout << "Try to create a project..." << endl;
	hd24project* newproj=testfs->createproject("selftest project 1");
	if (newproj==NULL)
	{
		fail("Creating project failed");
	} else {
		pass();
	}
	delete newproj; // we won't be using this object anymore.

	cout << "Make sure project creation updates project count..." << endl;
	pcount=testfs->projectcount();	
	if (pcount==2) pass(); else fail("Project count should have been 2 at this stage.");
	cout << "Trying to delete newly created project..." << endl;
	testfs->deleteproject(2);
	pcount=testfs->projectcount();	
	if (pcount==1) pass(); else fail("Deletion successful");

	cout << "Trying to create 98 new projects (should be possible)..." << endl;
	char projname[64];
	int failedcreate=0;	
	for (i=0;i<98;i++)
	{
		cout << "project=" << i << endl;
		sprintf(projname,"selftest project %d",i+2);
		hd24project* newproj=testfs->createproject(projname);
		pcount=testfs->projectcount();	
		if (pcount!=(i+2))
		{
			sprintf(projname,"could not create project %d",i);
			fail(projname);
			failedcreate=1;
			break;
		};
		delete newproj;
	}
	if (failedcreate==0)
	{
		pass();
	}
	cout << "Checking if project count is 99 as expected " << endl;
	pcount=testfs->projectcount();	
	if (pcount==99) pass(); else fail("Nope.");

	cout << "Trying if creating more projects than allowed is prevented" << endl;
	newproj=NULL;
	newproj=testfs->createproject(projname);
	if (newproj!=NULL)
	{
		fail("Project object was returned!");
	} else {
		pass();
	}
	
	pcount=testfs->projectcount();	
	cout << "Verifying project count to still be 99" <<endl;
	if (pcount==99) pass(); else fail("Project count unduely updated.");

	cout << "Deleting last 50 projects" << endl;
	/* this should leave 49 projects in place. */
	for (i=1;i<60;i++)
	{
		testfs->deleteproject(50);
	}
	pcount=testfs->projectcount();	
	if (pcount==49) pass(); else fail("Incorrect project count.");
	cout << "Creating 50th project again" << i << endl;
	sprintf(projname,"selftest project %d",i+2);
	if (newproj!=NULL) delete newproj;

	newproj=testfs->createproject(projname);
	pcount=testfs->projectcount();
	cout << "Expecting project count to be 50 now..." << endl;	
	if (pcount!=50) fail("Incorrect project count"); else pass();

	cout << "Checking project sector of first project (must be 0x14 or 20)" << endl;
	__uint32 projsec= rawfs->getprojectsectornum(1);
	cout << "Proj sector=" << projsec << endl;
	if (projsec!=0x14) fail("Incorrect sector"); else pass();
	
	cout << "Deleting first project (to empty a slot)" << endl;
	pcount=testfs->projectcount();	
	cout << "project count BEFORE=" <<pcount <<endl;

	testfs->deleteproject(1);
	int pcount2=testfs->projectcount();
	cout << "Project count AFTER=" <<pcount2 << endl;	
	if (pcount2!=(pcount-1)) fail("Expected project count to be 49."); else pass();
	projsec= rawfs->getprojectsectornum(1);
	cout << "Second project should originally have been on 0x15,"<<endl;
	cout << "expecting first project to start on that sector now..." <<endl;
	cout << "(in reality it is on " << projsec << ")" << endl;
	if (projsec!=0x15) fail("Incorrect sector"); else pass();
	/* now create a new project-- this project must be on sector 0x14
	again */
	cout << "Creating new project - it should overwrite the first project block" << endl;
	newproj=testfs->createproject(projname);
	pcount=testfs->projectcount();	
	cout << "Expecting project count of 50 again, in reality it is " << pcount << endl;
	if (pcount!=50) fail("Incorrect project count"); else pass();
	__sint32 projid=newproj->projectid();
	cout << "Project id=" << projid << endl;
	if (projid!=50) {
		fail("Unexpected project id");
	}
	projsec=rawfs->getprojectsectornum(projid);
	cout << "Expecting project sector of project " << projid << " to be 0x14," ;
	cout << " in reality it is " << projsec << endl;

	if (projsec!=0x14) fail("Incorrect sector"); else pass();

	newproj->projectname("Changed Name");
	string* projcname=newproj->projectname();
	if (*projcname!="Changed Name") fail("Project name change unsuccessful"); else pass();
	delete projcname;
	newproj->save();
	delete rawfs;		
}


void test_proj2()
{
	int pcount;
	string* strtest=new string("testimage2.h24");

	cout << "Delete testfs..." << endl;
	delete testfs;
	testfs=NULL;

	pass();

	testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	delete strtest;
	cout << "Checking current project count... (should be 50): ";

	pcount=testfs->projectcount();	
	cout << "Expecting project count of 50 again, in reality it is " << pcount << endl;
	if (pcount!=50) fail("Incorrect project count"); else pass();
	cout << "Getting existing project no. 50..." << endl;
	hd24project* currproj=testfs->getproject(50);
	if (currproj==NULL) { fail("Cannot get project"); } else {pass();}
	cout << "Getting project name: ";
	string* pname=currproj->projectname();
	cout << *pname << endl;
	if (*pname!="Changed Name") fail("Project name change unsuccessful"); else pass();
	
//	delete rawfs;		
	
}

void test_song()
{
	string* strtest=new string("testimage2.h24");

	cout << "Delete testfs..." << endl;
	delete testfs;
	testfs=NULL;

	pass();

	testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	delete strtest;

	// Check on-disk songcount
	hd24raw* rawfs=new hd24raw(testfs);
	int songcount=rawfs->songsondisk();
	cout << "Checking if song count is still zero as it should be "<<endl;
	if (songcount!=0)
	{
		fail("Song count of newly formatted drive should be 0.");
	} else {
		pass();
	}

	delete rawfs;		
	
}

void test_demoimage()
{
	string* strtest=new string("testimage2.h24");

	cout << "Delete testfs..." << endl;
	delete testfs;
	testfs=NULL;

	pass();

	testfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,strtest,false);
	delete strtest;
	
	testfs->setvolumename("Sizeable Hard Drive"); // only in memory!!!
	testfs->commit();
	
	string* volname=testfs->volumename();
	if (*volname!="Sizeable Hard Drive") fail(); else pass();
	delete volname;

	cout << "Checking FS version..." << endl;
	string* version=testfs->version();
	if (*version!="1.10") fail("Unexpected FS version (expectation was 1.10)"); else pass();
	delete version;

	cout << "Checking max. project count (99 expected)..." << endl;
	__uint32 maxprojcount=testfs->maxprojects();
	if (maxprojcount!=99) fail("Unexpected max project count"); else pass();

	cout << "Checking block size..." << endl;
	if (testfs->getblocksizeinsectors() != 0x480) fail("Unexpected block size"); else pass();

	// delete all but last project
	while (testfs->projectcount()>1)
	{
		// leave only last project	
		testfs->deleteproject(2);
	}

	// now up the total project count to 42	
	char projname[64];
	int i=1;
	hd24project* newproj=NULL;
	while (testfs->projectcount()!=42)
	{
		i++;
		sprintf(projname,"selftest project %d",i+2);
		int prevprojcount=testfs->projectcount();
		newproj=testfs->createproject(projname);
		int newprojcount=testfs->projectcount();
		if (newprojcount==prevprojcount)
		{
			fail("Failed to create project.");
			break;
		}
		if (newproj!=NULL) 
		{
			delete newproj;
			newproj=NULL;
		}
			
	}
	if (newproj!=NULL)
	{
		delete newproj; // we won't be using this object anymore.
		newproj=NULL;
	}

	// rename project now.
	hd24project* currproj;
	currproj=testfs->getproject(15); // must error
	testfs->lastprojectid(15);
	currproj->projectname("Client X");
	currproj->save();
	volname=testfs->volumename();
	cout <<"Volume name="<<*volname <<endl;
	testfs->commit();
	delete currproj;
	currproj=NULL;
	currproj=testfs->getproject(15);
	cout << "Test if project name change with commit works..." << endl;
	cout << "Projname is supposed to be 'Client X', and is: ";
	string* sprojname=currproj->projectname();
	cout << *sprojname << endl;
	if (*sprojname!="Client X") fail("project name change failed."); else pass();
	delete sprojname;
	cout << "Testing if song count is zero..." << endl;
	if (currproj->songcount()==0) pass(); else fail("Should have been 0");

	// Now it's time to create some songs.
	for (i=0;i<12;i++)
	{
		hd24song* currsong=currproj->createsong("A Huge Hit",24,48000);
		currsong->save();
		delete currsong;
	}
	currproj->lastsongid(8);
	currproj->save();
	testfs->commit();
	hd24song* currsong=currproj->getsong(currproj->lastsongid());
	cout << "Renaming song..." << endl;
	currsong->songname("A Huge Hit (final take)");
	currsong->save();
	testfs->commit();
	delete currsong;
	currsong=NULL;
	currsong=currproj->getsong(currproj->lastsongid());
	cout << "Checking if song ID is equal to last set..." << endl;
	if (currsong->songid()==8) pass(); else fail("Incorrect songid.");
	string* freespacebefore=testfs->freespace(48000,24);
	cout << "Lengthening song..." << endl;
	__uint32 desiredlen=10416000; //00:03:37.00
	__uint32 newlen=currsong->songlength_in_samples(desiredlen);
	if (newlen!=desiredlen)
	{
		fail("Song lengthening failed.");  
		cout << "Length in samples is " << newlen 
		     << "instead of " << desiredlen << endl;
	} else pass();
	
	currsong->setwriteprotected(true);
	currsong->save();
	testfs->commit();
	cout << "Free space on drive before lengthening: " << *freespacebefore << endl;
	string* freespace=testfs->freespace(48000,24);
	cout << "Free space on drive after lengthening: " << *freespace << endl;
	delete freespace;
}

int runselftest(HD24UserInterface* ui)
{
	cout << "=======TESTMODE ACTIVATED=======" << endl;
	passcount=0;
	failcount=0;
	test_createimage();
	test_useimage();
	test_commit();
	test_project();
	test_proj2();

	test_song();
	test_demoimage(); // create an interesting looking demo drive image


	cout << "Create 1 project, 99 projects, try 100th project" << endl;

	cout << "Create 1..99 songs" << endl;

	cout << "rename projects, rename songs" << endl;

	cout << "Delete 1.99 projects/songs" << endl;

	cout << "Record audio to songs" << endl;
	
	// Proceed to test gui.

	Fl_Window* window=ui->make_window(testfs);
	window->end();
	window->show();
	fl_message("Proceeding to test GUI.");
	cout << "====================== TEST COMPLETE ===================" << endl;
	cout << "PASS: " << passcount << endl;
	cout << "FAIL: " << failcount << endl;
	cout << "========================================================" << endl;
	return 0;
}