mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
662 lines
32 KiB
C#
662 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Aaru.Checksums;
|
|
using Aaru.CommonTypes;
|
|
using Aaru.CommonTypes.Enums;
|
|
using Aaru.CommonTypes.Interfaces;
|
|
using Aaru.CommonTypes.Structs;
|
|
using Aaru.Core.Media;
|
|
using Aaru.Devices;
|
|
using FluentAssertions;
|
|
using FluentAssertions.Execution;
|
|
using NUnit.Framework;
|
|
|
|
namespace Aaru.Tests.WritableImages;
|
|
|
|
public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
|
|
{
|
|
const uint SECTORS_TO_READ = 256;
|
|
public abstract OpticalImageTestExpected[] Tests { get; }
|
|
|
|
[Test]
|
|
public void Info()
|
|
{
|
|
Environment.CurrentDirectory = DataFolder;
|
|
ErrorNumber errno;
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
foreach(OpticalImageTestExpected test in Tests)
|
|
{
|
|
string testFile = test.TestFile;
|
|
|
|
bool exists = File.Exists(testFile);
|
|
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
|
|
|
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
|
// It arrives here...
|
|
if(!exists)
|
|
continue;
|
|
|
|
var filtersList = new FiltersList();
|
|
IFilter filter = filtersList.GetFilter(testFile);
|
|
filter.Open(testFile);
|
|
|
|
var image = Activator.CreateInstance(InputPlugin.GetType()) as IOpticalMediaImage;
|
|
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
|
|
|
|
ErrorNumber opened = image.Open(filter);
|
|
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
|
|
|
|
if(opened != ErrorNumber.NoError)
|
|
continue;
|
|
|
|
using(new AssertionScope())
|
|
{
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(test.Sectors, image.Info.Sectors,
|
|
string.Format(Localization.Sectors_0, testFile));
|
|
|
|
if(test.SectorSize > 0)
|
|
{
|
|
Assert.AreEqual(test.SectorSize, image.Info.SectorSize,
|
|
string.Format(Localization.Sector_size_0, testFile));
|
|
}
|
|
|
|
Assert.AreEqual(test.MediaType, image.Info.MediaType,
|
|
string.Format(Localization.Media_type_0, testFile));
|
|
|
|
if(image.Info.MetadataMediaType != MetadataMediaType.OpticalDisc)
|
|
return;
|
|
|
|
Assert.AreEqual(test.Tracks.Length, image.Tracks.Count,
|
|
string.Format(Localization.Tracks_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.Session).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.Session),
|
|
string.Format(Localization.Track_session_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.StartSector).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.Start),
|
|
string.Format(Localization.Track_start_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.EndSector).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.End),
|
|
string.Format(Localization.Track_end_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.Pregap).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.Pregap),
|
|
string.Format(Localization.Track_pregap_0, testFile));
|
|
|
|
var trackNo = 0;
|
|
|
|
var flags = new byte?[image.Tracks.Count];
|
|
ulong latestEndSector = 0;
|
|
|
|
foreach(Track currentTrack in image.Tracks)
|
|
{
|
|
if(currentTrack.EndSector > latestEndSector)
|
|
latestEndSector = currentTrack.EndSector;
|
|
|
|
if(image.Info.ReadableSectorTags.Contains(SectorTagType.CdTrackFlags))
|
|
{
|
|
errno = image.ReadSectorTag(currentTrack.Sequence, SectorTagType.CdTrackFlags,
|
|
out byte[] tmp);
|
|
|
|
if(errno == ErrorNumber.NoError)
|
|
flags[trackNo] = tmp[0];
|
|
}
|
|
|
|
trackNo++;
|
|
}
|
|
|
|
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags),
|
|
string.Format(Localization.Track_flags_0, testFile));
|
|
|
|
Assert.AreEqual(latestEndSector, image.Info.Sectors - 1,
|
|
string.Format(Localization.Last_sector_for_tracks_is_0_but_it_is_1_for_image,
|
|
latestEndSector, image.Info.Sectors));
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void Convert()
|
|
{
|
|
Environment.CurrentDirectory = DataFolder;
|
|
ErrorNumber errno;
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
foreach(OpticalImageTestExpected test in Tests)
|
|
{
|
|
string testFile = test.TestFile;
|
|
|
|
bool exists = File.Exists(testFile);
|
|
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
|
|
|
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
|
// It arrives here...
|
|
if(!exists)
|
|
continue;
|
|
|
|
var filtersList = new FiltersList();
|
|
IFilter filter = filtersList.GetFilter(testFile);
|
|
filter.Open(testFile);
|
|
|
|
var inputFormat = Activator.CreateInstance(InputPlugin.GetType()) as IOpticalMediaImage;
|
|
|
|
Assert.NotNull(inputFormat,
|
|
string.Format(Localization.Could_not_instantiate_input_plugin_for_0, testFile));
|
|
|
|
ErrorNumber opened = inputFormat.Open(filter);
|
|
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
|
|
|
|
if(opened != ErrorNumber.NoError)
|
|
continue;
|
|
|
|
string outputPath = Path.Combine(Path.GetTempPath(), $"{Path.GetRandomFileName()}.{OutputExtension}");
|
|
|
|
var outputFormat = Activator.CreateInstance(OutputPlugin.GetType()) as IWritableOpticalImage;
|
|
|
|
Assert.NotNull(outputFormat,
|
|
string.Format(Localization.Could_not_instantiate_output_plugin_for_0, testFile));
|
|
|
|
Assert.IsTrue(outputFormat.SupportedMediaTypes.Contains(inputFormat.Info.MediaType),
|
|
string.Format(Localization.Trying_to_convert_unsupported_media_type_0_for_1,
|
|
inputFormat.Info.MediaType, testFile));
|
|
|
|
bool useLong = inputFormat.Info.ReadableSectorTags.Except(new[] { SectorTagType.CdTrackFlags }).Any();
|
|
|
|
// TODO: Can be done with LINQ only
|
|
foreach(SectorTagType _ in inputFormat.Info.ReadableSectorTags.Where(sectorTag =>
|
|
!outputFormat.SupportedSectorTags.Contains(sectorTag)).Where(
|
|
sectorTag => sectorTag != SectorTagType.CdTrackFlags &&
|
|
sectorTag != SectorTagType.CdTrackIsrc &&
|
|
sectorTag != SectorTagType.CdSectorSubchannel))
|
|
useLong = false;
|
|
|
|
Assert.IsTrue(
|
|
outputFormat.Create(outputPath, inputFormat.Info.MediaType, new Dictionary<string, string>(),
|
|
inputFormat.Info.Sectors, inputFormat.Info.SectorSize),
|
|
string.Format(Localization.Error_0_creating_output_image, outputFormat.ErrorMessage));
|
|
|
|
foreach(MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags.Where(mediaTag =>
|
|
outputFormat.SupportedMediaTags.Contains(mediaTag)))
|
|
{
|
|
if(inputFormat.ReadMediaTag(mediaTag, out byte[] buffer) == ErrorNumber.NoError)
|
|
outputFormat.WriteMediaTag(buffer, mediaTag);
|
|
}
|
|
|
|
Assert.IsTrue(outputFormat.SetTracks(inputFormat.Tracks),
|
|
string.Format(Localization.Error_0_sending_tracks_list_to_output_image,
|
|
outputFormat.ErrorMessage));
|
|
|
|
ulong doneSectors;
|
|
|
|
foreach(Track track in inputFormat.Tracks)
|
|
{
|
|
doneSectors = 0;
|
|
ulong trackSectors = track.EndSector - track.StartSector + 1;
|
|
|
|
while(doneSectors < trackSectors)
|
|
{
|
|
byte[] sector;
|
|
|
|
uint sectorsToDo;
|
|
|
|
if(trackSectors - doneSectors >= SECTORS_TO_READ)
|
|
sectorsToDo = SECTORS_TO_READ;
|
|
else
|
|
sectorsToDo = (uint)(trackSectors - doneSectors);
|
|
|
|
var useNotLong = false;
|
|
var result = false;
|
|
|
|
if(useLong)
|
|
{
|
|
errno = sectorsToDo == 1
|
|
? inputFormat.ReadSectorLong(doneSectors + track.StartSector, out sector)
|
|
: inputFormat.ReadSectorsLong(doneSectors + track.StartSector, sectorsToDo,
|
|
out sector);
|
|
|
|
if(errno == ErrorNumber.NoError)
|
|
{
|
|
result = sectorsToDo == 1
|
|
? outputFormat.WriteSectorLong(sector, doneSectors + track.StartSector)
|
|
: outputFormat.WriteSectorsLong(sector, doneSectors + track.StartSector,
|
|
sectorsToDo);
|
|
}
|
|
else
|
|
result = false;
|
|
|
|
if(!result &&
|
|
sector.Length % 2352 != 0)
|
|
useNotLong = true;
|
|
}
|
|
|
|
if(!useLong || useNotLong)
|
|
{
|
|
errno = sectorsToDo == 1
|
|
? inputFormat.ReadSector(doneSectors + track.StartSector, out sector)
|
|
: inputFormat.ReadSectors(doneSectors + track.StartSector, sectorsToDo,
|
|
out sector);
|
|
|
|
Assert.AreEqual(ErrorNumber.NoError, errno);
|
|
|
|
result = sectorsToDo == 1
|
|
? outputFormat.WriteSector(sector, doneSectors + track.StartSector)
|
|
: outputFormat.WriteSectors(sector, doneSectors + track.StartSector,
|
|
sectorsToDo);
|
|
}
|
|
|
|
Assert.IsTrue(result,
|
|
string.Format(Localization.Error_0_writing_sector_1, outputFormat.ErrorMessage,
|
|
doneSectors + track.StartSector));
|
|
|
|
doneSectors += sectorsToDo;
|
|
}
|
|
}
|
|
|
|
Dictionary<byte, string> isrcs = new();
|
|
Dictionary<byte, byte> trackFlags = new();
|
|
string mcn = null;
|
|
HashSet<int> subchannelExtents = new();
|
|
Dictionary<byte, int> smallestPregapLbaPerTrack = new();
|
|
var tracks = new Track[inputFormat.Tracks.Count];
|
|
|
|
for(var i = 0; i < tracks.Length; i++)
|
|
{
|
|
tracks[i] = new Track
|
|
{
|
|
Indexes = new Dictionary<ushort, int>(),
|
|
Description = inputFormat.Tracks[i].Description,
|
|
EndSector = inputFormat.Tracks[i].EndSector,
|
|
StartSector = inputFormat.Tracks[i].StartSector,
|
|
Pregap = inputFormat.Tracks[i].Pregap,
|
|
Sequence = inputFormat.Tracks[i].Sequence,
|
|
Session = inputFormat.Tracks[i].Session,
|
|
BytesPerSector = inputFormat.Tracks[i].BytesPerSector,
|
|
RawBytesPerSector = inputFormat.Tracks[i].RawBytesPerSector,
|
|
Type = inputFormat.Tracks[i].Type,
|
|
SubchannelType = inputFormat.Tracks[i].SubchannelType
|
|
};
|
|
|
|
foreach(KeyValuePair<ushort, int> idx in inputFormat.Tracks[i].Indexes)
|
|
tracks[i].Indexes[idx.Key] = idx.Value;
|
|
}
|
|
|
|
foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags.
|
|
Where(t => t == SectorTagType.CdTrackIsrc).OrderBy(t => t))
|
|
{
|
|
foreach(Track track in tracks)
|
|
{
|
|
errno = inputFormat.ReadSectorTag(track.Sequence, tag, out byte[] isrc);
|
|
|
|
if(errno != ErrorNumber.NoError)
|
|
continue;
|
|
|
|
isrcs[(byte)track.Sequence] = Encoding.UTF8.GetString(isrc);
|
|
}
|
|
}
|
|
|
|
foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags.
|
|
Where(t => t == SectorTagType.CdTrackFlags).OrderBy(t => t))
|
|
{
|
|
foreach(Track track in tracks)
|
|
{
|
|
errno = inputFormat.ReadSectorTag(track.Sequence, tag, out byte[] flags);
|
|
|
|
if(errno != ErrorNumber.NoError)
|
|
continue;
|
|
|
|
trackFlags[(byte)track.Sequence] = flags[0];
|
|
}
|
|
}
|
|
|
|
for(ulong s = 0; s < inputFormat.Info.Sectors; s++)
|
|
{
|
|
if(s > int.MaxValue)
|
|
break;
|
|
|
|
subchannelExtents.Add((int)s);
|
|
}
|
|
|
|
foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags.OrderBy(t => t).
|
|
TakeWhile(_ => useLong))
|
|
{
|
|
switch(tag)
|
|
{
|
|
case SectorTagType.AppleSectorTag:
|
|
case SectorTagType.CdSectorSync:
|
|
case SectorTagType.CdSectorHeader:
|
|
case SectorTagType.CdSectorSubHeader:
|
|
case SectorTagType.CdSectorEdc:
|
|
case SectorTagType.CdSectorEccP:
|
|
case SectorTagType.CdSectorEccQ:
|
|
case SectorTagType.CdSectorEcc:
|
|
// This tags are inline in long sector
|
|
continue;
|
|
}
|
|
|
|
if(!outputFormat.SupportedSectorTags.Contains(tag))
|
|
continue;
|
|
|
|
foreach(Track track in inputFormat.Tracks)
|
|
{
|
|
doneSectors = 0;
|
|
ulong trackSectors = track.EndSector - track.StartSector + 1;
|
|
byte[] sector;
|
|
bool result;
|
|
|
|
switch(tag)
|
|
{
|
|
case SectorTagType.CdTrackFlags:
|
|
case SectorTagType.CdTrackIsrc:
|
|
errno = inputFormat.ReadSectorTag(track.Sequence, tag, out sector);
|
|
|
|
Assert.AreEqual(ErrorNumber.NoError, errno,
|
|
string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
|
|
|
|
result = outputFormat.WriteSectorTag(sector, track.Sequence, tag);
|
|
|
|
Assert.IsTrue(result,
|
|
string.Format(Localization.Error_0_writing_tag_not_continuing,
|
|
outputFormat.ErrorMessage));
|
|
|
|
continue;
|
|
}
|
|
|
|
while(doneSectors < trackSectors)
|
|
{
|
|
uint sectorsToDo;
|
|
|
|
if(trackSectors - doneSectors >= SECTORS_TO_READ)
|
|
sectorsToDo = SECTORS_TO_READ;
|
|
else
|
|
sectorsToDo = (uint)(trackSectors - doneSectors);
|
|
|
|
if(sectorsToDo == 1)
|
|
{
|
|
errno = inputFormat.ReadSectorTag(doneSectors + track.StartSector, tag, out sector);
|
|
|
|
Assert.AreEqual(ErrorNumber.NoError, errno,
|
|
string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
|
|
|
|
if(tag == SectorTagType.CdSectorSubchannel)
|
|
{
|
|
bool indexesChanged = CompactDisc.WriteSubchannelToImage(MmcSubchannel.Raw,
|
|
MmcSubchannel.Raw, sector, doneSectors + track.StartSector, 1, null, isrcs,
|
|
(byte)track.Sequence, ref mcn, tracks, subchannelExtents, true,
|
|
outputFormat, true, true, null, null, smallestPregapLbaPerTrack, false,
|
|
out _);
|
|
|
|
if(indexesChanged)
|
|
outputFormat.SetTracks(tracks.ToList());
|
|
|
|
result = true;
|
|
}
|
|
else
|
|
result = outputFormat.WriteSectorTag(sector, doneSectors + track.StartSector, tag);
|
|
}
|
|
else
|
|
{
|
|
errno = inputFormat.ReadSectorsTag(doneSectors + track.StartSector, sectorsToDo, tag,
|
|
out sector);
|
|
|
|
Assert.AreEqual(ErrorNumber.NoError, errno,
|
|
string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
|
|
|
|
if(tag == SectorTagType.CdSectorSubchannel)
|
|
{
|
|
bool indexesChanged = CompactDisc.WriteSubchannelToImage(MmcSubchannel.Raw,
|
|
MmcSubchannel.Raw, sector, doneSectors + track.StartSector, sectorsToDo,
|
|
null, isrcs, (byte)track.Sequence, ref mcn, tracks, subchannelExtents,
|
|
true, outputFormat, true, true, null, null, smallestPregapLbaPerTrack,
|
|
false, out _);
|
|
|
|
if(indexesChanged)
|
|
outputFormat.SetTracks(tracks.ToList());
|
|
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
result = outputFormat.WriteSectorsTag(sector, doneSectors + track.StartSector,
|
|
sectorsToDo, tag);
|
|
}
|
|
}
|
|
|
|
Assert.IsTrue(result,
|
|
string.Format(Localization.Error_0_writing_tag_for_sector_1_not_continuing,
|
|
outputFormat.ErrorMessage, doneSectors + track.StartSector));
|
|
|
|
doneSectors += sectorsToDo;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(isrcs.Count > 0)
|
|
{
|
|
foreach(KeyValuePair<byte, string> isrc in isrcs)
|
|
{
|
|
outputFormat.WriteSectorTag(Encoding.UTF8.GetBytes(isrc.Value), isrc.Key,
|
|
SectorTagType.CdTrackIsrc);
|
|
}
|
|
}
|
|
|
|
if(trackFlags.Count > 0)
|
|
{
|
|
foreach((byte track, byte flags) in trackFlags)
|
|
outputFormat.WriteSectorTag(new[] { flags }, track, SectorTagType.CdTrackFlags);
|
|
}
|
|
|
|
if(mcn != null)
|
|
outputFormat.WriteMediaTag(Encoding.UTF8.GetBytes(mcn), MediaTagType.CD_MCN);
|
|
|
|
// TODO: Progress
|
|
if(inputFormat.Info.MediaType is MediaType.CD or MediaType.CDDA or MediaType.CDG or MediaType.CDEG
|
|
or MediaType.CDI or MediaType.CDROM or MediaType.CDROMXA
|
|
or MediaType.CDPLUS or MediaType.CDMO
|
|
or MediaType.CDR or MediaType.CDRW or MediaType.CDMRW or MediaType.VCD
|
|
or MediaType.SVCD
|
|
or MediaType.PCD or MediaType.DTSCD or MediaType.CDMIDI or MediaType.CDV
|
|
or MediaType.CDIREADY
|
|
or MediaType.FMTOWNS or MediaType.PS1CD or MediaType.PS2CD
|
|
or MediaType.MEGACD or MediaType.SATURNCD
|
|
or MediaType.GDROM or MediaType.GDR or MediaType.MilCD
|
|
or MediaType.SuperCDROM2 or MediaType.JaguarCD
|
|
or MediaType.ThreeDO or MediaType.PCFX or MediaType.NeoGeoCD
|
|
or MediaType.CDTV or MediaType.CD32
|
|
or MediaType.Playdia or MediaType.Pippin or MediaType.VideoNow
|
|
or MediaType.VideoNowColor
|
|
or MediaType.VideoNowXp or MediaType.CVD)
|
|
{
|
|
CompactDisc.GenerateSubchannels(subchannelExtents, tracks, trackFlags, inputFormat.Info.Sectors,
|
|
null, null, null, null, null, outputFormat);
|
|
}
|
|
|
|
Assert.IsTrue(outputFormat.Close(),
|
|
string.Format(Localization.Error_0_closing_output_image_Contents_are_not_correct,
|
|
outputFormat.ErrorMessage));
|
|
|
|
filtersList = new FiltersList();
|
|
filter = filtersList.GetFilter(outputPath);
|
|
filter.Open(outputPath);
|
|
|
|
string tmpFolder = Path.GetDirectoryName(outputPath);
|
|
Environment.CurrentDirectory = tmpFolder;
|
|
|
|
var image = Activator.CreateInstance(OutputPlugin.GetType()) as IOpticalMediaImage;
|
|
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_output_plugin_for_0, testFile));
|
|
|
|
opened = image.Open(filter);
|
|
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_created_0, testFile));
|
|
|
|
if(opened != ErrorNumber.NoError)
|
|
continue;
|
|
|
|
using(new AssertionScope())
|
|
{
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(test.Sectors, image.Info.Sectors,
|
|
string.Format(Localization.Sectors_output_0, testFile));
|
|
|
|
if(test.SectorSize > 0)
|
|
{
|
|
Assert.AreEqual(test.SectorSize, image.Info.SectorSize,
|
|
string.Format(Localization.Sector_size_output_0, testFile));
|
|
}
|
|
|
|
Assert.AreEqual(test.Tracks.Length, image.Tracks.Count,
|
|
string.Format(Localization.Tracks_output_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.Session).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.Session),
|
|
string.Format(Localization.Track_session_output_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.StartSector).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.Start),
|
|
string.Format(Localization.Track_start_output_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.EndSector).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.End),
|
|
string.Format(Localization.Track_end_output_0, testFile));
|
|
|
|
image.Tracks.Select(t => t.Pregap).Should().
|
|
BeEquivalentTo(test.Tracks.Select(s => s.Pregap),
|
|
string.Format(Localization.Track_pregap_output_0, testFile));
|
|
|
|
var trackNo = 0;
|
|
|
|
var flags = new byte?[image.Tracks.Count];
|
|
ulong latestEndSector = 0;
|
|
|
|
foreach(Track currentTrack in image.Tracks)
|
|
{
|
|
if(currentTrack.EndSector > latestEndSector)
|
|
latestEndSector = currentTrack.EndSector;
|
|
|
|
if(image.Info.ReadableSectorTags.Contains(SectorTagType.CdTrackFlags))
|
|
{
|
|
errno = image.ReadSectorTag(currentTrack.Sequence, SectorTagType.CdTrackFlags,
|
|
out byte[] tmp);
|
|
|
|
if(errno == ErrorNumber.NoError)
|
|
flags[trackNo] = tmp[0];
|
|
}
|
|
|
|
trackNo++;
|
|
}
|
|
|
|
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags),
|
|
string.Format(Localization.Track_flags_output_0, testFile));
|
|
|
|
Assert.AreEqual(latestEndSector, image.Info.Sectors - 1,
|
|
string.
|
|
Format(
|
|
Localization.Last_sector_for_tracks_is_0_but_it_is_1_for_image_output,
|
|
latestEndSector, image.Info.Sectors));
|
|
});
|
|
}
|
|
|
|
Md5Context ctx;
|
|
|
|
foreach(bool @long in new[]
|
|
{
|
|
/*false,*/ true
|
|
})
|
|
{
|
|
ctx = new Md5Context();
|
|
|
|
foreach(Track currentTrack in image.Tracks)
|
|
{
|
|
ulong sectors = currentTrack.EndSector - currentTrack.StartSector + 1;
|
|
doneSectors = 0;
|
|
|
|
while(doneSectors < sectors)
|
|
{
|
|
byte[] sector;
|
|
|
|
if(sectors - doneSectors >= SECTORS_TO_READ)
|
|
{
|
|
errno = @long
|
|
? image.ReadSectorsLong(doneSectors, SECTORS_TO_READ,
|
|
currentTrack.Sequence, out sector)
|
|
: image.ReadSectors(doneSectors, SECTORS_TO_READ, currentTrack.Sequence,
|
|
out sector);
|
|
|
|
doneSectors += SECTORS_TO_READ;
|
|
}
|
|
else
|
|
{
|
|
errno = @long
|
|
? image.ReadSectorsLong(doneSectors, (uint)(sectors - doneSectors),
|
|
currentTrack.Sequence, out sector)
|
|
: image.ReadSectors(doneSectors, (uint)(sectors - doneSectors),
|
|
currentTrack.Sequence, out sector);
|
|
|
|
doneSectors += sectors - doneSectors;
|
|
}
|
|
|
|
Assert.AreEqual(ErrorNumber.NoError, errno);
|
|
|
|
ctx.Update(sector);
|
|
}
|
|
}
|
|
|
|
Assert.AreEqual(@long ? test.LongMd5 : test.Md5, ctx.End(),
|
|
string.Format("{0}: {1}",
|
|
@long ? Localization.Long_hash_output : Localization.Hash_output,
|
|
testFile));
|
|
}
|
|
|
|
if(!image.Info.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
|
|
return;
|
|
|
|
ctx = new Md5Context();
|
|
|
|
foreach(Track currentTrack in image.Tracks)
|
|
{
|
|
ulong sectors = currentTrack.EndSector - currentTrack.StartSector + 1;
|
|
doneSectors = 0;
|
|
|
|
while(doneSectors < sectors)
|
|
{
|
|
byte[] sector;
|
|
|
|
if(sectors - doneSectors >= SECTORS_TO_READ)
|
|
{
|
|
errno = image.ReadSectorsTag(doneSectors, SECTORS_TO_READ, currentTrack.Sequence,
|
|
SectorTagType.CdSectorSubchannel, out sector);
|
|
|
|
doneSectors += SECTORS_TO_READ;
|
|
}
|
|
else
|
|
{
|
|
errno = image.ReadSectorsTag(doneSectors, (uint)(sectors - doneSectors),
|
|
currentTrack.Sequence, SectorTagType.CdSectorSubchannel,
|
|
out sector);
|
|
|
|
doneSectors += sectors - doneSectors;
|
|
}
|
|
|
|
Assert.AreEqual(ErrorNumber.NoError, errno);
|
|
|
|
ctx.Update(sector);
|
|
}
|
|
}
|
|
|
|
Assert.AreEqual(test.SubchannelMd5, ctx.End(),
|
|
string.Format(Localization.Subchannel_hash_output_0, testFile));
|
|
}
|
|
});
|
|
}
|
|
} |