/// <summary>
/// Check the consistency of the filesystem and output a summary to the console.
/// </summary>
/// <param name="args">Command arguments: <disk image name></param>
private void CheckFilesystem(IEnumerable <string> args)
{
var ai = args.GetEnumerator();
if (!ai.MoveNext())
{
Console.Error.WriteLine("ERROR: Disk image name missing");
return;
}
var diskname = ai.Current;
using (var dos = DiskFilesystemFactory.OpenFilesystem(DiskFilesystemIdentifier.DragonDos, diskname, false))
{
if (dos == null)
{
Console.Error.WriteLine("ERROR: DragonDos disk image file \"{0}\" does not exist.", diskname);
return;
}
try
{
dos.Check();
Console.WriteLine("The filesystem in {0} is healthy.", diskname);
}
catch (FilesystemConsistencyException e)
{
Console.WriteLine("The filesystem in {0} is inconsistent.", diskname);
if (debug)
{
Console.WriteLine(e.Message);
}
}
}
}
/// <summary>
/// Read a file from the host filesystem and write it to the virtual DragonDos filesystem.
/// </summary>
/// <param name="args">Command arguments: DiskImage DragonDosFilename LocalFilename.</param>
private void WriteFile(IEnumerable <string> args)
{
var ai = args.GetEnumerator();
if (!ai.MoveNext())
{
Console.Error.WriteLine("ERROR: Disk image name missing.");
return;
}
var diskname = ai.Current;
if (!ai.MoveNext())
{
Console.Error.WriteLine("ERROR: DragonDos filename missing.");
return;
}
var dragonFilename = ai.Current;
var localFilename = ai.MoveNext() ? ai.Current : dragonFilename;
using (var dos = DiskFilesystemFactory.OpenFilesystem(DiskFilesystemIdentifier.DragonDos, diskname, true))
{
if (dos == null)
{
Console.Error.WriteLine("ERROR: DragonDos disk image file \"{0}\" does not exist.", diskname);
return;
}
var file = ReadLocalFile(localFilename, ai);
PrintFileInformation(file);
dos.WriteFile(dragonFilename, file);
}
}
public void FileExists(string diskimage, string filesystem, string file, bool exists)
{
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), testdata + diskimage, false))
{
Assert.Equal(exists, dos.FileExists(file));
}
}
public void IsValidFilename(string diskimage, string filesystem, string filename, bool isvalid)
{
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), testdata + diskimage, false))
{
Assert.Equal(isvalid, dos.IsValidFilename(filename));
}
}
public void Free(string diskimage, string filesystem, int freespace)
{
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), testdata + diskimage, false))
{
Assert.Equal(freespace, dos.Free());
}
}
// [Theory]
public void RenameFile(string diskimage, string filesystem, string oldfilename, string newfilename, bool writeprotected, string exception)
{
var readwrite = !writeprotected;
using (var srcdisk = DiskFactory.OpenDisk(testdata + diskimage, false))
{
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), new MemoryDisk(srcdisk), readwrite))
{
try
{
dos.RenameFile(oldfilename, newfilename);
Assert.True(exception == null);
Assert.False(dos.FileExists(oldfilename));
Assert.True(dos.FileExists(newfilename));
dos.Check();
}
catch (Exception e)
{
if (exception == null)
{
Assert.True(false, e.ToString());
}
else
{
Assert.Equal(e.GetType().FullName, exception);
}
}
}
}
}
public void ListFiles(string diskimage, string filesystem, string filelist)
{
var expectedfiles = filelist.Split(new char[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
Array.Sort(expectedfiles);
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), testdata + diskimage, false))
{
var files = dos.ListFiles();
Array.Sort(files);
Assert.Equal(expectedfiles, files);
}
}
/// <summary>
/// Display a map of the free disk sectors.
/// </summary>
/// <param name="args">Command arguments: <disk image name>.</param>
private void Freemap(IEnumerable <string> args)
{
var ai = args.GetEnumerator();
if (!ai.MoveNext())
{
Console.Error.WriteLine("ERROR: Disk image name missing");
return;
}
var diskname = ai.Current;
using (var dos = (DragonDos)DiskFilesystemFactory.OpenFilesystem(DiskFilesystemIdentifier.DragonDos, diskname, false))
{
if (dos == null)
{
Console.Error.WriteLine("ERROR: DragonDos disk image file \"{0}\" does not exist.", diskname);
return;
}
int freeSectors = 0;
int allocatedSectors = 0;
for (int track = 0; track < dos.Disk.Tracks; track++)
{
Console.Write("{0,2} : ", track + 1);
for (int head = 0; head < dos.Disk.Heads; head++)
{
for (int sector = 0; sector < DragonDos.SectorsPerHead; sector++)
{
if (dos.IsSectorAllocated(head, track, sector))
{
Console.Write('*');
allocatedSectors++;
}
else
{
Console.Write('.');
freeSectors++;
}
}
}
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine("{0} allocated sectors.", allocatedSectors);
Console.WriteLine("{0} free sectors.", freeSectors);
}
}
public void Check(string diskimage, string filesystem, bool isvalid)
{
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), testdata + diskimage, false))
{
try
{
dos.Check();
Assert.True(isvalid);
}
catch (FilesystemConsistencyException e)
{
if (isvalid)
{
throw e;
}
}
}
}
/// <summary>
/// Delete one or more files.
/// </summary>
/// <param name="args">Command arguments: <disk image name> {<file name>}.</param>
private void DeleteFile(IEnumerable <string> args)
{
var ai = args.GetEnumerator();
if (!ai.MoveNext())
{
Console.Error.WriteLine("ERROR: Disk image name missing.");
return;
}
var diskname = ai.Current;
using (var dos = DiskFilesystemFactory.OpenFilesystem(DiskFilesystemIdentifier.DragonDos, diskname, true))
{
if (dos == null)
{
Console.Error.WriteLine("ERROR: DragonDos disk image file \"{0}\" does not exist.", diskname);
return;
}
var deleteCount = 0;
while (ai.MoveNext())
{
var filename = ai.Current;
try
{
dos.DeleteFile(filename);
}
catch (FileNotFoundException)
{
Console.Error.WriteLine("WARNING: File {0} not found", filename);
continue;
}
deleteCount++;
Console.WriteLine("Deleted file {0}", filename);
}
if (deleteCount == 0)
{
Console.WriteLine("No files to delete.");
}
else
{
Console.WriteLine("Deleted {0} files.", deleteCount);
}
}
}
/// <summary>
/// Output directory listing to console.
/// </summary>
/// <param name="args">Command arugments: <disk image name>.</param>
private void ListDirectory(IEnumerable <string> args)
{
var ai = args.GetEnumerator();
if (!ai.MoveNext())
{
Console.Error.WriteLine("ERROR: Disk image name missing");
return;
}
var diskname = ai.Current;
using (var dos = DiskFilesystemFactory.OpenFilesystem(DiskFilesystemIdentifier.DragonDos, diskname, false))
{
if (dos == null)
{
Console.Error.WriteLine("ERROR: DragonDos disk image file \"{0}\" does not exist.", diskname);
return;
}
if (raw)
{
var directoryEntries = ((DragonDos)dos).GetDirectoryEntries();
for (var i = 0; i < directoryEntries.Length; i++)
{
Console.WriteLine("{0} {1}", i, directoryEntries[i]);
}
}
else
{
var filecount = 0;
var files = dos.ListFiles();
foreach (var file in files)
{
var fileinfo = dos.GetFileInfo(file);
Console.WriteLine("{0,-15} {1,6} {2}", file, fileinfo.Size, fileinfo.GetAttributes());
filecount++;
}
if (filecount > 0)
{
Console.WriteLine();
}
Console.WriteLine("{1} files, {0} bytes free.", dos.Free(), filecount);
}
}
}
// [Theory]
public void ReadFile(string diskimage, string filesystem, string filename, int length, string filetype, string exception)
{
//TODO Rewrite test to properly test for file type.
using (var dos = DiskFilesystemFactory.OpenFilesystem(ParseFilesystemID(filesystem), testdata + diskimage, false))
{
try
{
var file = dos.ReadFile(filename);
var fileinfo = file.FileInfo;
Assert.True(String.IsNullOrWhiteSpace(exception), "Expected exception " + exception);
Assert.Equal(filetype, file.GetType().FullName);
Assert.Equal(filename, fileinfo.Name);
Assert.Equal(length, fileinfo.Size);
}
catch (Exception e)
{
if (!String.Equals(exception, e.GetType().FullName))
{
throw e;
}
}
}
}
