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

Update devices unit tests.

Browse Source
This commit is contained in:
Natalia Portillo
2021-02-28 14:53:32 +00:00
parent 76732f4e3f
commit 16c077fa16
9 changed files with 270 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -26,11 +26,12 @@
// Copyright © 2011-2021 Natalia Portillo
// ****************************************************************************/
using System;
using System.IO;
using Aaru.CommonTypes;
using Aaru.CommonTypes.Interfaces;
using Aaru.DiscImages;
using Aaru.Filters;
using FluentAssertions.Execution;
using NUnit.Framework;
namespace Aaru.Tests.Devices
@@ -58,20 +59,39 @@ namespace Aaru.Tests.Devices
512
};
readonly string _dataFolder = Path.Combine(Consts.TEST_FILES_ROOT, "Device test dumps", "JAZ");
[Test]
public void Test()
public void Info()
{
for(int i = 0; i < _testFiles.Length; i++)
Environment.CurrentDirectory = _dataFolder;
Assert.Multiple(() =>
{
string location = Path.Combine(Consts.TEST_FILES_ROOT, "Device test dumps", "JAZ", _testFiles[i]);
IFilter filter = new LZip();
filter.Open(location);
IMediaImage image = new ZZZRawImage();
Assert.AreEqual(true, image.Open(filter), _testFiles[i]);
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, _testFiles[i]);
Assert.AreEqual(_sectors[i], image.Info.Sectors, _testFiles[i]);
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, _testFiles[i]);
}
for(int i = 0; i < _testFiles.Length; i++)
{
var filter = new LZip();
filter.Open(_testFiles[i]);
var image = new ZZZRawImage();
bool opened = image.Open(filter);
Assert.AreEqual(true, opened, $"Open: {_testFiles[i]}");
if(!opened)
continue;
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]}");
});
}
}
});
}
}
}

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

@@ -26,11 +26,12 @@
// Copyright © 2011-2021 Natalia Portillo
// ****************************************************************************/
using System;
using System.IO;
using Aaru.CommonTypes;
using Aaru.CommonTypes.Interfaces;
using Aaru.DiscImages;
using Aaru.Filters;
using FluentAssertions.Execution;
using NUnit.Framework;
namespace Aaru.Tests.Devices
@@ -58,20 +59,39 @@ namespace Aaru.Tests.Devices
512, 512, 512
};
readonly string _dataFolder = Path.Combine(Consts.TEST_FILES_ROOT, "Device test dumps", "LS-120");
[Test]
public void Test()
public void Info()
{
for(int i = 0; i < _testFiles.Length; i++)
Environment.CurrentDirectory = _dataFolder;
Assert.Multiple(() =>
{
string location = Path.Combine(Consts.TEST_FILES_ROOT, "Device test dumps", "LS-120", _testFiles[i]);
IFilter filter = new LZip();
filter.Open(location);
IMediaImage image = new ZZZRawImage();
Assert.AreEqual(true, image.Open(filter), _testFiles[i]);
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, _testFiles[i]);
Assert.AreEqual(_sectors[i], image.Info.Sectors, _testFiles[i]);
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, _testFiles[i]);
}
for(int i = 0; i < _testFiles.Length; i++)
{
var filter = new LZip();
filter.Open(_testFiles[i]);
var image = new ZZZRawImage();
bool opened = image.Open(filter);
Assert.AreEqual(true, opened, $"Open: {_testFiles[i]}");
if(!opened)
continue;
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]}");
});
}
}
});
}
}
}

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

@@ -1,4 +1,5 @@
using Aaru.Helpers;
using FluentAssertions.Execution;
using NUnit.Framework;
// ReSharper disable InconsistentNaming
@@ -58,17 +59,23 @@ namespace Aaru.Tests.Devices.MultiMediaCard
{
for(int i = 0; i < cards.Length; i++)
{
int count = Marshal.ConvertFromHexAscii(cids[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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]}");
using(new AssertionScope())
{
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(cids[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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]}");
});
}
}
}
}

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

@@ -1,4 +1,5 @@
using Aaru.Helpers;
using FluentAssertions.Execution;
using NUnit.Framework;
// ReSharper disable InconsistentNaming
@@ -178,68 +179,80 @@ namespace Aaru.Tests.Devices.MultiMediaCard
{
for(int i = 0; i < cards.Length; i++)
{
int count = Marshal.ConvertFromHexAscii(csds[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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.AreEqual(read_partial_blocks[i], csd.ReadsPartialBlocks, $"Reads partial blocks - {cards[i]}");
using(new AssertionScope())
{
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(csds[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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.AreEqual(write_misaligned_block[i], csd.WriteMisalignment,
$"Writes misaligned blocks - {cards[i]}");
Assert.AreEqual(read_partial_blocks[i], csd.ReadsPartialBlocks,
$"Reads partial blocks - {cards[i]}");
Assert.AreEqual(read_misaligned_block[i], csd.ReadMisalignment,
$"Reads misaligned blocks - {cards[i]}");
Assert.AreEqual(write_misaligned_block[i], csd.WriteMisalignment,
$"Writes misaligned blocks - {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(read_misaligned_block[i], csd.ReadMisalignment,
$"Reads misaligned blocks - {cards[i]}");
Assert.AreEqual(min_read_current[i], csd.ReadCurrentAtVddMin,
$"Reading current at minimum Vdd - {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(max_read_current[i], csd.ReadCurrentAtVddMax,
$"Reading current at maximum Vdd - {cards[i]}");
Assert.AreEqual(min_read_current[i], csd.ReadCurrentAtVddMin,
$"Reading current at minimum Vdd - {cards[i]}");
Assert.AreEqual(min_write_current[i], csd.WriteCurrentAtVddMin,
$"Writing current at minimum Vdd - {cards[i]}");
Assert.AreEqual(max_read_current[i], csd.ReadCurrentAtVddMax,
$"Reading current at maximum Vdd - {cards[i]}");
Assert.AreEqual(max_write_current[i], csd.WriteCurrentAtVddMax,
$"Writing current at maximum Vdd - {cards[i]}");
Assert.AreEqual(min_write_current[i], csd.WriteCurrentAtVddMin,
$"Writing current at minimum Vdd - {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(erase_sector_sizes[i], csd.EraseGroupSizeMultiplier, $"Erase group size - {cards[i]}");
Assert.AreEqual(max_write_current[i], csd.WriteCurrentAtVddMax,
$"Writing current at maximum Vdd - {cards[i]}");
Assert.AreEqual(write_protect_group_size[i], csd.WriteProtectGroupSize,
$"Write protect group size - {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(write_protect_group_enable[i], csd.WriteProtectGroupEnable,
$"Write protect group enable - {cards[i]}");
Assert.AreEqual(erase_sector_sizes[i], csd.EraseGroupSizeMultiplier,
$"Erase group size - {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(write_block_lengths[i], csd.WriteBlockLength, $"write block length - {cards[i]}");
Assert.AreEqual(write_protect_group_size[i], csd.WriteProtectGroupSize,
$"Write protect group size - {cards[i]}");
Assert.AreEqual(write_partial_blocks[i], csd.WritesPartialBlocks,
$"Writes partial blocks - {cards[i]}");
Assert.AreEqual(write_protect_group_enable[i], csd.WriteProtectGroupEnable,
$"Write protect group enable - {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(default_eccs[i], csd.DefaultECC, $"Default ECC - {cards[i]}");
Assert.AreEqual(r2w_factors[i], csd.WriteSpeedFactor, $"Read to write factor - {cards[i]}");
Assert.AreEqual(permanent_write_protect[i], csd.PermanentWriteProtect,
$"Permanent write protect - {cards[i]}");
Assert.AreEqual(write_block_lengths[i], csd.WriteBlockLength,
$"write block length - {cards[i]}");
Assert.AreEqual(temporary_write_protect[i], csd.TemporaryWriteProtect,
$"Temporary write protect - {cards[i]}");
Assert.AreEqual(write_partial_blocks[i], csd.WritesPartialBlocks,
$"Writes partial blocks - {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_group[i], csd.FileFormatGroup, $"File format group - {cards[i]}");
Assert.AreEqual(copy[i], csd.Copy, $"Copy - {cards[i]}");
Assert.AreEqual(permanent_write_protect[i], csd.PermanentWriteProtect,
$"Permanent write protect - {cards[i]}");
Assert.AreEqual(temporary_write_protect[i], csd.TemporaryWriteProtect,
$"Temporary write protect - {cards[i]}");
Assert.AreEqual(file_format[i], csd.FileFormat, $"File format - {cards[i]}");
Assert.AreEqual(ecc[i], csd.ECC, $"ECC - {cards[i]}");
});
}
}
}
}

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

@@ -219,7 +219,6 @@ namespace Aaru.Tests.Devices.MultiMediaCard
Decoders.MMC.ExtendedCSD csd = Decoders.MMC.Decoders.DecodeExtendedCSD(ecsd[i]);
Assert.IsNotNull(csd, $"Not decoded - {i}");
csd.Should().BeEquivalentTo(decoded[i]);
string foo = Decoders.MMC.Decoders.PrettifyExtendedCSD(csd);
}
}
}

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

@@ -26,11 +26,12 @@
// Copyright © 2011-2021 Natalia Portillo
// ****************************************************************************/
using System;
using System.IO;
using Aaru.CommonTypes;
using Aaru.CommonTypes.Interfaces;
using Aaru.DiscImages;
using Aaru.Filters;
using FluentAssertions.Execution;
using NUnit.Framework;
namespace Aaru.Tests.Devices
@@ -58,20 +59,39 @@ namespace Aaru.Tests.Devices
512, 512
};
readonly string _dataFolder = Path.Combine(Consts.TEST_FILES_ROOT, "Device test dumps", "PocketZIP");
[Test]
public void Test()
public void Info()
{
for(int i = 0; i < _testFiles.Length; i++)
Environment.CurrentDirectory = _dataFolder;
Assert.Multiple(() =>
{
string location = Path.Combine(Consts.TEST_FILES_ROOT, "Device test dumps", "PocketZIP", _testFiles[i]);
IFilter filter = new LZip();
filter.Open(location);
IMediaImage image = new ZZZRawImage();
Assert.AreEqual(true, image.Open(filter), _testFiles[i]);
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, _testFiles[i]);
Assert.AreEqual(_sectors[i], image.Info.Sectors, _testFiles[i]);
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, _testFiles[i]);
}
for(int i = 0; i < _testFiles.Length; i++)
{
var filter = new LZip();
filter.Open(_testFiles[i]);
var image = new ZZZRawImage();
bool opened = image.Open(filter);
Assert.AreEqual(true, opened, $"Open: {_testFiles[i]}");
if(!opened)
continue;
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]}");
});
}
}
});
}
}
}

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

@@ -1,4 +1,5 @@
using Aaru.Helpers;
using FluentAssertions.Execution;
using NUnit.Framework;
// ReSharper disable InconsistentNaming
@@ -65,17 +66,23 @@ namespace Aaru.Tests.Devices.SecureDigital
{
for(int i = 0; i < cards.Length; i++)
{
int count = Marshal.ConvertFromHexAscii(cids[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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]}");
using(new AssertionScope())
{
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(cids[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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]}");
});
}
}
}
}

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

@@ -1,4 +1,5 @@
using Aaru.Helpers;
using FluentAssertions.Execution;
using NUnit.Framework;
// ReSharper disable InconsistentNaming
@@ -159,60 +160,71 @@ namespace Aaru.Tests.Devices.SecureDigital
{
for(int i = 0; i < cards.Length; i++)
{
int count = Marshal.ConvertFromHexAscii(csds[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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.AreEqual(read_partial_blocks[i], csd.ReadsPartialBlocks, $"Reads partial blocks - {cards[i]}");
using(new AssertionScope())
{
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(csds[i], out byte[] response);
Assert.AreEqual(16, count, $"Size - {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.AreEqual(write_misaligned_block[i], csd.WriteMisalignment,
$"Writes misaligned blocks - {cards[i]}");
Assert.AreEqual(read_partial_blocks[i], csd.ReadsPartialBlocks,
$"Reads partial blocks - {cards[i]}");
Assert.AreEqual(read_misaligned_block[i], csd.ReadMisalignment,
$"Reads misaligned blocks - {cards[i]}");
Assert.AreEqual(write_misaligned_block[i], csd.WriteMisalignment,
$"Writes misaligned blocks - {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(read_misaligned_block[i], csd.ReadMisalignment,
$"Reads misaligned blocks - {cards[i]}");
Assert.AreEqual(min_read_current[i], csd.ReadCurrentAtVddMin,
$"Reading current at minimum Vdd - {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(max_read_current[i], csd.ReadCurrentAtVddMax,
$"Reading current at maximum Vdd - {cards[i]}");
Assert.AreEqual(min_read_current[i], csd.ReadCurrentAtVddMin,
$"Reading current at minimum Vdd - {cards[i]}");
Assert.AreEqual(min_write_current[i], csd.WriteCurrentAtVddMin,
$"Writing current at minimum Vdd - {cards[i]}");
Assert.AreEqual(max_read_current[i], csd.ReadCurrentAtVddMax,
$"Reading current at maximum Vdd - {cards[i]}");
Assert.AreEqual(max_write_current[i], csd.WriteCurrentAtVddMax,
$"Writing current at maximum Vdd - {cards[i]}");
Assert.AreEqual(min_write_current[i], csd.WriteCurrentAtVddMin,
$"Writing current at minimum Vdd - {cards[i]}");
Assert.AreEqual(size_multiplier[i], csd.SizeMultiplier, $"Card size multiplier - {cards[i]}");
Assert.AreEqual(erase_block_enable[i], csd.EraseBlockEnable, $"Erase block enable - {cards[i]}");
Assert.AreEqual(erase_sector_sizes[i], csd.EraseSectorSize, $"Erase sector size - {cards[i]}");
Assert.AreEqual(max_write_current[i], csd.WriteCurrentAtVddMax,
$"Writing current at maximum Vdd - {cards[i]}");
Assert.AreEqual(write_protect_group_size[i], csd.WriteProtectGroupSize,
$"Write protect group size - {cards[i]}");
Assert.AreEqual(size_multiplier[i], csd.SizeMultiplier, $"Card size multiplier - {cards[i]}");
Assert.AreEqual(write_protect_group_enable[i], csd.WriteProtectGroupEnable,
$"Write protect group enable - {cards[i]}");
Assert.AreEqual(erase_block_enable[i], csd.EraseBlockEnable,
$"Erase block enable - {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(erase_sector_sizes[i], csd.EraseSectorSize, $"Erase sector size - {cards[i]}");
Assert.AreEqual(permanent_write_protect[i], csd.PermanentWriteProtect,
$"Permanent write protect - {cards[i]}");
Assert.AreEqual(write_protect_group_size[i], csd.WriteProtectGroupSize,
$"Write protect group size - {cards[i]}");
Assert.AreEqual(temporary_write_protect[i], csd.TemporaryWriteProtect,
$"Temporary write protect - {cards[i]}");
Assert.AreEqual(write_protect_group_enable[i], csd.WriteProtectGroupEnable,
$"Write protect group enable - {cards[i]}");
Assert.AreEqual(file_format[i], csd.FileFormat, $"File format - {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(permanent_write_protect[i], csd.PermanentWriteProtect,
$"Permanent write protect - {cards[i]}");
Assert.AreEqual(temporary_write_protect[i], csd.TemporaryWriteProtect,
$"Temporary write protect - {cards[i]}");
Assert.AreEqual(file_format[i], csd.FileFormat, $"File format - {cards[i]}");
});
}
}
}
}

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

@@ -1,4 +1,6 @@
using Aaru.Decoders.SecureDigital;
using Aaru.Helpers;
using FluentAssertions.Execution;
using NUnit.Framework;
// ReSharper disable InconsistentNaming
@@ -137,24 +139,33 @@ namespace Aaru.Tests.Devices.SecureDigital
{
for(int i = 0; i < cards.Length; i++)
{
int count = Marshal.ConvertFromHexAscii(scrs[i], out byte[] response);
Assert.AreEqual(8, count, $"Size - {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]}");
using(new AssertionScope())
{
Assert.Multiple(() =>
{
int count = Marshal.ConvertFromHexAscii(scrs[i], out byte[] response);
Assert.AreEqual(8, count, $"Size - {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.AreEqual(data_stat_after_erase[i], scr.DataStatusAfterErase,
$"Data stat after erase - {cards[i]}");
Assert.AreEqual(data_stat_after_erase[i], scr.DataStatusAfterErase,
$"Data stat after erase - {cards[i]}");
Assert.AreEqual(sd_security[i], scr.Security, $"Security - {cards[i]}");
Assert.AreEqual(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(cmd_support[i], scr.CommandSupport, $"Command support - {cards[i]}");
Assert.AreEqual(mfg[i], scr.ManufacturerReserved, $"Manufacturer reserved - {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((CommandSupport)cmd_support[i], scr.CommandSupport,
$"Command support - {cards[i]}");
Assert.AreEqual(mfg[i], scr.ManufacturerReserved, $"Manufacturer reserved - {cards[i]}");
});
}
}
}
}