aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move all localizable strings from Aaru.Tests project to resources.

Browse Source
This commit is contained in:
Natalia Portillo
2022-11-29 10:33:40 +00:00
parent 8b20b4ef25
commit d2962850e9
25 changed files with 2173 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
Aaru.Tests/Aaru.Tests.csproj
View File

@@ -33,4 +33,19 @@
<ProjectReference Include="..\Aaru.Images\Aaru.Images.csproj"/>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Update="Localization\Localization.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Localization.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<Compile Update="Localization\Localization.Designer.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>Localization.resx</DependentUpon>
</Compile>
</ItemGroup>
</Project>

5
Aaru.Tests/Aaru.Tests.csproj.DotSettings Normal file
View File

@@ -0,0 +1,5 @@
<wpf:ResourceDictionary xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib"
xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xml:space="preserve">
<s:Boolean
x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=localization/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

13
Aaru.Tests/Devices/IomegaJaz.cs
View File

@@ -77,7 +77,7 @@ public class IomegaJaz
var image = new ZZZRawImage();
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {_testFiles[i]}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, _testFiles[i]));
if(opened != ErrorNumber.NoError)
continue;
@@ -85,9 +85,14 @@ public class IomegaJaz
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(_sectors[i], image.Info.Sectors, $"Sectors: {_testFiles[i]}");
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, $"Sector size: {_testFiles[i]}");
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, $"Media type: {_testFiles[i]}");
Assert.AreEqual(_sectors[i], image.Info.Sectors,
string.Format(Localization.Sectors_0, _testFiles[i]));
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize,
string.Format(Localization.Sector_size_0, _testFiles[i]));
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType,
string.Format(Localization.Media_type_0, _testFiles[i]));
});
}
});

13
Aaru.Tests/Devices/LS120.cs
View File

@@ -77,7 +77,7 @@ public class Ls120
var image = new ZZZRawImage();
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {_testFiles[i]}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, _testFiles[i]));
if(opened != ErrorNumber.NoError)
continue;
@@ -85,9 +85,14 @@ public class Ls120
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(_sectors[i], image.Info.Sectors, $"Sectors: {_testFiles[i]}");
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, $"Sector size: {_testFiles[i]}");
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, $"Media type: {_testFiles[i]}");
Assert.AreEqual(_sectors[i], image.Info.Sectors,
string.Format(Localization.Sectors_0, _testFiles[i]));
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize,
string.Format(Localization.Sector_size_0, _testFiles[i]));
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType,
string.Format(Localization.Media_type_0, _testFiles[i]));
});
}
});

30
Aaru.Tests/Devices/MultiMediaCard/CID.cs
View File

@@ -62,16 +62,28 @@ public class CID
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(cids[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {cards[i]}");
Assert.AreEqual(16, count, string.Format(Localization.Size_0, cards[i]));
Decoders.MMC.CID cid = Decoders.MMC.Decoders.DecodeCID(response);
Assert.IsNotNull(cid, $"Decoded - {cards[i]}");
Assert.AreEqual(manufacturers[i], cid.Manufacturer, $"Manufacturer - {cards[i]}");
Assert.AreEqual(applications[i], cid.ApplicationID, $"Application ID - {cards[i]}");
Assert.AreEqual(names[i], cid.ProductName, $"Product name - {cards[i]}");
Assert.AreEqual(revisions[i], cid.ProductRevision, $"Product revision - {cards[i]}");
Assert.AreEqual(serials[i], cid.ProductSerialNumber, $"Serial number - {cards[i]}");
Assert.AreEqual(dates[i], cid.ManufacturingDate, $"Manufacturing date - {cards[i]}");
Assert.AreEqual(crcs[i], cid.CRC, $"CRC - {cards[i]}");
Assert.IsNotNull(cid, string.Format(Localization.Decoded_0, cards[i]));
Assert.AreEqual(manufacturers[i], cid.Manufacturer,
string.Format(Localization.Manufacturer_0, cards[i]));
Assert.AreEqual(applications[i], cid.ApplicationID,
string.Format(Localization.Application_ID_0, cards[i]));
Assert.AreEqual(names[i], cid.ProductName, string.Format(Localization.Product_name_0, cards[i]));
Assert.AreEqual(revisions[i], cid.ProductRevision,
string.Format(Localization.Product_revision_0, cards[i]));
Assert.AreEqual(serials[i], cid.ProductSerialNumber,
string.Format(Localization.Serial_number_0, cards[i]));
Assert.AreEqual(dates[i], cid.ManufacturingDate,
string.Format(Localization.Manufacturing_date_0, cards[i]));
Assert.AreEqual(crcs[i], cid.CRC, string.Format(Localization.CRC_0, cards[i]));
});
}
}

86
Aaru.Tests/Devices/MultiMediaCard/CSD.cs
View File

@@ -182,72 +182,92 @@ public class CSD
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(csds[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {cards[i]}");
Assert.AreEqual(16, count, string.Format(Localization.Size_0, cards[i]));
Decoders.MMC.CSD csd = Decoders.MMC.Decoders.DecodeCSD(response);
Assert.IsNotNull(csd, $"Decoded - {cards[i]}");
Assert.AreEqual(structure_versions[i], csd.Structure, $"Structure version - {cards[i]}");
Assert.AreEqual(spec_versions[i], csd.Version, $"Specification version - {cards[i]}");
Assert.AreEqual(taacs[i], csd.TAAC, $"TAAC - {cards[i]}");
Assert.AreEqual(nsacs[i], csd.NSAC, $"NSAC - {cards[i]}");
Assert.AreEqual(speeds[i], csd.Speed, $"Transfer speed - {cards[i]}");
Assert.AreEqual(classes[i], csd.Classes, $"Classes - {cards[i]}");
Assert.AreEqual(read_block_lengths[i], csd.ReadBlockLength, $"Read block length - {cards[i]}");
Assert.IsNotNull(csd, string.Format(Localization.Decoded_0, cards[i]));
Assert.AreEqual(structure_versions[i], csd.Structure,
string.Format(Localization.Structure_version_0, cards[i]));
Assert.AreEqual(spec_versions[i], csd.Version,
string.Format(Localization.Specification_version_0, cards[i]));
Assert.AreEqual(taacs[i], csd.TAAC, string.Format(Localization.TAAC_0, cards[i]));
Assert.AreEqual(nsacs[i], csd.NSAC, string.Format(Localization.NSAC_0, cards[i]));
Assert.AreEqual(speeds[i], csd.Speed, string.Format(Localization.Transfer_speed_0, cards[i]));
Assert.AreEqual(classes[i], csd.Classes, string.Format(Localization.Classes_0, cards[i]));
Assert.AreEqual(read_block_lengths[i], csd.ReadBlockLength,
string.Format(Localization.Read_block_length_0, cards[i]));
Assert.AreEqual(read_partial_blocks[i], csd.ReadsPartialBlocks,
$"Reads partial blocks - {cards[i]}");
string.Format(Localization.Reads_partial_blocks_0, cards[i]));
Assert.AreEqual(write_misaligned_block[i], csd.WriteMisalignment,
$"Writes misaligned blocks - {cards[i]}");
string.Format(Localization.Writes_misaligned_blocks_0, cards[i]));
Assert.AreEqual(read_misaligned_block[i], csd.ReadMisalignment,
$"Reads misaligned blocks - {cards[i]}");
string.Format(Localization.Reads_misaligned_blocks_0, cards[i]));
Assert.AreEqual(dsr_implemented[i], csd.DSRImplemented, $"DSR implemented - {cards[i]}");
Assert.AreEqual(card_sizes[i], csd.Size, $"Card size - {cards[i]}");
Assert.AreEqual(dsr_implemented[i], csd.DSRImplemented,
string.Format(Localization.DSR_implemented_0, cards[i]));
Assert.AreEqual(card_sizes[i], csd.Size, string.Format(Localization.Card_size_0, cards[i]));
Assert.AreEqual(min_read_current[i], csd.ReadCurrentAtVddMin,
$"Reading current at minimum Vdd - {cards[i]}");
string.Format(Localization.Reading_current_at_minimum_Vdd_0, cards[i]));
Assert.AreEqual(max_read_current[i], csd.ReadCurrentAtVddMax,
$"Reading current at maximum Vdd - {cards[i]}");
string.Format(Localization.Reading_current_at_maximum_Vdd_0, cards[i]));
Assert.AreEqual(min_write_current[i], csd.WriteCurrentAtVddMin,
$"Writing current at minimum Vdd - {cards[i]}");
string.Format(Localization.Writing_current_at_minimum_Vdd_0, cards[i]));
Assert.AreEqual(max_write_current[i], csd.WriteCurrentAtVddMax,
$"Writing current at maximum Vdd - {cards[i]}");
string.Format(Localization.Writing_current_at_maximum_Vdd_0, cards[i]));
Assert.AreEqual(size_multiplier[i], csd.SizeMultiplier, $"Card size multiplier - {cards[i]}");
Assert.AreEqual(sector_sizes[i], csd.EraseGroupSize, $"Erase sector size - {cards[i]}");
Assert.AreEqual(size_multiplier[i], csd.SizeMultiplier,
string.Format(Localization.Card_size_multiplier_0, cards[i]));
Assert.AreEqual(sector_sizes[i], csd.EraseGroupSize,
string.Format(Localization.Erase_sector_size_0, cards[i]));
Assert.AreEqual(erase_sector_sizes[i], csd.EraseGroupSizeMultiplier,
$"Erase group size - {cards[i]}");
string.Format(Localization.Erase_group_size_0, cards[i]));
Assert.AreEqual(write_protect_group_size[i], csd.WriteProtectGroupSize,
$"Write protect group size - {cards[i]}");
string.Format(Localization.Write_protect_group_size_0, cards[i]));
Assert.AreEqual(write_protect_group_enable[i], csd.WriteProtectGroupEnable,
$"Write protect group enable - {cards[i]}");
string.Format(Localization.Write_protect_group_enable_0, cards[i]));
Assert.AreEqual(default_eccs[i], csd.DefaultECC, $"Default ECC - {cards[i]}");
Assert.AreEqual(r2w_factors[i], csd.WriteSpeedFactor, $"Read to write factor - {cards[i]}");
Assert.AreEqual(default_eccs[i], csd.DefaultECC,
string.Format(Localization.Default_ECC_0, cards[i]));
Assert.AreEqual(write_block_lengths[i], csd.WriteBlockLength, $"write block length - {cards[i]}");
Assert.AreEqual(r2w_factors[i], csd.WriteSpeedFactor,
string.Format(Localization.Read_to_write_factor_0, cards[i]));
Assert.AreEqual(write_block_lengths[i], csd.WriteBlockLength,
string.Format(Localization.write_block_length_0, cards[i]));
Assert.AreEqual(write_partial_blocks[i], csd.WritesPartialBlocks,
$"Writes partial blocks - {cards[i]}");
string.Format(Localization.Writes_partial_blocks_0, cards[i]));
Assert.AreEqual(file_format_group[i], csd.FileFormatGroup, $"File format group - {cards[i]}");
Assert.AreEqual(copy[i], csd.Copy, $"Copy - {cards[i]}");
Assert.AreEqual(file_format_group[i], csd.FileFormatGroup,
string.Format(Localization.File_format_group_0, cards[i]));
Assert.AreEqual(copy[i], csd.Copy, string.Format(Localization.Copy_0, cards[i]));
Assert.AreEqual(permanent_write_protect[i], csd.PermanentWriteProtect,
$"Permanent write protect - {cards[i]}");
string.Format(Localization.Permanent_write_protect_0, cards[i]));
Assert.AreEqual(temporary_write_protect[i], csd.TemporaryWriteProtect,
$"Temporary write protect - {cards[i]}");
string.Format(Localization.Temporary_write_protect_0, cards[i]));
Assert.AreEqual(file_format[i], csd.FileFormat, $"File format - {cards[i]}");
Assert.AreEqual(ecc[i], csd.ECC, $"ECC - {cards[i]}");
Assert.AreEqual(file_format[i], csd.FileFormat,
string.Format(Localization.File_format_0, cards[i]));
Assert.AreEqual(ecc[i], csd.ECC, string.Format(Localization.ECC_0, cards[i]));
});
}
}

2
Aaru.Tests/Devices/MultiMediaCard/ExtendedCSD.cs
View File

@@ -215,7 +215,7 @@ public class ExtendedCSD
for(int i = 0; i < _ecsd.Length; i++)
{
Decoders.MMC.ExtendedCSD csd = Decoders.MMC.Decoders.DecodeExtendedCSD(_ecsd[i]);
Assert.IsNotNull(csd, $"Not decoded - {i}");
Assert.IsNotNull(csd, string.Format(Localization.Not_decoded_0, i));
csd.Should().BeEquivalentTo(_decoded[i]);
}
}

13
Aaru.Tests/Devices/PocketZip.cs
View File

@@ -77,7 +77,7 @@ public class PocketZip
var image = new ZZZRawImage();
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {_testFiles[i]}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, _testFiles[i]));
if(opened != ErrorNumber.NoError)
continue;
@@ -85,9 +85,14 @@ public class PocketZip
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(_sectors[i], image.Info.Sectors, $"Sectors: {_testFiles[i]}");
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, $"Sector size: {_testFiles[i]}");
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, $"Media type: {_testFiles[i]}");
Assert.AreEqual(_sectors[i], image.Info.Sectors,
string.Format(Localization.Sectors_0, _testFiles[i]));
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize,
string.Format(Localization.Sector_size_0, _testFiles[i]));
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType,
string.Format(Localization.Media_type_0, _testFiles[i]));
});
}
});

30
Aaru.Tests/Devices/SecureDigital/CID.cs
View File

@@ -69,16 +69,28 @@ public class CID
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(cids[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {cards[i]}");
Assert.AreEqual(16, count, string.Format(Localization.Size_0, cards[i]));
Decoders.SecureDigital.CID cid = Decoders.SecureDigital.Decoders.DecodeCID(response);
Assert.IsNotNull(cid, $"Decoded - {cards[i]}");
Assert.AreEqual(manufacturers[i], cid.Manufacturer, $"Manufacturer - {cards[i]}");
Assert.AreEqual(applications[i], cid.ApplicationID, $"Application ID - {cards[i]}");
Assert.AreEqual(names[i], cid.ProductName, $"Product name - {cards[i]}");
Assert.AreEqual(revisions[i], cid.ProductRevision, $"Product revision - {cards[i]}");
Assert.AreEqual(serials[i], cid.ProductSerialNumber, $"Serial number - {cards[i]}");
Assert.AreEqual(dates[i], cid.ManufacturingDate, $"Manufacturing date - {cards[i]}");
Assert.AreEqual(crcs[i], cid.CRC, $"CRC - {cards[i]}");
Assert.IsNotNull(cid, string.Format(Localization.Decoded_0, cards[i]));
Assert.AreEqual(manufacturers[i], cid.Manufacturer,
string.Format(Localization.Manufacturer_0, cards[i]));
Assert.AreEqual(applications[i], cid.ApplicationID,
string.Format(Localization.Application_ID_0, cards[i]));
Assert.AreEqual(names[i], cid.ProductName, string.Format(Localization.Product_name_0, cards[i]));
Assert.AreEqual(revisions[i], cid.ProductRevision,
string.Format(Localization.Product_revision_0, cards[i]));
Assert.AreEqual(serials[i], cid.ProductSerialNumber,
string.Format(Localization.Serial_number_0, cards[i]));
Assert.AreEqual(dates[i], cid.ManufacturingDate,
string.Format(Localization.Manufacturing_date_0, cards[i]));
Assert.AreEqual(crcs[i], cid.CRC, string.Format(Localization.CRC_0, cards[i]));
});
}
}

71
Aaru.Tests/Devices/SecureDigital/CSD.cs
View File

@@ -163,63 +163,78 @@ public class CSD
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(csds[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {cards[i]}");
Assert.AreEqual(16, count, string.Format(Localization.Size_0, cards[i]));
Decoders.SecureDigital.CSD csd = Decoders.SecureDigital.Decoders.DecodeCSD(response);
Assert.IsNotNull(csd, $"Decoded - {cards[i]}");
Assert.AreEqual(structure_versions[i], csd.Structure, $"Version - {cards[i]}");
Assert.AreEqual(taacs[i], csd.TAAC, $"TAAC - {cards[i]}");
Assert.AreEqual(nsacs[i], csd.NSAC, $"NSAC - {cards[i]}");
Assert.AreEqual(speeds[i], csd.Speed, $"Transfer speed - {cards[i]}");
Assert.AreEqual(classes[i], csd.Classes, $"Classes - {cards[i]}");
Assert.AreEqual(read_block_lengths[i], csd.ReadBlockLength, $"Read block length - {cards[i]}");
Assert.IsNotNull(csd, string.Format(Localization.Decoded_0, cards[i]));
Assert.AreEqual(structure_versions[i], csd.Structure,
string.Format(Localization.Version_0, cards[i]));
Assert.AreEqual(taacs[i], csd.TAAC, string.Format(Localization.TAAC_0, cards[i]));
Assert.AreEqual(nsacs[i], csd.NSAC, string.Format(Localization.NSAC_0, cards[i]));
Assert.AreEqual(speeds[i], csd.Speed, string.Format(Localization.Transfer_speed_0, cards[i]));
Assert.AreEqual(classes[i], csd.Classes, string.Format(Localization.Classes_0, cards[i]));
Assert.AreEqual(read_block_lengths[i], csd.ReadBlockLength,
string.Format(Localization.Read_block_length_0, cards[i]));
Assert.AreEqual(read_partial_blocks[i], csd.ReadsPartialBlocks,
$"Reads partial blocks - {cards[i]}");
string.Format(Localization.Reads_partial_blocks_0, cards[i]));
Assert.AreEqual(write_misaligned_block[i], csd.WriteMisalignment,
$"Writes misaligned blocks - {cards[i]}");
string.Format(Localization.Writes_misaligned_blocks_0, cards[i]));
Assert.AreEqual(read_misaligned_block[i], csd.ReadMisalignment,
$"Reads misaligned blocks - {cards[i]}");
string.Format(Localization.Reads_misaligned_blocks_0, cards[i]));
Assert.AreEqual(dsr_implemented[i], csd.DSRImplemented, $"DSR implemented - {cards[i]}");
Assert.AreEqual(card_sizes[i], csd.Size, $"Card size - {cards[i]}");
Assert.AreEqual(dsr_implemented[i], csd.DSRImplemented,
string.Format(Localization.DSR_implemented_0, cards[i]));
Assert.AreEqual(card_sizes[i], csd.Size, string.Format(Localization.Card_size_0, cards[i]));
Assert.AreEqual(min_read_current[i], csd.ReadCurrentAtVddMin,
$"Reading current at minimum Vdd - {cards[i]}");
string.Format(Localization.Reading_current_at_minimum_Vdd_0, cards[i]));
Assert.AreEqual(max_read_current[i], csd.ReadCurrentAtVddMax,
$"Reading current at maximum Vdd - {cards[i]}");
string.Format(Localization.Reading_current_at_maximum_Vdd_0, cards[i]));
Assert.AreEqual(min_write_current[i], csd.WriteCurrentAtVddMin,
$"Writing current at minimum Vdd - {cards[i]}");
string.Format(Localization.Writing_current_at_minimum_Vdd_0, cards[i]));
Assert.AreEqual(max_write_current[i], csd.WriteCurrentAtVddMax,
$"Writing current at maximum Vdd - {cards[i]}");
string.Format(Localization.Writing_current_at_maximum_Vdd_0, cards[i]));
Assert.AreEqual(size_multiplier[i], csd.SizeMultiplier, $"Card size multiplier - {cards[i]}");
Assert.AreEqual(size_multiplier[i], csd.SizeMultiplier,
string.Format(Localization.Card_size_multiplier_0, cards[i]));
Assert.AreEqual(erase_block_enable[i], csd.EraseBlockEnable, $"Erase block enable - {cards[i]}");
Assert.AreEqual(erase_block_enable[i], csd.EraseBlockEnable,
string.Format(Localization.Erase_block_enable_0, cards[i]));
Assert.AreEqual(erase_sector_sizes[i], csd.EraseSectorSize, $"Erase sector size - {cards[i]}");
Assert.AreEqual(erase_sector_sizes[i], csd.EraseSectorSize,
string.Format(Localization.Erase_sector_size_0, cards[i]));
Assert.AreEqual(write_protect_group_size[i], csd.WriteProtectGroupSize,
$"Write protect group size - {cards[i]}");
string.Format(Localization.Write_protect_group_size_0, cards[i]));
Assert.AreEqual(write_protect_group_enable[i], csd.WriteProtectGroupEnable,
$"Write protect group enable - {cards[i]}");
string.Format(Localization.Write_protect_group_enable_0, cards[i]));
Assert.AreEqual(r2w_factors[i], csd.WriteSpeedFactor, $"Read to write factor - {cards[i]}");
Assert.AreEqual(file_format_group[i], csd.FileFormatGroup, $"File format group - {cards[i]}");
Assert.AreEqual(copy[i], csd.Copy, $"Copy - {cards[i]}");
Assert.AreEqual(r2w_factors[i], csd.WriteSpeedFactor,
string.Format(Localization.Read_to_write_factor_0, cards[i]));
Assert.AreEqual(file_format_group[i], csd.FileFormatGroup,
string.Format(Localization.File_format_group_0, cards[i]));
Assert.AreEqual(copy[i], csd.Copy, string.Format(Localization.Copy_0, cards[i]));
Assert.AreEqual(permanent_write_protect[i], csd.PermanentWriteProtect,
$"Permanent write protect - {cards[i]}");
string.Format(Localization.Permanent_write_protect_0, cards[i]));
Assert.AreEqual(temporary_write_protect[i], csd.TemporaryWriteProtect,
$"Temporary write protect - {cards[i]}");
string.Format(Localization.Temporary_write_protect_0, cards[i]));
Assert.AreEqual(file_format[i], csd.FileFormat, $"File format - {cards[i]}");
Assert.AreEqual(file_format[i], csd.FileFormat,
string.Format(Localization.File_format_0, cards[i]));
});
}
}

37
Aaru.Tests/Devices/SecureDigital/SCR.cs
View File

@@ -142,26 +142,37 @@ public class SCR
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(scrs[i], out byte[] response);
Assert.AreEqual(8, count, $"Size - {cards[i]}");
Assert.AreEqual(8, count, string.Format(Localization.Size_0, cards[i]));
Decoders.SecureDigital.SCR scr = Decoders.SecureDigital.Decoders.DecodeSCR(response);
Assert.IsNotNull(scr, $"Decoded - {cards[i]}");
Assert.AreEqual(structure_version[i], scr.Structure, $"Version - {cards[i]}");
Assert.AreEqual(specification_version[i], scr.Spec, $"Specification version - {cards[i]}");
Assert.IsNotNull(scr, string.Format(Localization.Decoded_0, cards[i]));
Assert.AreEqual(structure_version[i], scr.Structure,
string.Format(Localization.Version_0, cards[i]));
Assert.AreEqual(specification_version[i], scr.Spec,
string.Format(Localization.Specification_version_0, cards[i]));
Assert.AreEqual(data_stat_after_erase[i], scr.DataStatusAfterErase,
$"Data stat after erase - {cards[i]}");
string.Format(Localization.Data_stat_after_erase_0, cards[i]));
Assert.AreEqual(sd_security[i], scr.Security, $"Security - {cards[i]}");
Assert.AreEqual((BusWidth)sd_bus_widths[i], scr.BusWidth, $"Bus widths - {cards[i]}");
Assert.AreEqual(sd_spec3[i], scr.Spec3, $"Spec 3 - {cards[i]}");
Assert.AreEqual(ex_security[i], scr.ExtendedSecurity, $"Extended security - {cards[i]}");
Assert.AreEqual(sd_spec4[i], scr.Spec4, $"Spec 4 - {cards[i]}");
Assert.AreEqual(sd_specx[i], scr.SpecX, $"Spec X - {cards[i]}");
Assert.AreEqual(sd_security[i], scr.Security, string.Format(Localization.Security_0, cards[i]));
Assert.AreEqual((BusWidth)sd_bus_widths[i], scr.BusWidth,
string.Format(Localization.Bus_widths_0, cards[i]));
Assert.AreEqual(sd_spec3[i], scr.Spec3, string.Format(Localization.Spec_3_0, cards[i]));
Assert.AreEqual(ex_security[i], scr.ExtendedSecurity,
string.Format(Localization.Extended_security_0, cards[i]));
Assert.AreEqual(sd_spec4[i], scr.Spec4, string.Format(Localization.Spec_4_0, cards[i]));
Assert.AreEqual(sd_specx[i], scr.SpecX, string.Format(Localization.Spec_X_0, cards[i]));
Assert.AreEqual((CommandSupport)cmd_support[i], scr.CommandSupport,
$"Command support - {cards[i]}");
string.Format(Localization.Command_support_0, cards[i]));
Assert.AreEqual(mfg[i], scr.ManufacturerReserved, $"Manufacturer reserved - {cards[i]}");
Assert.AreEqual(mfg[i], scr.ManufacturerReserved,
string.Format(Localization.Manufacturer_reserved_0, cards[i]));
});
}
}

71
Aaru.Tests/Filesystems/FilesystemTest.cs
View File

@@ -35,7 +35,7 @@ public abstract class FilesystemTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -45,13 +45,14 @@ public abstract class FilesystemTest
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(testFile);
Assert.IsNotNull(inputFilter, $"Filter: {testFile}");
Assert.IsNotNull(inputFilter, string.Format(Localization.Filter_0, testFile));
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, $"Image format: {testFile}");
Assert.IsNotNull(image, string.Format(Localization.Image_format_0, testFile));
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), $"Cannot open image for {testFile}");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter),
string.Format(Localization.Cannot_open_image_for_0, testFile));
List<string> idPlugins;
@@ -59,7 +60,8 @@ public abstract class FilesystemTest
{
List<Partition> partitionsList = Core.Partitions.GetAll(image);
Assert.Greater(partitionsList.Count, 0, $"No partitions found for {testFile}");
Assert.Greater(partitionsList.Count, 0,
string.Format(Localization.No_partitions_found_for_0, testFile));
bool found = false;
@@ -78,7 +80,7 @@ public abstract class FilesystemTest
break;
}
Assert.True(found, $"Filesystem not identified for {testFile}");
Assert.True(found, string.Format(Localization.Filesystem_not_identified_for_0, testFile));
}
else
{
@@ -91,9 +93,11 @@ public abstract class FilesystemTest
Core.Filesystems.Identify(image, out idPlugins, wholePart, true);
Assert.Greater(idPlugins.Count, 0, $"No filesystems found for {testFile}");
Assert.Greater(idPlugins.Count, 0,
string.Format(Localization.No_filesystems_found_for_0, testFile));
Assert.True(idPlugins.Contains(Plugin.Id.ToString()), $"Not identified for {testFile}");
Assert.True(idPlugins.Contains(Plugin.Id.ToString()),
string.Format(Localization.Not_identified_for_0, testFile));
}
}
});
@@ -111,7 +115,7 @@ public abstract class FilesystemTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -121,13 +125,14 @@ public abstract class FilesystemTest
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(testFile);
Assert.IsNotNull(inputFilter, $"Filter: {testFile}");
Assert.IsNotNull(inputFilter, string.Format(Localization.Filter_0, testFile));
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, $"Image format: {testFile}");
Assert.IsNotNull(image, string.Format(Localization.Image_format_0, testFile));
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), $"Cannot open image for {testFile}");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter),
string.Format(Localization.Cannot_open_image_for_0, testFile));
Assert.AreEqual(test.MediaType, image.Info.MediaType, testFile);
Assert.AreEqual(test.Sectors, image.Info.Sectors, testFile);
@@ -150,7 +155,7 @@ public abstract class FilesystemTest
var partition = new Partition();
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -160,13 +165,14 @@ public abstract class FilesystemTest
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(testFile);
Assert.IsNotNull(inputFilter, $"Filter: {testFile}");
Assert.IsNotNull(inputFilter, string.Format(Localization.Filter_0, testFile));
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, $"Image format: {testFile}");
Assert.IsNotNull(image, string.Format(Localization.Image_format_0, testFile));
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), $"Cannot open image for {testFile}");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter),
string.Format(Localization.Cannot_open_image_for_0, testFile));
List<string> idPlugins;
@@ -174,7 +180,8 @@ public abstract class FilesystemTest
{
List<Partition> partitionsList = Core.Partitions.GetAll(image);
Assert.Greater(partitionsList.Count, 0, $"No partitions found for {testFile}");
Assert.Greater(partitionsList.Count, 0,
string.Format(Localization.No_partitions_found_for_0, testFile));
// In reverse to skip boot partitions we're not interested in
for(int index = partitionsList.Count - 1; index >= 0; index--)
@@ -204,12 +211,13 @@ public abstract class FilesystemTest
Core.Filesystems.Identify(image, out idPlugins, partition, true);
Assert.Greater(idPlugins.Count, 0, $"No filesystems found for {testFile}");
Assert.Greater(idPlugins.Count, 0,
string.Format(Localization.No_filesystems_found_for_0, testFile));
found = idPlugins.Contains(Plugin.Id.ToString());
}
Assert.True(found, $"Filesystem not identified for {testFile}");
Assert.True(found, string.Format(Localization.Filesystem_not_identified_for_0, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It is not the case, it changes
@@ -218,25 +226,32 @@ public abstract class FilesystemTest
var fs = Activator.CreateInstance(Plugin.GetType()) as IFilesystem;
Assert.NotNull(fs, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(fs, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
fs.GetInformation(image, partition, out _, null);
if(test.ApplicationId != null)
Assert.AreEqual(test.ApplicationId, fs.XmlFsType.ApplicationIdentifier,
$"Application ID: {testFile}");
string.Format(Localization.Application_ID_0, testFile));
Assert.AreEqual(test.Bootable, fs.XmlFsType.Bootable, $"Bootable: {testFile}");
Assert.AreEqual(test.Clusters, fs.XmlFsType.Clusters, $"Clusters: {testFile}");
Assert.AreEqual(test.ClusterSize, fs.XmlFsType.ClusterSize, $"Cluster size: {testFile}");
Assert.AreEqual(test.Bootable, fs.XmlFsType.Bootable, string.Format(Localization.Bootable_0, testFile));
Assert.AreEqual(test.Clusters, fs.XmlFsType.Clusters, string.Format(Localization.Clusters_0, testFile));
Assert.AreEqual(test.ClusterSize, fs.XmlFsType.ClusterSize,
string.Format(Localization.Cluster_size_0, testFile));
if(test.SystemId != null)
Assert.AreEqual(test.SystemId, fs.XmlFsType.SystemIdentifier, $"System ID: {testFile}");
Assert.AreEqual(test.SystemId, fs.XmlFsType.SystemIdentifier,
string.Format(Localization.System_ID_0, testFile));
Assert.AreEqual(_fileSystemType ?? test.Type, fs.XmlFsType.Type, $"Filesystem type: {testFile}");
Assert.AreEqual(_fileSystemType ?? test.Type, fs.XmlFsType.Type,
string.Format(Localization.Filesystem_type_0, testFile));
Assert.AreEqual(test.VolumeName, fs.XmlFsType.VolumeName, $"Volume name: {testFile}");
Assert.AreEqual(test.VolumeSerial, fs.XmlFsType.VolumeSerial, $"Volume serial: {testFile}");
Assert.AreEqual(test.VolumeName, fs.XmlFsType.VolumeName,
string.Format(Localization.Volume_name_0, testFile));
Assert.AreEqual(test.VolumeSerial, fs.XmlFsType.VolumeSerial,
string.Format(Localization.Volume_serial_0, testFile));
}
});
}

82
Aaru.Tests/Filesystems/ReadOnlyFilesystemTest.cs
View File

@@ -36,7 +36,7 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
var partition = new Partition();
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -46,13 +46,14 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(testFile);
Assert.IsNotNull(inputFilter, $"Filter: {testFile}");
Assert.IsNotNull(inputFilter, string.Format(Localization.Filter_0, testFile));
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, $"Image format: {testFile}");
Assert.IsNotNull(image, string.Format(Localization.Image_format_0, testFile));
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), $"Cannot open image for {testFile}");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter),
string.Format(Localization.Cannot_open_image_for_0, testFile));
List<string> idPlugins;
@@ -60,7 +61,8 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
{
List<Partition> partitionsList = Core.Partitions.GetAll(image);
Assert.Greater(partitionsList.Count, 0, $"No partitions found for {testFile}");
Assert.Greater(partitionsList.Count, 0,
string.Format(Localization.No_partitions_found_for_0, testFile));
// In reverse to skip boot partitions we're not interested in
for(int index = partitionsList.Count - 1; index >= 0; index--)
@@ -90,12 +92,13 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
Core.Filesystems.Identify(image, out idPlugins, partition, true);
Assert.Greater(idPlugins.Count, 0, $"No filesystems found for {testFile}");
Assert.Greater(idPlugins.Count, 0,
string.Format(Localization.No_filesystems_found_for_0, testFile));
found = idPlugins.Contains(Plugin.Id.ToString());
}
Assert.True(found, $"Filesystem not identified for {testFile}");
Assert.True(found, string.Format(Localization.Filesystem_not_identified_for_0, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It is not the case, it changes
@@ -104,13 +107,13 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
var fs = Activator.CreateInstance(Plugin.GetType()) as IReadOnlyFilesystem;
Assert.NotNull(fs, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(fs, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
test.Encoding ??= Encoding.ASCII;
ErrorNumber ret = fs.Mount(image, partition, test.Encoding, null, test.Namespace);
Assert.AreEqual(ErrorNumber.NoError, ret, $"Unmountable: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, ret, string.Format(Localization.Unmountable_0, testFile));
var serializer = new JsonSerializer
{
@@ -285,7 +288,8 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
ErrorNumber ret = fs.ReadDir(path, out List<string> contents);
Assert.AreEqual(ErrorNumber.NoError, ret,
$"Unexpected error {ret} when reading directory \"{path}\" of {testFile}.");
string.Format(Localization.Unexpected_error_0_when_reading_directory_1_of_2, ret, path,
testFile));
if(children.Count == 0 &&
contents.Count == 0)
@@ -313,9 +317,11 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
contents.Remove(child.Key);
Assert.AreEqual(ErrorNumber.NoError, ret,
$"Unexpected error {ret} retrieving stats for \"{childPath}\" in {testFile}");
string.Format(Localization.Unexpected_error_0_retrieving_stats_for_1_in_2, ret, childPath,
testFile));
stat.Should().BeEquivalentTo(child.Value.Info, $"Wrong info for \"{childPath}\" in {testFile}");
stat.Should().BeEquivalentTo(child.Value.Info,
string.Format(Localization.Wrong_info_for_0_in_1, childPath, testFile));
byte[] buffer = Array.Empty<byte>();
@@ -324,11 +330,12 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
ret = fs.Read(childPath, 0, 1, ref buffer);
Assert.AreEqual(ErrorNumber.IsDirectory, ret,
$"Got wrong data for directory \"{childPath}\" in {testFile}");
string.Format(Localization.Got_wrong_data_for_directory_0_in_1, childPath, testFile));
Assert.IsNotNull(child.Value.Children,
$"Contents for \"{childPath}\" in {testFile
} must be defined in unit test declaration!");
string.
Format(Localization.Contents_for_0_in_1_must_be_defined_in_unit_test_declaration,
childPath, testFile));
if(child.Value.Children != null)
TestDirectory(fs, childPath, child.Value.Children, testFile, testXattr);
@@ -338,10 +345,12 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
ret = fs.ReadLink(childPath, out string link);
Assert.AreEqual(ErrorNumber.NoError, ret,
$"Got wrong data for symbolic link \"{childPath}\" in {testFile}");
string.Format(Localization.Got_wrong_data_for_symbolic_link_0_in_1, childPath,
testFile));
Assert.AreEqual(child.Value.LinkTarget, link,
$"Invalid target for symbolic link \"{childPath}\" in {testFile}");
string.Format(Localization.Invalid_target_for_symbolic_link_0_in_1, childPath,
testFile));
}
else
@@ -356,20 +365,22 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
if(ret == ErrorNumber.NotSupported)
{
Assert.IsNull(child.Value.XattrsWithMd5,
$"Defined extended attributes for \"{childPath}\" in {testFile
} are not supported by filesystem.");
string.
Format(Localization.Defined_extended_attributes_for_0_in_1_are_not_supported_by_filesystem,
childPath, testFile));
continue;
}
Assert.AreEqual(ErrorNumber.NoError, ret,
$"Unexpected error {ret} when listing extended attributes for \"{childPath}\" in {testFile
}");
string.Format(Localization.Unexpected_error_0_when_listing_extended_attributes_for_1_in_2,
ret, childPath, testFile));
if(xattrs.Count > 0)
Assert.IsNotNull(child.Value.XattrsWithMd5,
$"Extended attributes for \"{childPath}\" in {testFile
} must be defined in unit test declaration!");
string.
Format(Localization.Extended_attributes_for_0_in_1_must_be_defined_in_unit_test_declaration,
childPath, testFile));
if(xattrs.Count > 0 ||
child.Value.XattrsWithMd5?.Count > 0)
@@ -377,13 +388,13 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
}
Assert.IsEmpty(expectedNotFound,
$"Could not find the children of \"{path}\" in {testFile}: {string.Join(" ", expectedNotFound)
}");
string.Format(Localization.Could_not_find_the_children_of_0_in_1_2, path, testFile,
string.Join(" ", expectedNotFound)));
if(contents != null)
Assert.IsEmpty(contents,
$"Found the following unexpected children of \"{path}\" in {testFile}: {
string.Join(" ", contents)}");
string.Format(Localization.Found_the_following_unexpected_children_of_0_in_1_2, path,
testFile, string.Join(" ", contents)));
}
static void TestFile(IReadOnlyFilesystem fs, string path, string md5, long length, string testFile)
@@ -391,7 +402,8 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
byte[] buffer = new byte[length];
ErrorNumber ret = fs.Read(path, 0, length, ref buffer);
Assert.AreEqual(ErrorNumber.NoError, ret, $"Unexpected error {ret} when reading \"{path}\" in {testFile}");
Assert.AreEqual(ErrorNumber.NoError, ret,
string.Format(Localization.Unexpected_error_0_when_reading_1_in_2, ret, path, testFile));
string data = Md5Context.Data(buffer, out _);
@@ -428,20 +440,22 @@ public abstract class ReadOnlyFilesystemTest : FilesystemTest
contents.Remove(xattr.Key);
Assert.AreEqual(ErrorNumber.NoError, ret,
$"Unexpected error {ret} retrieving extended attributes for \"{path}\" in {testFile}");
string.Format(Localization.Unexpected_error_0_retrieving_extended_attributes_for_1_in_2,
ret, path, testFile));
string data = Md5Context.Data(buffer, out _);
Assert.AreEqual(xattr.Value, data,
$"Got MD5 {data} for {xattr.Key} of \"{path}\" in {testFile} but expected {xattr.Value}");
string.Format(Localization.Got_MD5_0_for_1_of_2_in_3_but_expected_4, data, xattr.Key, path,
testFile, xattr.Value));
}
Assert.IsEmpty(expectedNotFound,
$"Could not find the following extended attributes of \"{path}\" in {testFile}: {
string.Join(" ", expectedNotFound)}");
string.Format(Localization.Could_not_find_the_following_extended_attributes_of_0_in_1_2, path,
testFile, string.Join(" ", expectedNotFound)));
Assert.IsEmpty(contents,
$"Found the following unexpected extended attributes of \"{path}\" in {testFile}: {
string.Join(" ", contents)}");
string.Format(Localization.Found_the_following_unexpected_extended_attributes_of_0_in_1_2, path,
testFile, string.Join(" ", contents)));
}
}

53
Aaru.Tests/Images/BlockMediaImageTest.cs
View File

@@ -32,7 +32,7 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -44,10 +44,10 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -55,9 +55,14 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(test.Sectors, image.Info.Sectors, $"Sectors: {testFile}");
Assert.AreEqual(test.SectorSize, image.Info.SectorSize, $"Sector size: {testFile}");
Assert.AreEqual(test.MediaType, image.Info.MediaType, $"Media type: {testFile}");
Assert.AreEqual(test.Sectors, image.Info.Sectors,
string.Format(Localization.Sectors_0, testFile));
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));
});
}
});
@@ -76,7 +81,7 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -88,10 +93,10 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -119,7 +124,7 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
ctx.Update(sector);
}
Assert.AreEqual(test.Md5, ctx.End(), $"Hash: {testFile}");
Assert.AreEqual(test.Md5, ctx.End(), string.Format(Localization.Hash_0, testFile));
}
});
}
@@ -140,7 +145,7 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -152,10 +157,10 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -174,8 +179,8 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
});
Assert.AreEqual(test.Partitions.Length, partitions.Count,
$"Expected {test.Partitions.Length} partitions in {testFile} but found {partitions.Count
}");
string.Format(Localization.Expected_0_partitions_in_1_but_found_2,
test.Partitions.Length, testFile, partitions.Count));
using(new AssertionScope())
Assert.Multiple(() =>
@@ -186,12 +191,14 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
Partition foundPartition = partitions[i];
Assert.AreEqual(expectedPartition.Start, foundPartition.Start,
$"Expected partition {i} to start at sector {expectedPartition.Start
} but found it starts at {foundPartition.Start} in {testFile}");
string.
Format(Localization.Expected_partition_0_to_start_at_sector_1_but_found_it_starts_at_2_in_3,
i, expectedPartition.Start, foundPartition.Start, testFile));
Assert.AreEqual(expectedPartition.Length, foundPartition.Length,
$"Expected partition {i} to have {expectedPartition.Length
} sectors but found it has {foundPartition.Length} sectors in {testFile}");
string.
Format(Localization.Expected_partition_0_to_have_1_sectors_but_found_it_has_2_sectors_in_3,
i, expectedPartition.Length, foundPartition.Length, testFile));
string expectedDataFilename = $"{testFile}.contents.partition{i}.json";
@@ -230,18 +237,18 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
out IReadOnlyFilesystem plugin))
continue;
Assert.IsNotNull(plugin, "Could not instantiate filesystem plugin");
Assert.IsNotNull(plugin, Localization.Could_not_instantiate_filesystem_plugin);
var fs = (IReadOnlyFilesystem)plugin.GetType().GetConstructor(Type.EmptyTypes)?.
Invoke(new object[]
{});
Assert.IsNotNull(fs, $"Could not instantiate filesystem {pluginName}");
Assert.IsNotNull(fs, string.Format(Localization.Could_not_instantiate_filesystem_0, pluginName));
Errno error = fs.Mount(image, partitions[i], null, null, null);
Assert.AreEqual(ErrorNumber.NoError, error,
$"Could not mount {pluginName} in partition {i}.");
string.Format(Localization.Could_not_mount_0_in_partition_1, pluginName, i));
if(error != ErrorNumber.NoError)
continue;
@@ -271,7 +278,7 @@ public abstract class BlockMediaImageTest : BaseMediaImageTest
if(!plugins.ReadOnlyFilesystems.TryGetValue(pluginName, out IReadOnlyFilesystem plugin))
continue;
Assert.IsNotNull(plugin, "Could not instantiate filesystem plugin");
Assert.IsNotNull(plugin, Localization.Could_not_instantiate_filesystem_plugin);
var fs = (IReadOnlyFilesystem)plugin.GetType().GetConstructor(Type.EmptyTypes)?.
Invoke(Array.Empty<object>());

87
Aaru.Tests/Images/OpticalMediaImageTest.cs
View File

@@ -36,7 +36,7 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -48,10 +48,10 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IOpticalMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -59,29 +59,37 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(test.Sectors, image.Info.Sectors, $"Sectors: {testFile}");
Assert.AreEqual(test.Sectors, image.Info.Sectors,
string.Format(Localization.Sectors_0, testFile));
if(test.SectorSize > 0)
Assert.AreEqual(test.SectorSize, image.Info.SectorSize, $"Sector size: {testFile}");
Assert.AreEqual(test.SectorSize, image.Info.SectorSize,
string.Format(Localization.Sector_size_0, testFile));
Assert.AreEqual(test.MediaType, image.Info.MediaType, $"Media type: {testFile}");
Assert.AreEqual(test.MediaType, image.Info.MediaType,
string.Format(Localization.Media_type_0, testFile));
if(image.Info.XmlMediaType != XmlMediaType.OpticalDisc)
return;
Assert.AreEqual(test.Tracks.Length, image.Tracks.Count, $"Tracks: {testFile}");
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), $"Track session: {testFile}");
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), $"Track start: {testFile}");
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), $"Track end: {testFile}");
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), $"Track pregap: {testFile}");
BeEquivalentTo(test.Tracks.Select(s => s.Pregap),
string.Format(Localization.Track_pregap_0, testFile));
int trackNo = 0;
@@ -108,11 +116,12 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
trackNo++;
}
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags), $"Track flags: {testFile}");
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags),
string.Format(Localization.Track_flags_0, testFile));
Assert.AreEqual(latestEndSector, image.Info.Sectors - 1,
$"Last sector for tracks is {latestEndSector}, but it is {image.Info.Sectors
} for image");
string.Format(Localization.Last_sector_for_tracks_is_0_but_it_is_1_for_image,
latestEndSector, image.Info.Sectors));
});
}
});
@@ -130,7 +139,7 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -142,10 +151,10 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IOpticalMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -173,8 +182,8 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
Core.Filesystems.Identify(image, out List<string> idPlugins, partition);
Assert.AreEqual(track.FileSystems.Length, idPlugins.Count,
$"Expected {track.FileSystems.Length} filesystems in {testFile} but found {
idPlugins.Count}");
string.Format(Localization.Expected_0_filesystems_in_1_but_found_2,
track.FileSystems.Length, testFile, idPlugins.Count));
for(int i = 0; i < track.FileSystems.Length; i++)
{
@@ -188,35 +197,38 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
var fs = Activator.CreateInstance(plugin.GetType()) as IFilesystem;
Assert.NotNull(fs, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(fs,
string.Format(Localization.Could_not_instantiate_filesystem_for_0,
testFile));
fs.GetInformation(image, partition, out _, null);
if(track.FileSystems[i].ApplicationId != null)
Assert.AreEqual(track.FileSystems[i].ApplicationId,
fs.XmlFsType.ApplicationIdentifier, $"Application ID: {testFile}");
fs.XmlFsType.ApplicationIdentifier,
string.Format(Localization.Application_ID_0, testFile));
Assert.AreEqual(track.FileSystems[i].Bootable, fs.XmlFsType.Bootable,
$"Bootable: {testFile}");
string.Format(Localization.Bootable_0, testFile));
Assert.AreEqual(track.FileSystems[i].Clusters, fs.XmlFsType.Clusters,
$"Clusters: {testFile}");
string.Format(Localization.Clusters_0, testFile));
Assert.AreEqual(track.FileSystems[i].ClusterSize, fs.XmlFsType.ClusterSize,
$"Cluster size: {testFile}");
string.Format(Localization.Cluster_size_0, testFile));
if(track.FileSystems[i].SystemId != null)
Assert.AreEqual(track.FileSystems[i].SystemId, fs.XmlFsType.SystemIdentifier,
$"System ID: {testFile}");
string.Format(Localization.System_ID_0, testFile));
Assert.AreEqual(track.FileSystems[i].Type, fs.XmlFsType.Type,
$"Filesystem type: {testFile}");
string.Format(Localization.Filesystem_type_0, testFile));
Assert.AreEqual(track.FileSystems[i].VolumeName, fs.XmlFsType.VolumeName,
$"Volume name: {testFile}");
string.Format(Localization.Volume_name_0, testFile));
Assert.AreEqual(track.FileSystems[i].VolumeSerial, fs.XmlFsType.VolumeSerial,
$"Volume serial: {testFile}");
string.Format(Localization.Volume_serial_0, testFile));
if(Activator.CreateInstance(plugin.GetType()) is not IReadOnlyFilesystem rofs)
{
@@ -224,8 +236,9 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
track.FileSystems[i].ContentsJson != null ||
File.Exists($"{testFile}.track{track.Number}.filesystem{i}.contents.json"))
Assert.NotNull(null,
$"Could not instantiate filesystem for {testFile}, track {
track.Number}, filesystem {i}");
string.
Format(Localization.Could_not_instantiate_filesystem_for_0_track_1_filesystem_2,
testFile, track.Number, i));
continue;
}
@@ -235,7 +248,8 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
ErrorNumber ret = rofs.Mount(image, partition, track.FileSystems[i].Encoding, null,
track.FileSystems[i].Namespace);
Assert.AreEqual(ErrorNumber.NoError, ret, $"Unmountable: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, ret,
string.Format(Localization.Unmountable_0, testFile));
var serializer = new JsonSerializer
{
@@ -294,7 +308,7 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
string testFile = Tests[i].TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -306,10 +320,10 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IOpticalMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
return;
@@ -398,7 +412,8 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
}
}
Assert.AreEqual(Tests[i].SubchannelMd5, ctx.End(), $"Subchannel hash: {testFile}");
Assert.AreEqual(Tests[i].SubchannelMd5, ctx.End(),
string.Format(Localization.Subchannel_hash_0, testFile));
}
else
{
@@ -426,7 +441,7 @@ public abstract class OpticalMediaImageTest : BaseMediaImageTest
ctx.Update(sector);
}
Assert.AreEqual(Tests[i].Md5, ctx.End(), $"Hash: {testFile}");
Assert.AreEqual(Tests[i].Md5, ctx.End(), string.Format(Localization.Hash_0, testFile));
}
});
});

39
Aaru.Tests/Images/TapeMediaImageTest.cs
View File

@@ -29,7 +29,7 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -41,22 +41,24 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as ITapeImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
Assert.AreEqual(true, image.IsTape, $"Is tape?: {testFile}");
Assert.AreEqual(true, image.IsTape, string.Format(Localization.Is_tape_0, testFile));
using(new AssertionScope())
Assert.Multiple(() =>
{
image.Files.Should().BeEquivalentTo(test.Files, $"Tape files: {testFile}");
image.Files.Should().
BeEquivalentTo(test.Files, string.Format(Localization.Tape_files_0, testFile));
image.TapePartitions.Should().BeEquivalentTo(test.Partitions, $"Tape partitions: {testFile}");
image.TapePartitions.Should().
BeEquivalentTo(test.Partitions, string.Format(Localization.Tape_partitions_0, testFile));
});
}
});
@@ -74,7 +76,7 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -86,10 +88,10 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -97,9 +99,14 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(test.Sectors, image.Info.Sectors, $"Sectors: {testFile}");
Assert.AreEqual(test.SectorSize, image.Info.SectorSize, $"Sector size: {testFile}");
Assert.AreEqual(test.MediaType, image.Info.MediaType, $"Media type: {testFile}");
Assert.AreEqual(test.Sectors, image.Info.Sectors,
string.Format(Localization.Sectors_0, testFile));
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));
});
}
});
@@ -118,7 +125,7 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -130,10 +137,10 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(Plugin.GetType()) as IMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -161,7 +168,7 @@ public abstract class TapeMediaImageTest : BaseMediaImageTest
ctx.Update(sector);
}
Assert.AreEqual(test.Md5, ctx.End(), $"Hash: {testFile}");
Assert.AreEqual(test.Md5, ctx.End(), string.Format(Localization.Hash_0, testFile));
}
});
}

79
Aaru.Tests/Issues/FsExtractHashIssueTest.cs
View File

@@ -39,7 +39,7 @@ public abstract class FsExtractHashIssueTest
Dictionary<string, string> options = ParsedOptions;
options["debug"] = Debug.ToString();
Assert.IsNotNull(inputFilter, "Cannot open specified file.");
Assert.IsNotNull(inputFilter, Localization.Cannot_open_specified_file);
Encoding encodingClass = null;
@@ -50,15 +50,15 @@ public abstract class FsExtractHashIssueTest
var imageFormat = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.NotNull(imageFormat, "Image format not identified, not proceeding with analysis.");
Assert.NotNull(imageFormat, Localization.Image_format_not_identified_not_proceeding_with_analysis);
Assert.AreEqual(ErrorNumber.NoError, imageFormat.Open(inputFilter), "Unable to open image format");
Assert.AreEqual(ErrorNumber.NoError, imageFormat.Open(inputFilter), Localization.Unable_to_open_image_format);
List<Partition> partitions = Core.Partitions.GetAll(imageFormat);
if(partitions.Count == 0)
{
Assert.IsFalse(ExpectPartitions, "No partitions found");
Assert.IsFalse(ExpectPartitions, Localization.No_partitions_found);
partitions.Add(new Partition
{
@@ -90,7 +90,8 @@ public abstract class FsExtractHashIssueTest
Assert.NotNull(expectedData);
Assert.AreEqual(expectedData.Partitions.Length, partitions.Count,
$"Excepted {expectedData.Partitions.Length} partitions but found {partitions.Count}");
string.Format(Localization.Excepted_0_partitions_but_found_1, expectedData.Partitions.Length,
partitions.Count));
for(int i = 0; i < partitions.Count; i++)
{
@@ -99,7 +100,8 @@ public abstract class FsExtractHashIssueTest
if(idPlugins.Count == 0)
{
Assert.IsNull(expectedData.Partitions[i],
$"Expected no filesystems identified in partition {i} but found {idPlugins.Count}");
string.Format(Localization.Expected_no_filesystems_identified_in_partition_0_but_found_1,
i, idPlugins.Count));
continue;
}
@@ -108,8 +110,8 @@ public abstract class FsExtractHashIssueTest
continue;
Assert.AreEqual(expectedData.Partitions[i].Volumes.Length, idPlugins.Count,
$"Expected {expectedData.Partitions[i].Volumes.Length} filesystems identified in partition {
i} but found {idPlugins.Count}");
string.Format(Localization.Expected_0_filesystems_identified_in_partition_1_but_found_2,
expectedData.Partitions[i].Volumes.Length, i, idPlugins.Count));
for(int j = 0; j < idPlugins.Count; j++)
{
@@ -118,33 +120,38 @@ public abstract class FsExtractHashIssueTest
if(!plugins.ReadOnlyFilesystems.TryGetValue(pluginName, out IReadOnlyFilesystem plugin))
continue;
Assert.IsNotNull(plugin, "Could not instantiate filesystem plugin");
Assert.IsNotNull(plugin, Localization.Could_not_instantiate_filesystem_plugin);
var fs = (IReadOnlyFilesystem)plugin.GetType().GetConstructor(Type.EmptyTypes)?.
Invoke(Array.Empty<object>());
Assert.IsNotNull(fs, $"Could not instantiate filesystem {pluginName}");
Assert.IsNotNull(fs, string.Format(Localization.Could_not_instantiate_filesystem_0, pluginName));
filesystemFound = true;
ErrorNumber error = fs.Mount(imageFormat, partitions[i], encodingClass, options, Namespace);
Assert.AreEqual(ErrorNumber.NoError, error, $"Could not mount {pluginName} in partition {i}.");
Assert.AreEqual(ErrorNumber.NoError, error,
string.Format(Localization.Could_not_mount_0_in_partition_1, pluginName, i));
Assert.AreEqual(expectedData.Partitions[i].Volumes[j].VolumeName, fs.XmlFsType.VolumeName,
$"Excepted volume name \"{expectedData.Partitions[i].Volumes[j].VolumeName
}\" for filesystem {j} in partition {i} but found \"{fs.XmlFsType.VolumeName}\"");
string.
Format(Localization.Excepted_volume_name_0_for_filesystem_1_in_partition_2_but_found_3,
expectedData.Partitions[i].Volumes[j].VolumeName, j, i,
fs.XmlFsType.VolumeName));
VolumeData volumeData = expectedData.Partitions[i].Volumes[j];
ExtractFilesInDir("/", fs, Xattrs, volumeData);
volumeData.Directories.Should().BeEmpty("Expected directories not found:", volumeData.Directories);
volumeData.Files.Should().BeEmpty("Expected files not found:", volumeData.Files.Keys);
volumeData.Directories.Should().
BeEmpty(Localization.Expected_directories_not_found, volumeData.Directories);
volumeData.Files.Should().BeEmpty(Localization.Expected_files_not_found, volumeData.Files.Keys);
}
}
Assert.IsTrue(filesystemFound, "No filesystems found.");
Assert.IsTrue(filesystemFound, Localization.No_filesystems_found);
}
static void ExtractFilesInDir(string path, IReadOnlyFilesystem fs, bool doXattrs, VolumeData volumeData)
@@ -155,25 +162,28 @@ public abstract class FsExtractHashIssueTest
ErrorNumber error = fs.ReadDir(path, out List<string> directory);
Assert.AreEqual(ErrorNumber.NoError, error,
string.Format("Error {0} reading root directory {0}", error.ToString()));
string.Format(Localization.Error_0_reading_root_directory_0, error.ToString()));
foreach(string entry in directory)
{
error = fs.Stat(path + "/" + entry, out FileEntryInfo stat);
Assert.AreEqual(ErrorNumber.NoError, error, $"Error getting stat for entry {entry}");
Assert.AreEqual(ErrorNumber.NoError, error,
string.Format(Localization.Error_getting_stat_for_entry_0, entry));
if(stat.Attributes.HasFlag(FileAttributes.Directory))
{
if(string.IsNullOrWhiteSpace(path))
{
Assert.True(volumeData.Directories.Contains(entry), $"Found unexpected directory {entry}");
Assert.True(volumeData.Directories.Contains(entry),
string.Format(Localization.Found_unexpected_directory_0, entry));
volumeData.Directories.Remove(entry);
}
else
{
Assert.True(volumeData.Directories.Contains(path + "/" + entry),
$"Found unexpected directory {path + "/" + entry}");
Assert.True(volumeData.Directories.Contains(path + "/" + entry),
string.Format(Localization.Found_unexpected_directory_0, path + "/" + entry));
volumeData.Directories.Remove(path + "/" + entry);
}
@@ -187,14 +197,15 @@ public abstract class FsExtractHashIssueTest
if(string.IsNullOrWhiteSpace(path))
{
Assert.IsTrue(volumeData.Files.TryGetValue(entry, out fileData), $"Found unexpected file {entry}");
Assert.IsTrue(volumeData.Files.TryGetValue(entry, out fileData),
string.Format(Localization.Found_unexpected_file_0, entry));
volumeData.Files.Remove(entry);
}
else
{
Assert.IsTrue(volumeData.Files.TryGetValue(path + "/" + entry, out fileData),
$"Found unexpected file {path + "/" + entry}");
Assert.IsTrue(volumeData.Files.TryGetValue(path + "/" + entry, out fileData),
string.Format(Localization.Found_unexpected_file_0, path + "/" + entry));
volumeData.Files.Remove(path + "/" + entry);
}
@@ -204,7 +215,8 @@ public abstract class FsExtractHashIssueTest
error = fs.ListXAttr(path + "/" + entry, out List<string> xattrs);
Assert.AreEqual(ErrorNumber.NoError, error,
$"Error {error} getting extended attributes for entry {path + "/" + entry}");
string.Format(Localization.Error_0_getting_extended_attributes_for_entry_1, error,
path + "/" + entry));
Dictionary<string, string> expectedXattrs = fileData.XattrsWithMd5;
@@ -212,7 +224,8 @@ public abstract class FsExtractHashIssueTest
foreach(string xattr in xattrs)
{
Assert.IsTrue(expectedXattrs.TryGetValue(xattr, out string expectedXattrMd5),
$"Found unexpected extended attribute {xattr} in file {entry}");
string.Format(Localization.Found_unexpected_extended_attribute_0_in_file_1, xattr,
entry));
expectedXattrs.Remove(xattr);
@@ -220,16 +233,18 @@ public abstract class FsExtractHashIssueTest
error = fs.GetXattr(path + "/" + entry, xattr, ref xattrBuf);
Assert.AreEqual(ErrorNumber.NoError, error,
$"Error {error} reading extended attributes for entry {path + "/" + entry}");
string.Format(Localization.Error_0_reading_extended_attributes_for_entry_1,
error, path + "/" + entry));
string xattrMd5 = Md5Context.Data(xattrBuf, out _);
Assert.AreEqual(expectedXattrMd5, xattrMd5,
$"Invalid checksum for xattr {xattr} for file {path + "/" + entry}");
string.Format(Localization.Invalid_checksum_for_xattr_0_for_file_1, xattr,
path + "/" + entry));
}
expectedXattrs.Should().
BeEmpty($"Expected extended attributes not found for file {path + "/" + entry}:",
BeEmpty(string.Format(Localization.Expected_extended_attributes_not_found_for_file_0, path + "/" + entry),
expectedXattrs);
}
@@ -237,11 +252,13 @@ public abstract class FsExtractHashIssueTest
error = fs.Read(path + "/" + entry, 0, stat.Length, ref outBuf);
Assert.AreEqual(ErrorNumber.NoError, error, $"Error {error} reading file {path + "/" + entry}");
Assert.AreEqual(ErrorNumber.NoError, error,
string.Format(Localization.Error_0_reading_file_1, error, path + "/" + entry));
string calculatedMd5 = Md5Context.Data(outBuf, out _);
Assert.AreEqual(fileData.Md5, calculatedMd5, $"Invalid checksum for file {path + "/" + entry}");
Assert.AreEqual(fileData.Md5, calculatedMd5,
string.Format(Localization.Invalid_checksum_for_file_0, path + "/" + entry));
}
}
}

30
Aaru.Tests/Issues/FsExtractIssueTest.cs
View File

@@ -33,7 +33,7 @@ public abstract class FsExtractIssueTest
Dictionary<string, string> options = ParsedOptions;
options["debug"] = Debug.ToString();
Assert.IsNotNull(inputFilter, "Cannot open specified file.");
Assert.IsNotNull(inputFilter, Localization.Cannot_open_specified_file);
Encoding encodingClass = null;
@@ -44,15 +44,15 @@ public abstract class FsExtractIssueTest
var imageFormat = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.NotNull(imageFormat, "Image format not identified, not proceeding with analysis.");
Assert.NotNull(imageFormat, Localization.Image_format_not_identified_not_proceeding_with_analysis);
Assert.AreEqual(ErrorNumber.NoError, imageFormat.Open(inputFilter), "Unable to open image format");
Assert.AreEqual(ErrorNumber.NoError, imageFormat.Open(inputFilter), Localization.Unable_to_open_image_format);
List<Partition> partitions = Core.Partitions.GetAll(imageFormat);
if(partitions.Count == 0)
{
Assert.IsFalse(ExpectPartitions, "No partitions found");
Assert.IsFalse(ExpectPartitions, Localization.No_partitions_found);
partitions.Add(new Partition
{
@@ -82,18 +82,18 @@ public abstract class FsExtractIssueTest
foreach(string pluginName in idPlugins)
if(plugins.ReadOnlyFilesystems.TryGetValue(pluginName, out plugin))
{
Assert.IsNotNull(plugin, "Could not instantiate filesystem plugin");
Assert.IsNotNull(plugin, Localization.Could_not_instantiate_filesystem_plugin);
var fs = (IReadOnlyFilesystem)plugin.GetType().GetConstructor(Type.EmptyTypes)?.
Invoke(Array.Empty<object>());
Assert.IsNotNull(fs, $"Could not instantiate filesystem {pluginName}");
Assert.IsNotNull(fs, string.Format(Localization.Could_not_instantiate_filesystem_0, pluginName));
filesystemFound = true;
error = fs.Mount(imageFormat, partitions[i], encodingClass, options, Namespace);
Assert.AreEqual(ErrorNumber.NoError, error, $"Could not mount {pluginName} in partition {i}.");
Assert.AreEqual(ErrorNumber.NoError, error, string.Format(Localization.Could_not_mount_0_in_partition_1, pluginName, i));
ExtractFilesInDir("/", fs, Xattrs);
}
@@ -108,19 +108,19 @@ public abstract class FsExtractIssueTest
var fs = (IReadOnlyFilesystem)plugin.GetType().GetConstructor(Type.EmptyTypes)?.
Invoke(Array.Empty<object>());
Assert.IsNotNull(fs, $"Could not instantiate filesystem {plugin.Name}");
Assert.IsNotNull(fs, string.Format(Localization.Could_not_instantiate_filesystem_0, plugin.Name));
filesystemFound = true;
error = fs.Mount(imageFormat, partitions[i], encodingClass, options, Namespace);
Assert.AreEqual(ErrorNumber.NoError, error, $"Could not mount {plugin.Name} in partition {i}.");
Assert.AreEqual(ErrorNumber.NoError, error, string.Format(Localization.Could_not_mount_0_in_partition_1, plugin.Name, i));
ExtractFilesInDir("/", fs, Xattrs);
}
}
Assert.IsTrue(filesystemFound, "No filesystems found.");
Assert.IsTrue(filesystemFound, Localization.No_filesystems_found);
}
static void ExtractFilesInDir(string path, IReadOnlyFilesystem fs, bool doXattrs)
@@ -131,13 +131,13 @@ public abstract class FsExtractIssueTest
ErrorNumber error = fs.ReadDir(path, out List<string> directory);
Assert.AreEqual(ErrorNumber.NoError, error,
string.Format("Error {0} reading root directory {0}", error.ToString()));
string.Format(Localization.Error_0_reading_root_directory_0, error.ToString()));
foreach(string entry in directory)
{
error = fs.Stat(path + "/" + entry, out FileEntryInfo stat);
Assert.AreEqual(ErrorNumber.NoError, error, $"Error getting stat for entry {entry}");
Assert.AreEqual(ErrorNumber.NoError, error, string.Format(Localization.Error_getting_stat_for_entry_0, entry));
if(stat.Attributes.HasFlag(FileAttributes.Directory))
{
@@ -151,7 +151,7 @@ public abstract class FsExtractIssueTest
error = fs.ListXAttr(path + "/" + entry, out List<string> xattrs);
Assert.AreEqual(ErrorNumber.NoError, error,
$"Error {error} getting extended attributes for entry {path + "/" + entry}");
string.Format(Localization.Error_0_getting_extended_attributes_for_entry_1, error, path + "/" + entry));
if(error == ErrorNumber.NoError)
foreach(string xattr in xattrs)
@@ -160,7 +160,7 @@ public abstract class FsExtractIssueTest
error = fs.GetXattr(path + "/" + entry, xattr, ref xattrBuf);
Assert.AreEqual(ErrorNumber.NoError, error,
$"Error {error} reading extended attributes for entry {path + "/" + entry}");
string.Format(Localization.Error_0_reading_extended_attributes_for_entry_1, error, path + "/" + entry));
}
}
@@ -168,7 +168,7 @@ public abstract class FsExtractIssueTest
error = fs.Read(path + "/" + entry, 0, stat.Length, ref outBuf);
Assert.AreEqual(ErrorNumber.NoError, error, $"Error {error} reading file {path + "/" + entry}");
Assert.AreEqual(ErrorNumber.NoError, error, string.Format(Localization.Error_0_reading_file_1, error, path + "/" + entry));
}
}
}

8
Aaru.Tests/Issues/ImageReadIssueTest.cs
View File

@@ -22,18 +22,18 @@ public abstract class ImageReadIssueTest
Environment.CurrentDirectory = DataFolder;
bool exists = File.Exists(TestFile);
Assert.True(exists, "Test file not found");
Assert.True(exists, Localization.Test_file_not_found);
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(TestFile);
Assert.IsNotNull(inputFilter, "Filter for test file is not detected");
Assert.IsNotNull(inputFilter, Localization.Filter_for_test_file_is_not_detected);
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, "Image format for test file is not detected");
Assert.IsNotNull(image, Localization.Image_format_for_test_file_is_not_detected);
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), "Cannot open image for test file");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), Localization.Cannot_open_image_for_test_file);
ulong doneSectors = 0;
var ctx = new Crc32Context();

46
Aaru.Tests/Issues/OpticalImageConvertIssueTest.cs
View File

@@ -49,33 +49,33 @@ public abstract class OpticalImageConvertIssueTest
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(InputPath);
Assert.IsNotNull(inputFilter, "Cannot open specified file.");
Assert.IsNotNull(inputFilter, Localization.Cannot_open_specified_file);
string outputPath = Path.Combine(Path.GetTempPath(), SuggestedOutputFilename);
Assert.IsFalse(File.Exists(outputPath), "Output file already exists, not continuing.");
Assert.IsFalse(File.Exists(outputPath), Localization.Output_file_already_exists_not_continuing);
var inputFormat = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(inputFormat, "Input image format not identified, not proceeding with conversion.");
Assert.IsNotNull(inputFormat, Localization.Input_image_format_not_identified_not_proceeding_with_conversion);
Assert.AreEqual(ErrorNumber.NoError, inputFormat.Open(inputFilter), "Unable to open image format");
Assert.AreEqual(ErrorNumber.NoError, inputFormat.Open(inputFilter), Localization.Unable_to_open_image_format);
Assert.IsTrue(OutputFormat.SupportedMediaTypes.Contains(inputFormat.Info.MediaType),
"Output format does not support media type, cannot continue...");
Localization.Output_format_does_not_support_media_type_cannot_continue);
if(inputFormat.Info.ReadableSectorTags.Count == 0)
Assert.IsFalse(UseLong, "Input image does not support long sectors.");
Assert.IsFalse(UseLong, Localization.Input_image_does_not_support_long_sectors);
var inputOptical = inputFormat as IOpticalMediaImage;
var outputOptical = OutputFormat as IWritableOpticalImage;
Assert.IsNotNull(inputOptical, "Could not treat existing image as optical disc.");
Assert.IsNotNull(outputOptical, "Could not treat new image as optical disc.");
Assert.IsNotNull(inputOptical.Tracks, "Existing image contains no tracks.");
Assert.IsNotNull(inputOptical, Localization.Could_not_treat_existing_image_as_optical_disc);
Assert.IsNotNull(outputOptical, Localization.Could_not_treat_new_image_as_optical_disc);
Assert.IsNotNull(inputOptical.Tracks, Localization.Existing_image_contains_no_tracks);
Assert.IsTrue(outputOptical.Create(outputPath, inputFormat.Info.MediaType, ParsedOptions, inputFormat.Info.Sectors, inputFormat.Info.SectorSize),
$"Error {outputOptical.ErrorMessage} creating output image.");
string.Format(Localization.Error_0_creating_output_image, outputOptical.ErrorMessage));
var metadata = new ImageInfo
{
@@ -97,7 +97,7 @@ public abstract class OpticalImageConvertIssueTest
MediaTitle = inputFormat.Info.MediaTitle
};
Assert.IsTrue(outputOptical.SetMetadata(metadata), $"Error {outputOptical.ErrorMessage} setting metadata, ");
Assert.IsTrue(outputOptical.SetMetadata(metadata), string.Format(Localization.Error_0_setting_metadata, outputOptical.ErrorMessage));
CICMMetadataType cicmMetadata = inputFormat.CicmMetadata;
List<DumpHardwareType> dumpHardware = inputFormat.DumpHardware;
@@ -105,18 +105,18 @@ public abstract class OpticalImageConvertIssueTest
foreach(MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags.Where(mediaTag =>
outputOptical.SupportedMediaTags.Contains(mediaTag)))
{
AaruConsole.WriteLine("Converting media tag {0}", mediaTag);
AaruConsole.WriteLine(Localization.Converting_media_tag_0, mediaTag);
errno = inputFormat.ReadMediaTag(mediaTag, out byte[] tag);
Assert.AreEqual(ErrorNumber.NoError, errno);
Assert.IsTrue(outputOptical.WriteMediaTag(tag, mediaTag));
}
AaruConsole.WriteLine("{0} sectors to convert", inputFormat.Info.Sectors);
AaruConsole.WriteLine(Localization._0_sectors_to_convert, inputFormat.Info.Sectors);
ulong doneSectors;
Assert.IsTrue(outputOptical.SetTracks(inputOptical.Tracks),
$"Error {outputOptical.ErrorMessage} sending tracks list to output image.");
string.Format(Localization.Error_0_sending_tracks_list_to_output_image, outputOptical.ErrorMessage));
foreach(Track track in inputOptical.Tracks)
{
@@ -167,8 +167,7 @@ public abstract class OpticalImageConvertIssueTest
}
Assert.IsTrue(result,
$"Error {outputOptical.ErrorMessage} writing sector {doneSectors + track.StartSector
}, not continuing...");
string.Format(Localization.Error_0_writing_sector_1_not_continuing, outputOptical.ErrorMessage, doneSectors + track.StartSector));
doneSectors += sectorsToDo;
}
@@ -270,11 +269,11 @@ public abstract class OpticalImageConvertIssueTest
case SectorTagType.CdTrackIsrc:
errno = inputFormat.ReadSectorTag(track.Sequence, tag, out sector);
Assert.AreEqual(ErrorNumber.NoError, errno, $"Error {errno} reading tag, not continuing...");
Assert.AreEqual(ErrorNumber.NoError, errno, string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
result = outputOptical.WriteSectorTag(sector, track.Sequence, tag);
Assert.IsTrue(result, $"Error {outputOptical.ErrorMessage} writing tag, not continuing...");
Assert.IsTrue(result, string.Format(Localization.Error_0_writing_tag_not_continuing, outputOptical.ErrorMessage));
continue;
}
@@ -292,7 +291,7 @@ public abstract class OpticalImageConvertIssueTest
{
errno = inputFormat.ReadSectorTag(doneSectors + track.StartSector, tag, out sector);
Assert.AreEqual(ErrorNumber.NoError, errno, $"Error {errno} reading tag, not continuing...");
Assert.AreEqual(ErrorNumber.NoError, errno, string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
if(tag == SectorTagType.CdSectorSubchannel)
{
@@ -314,7 +313,7 @@ public abstract class OpticalImageConvertIssueTest
errno = inputFormat.ReadSectorsTag(doneSectors + track.StartSector, sectorsToDo, tag,
out sector);
Assert.AreEqual(ErrorNumber.NoError, errno, $"Error {errno} reading tag, not continuing...");
Assert.AreEqual(ErrorNumber.NoError, errno, string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
if(tag == SectorTagType.CdSectorSubchannel)
{
@@ -334,8 +333,7 @@ public abstract class OpticalImageConvertIssueTest
}
Assert.IsTrue(result,
$"Error {outputOptical.ErrorMessage} writing tag for sector {
doneSectors + track.StartSector}, not continuing...");
string.Format(Localization.Error_0_writing_tag_for_sector_1_not_continuing, outputOptical.ErrorMessage, doneSectors + track.StartSector));
doneSectors += sectorsToDo;
}
@@ -375,14 +373,14 @@ public abstract class OpticalImageConvertIssueTest
}
Assert.True(outputOptical.Close(),
$"Error {outputOptical.ErrorMessage} closing output image... Contents are not correct.");
string.Format(Localization.Error_0_closing_output_image_Contents_are_not_correct, outputOptical.ErrorMessage));
// Some images will never generate the same
if(Md5 != null)
{
string md5 = Md5Context.File(outputPath, out _);
Assert.AreEqual(Md5, md5, "Hashes are different");
Assert.AreEqual(Md5, md5, Localization.Hashes_are_different);
}
File.Delete(outputPath);

10
Aaru.Tests/Issues/OpticalImageReadIssueTest.cs
View File

@@ -24,22 +24,22 @@ public abstract class OpticalImageReadIssueTest
Environment.CurrentDirectory = DataFolder;
bool exists = File.Exists(TestFile);
Assert.True(exists, "Test file not found");
Assert.True(exists, Localization.Test_file_not_found);
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(TestFile);
Assert.IsNotNull(inputFilter, "Filter for test file is not detected");
Assert.IsNotNull(inputFilter, Localization.Filter_for_test_file_is_not_detected);
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, "Image format for test file is not detected");
Assert.IsNotNull(image, Localization.Image_format_for_test_file_is_not_detected);
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), "Cannot open image for test file");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), Localization.Cannot_open_image_for_test_file);
var opticalInput = image as IOpticalMediaImage;
Assert.IsNotNull(opticalInput, "Image format for test file is not for an optical disc");
Assert.IsNotNull(opticalInput, Localization.Image_format_for_test_file_is_not_for_an_optical_disc);
var ctx = new Crc32Context();

1086
Aaru.Tests/Localization/Localization.Designer.cs generated Normal file
View File

File diff suppressed because it is too large Load Diff

543
Aaru.Tests/Localization/Localization.resx Normal file
View File

@@ -0,0 +1,543 @@
<?xml version="1.0" encoding="utf-8" ?>
<root>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" id="root"
xmlns="">
<xsd:element name="root" msdata:IsDataSet="true"></xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>1.3</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089
</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089
</value>
</resheader>
<data name="Size_0" xml:space="preserve">
<value>Size - {0}</value>
</data>
<data name="Decoded_0" xml:space="preserve">
<value>Decoded - {0}</value>
</data>
<data name="Manufacturer_0" xml:space="preserve">
<value>Manufacturer - {0}</value>
</data>
<data name="Product_name_0" xml:space="preserve">
<value>Product name - {0}</value>
</data>
<data name="Product_revision_0" xml:space="preserve">
<value>Product revision - {0}</value>
</data>
<data name="Serial_number_0" xml:space="preserve">
<value>Serial number - {0}</value>
</data>
<data name="Manufacturing_date_0" xml:space="preserve">
<value>Manufacturing date - {0}</value>
</data>
<data name="CRC_0" xml:space="preserve">
<value>CRC - {0}</value>
</data>
<data name="Structure_version_0" xml:space="preserve">
<value>Structure version - {0}</value>
</data>
<data name="Specification_version_0" xml:space="preserve">
<value>Specification version - {0}</value>
</data>
<data name="TAAC_0" xml:space="preserve">
<value>TAAC - {0}</value>
</data>
<data name="NSAC_0" xml:space="preserve">
<value>NSAC - {0}</value>
</data>
<data name="Transfer_speed_0" xml:space="preserve">
<value>Transfer speed - {0}</value>
</data>
<data name="Classes_0" xml:space="preserve">
<value>Classes - {0}</value>
</data>
<data name="Read_block_length_0" xml:space="preserve">
<value>Read block length - {0}</value>
</data>
<data name="Reads_partial_blocks_0" xml:space="preserve">
<value>Reads partial blocks - {0}</value>
</data>
<data name="Writes_misaligned_blocks_0" xml:space="preserve">
<value>Writes misaligned blocks - {0}</value>
</data>
<data name="Reads_misaligned_blocks_0" xml:space="preserve">
<value>Reads misaligned blocks - {0}</value>
</data>
<data name="DSR_implemented_0" xml:space="preserve">
<value>DSR implemented - {0}</value>
</data>
<data name="Card_size_0" xml:space="preserve">
<value>Card size - {0}</value>
</data>
<data name="Reading_current_at_minimum_Vdd_0" xml:space="preserve">
<value>Reading current at minimum Vdd - {0}</value>
</data>
<data name="Reading_current_at_maximum_Vdd_0" xml:space="preserve">
<value>Reading current at maximum Vdd - {0}</value>
</data>
<data name="Writing_current_at_minimum_Vdd_0" xml:space="preserve">
<value>Writing current at minimum Vdd - {0}</value>
</data>
<data name="Writing_current_at_maximum_Vdd_0" xml:space="preserve">
<value>Writing current at maximum Vdd - {0}</value>
</data>
<data name="Card_size_multiplier_0" xml:space="preserve">
<value>Card size multiplier - {0}</value>
</data>
<data name="Erase_sector_size_0" xml:space="preserve">
<value>Erase sector size - {0}</value>
</data>
<data name="Erase_group_size_0" xml:space="preserve">
<value>Erase group size - {0}</value>
</data>
<data name="Write_protect_group_size_0" xml:space="preserve">
<value>Write protect group size - {0}</value>
</data>
<data name="Write_protect_group_enable_0" xml:space="preserve">
<value>Write protect group enable - {0}</value>
</data>
<data name="Default_ECC_0" xml:space="preserve">
<value>Default ECC - {0}</value>
</data>
<data name="Read_to_write_factor_0" xml:space="preserve">
<value>Read to write factor - {0}</value>
</data>
<data name="write_block_length_0" xml:space="preserve">
<value>write block length - {0}</value>
</data>
<data name="Writes_partial_blocks_0" xml:space="preserve">
<value>Writes partial blocks - {0}</value>
</data>
<data name="File_format_group_0" xml:space="preserve">
<value>File format group - {0}</value>
</data>
<data name="Copy_0" xml:space="preserve">
<value>Copy - {0}</value>
</data>
<data name="Permanent_write_protect_0" xml:space="preserve">
<value>Permanent write protect - {0}</value>
</data>
<data name="Temporary_write_protect_0" xml:space="preserve">
<value>Temporary write protect - {0}</value>
</data>
<data name="File_format_0" xml:space="preserve">
<value>File format - {0}</value>
</data>
<data name="ECC_0" xml:space="preserve">
<value>ECC - {0}</value>
</data>
<data name="Not_decoded_0" xml:space="preserve">
<value>Not decoded - {0}</value>
</data>
<data name="Version_0" xml:space="preserve">
<value>Version - {0}</value>
</data>
<data name="Erase_block_enable_0" xml:space="preserve">
<value>Erase block enable - {0}</value>
</data>
<data name="Data_stat_after_erase_0" xml:space="preserve">
<value>Data stat after erase - {0}</value>
</data>
<data name="Security_0" xml:space="preserve">
<value>Security - {0}</value>
</data>
<data name="Bus_widths_0" xml:space="preserve">
<value>Bus widths - {0}</value>
</data>
<data name="Spec_3_0" xml:space="preserve">
<value>Spec 3 - {0}</value>
</data>
<data name="Extended_security_0" xml:space="preserve">
<value>Extended security - {0}</value>
</data>
<data name="Spec_4_0" xml:space="preserve">
<value>Spec 4 - {0}</value>
</data>
<data name="Spec_X_0" xml:space="preserve">
<value>Spec X - {0}</value>
</data>
<data name="Command_support_0" xml:space="preserve">
<value>Command support - {0}</value>
</data>
<data name="Manufacturer_reserved_0" xml:space="preserve">
<value>Manufacturer reserved - {0}</value>
</data>
<data name="Open_0" xml:space="preserve">
<value>Open: {0}</value>
</data>
<data name="Sectors_0" xml:space="preserve">
<value>Sectors: {0}</value>
</data>
<data name="Sector_size_0" xml:space="preserve">
<value>Sector size: {0}</value>
</data>
<data name="Media_type_0" xml:space="preserve">
<value>Media type: {0}</value>
</data>
<data name="_0_not_found" xml:space="preserve">
<value>{0} not found</value>
</data>
<data name="Filter_0" xml:space="preserve">
<value>Filter: {0}</value>
</data>
<data name="Image_format_0" xml:space="preserve">
<value>Image format: {0}</value>
</data>
<data name="Cannot_open_image_for_0" xml:space="preserve">
<value>Cannot open image for {0}</value>
</data>
<data name="No_partitions_found_for_0" xml:space="preserve">
<value>No partitions found for {0}</value>
</data>
<data name="Filesystem_not_identified_for_0" xml:space="preserve">
<value>Filesystem not identified for {0}</value>
</data>
<data name="No_filesystems_found_for_0" xml:space="preserve">
<value>No filesystems found for {0}</value>
</data>
<data name="Not_identified_for_0" xml:space="preserve">
<value>Not identified for {0}</value>
</data>
<data name="Could_not_instantiate_filesystem_for_0" xml:space="preserve">
<value>Could not instantiate filesystem for {0}</value>
</data>
<data name="Application_ID_0" xml:space="preserve">
<value>Application ID: {0}</value>
</data>
<data name="Bootable_0" xml:space="preserve">
<value>Bootable: {0}</value>
</data>
<data name="Clusters_0" xml:space="preserve">
<value>Clusters: {0}</value>
</data>
<data name="Cluster_size_0" xml:space="preserve">
<value>Cluster size: {0}</value>
</data>
<data name="System_ID_0" xml:space="preserve">
<value>System ID: {0}</value>
</data>
<data name="Filesystem_type_0" xml:space="preserve">
<value>Filesystem type: {0}</value>
</data>
<data name="Volume_name_0" xml:space="preserve">
<value>Volume name: {0}</value>
</data>
<data name="Volume_serial_0" xml:space="preserve">
<value>Volume serial: {0}</value>
</data>
<data name="Unmountable_0" xml:space="preserve">
<value>Unmountable: {0}</value>
</data>
<data name="Unexpected_error_0_when_reading_directory_1_of_2" xml:space="preserve">
<value>Unexpected error {0} when reading directory "{1}" of {2}.</value>
</data>
<data name="Unexpected_error_0_retrieving_stats_for_1_in_2" xml:space="preserve">
<value>Unexpected error {0} retrieving stats for "{1}" in {2}</value>
</data>
<data name="Wrong_info_for_0_in_1" xml:space="preserve">
<value>Wrong info for "{0}" in {1}</value>
</data>
<data name="Got_wrong_data_for_directory_0_in_1" xml:space="preserve">
<value>Got wrong data for directory "{0}" in {1}</value>
</data>
<data name="Contents_for_0_in_1_must_be_defined_in_unit_test_declaration" xml:space="preserve">
<value>Contents for "{0}" in {1} must be defined in unit test declaration!</value>
</data>
<data name="Got_wrong_data_for_symbolic_link_0_in_1" xml:space="preserve">
<value>Got wrong data for symbolic link "{0}" in {1}</value>
</data>
<data name="Invalid_target_for_symbolic_link_0_in_1" xml:space="preserve">
<value>Invalid target for symbolic link "{0}" in {1}</value>
</data>
<data name="Defined_extended_attributes_for_0_in_1_are_not_supported_by_filesystem" xml:space="preserve">
<value>Defined extended attributes for "{0}" in {1} are not supported by filesystem.</value>
</data>
<data name="Unexpected_error_0_when_listing_extended_attributes_for_1_in_2" xml:space="preserve">
<value>Unexpected error {0} when listing extended attributes for "{1}" in {2}</value>
</data>
<data name="Extended_attributes_for_0_in_1_must_be_defined_in_unit_test_declaration" xml:space="preserve">
<value>Extended attributes for "{0}" in {1} must be defined in unit test declaration!</value>
</data>
<data name="Could_not_find_the_children_of_0_in_1_2" xml:space="preserve">
<value>Could not find the children of "{0}" in {1}: {2}</value>
</data>
<data name="Found_the_following_unexpected_children_of_0_in_1_2" xml:space="preserve">
<value>Found the following unexpected children of "{0}" in {1}: {2}</value>
</data>
<data name="Unexpected_error_0_when_reading_1_in_2" xml:space="preserve">
<value>Unexpected error {0} when reading "{1}" in {2}</value>
</data>
<data name="Unexpected_error_0_retrieving_extended_attributes_for_1_in_2" xml:space="preserve">
<value>Unexpected error {0} retrieving extended attributes for "{1}" in {2}</value>
</data>
<data name="Got_MD5_0_for_1_of_2_in_3_but_expected_4" xml:space="preserve">
<value>Got MD5 {0} for {1} of "{2}" in {3} but expected {4}</value>
</data>
<data name="Could_not_find_the_following_extended_attributes_of_0_in_1_2" xml:space="preserve">
<value>Could not find the following extended attributes of "{0}" in {1}: {2}</value>
</data>
<data name="Found_the_following_unexpected_extended_attributes_of_0_in_1_2" xml:space="preserve">
<value>Found the following unexpected extended attributes of "{0}" in {1}: {2}</value>
</data>
<data name="Hash_0" xml:space="preserve">
<value>Hash: {0}</value>
</data>
<data name="Expected_0_partitions_in_1_but_found_2" xml:space="preserve">
<value>Expected {0} partitions in {1} but found {2}</value>
</data>
<data name="Expected_partition_0_to_start_at_sector_1_but_found_it_starts_at_2_in_3" xml:space="preserve">
<value>Expected partition {0} to start at sector {1} but found it starts at {2} in {3}</value>
</data>
<data name="Expected_partition_0_to_have_1_sectors_but_found_it_has_2_sectors_in_3" xml:space="preserve">
<value>Expected partition {0} to have {1} sectors but found it has {2} sectors in {3}</value>
</data>
<data name="Could_not_instantiate_filesystem_plugin" xml:space="preserve">
<value>Could not instantiate filesystem plugin</value>
</data>
<data name="Could_not_instantiate_filesystem_0" xml:space="preserve">
<value>Could not instantiate filesystem {0}</value>
</data>
<data name="Could_not_mount_0_in_partition_1" xml:space="preserve">
<value>Could not mount {0} in partition {1}.</value>
</data>
<data name="Tracks_0" xml:space="preserve">
<value>Tracks: {0}</value>
</data>
<data name="Track_session_0" xml:space="preserve">
<value>Track session: {0}</value>
</data>
<data name="Track_start_0" xml:space="preserve">
<value>Track start: {0}</value>
</data>
<data name="Track_end_0" xml:space="preserve">
<value>Track end: {0}</value>
</data>
<data name="Track_pregap_0" xml:space="preserve">
<value>Track pregap: {0}</value>
</data>
<data name="Track_flags_0" xml:space="preserve">
<value>Track flags: {0}</value>
</data>
<data name="Last_sector_for_tracks_is_0_but_it_is_1_for_image" xml:space="preserve">
<value>Last sector for tracks is {0}, but it is {1} for image</value>
</data>
<data name="Expected_0_filesystems_in_1_but_found_2" xml:space="preserve">
<value>Expected {0} filesystems in {1} but found {2}</value>
</data>
<data name="Could_not_instantiate_filesystem_for_0_track_1_filesystem_2" xml:space="preserve">
<value>Could not instantiate filesystem for {0}, track {1}, filesystem {2}</value>
</data>
<data name="Subchannel_hash_0" xml:space="preserve">
<value>Subchannel hash: {0}</value>
</data>
<data name="Is_tape_0" xml:space="preserve">
<value>Is tape?: {0}</value>
</data>
<data name="Tape_files_0" xml:space="preserve">
<value>Tape files: {0}</value>
</data>
<data name="Tape_partitions_0" xml:space="preserve">
<value>Tape partitions: {0}</value>
</data>
<data name="Cannot_open_specified_file" xml:space="preserve">
<value>Cannot open specified file.</value>
</data>
<data name="Image_format_not_identified_not_proceeding_with_analysis" xml:space="preserve">
<value>Image format not identified, not proceeding with analysis.</value>
</data>
<data name="Unable_to_open_image_format" xml:space="preserve">
<value>Unable to open image format</value>
</data>
<data name="No_partitions_found" xml:space="preserve">
<value>No partitions found</value>
</data>
<data name="Excepted_0_partitions_but_found_1" xml:space="preserve">
<value>Excepted {0} partitions but found {1}</value>
</data>
<data name="Expected_no_filesystems_identified_in_partition_0_but_found_1" xml:space="preserve">
<value>Expected no filesystems identified in partition {0} but found {1}</value>
</data>
<data name="Expected_0_filesystems_identified_in_partition_1_but_found_2" xml:space="preserve">
<value>Expected {0} filesystems identified in partition {1} but found {2}</value>
</data>
<data name="Excepted_volume_name_0_for_filesystem_1_in_partition_2_but_found_3" xml:space="preserve">
<value>Excepted volume name "{0}" for filesystem {1} in partition {2} but found "{3}"</value>
</data>
<data name="Expected_directories_not_found" xml:space="preserve">
<value>Expected directories not found:</value>
</data>
<data name="Expected_files_not_found" xml:space="preserve">
<value>Expected files not found:</value>
</data>
<data name="Error_0_reading_root_directory_0" xml:space="preserve">
<value>Error {0} reading root directory {0}</value>
</data>
<data name="Error_getting_stat_for_entry_0" xml:space="preserve">
<value>Error getting stat for entry {0}</value>
</data>
<data name="Found_unexpected_directory_0" xml:space="preserve">
<value>Found unexpected directory {0}</value>
</data>
<data name="Found_unexpected_file_0" xml:space="preserve">
<value>Found unexpected file {0}</value>
</data>
<data name="Error_0_getting_extended_attributes_for_entry_1" xml:space="preserve">
<value>Error {0} getting extended attributes for entry {1}</value>
</data>
<data name="Found_unexpected_extended_attribute_0_in_file_1" xml:space="preserve">
<value>Found unexpected extended attribute {0} in file {1}</value>
</data>
<data name="Error_0_reading_extended_attributes_for_entry_1" xml:space="preserve">
<value>Error {0} reading extended attributes for entry {1}</value>
</data>
<data name="Invalid_checksum_for_xattr_0_for_file_1" xml:space="preserve">
<value>Invalid checksum for xattr {0} for file {1}</value>
</data>
<data name="Expected_extended_attributes_not_found_for_file_0" xml:space="preserve">
<value>Expected extended attributes not found for file {0}:</value>
</data>
<data name="Error_0_reading_file_1" xml:space="preserve">
<value>Error {0} reading file {1}</value>
</data>
<data name="Invalid_checksum_for_file_0" xml:space="preserve">
<value>Invalid checksum for file {0}</value>
</data>
<data name="No_filesystems_found" xml:space="preserve">
<value>No filesystems found.</value>
</data>
<data name="Test_file_not_found" xml:space="preserve">
<value>Test file not found</value>
</data>
<data name="Filter_for_test_file_is_not_detected" xml:space="preserve">
<value>Filter for test file is not detected</value>
</data>
<data name="Image_format_for_test_file_is_not_detected" xml:space="preserve">
<value>Image format for test file is not detected</value>
</data>
<data name="Cannot_open_image_for_test_file" xml:space="preserve">
<value>Cannot open image for test file</value>
</data>
<data name="Output_file_already_exists_not_continuing" xml:space="preserve">
<value>Output file already exists, not continuing.</value>
</data>
<data name="Input_image_format_not_identified_not_proceeding_with_conversion" xml:space="preserve">
<value>Input image format not identified, not proceeding with conversion.</value>
</data>
<data name="Output_format_does_not_support_media_type_cannot_continue" xml:space="preserve">
<value>Output format does not support media type, cannot continue...</value>
</data>
<data name="Input_image_does_not_support_long_sectors" xml:space="preserve">
<value>Input image does not support long sectors.</value>
</data>
<data name="Could_not_treat_existing_image_as_optical_disc" xml:space="preserve">
<value>Could not treat existing image as optical disc.</value>
</data>
<data name="Could_not_treat_new_image_as_optical_disc" xml:space="preserve">
<value>Could not treat new image as optical disc.</value>
</data>
<data name="Existing_image_contains_no_tracks" xml:space="preserve">
<value>Existing image contains no tracks.</value>
</data>
<data name="Error_0_creating_output_image" xml:space="preserve">
<value>Error {0} creating output image.</value>
</data>
<data name="Error_0_setting_metadata" xml:space="preserve">
<value>Error {0} setting metadata,</value>
</data>
<data name="Converting_media_tag_0" xml:space="preserve">
<value>Converting media tag {0}</value>
</data>
<data name="_0_sectors_to_convert" xml:space="preserve">
<value>{0} sectors to convert</value>
</data>
<data name="Error_0_sending_tracks_list_to_output_image" xml:space="preserve">
<value>Error {0} sending tracks list to output image.</value>
</data>
<data name="Error_0_writing_sector_1_not_continuing" xml:space="preserve">
<value>Error {0} writing sector {1}, not continuing...</value>
</data>
<data name="Error_0_reading_tag_not_continuing" xml:space="preserve">
<value>Error {0} reading tag, not continuing...</value>
</data>
<data name="Error_0_writing_tag_not_continuing" xml:space="preserve">
<value>Error {0} writing tag, not continuing...</value>
</data>
<data name="Error_0_writing_tag_for_sector_1_not_continuing" xml:space="preserve">
<value>Error {0} writing tag for sector {1}, not continuing...</value>
</data>
<data name="Error_0_closing_output_image_Contents_are_not_correct" xml:space="preserve">
<value>Error {0} closing output image... Contents are not correct.</value>
</data>
<data name="Hashes_are_different" xml:space="preserve">
<value>Hashes are different</value>
</data>
<data name="Image_format_for_test_file_is_not_for_an_optical_disc" xml:space="preserve">
<value>Image format for test file is not for an optical disc</value>
</data>
<data name="Partitions_0" xml:space="preserve">
<value>Partitions: {0}</value>
</data>
<data name="Could_not_instantiate_input_plugin_for_0" xml:space="preserve">
<value>Could not instantiate input plugin for {0}</value>
</data>
<data name="Could_not_instantiate_output_plugin_for_0" xml:space="preserve">
<value>Could not instantiate output plugin for {0}</value>
</data>
<data name="Trying_to_convert_unsupported_media_type_0_for_1" xml:space="preserve">
<value>Trying to convert unsupported media type {0} for {1}</value>
</data>
<data name="Error_0_writing_sector_1" xml:space="preserve">
<value>Error {0} writing sector {1}...</value>
</data>
<data name="Open_created_0" xml:space="preserve">
<value>Open created: {0}</value>
</data>
<data name="Sectors_output_0" xml:space="preserve">
<value>Sectors (output): {0}</value>
</data>
<data name="Sector_size_output_0" xml:space="preserve">
<value>Sector size (output): {0}</value>
</data>
<data name="Tracks_output_0" xml:space="preserve">
<value>Tracks (output): {0}</value>
</data>
<data name="Track_session_output_0" xml:space="preserve">
<value>Track session (output): {0}</value>
</data>
<data name="Track_start_output_0" xml:space="preserve">
<value>Track start (output): {0}</value>
</data>
<data name="Track_end_output_0" xml:space="preserve">
<value>Track end (output): {0}</value>
</data>
<data name="Track_pregap_output_0" xml:space="preserve">
<value>Track pregap (output): {0}</value>
</data>
<data name="Track_flags_output_0" xml:space="preserve">
<value>Track flags (output): {0}</value>
</data>
<data name="Last_sector_for_tracks_is_0_but_it_is_1_for_image_output" xml:space="preserve">
<value>Last sector for tracks is {0}, but it is {1} for image (output)</value>
</data>
<data name="Long_hash_output" xml:space="preserve">
<value>Long hash (output)</value>
</data>
<data name="Hash_output" xml:space="preserve">
<value>Hash (output)</value>
</data>
<data name="Subchannel_hash_output_0" xml:space="preserve">
<value>Subchannel hash (output): {0}</value>
</data>
</root>

10
Aaru.Tests/Partitions/PartitionSchemeTest.cs
View File

@@ -24,7 +24,7 @@ public abstract class PartitionSchemeTest
Environment.CurrentDirectory = DataFolder;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -36,17 +36,17 @@ public abstract class PartitionSchemeTest
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(testFile);
Assert.IsNotNull(inputFilter, $"Filter: {testFile}");
Assert.IsNotNull(inputFilter, string.Format(Localization.Filter_0, testFile));
var image = ImageFormat.Detect(inputFilter) as IMediaImage;
Assert.IsNotNull(image, $"Image format: {testFile}");
Assert.IsNotNull(image, string.Format(Localization.Image_format_0, testFile));
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), $"Cannot open image for {testFile}");
Assert.AreEqual(ErrorNumber.NoError, image.Open(inputFilter), string.Format(Localization.Cannot_open_image_for_0, testFile));
List<Partition> partitions = Core.Partitions.GetAll(image);
partitions.Should().BeEquivalentTo(test.Partitions, $"Partitions: {testFile}");
partitions.Should().BeEquivalentTo(test.Partitions, string.Format(Localization.Partitions_0, testFile));
}
}
}

84
Aaru.Tests/WritableImages/WritableOpticalMediaImageTest.cs
View File

@@ -34,7 +34,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -46,10 +46,10 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
filter.Open(testFile);
var image = Activator.CreateInstance(InputPlugin.GetType()) as IOpticalMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_filesystem_for_0, testFile));
ErrorNumber opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -57,29 +57,29 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(test.Sectors, image.Info.Sectors, $"Sectors: {testFile}");
Assert.AreEqual(test.Sectors, image.Info.Sectors, string.Format(Localization.Sectors_0, testFile));
if(test.SectorSize > 0)
Assert.AreEqual(test.SectorSize, image.Info.SectorSize, $"Sector size: {testFile}");
Assert.AreEqual(test.SectorSize, image.Info.SectorSize, string.Format(Localization.Sector_size_0, testFile));
Assert.AreEqual(test.MediaType, image.Info.MediaType, $"Media type: {testFile}");
Assert.AreEqual(test.MediaType, image.Info.MediaType, string.Format(Localization.Media_type_0, testFile));
if(image.Info.XmlMediaType != XmlMediaType.OpticalDisc)
return;
Assert.AreEqual(test.Tracks.Length, image.Tracks.Count, $"Tracks: {testFile}");
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), $"Track session: {testFile}");
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), $"Track start: {testFile}");
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), $"Track end: {testFile}");
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), $"Track pregap: {testFile}");
BeEquivalentTo(test.Tracks.Select(s => s.Pregap), string.Format(Localization.Track_pregap_0, testFile));
int trackNo = 0;
@@ -103,11 +103,10 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
trackNo++;
}
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags), $"Track flags: {testFile}");
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags), string.Format(Localization.Track_flags_0, testFile));
Assert.AreEqual(latestEndSector, image.Info.Sectors - 1,
$"Last sector for tracks is {latestEndSector}, but it is {image.Info.Sectors
} for image");
string.Format(Localization.Last_sector_for_tracks_is_0_but_it_is_1_for_image, latestEndSector, image.Info.Sectors));
});
}
});
@@ -126,7 +125,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
Assert.True(exists, string.Format(Localization._0_not_found, testFile));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
@@ -138,10 +137,10 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
filter.Open(testFile);
var inputFormat = Activator.CreateInstance(InputPlugin.GetType()) as IOpticalMediaImage;
Assert.NotNull(inputFormat, $"Could not instantiate input plugin for {testFile}");
Assert.NotNull(inputFormat, string.Format(Localization.Could_not_instantiate_input_plugin_for_0, testFile));
ErrorNumber opened = inputFormat.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -149,10 +148,10 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
string outputPath = Path.Combine(Path.GetTempPath(), $"{Path.GetRandomFileName()}.{OutputExtension}");
var outputFormat = Activator.CreateInstance(OutputPlugin.GetType()) as IWritableOpticalImage;
Assert.NotNull(outputFormat, $"Could not instantiate output plugin for {testFile}");
Assert.NotNull(outputFormat, string.Format(Localization.Could_not_instantiate_output_plugin_for_0, testFile));
Assert.IsTrue(outputFormat.SupportedMediaTypes.Contains(inputFormat.Info.MediaType),
$"Trying to convert unsupported media type {inputFormat.Info.MediaType} for {testFile}");
string.Format(Localization.Trying_to_convert_unsupported_media_type_0_for_1, inputFormat.Info.MediaType, testFile));
bool useLong = inputFormat.Info.ReadableSectorTags.Count != 0;
@@ -164,7 +163,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
useLong = false;
Assert.IsTrue(outputFormat.Create(outputPath, inputFormat.Info.MediaType, new Dictionary<string, string>(), inputFormat.Info.Sectors, inputFormat.Info.SectorSize),
$"Error {outputFormat.ErrorMessage} creating output image.");
string.Format(Localization.Error_0_creating_output_image, outputFormat.ErrorMessage));
foreach(MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags.Where(mediaTag =>
outputFormat.SupportedMediaTags.Contains(mediaTag)))
@@ -172,7 +171,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
outputFormat.WriteMediaTag(buffer, mediaTag);
Assert.IsTrue(outputFormat.SetTracks(inputFormat.Tracks),
$"Error {outputFormat.ErrorMessage} sending tracks list to output image.");
string.Format(Localization.Error_0_sending_tracks_list_to_output_image, outputFormat.ErrorMessage));
ulong doneSectors;
@@ -231,8 +230,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
}
Assert.IsTrue(result,
$"Error {outputFormat.ErrorMessage} writing sector {
doneSectors + track.StartSector}...");
string.Format(Localization.Error_0_writing_sector_1, outputFormat.ErrorMessage, doneSectors + track.StartSector));
doneSectors += sectorsToDo;
}
@@ -336,12 +334,12 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
errno = inputFormat.ReadSectorTag(track.Sequence, tag, out sector);
Assert.AreEqual(ErrorNumber.NoError, errno,
$"Error {errno} reading tag, not continuing...");
string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
result = outputFormat.WriteSectorTag(sector, track.Sequence, tag);
Assert.IsTrue(result,
$"Error {outputFormat.ErrorMessage} writing tag, not continuing...");
string.Format(Localization.Error_0_writing_tag_not_continuing, outputFormat.ErrorMessage));
continue;
}
@@ -360,7 +358,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
errno = inputFormat.ReadSectorTag(doneSectors + track.StartSector, tag, out sector);
Assert.AreEqual(ErrorNumber.NoError, errno,
$"Error {errno} reading tag, not continuing...");
string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
if(tag == SectorTagType.CdSectorSubchannel)
{
@@ -384,7 +382,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
out sector);
Assert.AreEqual(ErrorNumber.NoError, errno,
$"Error {errno} reading tag, not continuing...");
string.Format(Localization.Error_0_reading_tag_not_continuing, errno));
if(tag == SectorTagType.CdSectorSubchannel)
{
@@ -405,8 +403,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
}
Assert.IsTrue(result,
$"Error {outputFormat.ErrorMessage} writing tag for sector {
doneSectors + track.StartSector}, not continuing...");
string.Format(Localization.Error_0_writing_tag_for_sector_1_not_continuing, outputFormat.ErrorMessage, doneSectors + track.StartSector));
doneSectors += sectorsToDo;
}
@@ -442,7 +439,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
null, null, null, null, null, outputFormat);
Assert.IsTrue(outputFormat.Close(),
$"Error {outputFormat.ErrorMessage} closing output image... Contents are not correct.");
string.Format(Localization.Error_0_closing_output_image_Contents_are_not_correct, outputFormat.ErrorMessage));
filtersList = new FiltersList();
filter = filtersList.GetFilter(outputPath);
@@ -452,10 +449,10 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
Environment.CurrentDirectory = tmpFolder;
var image = Activator.CreateInstance(OutputPlugin.GetType()) as IOpticalMediaImage;
Assert.NotNull(image, $"Could not instantiate output plugin for {testFile}");
Assert.NotNull(image, string.Format(Localization.Could_not_instantiate_output_plugin_for_0, testFile));
opened = image.Open(filter);
Assert.AreEqual(ErrorNumber.NoError, opened, $"Open created: {testFile}");
Assert.AreEqual(ErrorNumber.NoError, opened, string.Format(Localization.Open_created_0, testFile));
if(opened != ErrorNumber.NoError)
continue;
@@ -463,25 +460,25 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
using(new AssertionScope())
Assert.Multiple(() =>
{
Assert.AreEqual(test.Sectors, image.Info.Sectors, $"Sectors (output): {testFile}");
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,
$"Sector size (output): {testFile}");
string.Format(Localization.Sector_size_output_0, testFile));
Assert.AreEqual(test.Tracks.Length, image.Tracks.Count, $"Tracks (output): {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), $"Track session (output): {testFile}");
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), $"Track start (output): {testFile}");
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), $"Track end (output): {testFile}");
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), $"Track pregap (output): {testFile}");
BeEquivalentTo(test.Tracks.Select(s => s.Pregap), string.Format(Localization.Track_pregap_output_0, testFile));
int trackNo = 0;
@@ -506,11 +503,10 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
}
flags.Should().BeEquivalentTo(test.Tracks.Select(s => s.Flags),
$"Track flags (output): {testFile}");
string.Format(Localization.Track_flags_output_0, testFile));
Assert.AreEqual(latestEndSector, image.Info.Sectors - 1,
$"Last sector for tracks is {latestEndSector}, but it is {image.Info.Sectors
} for image (output)");
string.Format(Localization.Last_sector_for_tracks_is_0_but_it_is_1_for_image_output, latestEndSector, image.Info.Sectors));
});
Md5Context ctx;
@@ -557,7 +553,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
}
Assert.AreEqual(@long ? test.LongMd5 : test.Md5, ctx.End(),
$"{(@long ? "Long hash (output)" : "Hash (output)")}: {testFile}");
string.Format("{0}: {1}", (@long ? Localization.Long_hash_output : Localization.Hash_output), testFile));
}
if(!image.Info.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
@@ -596,7 +592,7 @@ public abstract class WritableOpticalMediaImageTest : BaseWritableMediaImageTest
}
}
Assert.AreEqual(test.SubchannelMd5, ctx.End(), $"Subchannel hash (output): {testFile}");
Assert.AreEqual(test.SubchannelMd5, ctx.End(), string.Format(Localization.Subchannel_hash_output_0, testFile));
}
});
}