public override int GetHashCode() { unchecked { return((ProgramIdentifier.GetHashCode() * 397) ^ LineNumber); } }
internal void AddEntries(TestProgramInformation information) { foreach (var crcData in information.Crcs.Cast <CrcDataAdvanced>()) { var programIdentifier = new ProgramIdentifier(crcData.Crc, crcData.CfgCrc); _entries[programIdentifier] = information; } }
public void ProgramRomInformationBuilder_BuildWithId_ResultsInExpectedId() { var builder = CreateBuilderWithRequiredFields("Testing Id"); var expectedId = new ProgramIdentifier(4u, 8u); var programRomInformation = builder.WithId(expectedId).Build(); Assert.Equal(expectedId, programRomInformation.Id); }
public void ProgramIdentifier_ToString_ProducesCorrectString() { var dataPart = 0xFEDCBA98u; var otherPart = 0x76543210u; var expectedString = string.Format(CultureInfo.InvariantCulture, "{0:X8},{1:X8}", dataPart, otherPart); var identifier = new ProgramIdentifier(dataPart, otherPart); Assert.Equal(expectedString, identifier.ToString()); }
public void ProgramIdentifier_CreateWithDataCrc_CreatesProperIdentifier() { var dataPart = 0xFEDBADu; var expectedId = ((ulong)dataPart) << 32; var identifier = new ProgramIdentifier(dataPart); Assert.Equal(dataPart, identifier.DataCrc); Assert.Equal(0u, identifier.OtherData); Assert.Equal(expectedId, identifier.Id); }
public void ProgramIdentifier_GetHashcode_ProducesCorrectHash() { var dataPart = 0x123u; var otherPart = 0x456u; var identifier = new ProgramIdentifier(dataPart, otherPart); var combinedParts = (((ulong)dataPart) << 32) | otherPart; var expectedHash = combinedParts.GetHashCode(); Assert.Equal(expectedHash, identifier.GetHashCode()); }
public void ProgramIdentifier_ImplicitOperator_CreatesProperIdentifier() { var crc = 0x48736251u; var expectedId = ((ulong)crc) << 32; ProgramIdentifier identifier = crc; Assert.Equal(crc, identifier.DataCrc); Assert.Equal(0u, identifier.OtherData); Assert.Equal(expectedId, identifier.Id); }
public void ProgramIdentifier_CreateWithId_CreatesProperIdentifier() { var expectedId = 0x01234567FEDCBA98u; var expectedData = (uint)(expectedId >> 32); var expectedOtherData = (uint)(expectedId & 0xFFFFFFFF); var identifier = new ProgramIdentifier(expectedId); Assert.Equal(expectedData, identifier.DataCrc); Assert.Equal(expectedOtherData, identifier.OtherData); Assert.Equal(expectedId, identifier.Id); }
public void ProgramIdentifier_CreateWithDataAndOtherCrcs_CreatesProperIdentifier() { var dataPart = 0xFEDCBA98u; var otherPart = 0x76543210u; var expectedId = (((ulong)dataPart) << 32) | otherPart; var identifier = new ProgramIdentifier(dataPart, otherPart); Assert.Equal(dataPart, identifier.DataCrc); Assert.Equal(otherPart, identifier.OtherData); Assert.Equal(expectedId, identifier.Id); }
public void Ecs_IRomCompatibleWithEcsRom_IsTrue() { var ecs = new Ecs(); var programInformationTable = ProgramInformationTable.Initialize(Enumerable.Empty <ProgramInformationTableDescriptor>().ToArray()); var mindStrikeProgramId = new ProgramIdentifier(0x9D57498F); var mindStrikeInfo = programInformationTable.FindProgram(mindStrikeProgramId); Assert.NotNull(mindStrikeInfo); var mindStrikeDescription = new ProgramDescription(mindStrikeProgramId.DataCrc, null, mindStrikeInfo); Assert.True(ecs.IsRomCompatible(mindStrikeDescription)); }
/// <summary> /// Checks if the given ROM's CRC data matches the given program identifier with selectable strictness. See remarks. /// </summary> /// <param name="rom">The ROM to check for a match.</param> /// <param name="programIdentifier">The program identifier to match.</param> /// <param name="cfgCrcMustMatch">If <c>true</c> and a .BIN format ROM is being checked, determines whether the CRC of the config file must match as well.</param> /// <returns><c>true</c> if <paramref name="rom"/>'s CRC data matches the given <paramref name="programIdentifier"/>, <c>false</c> otherwise.</returns> /// <remarks><para>For .BIN format ROMs, there is the possibility, depending on the value if <paramref name="cfgCrcMustMatch"/>, that a match is reported, even though /// the .CFG file could have a profound impact on the actual ROM being used. The .CFG file can actually cause modifications to the ROM itself, or describe different /// features in the ROM (e.g. different compatibility or metadata). While metadata and compatibility differences could be considered cosmetic only, they can affect /// how the ROM is handled by hardware in the case of LTO Flash! for example. Most important of course is the matter of the memory map, RAM mappings, or actual /// code modification (e.g. the patch for Dreadnaught Factor for PAL systems). That said, until .CFG CRC values are computed on a 'canonicalized' form of the .CFG /// file, it is important to note that mere whitespace changes will cause .CFG mismatches, making it fragile to do full compares when working with database.</para> /// <para>Similarly, when working with the .ROM format, it is important to note that at this time, the CRC is computed for the entire file, including metadata that /// may be provided. This means that mismatches can occur because a documentation credit was modified in the metadata of one version of the file, even though /// the executable ROM itself was not changed.</para> /// <para>Finally, for the LUIGI format, there is an additional challenge. To this point, this ROM format is only used as the destination format for ROMs copied to /// the LTO Flash! hardware, though the jzIntv emulator supports it as well. As such, it is more than a container format for .BIN or .ROM formats, as it is different /// in several important ways. However, it has not yet (and possibly will never become) a target ROM format. It addresses some deficiencies in the original .ROM format /// that parallel the limitations of the original Intellicart and CuttleCart 3 hardware. That said, in theory the LUIGI header's UID entry poses a challenge. If the /// LUIGI file was created from a .ROM-format ROM, it is unambiguous. However, thereafter it is not clear if the file was created directly from the assembler, in which /// case the UID contains an as-yet-to-be-defined strong hash of something, or wither it contains a pair of 32-bit CRC values, one from the .BIN file, the other from /// the corresponding .CFG file. Given the nature of more modern Intellivision programs to commonly stray from the standard set of common .CFG files (and memory maps), /// it will be an interesting challenge to distinguish a LUIGI created via bin2luigi from one created directly by the assembler. In such a case, most likely we'd want /// to bump the version number of the LUIGI header and at least set a flag somewhere in the sea of bits that we swim through to figure out all these intricacies.</para></remarks> public static bool MatchesProgramIdentifier(this IRom rom, ProgramIdentifier programIdentifier, bool cfgCrcMustMatch) { var match = false; if (rom != null) { switch (rom.Format) { case RomFormat.Bin: match = (programIdentifier.DataCrc == rom.Crc) && (!cfgCrcMustMatch || (programIdentifier.OtherData == rom.CfgCrc)); break; case RomFormat.Rom: case RomFormat.CuttleCart3: case RomFormat.CuttleCart3Advanced: match = programIdentifier.DataCrc == rom.Crc; break; case RomFormat.Luigi: var luigiHeader = rom.GetLuigiHeader(); if (luigiHeader != null) { match = programIdentifier.Id == luigiHeader.Uid; // probably will never use this result, but... if (luigiHeader.OriginalRomFormat == RomFormat.Bin) { match = (programIdentifier.DataCrc == luigiHeader.OriginalRomCrc32) && (!cfgCrcMustMatch || (programIdentifier.OtherData == luigiHeader.OriginalCfgCrc32)); } else if (luigiHeader.OriginalRomFormat == RomFormat.Rom) { match = programIdentifier.DataCrc == luigiHeader.OriginalRomCrc32; } // else .. Should we throw here? This situation (as of 2. Sept. 2018) cannot exist. } break; default: throw new InvalidOperationException(); } } return(match); }
public void MergedProgramInformationTable_FindRomWithProgramIdentifier_FindsInformationAsExpected() { var mergedInformationTable = new MergedProgramInformationTable(); var testProgramIdentifier = new ProgramIdentifier(0x123u, 0x456u); var testProgramInformation = new TestProgramInformation() { Title = "Buffy Buckingham", Features = ProgramFeatures.GetUnrecognizedRomFeatures() }; testProgramInformation.AddCrcs(3); testProgramInformation.AddCrc(testProgramIdentifier.DataCrc, "Version 0", IncompatibilityFlags.Tutorvision, testProgramIdentifier.OtherData); var table = new TestProgramInformationTable(); table.AddEntries(testProgramInformation); mergedInformationTable.MergeTable(table); var foundInformation = mergedInformationTable.FindProgram(testProgramIdentifier); Assert.NotNull(foundInformation); }
public IProgramInformation FindProgram(ProgramIdentifier programIdentifier) { var information = _entries.FirstOrDefault(e => e.Key == programIdentifier.DataCrc).Value; return(information); }
/// <inheritdoc /> public IProgramInformation FindProgram(ProgramIdentifier programIdentifier) { return(FindProgram(programIdentifier.DataCrc)); }
public void ProgramIdentifier_OperatorNotEqual_ComparesIdentifiersCorrectly(ProgramIdentifier lhs, ProgramIdentifier rhs, bool expectedEqual) { Assert.NotEqual(expectedEqual, lhs != rhs); }
public void ProgramIdentifier_EqualsObject_ComparesAsExpected(ProgramIdentifier identifier, object other, bool expectedEqual) { Assert.Equal(expectedEqual, identifier.Equals(other)); }