public void Day2b()
{
var input = File.ReadAllText(".\\Content\\Day02.txt");
var answer = ChecksumCalculator.GetSimilarCodes(input.SplitOnNewline().ToArray());
answer.Should().Be("uqyoeizfvmbistpkgnocjtwld");
}
public void Day2b_Test()
{
var input = "abcde\r\nfghij\r\nklmno\r\npqrst\r\nfguij\r\naxcye\r\nwvxyz";
var answer = ChecksumCalculator.GetSimilarCodes(input.SplitOnNewline().ToArray());
answer.Should().Be("fgij");
}
public void Refresh()
{
if (_dscFile.Exists)
{
LoadChildProperties();
Size = _dscFile.Length;
Created = _dscFile.CreationTime;
Checksum = "";
ChecksumStatus = "Missing";
if (_sumFile.Exists)
{
Checksum = File.ReadAllText(_sumFile.FullName);
ChecksumStatus = "Invalid";
if (ChecksumCalculator.Validate(_dscFile.FullName, Checksum))
{
ChecksumStatus = "Valid";
}
}
}
else
{
throw new FileNotFoundException("File not found!", _dscFile.FullName);
}
}
public void Day2a_Test()
{
var input = "abcdef\r\nbababc\r\nabbcde\r\nabcccd\r\naabcdd\r\nabcdee\r\nababab";
var answer = ChecksumCalculator.CalculateChecksum(input);
answer.Should().Be(12);
}
internal /* for testing */ static IFilterableIssue CreateFilterableIssue(Issue issue, ITextSnapshot textSnapshot)
{
// SonarLint issues line numbers are 1-based, spans lines are 0-based
if (issue == null)
{
return(null);
}
// A start line of zero means the issue is file-level i.e. not associated with a particular line
if (issue.StartLine == 0)
{
return(new DaemonIssueAdapter(issue, null, null));
}
if (issue.StartLine > textSnapshot.LineCount)
{
// Race condition: the line reported in the diagnostic is beyond the end of the file, so presumably
// the file has been edited while the analysis was being executed
return(null);
}
var text = textSnapshot.GetLineFromLineNumber(issue.StartLine - 1).GetText();
var lineHash = ChecksumCalculator.Calculate(text);
return(new DaemonIssueAdapter(issue, text, lineHash));
}
public void CalcChecksum_CalcSumManyRows_RawSumDivisionAlg_ProperResult()
{
cc = new ChecksumCalculator(new RowSumEvenDivisionAlgorithm());
int sum = cc.CalcChecksum("5 9 2 8\n9 4 7 3\n3 8 6 5");
Assert.AreEqual(9, sum);
}
public void Simple16Test()
{
//Stage
Span <byte> bytes = new byte[] {
0x7B, 0xFF, //prefix
0x20, 0x00, // request
0x06, 0x00, // extended length
0x4e, 0x01, 0x00, 0x00, //packet number
0x00, 0x00, //checksum 0
0x03, 0x08, // request type
0x00, 0x00, // request type 2
0x00, 0x00, // checksum1
};
var shorts = MemoryMarshal.Cast <byte, ushort>(bytes);
//Mock
//Test
var provider = new ChecksumCalculator();
var results = new[] {
provider.Simple16(shorts.Slice(0, 6)),
provider.Simple16(shorts.Slice(6, 3)),
};
//Assert
Assert.AreEqual((ushort)0xff0f, results[0]);
Assert.AreEqual((ushort)0xf7fc, results[1]);
//Verify
}
/// <summary>
/// Returns the checksum for this UDPFrame. This method works not always clean. An alternative is to set the checksum of an UDP frame to an empty byte array with the length of two.
/// </summary>
/// <param name="bPseudoHeader">The IP which should be included into the checksum calculation</param>
/// <returns>The checksum data</returns>
public byte[] CalculateChecksum(byte[] bPseudoHeader)
{
if (bPseudoHeader.Length % 2 != 0)
{
throw new ArgumentException("Pseudo header length must be a multiple of two.");
}
int iLength = this.Length;
byte[] bInnerData = fEncapsulatedFrame != null ? fEncapsulatedFrame.FrameBytes : new byte[0];
byte[] bUDPFrame = new byte[8 + bInnerData.Length + (bInnerData.Length % 2 == 0 ? 0 : 1) + bPseudoHeader.Length];
bPseudoHeader.CopyTo(bUDPFrame, 0);
bUDPFrame[bPseudoHeader.Length + 0] = (byte)((iSourcePort >> 8) & 0xFF);
bUDPFrame[bPseudoHeader.Length + 1] = (byte)((iSourcePort) & 0xFF);
bUDPFrame[bPseudoHeader.Length + 2] = (byte)((iDestinationPort >> 8) & 0xFF);
bUDPFrame[bPseudoHeader.Length + 3] = (byte)((iDestinationPort) & 0xFF);
bUDPFrame[bPseudoHeader.Length + 4] = (byte)((iLength >> 8) & 0xFF);
bUDPFrame[bPseudoHeader.Length + 5] = (byte)((iLength) & 0xFF);
bUDPFrame[bPseudoHeader.Length + 6] = 0;
bUDPFrame[bPseudoHeader.Length + 7] = 0;
bInnerData.CopyTo(bUDPFrame, bPseudoHeader.Length + 8);
return(ChecksumCalculator.CalculateChecksum(bUDPFrame));
}
public void Day2a()
{
var input = File.ReadAllText(".\\Content\\Day02.txt");
var answer = ChecksumCalculator.CalculateChecksum(input);
answer.Should().Be(5681);
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
if (sfdSave.ShowDialog() != DialogResult.OK)
{
return;
}
// Update values
SaveData();
// Update Checksum
ChecksumCalculator.UpdateChecksum(_saveData);
try
{
// Write save file
File.WriteAllBytes(sfdSave.FileName, _saveData);
// Inform the user
MessageBox.Show("Saved successfully!", "Success!");
}
catch (Exception)
{
MessageBox.Show("An error occured while attempting to save!", "Error", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
/// <summary>
/// Calculates the TCP checksum of this frame
/// </summary>
/// <param name="bPseudoHeader">The IP pseudo header to add to the checksum</param>
/// <returns>The checksum data</returns>
public byte[] CalculateChecksum(byte[] bPseudoHeader)
{
if (bPseudoHeader.Length % 2 != 0)
{
throw new ArgumentException("Pseudo header length must be a multiple of two.");
}
byte[] bInnerData = this.fEncapsulatedFrame != null ? this.fEncapsulatedFrame.FrameBytes : new byte[0];
int iTotalLen = bPseudoHeader.Length + Length;
if (iTotalLen % 2 != 0)
{
iTotalLen += 1;
}
byte[] bTCPFrame = new byte[iTotalLen];
int iDataOffset = 20 + oOptions.OptionLength;
if (iDataOffset % 4 != 0)
{
iDataOffset += 4 - (iDataOffset % 4);
}
bPseudoHeader.CopyTo(bTCPFrame, 0);
bTCPFrame[bPseudoHeader.Length + 0] = (byte)((iSourcePort >> 8) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 1] = (byte)((iSourcePort) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 2] = (byte)((iDestinationPort >> 8) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 3] = (byte)((iDestinationPort) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 4] = (byte)((iSequenceNumber >> 24) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 5] = (byte)((iSequenceNumber >> 16) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 6] = (byte)((iSequenceNumber >> 8) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 7] = (byte)((iSequenceNumber) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 8] = (byte)((iAcknowledgmentNumber >> 24) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 9] = (byte)((iAcknowledgmentNumber >> 16) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 10] = (byte)((iAcknowledgmentNumber >> 8) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 11] = (byte)((iAcknowledgmentNumber) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 12] = (byte)((((iDataOffset) / 4) << 4) & 0xF0);
bTCPFrame[bPseudoHeader.Length + 13] |= (byte)(bUrgent ? 0x20 : 0x00);
bTCPFrame[bPseudoHeader.Length + 13] |= (byte)(bAcknowledgement ? 0x10 : 0x00);
bTCPFrame[bPseudoHeader.Length + 13] |= (byte)(bPush ? 0x8 : 0x00);
bTCPFrame[bPseudoHeader.Length + 13] |= (byte)(bReset ? 0x4 : 0x00);
bTCPFrame[bPseudoHeader.Length + 13] |= (byte)(bSynchronize ? 0x2 : 0x00);
bTCPFrame[bPseudoHeader.Length + 13] |= (byte)(bFinish ? 0x1 : 0x00);
bTCPFrame[bPseudoHeader.Length + 14] = (byte)((iWindow >> 8) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 15] = (byte)((iWindow) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 16] = 0;
bTCPFrame[bPseudoHeader.Length + 17] = 0;
bTCPFrame[bPseudoHeader.Length + 18] = (byte)((iUrgentPointer >> 8) & 0xFF);
bTCPFrame[bPseudoHeader.Length + 19] = (byte)((iUrgentPointer) & 0xFF);
oOptions.Raw.CopyTo(bTCPFrame, bPseudoHeader.Length + 20);
bInnerData.CopyTo(bTCPFrame, bPseudoHeader.Length + iDataOffset);
return(ChecksumCalculator.CalculateChecksum(bTCPFrame));
}
public void ChecksumCalculator_When_CalculateAdditionChecksum_Called_With_Zero_It_Returns_Zero()
{
var sut = new ChecksumCalculator();
var checksum = sut.CalculateAdditionChecksum(0);
Assert.AreEqual(0, checksum);
}
/// <summary>
/// Calculates an IPv6 ICMP checksum from this frame.
/// </summary>
/// <param name="bPseudoHeader">The IPv6 pseudo header to use for the calculation.</param>
/// <returns>The ICMPv6 checksum.</returns>
public byte[] CalculateChecksum(byte[] bPseudoHeader)
{
byte[] bChecksumData = new byte[bPseudoHeader.Length + this.Length];
Array.Copy(bPseudoHeader, 0, bChecksumData, 0, bPseudoHeader.Length);
Array.Copy(this.FrameBytes, 0, bChecksumData, bPseudoHeader.Length, this.Length);
return(ChecksumCalculator.CalculateChecksum(bChecksumData));
}
public void TestPart2Problem(string dataFile, int expected)
{
var sut = new ChecksumCalculator();
var actual = sut.CalculatePart2(TestFixture(dataFile));
Assert.That(actual, Is.EqualTo(expected));
}
public void TestTrainNumberCheckSum()
{
Assert.AreEqual(4, ChecksumCalculator.TrainNumberCheckSum("50852673106"));
Assert.AreEqual(1, ChecksumCalculator.TrainNumberCheckSum("50853633111"));
Assert.AreEqual(0, ChecksumCalculator.TrainNumberCheckSum("50858633111"));
Assert.AreEqual(8, ChecksumCalculator.TrainNumberCheckSum("91854450008"));
Assert.AreEqual(4, ChecksumCalculator.TrainNumberCheckSum("50652673306"));
}
public void ChecksumCalculator_When_CalculateMultiplicationChecksum_Called_With_Small_Integer_It_Returns_Checksum()
{
var sut = new ChecksumCalculator();
var checksum = sut.CalculateMultiplicationChecksum(1234);
Assert.AreEqual(24, checksum);
}
private void CreateSumFile(FileInfo dscFile)
{
FileInfo sumFile = new FileInfo(dscFile.FullName + ".checksum");
string sumFileContent = ChecksumCalculator.Create(dscFile.FullName);
File.WriteAllText(sumFile.FullName, sumFileContent);
}
public void ChecksumCalculator_When_CalculateAdditionChecksum_Called_With_Large_Integer_It_Returns_Checksum()
{
var sut = new ChecksumCalculator();
var checksum = sut.CalculateAdditionChecksum(786743259);
Assert.AreEqual(51, checksum);
}
public void PuzzleTest1()
{
string puzzle = "5 1 9 5";
ChecksumCalculator checksum = new ChecksumCalculator();
int value = checksum.RowChecksum(puzzle);
Assert.Equal(value, 8);
}
private void SetLiveIssue(Diagnostic diagnostic, int startLine, string wholeLineText)
{
LiveIssue liveIssue = new LiveIssue(diagnostic.Id, Guid.NewGuid().ToString(),
filePath: "dummy file path",
startLine: startLine,
lineHash: ChecksumCalculator.Calculate(wholeLineText));
SetLiveIssue(liveIssue);
}
static void Main(string[] args)
{
var calculator = new ChecksumCalculator();
var matrix = calculator.LoadMatrixFromFile("day2_in.txt");
Console.WriteLine(calculator.CalculateChecksum(matrix));
Console.ReadKey();
}
public TestableRunner(ChecksumCalculator checksumCalculator, FileSystem fileSystem, InputOutput console)
: base(checksumCalculator, fileSystem, console)
{
Calculator = checksumCalculator;
FileSystem = fileSystem;
FileSystem.FileExists(Arg.Any <string>()).Returns(true);
Console = console;
Console.WriteLine(Arg.Any <string>());
}
public void CalculateChecksum_DoesWhatItShould()
{
var bytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var checksumCalculator = new ChecksumCalculator();
var checksum = checksumCalculator.Calculate(bytes);
checksum.Checksum1.Should().Be(36);
checksum.Checksum2.Should().Be(52201);
}
public void PuzzleTest4()
{
string puzzle = @"5 1 9 5
7 5 3
2 4 6 8" ;
ChecksumCalculator checksum = new ChecksumCalculator();
int value = checksum.TotalChecksum(puzzle);
Assert.Equal(value, 18);
}
private HashSet <int> UploadChannelData(List <OxigenIIAdvertising.AppData.Channel> channels)
{
MasterDataMarshallerStreamerClient streamerClient = null;
MemoryStream ms = null;
AppDataFileStreamParameterMessage message = null;
HashSet <int> channelIDs = new HashSet <int>();
try
{
streamerClient = new MasterDataMarshallerStreamerClient();
foreach (OxigenIIAdvertising.AppData.Channel channel in channels)
{
try
{
ms = Serializer.SerializeWithEncryption(channel, _cryptPassword);
message = new AppDataFileStreamParameterMessage();
message.Stream = ms;
message.SystemPassPhrase = _systemPassPhrase;
message.Checksum = ChecksumCalculator.GetChecksum(ms);
message.ChannelID = channel.ChannelID;
message.DataFileType = DataFileType.ChannelData;
streamerClient.SetAppDataFiles(message);
channelIDs.Add(channel.ChannelID);
}
catch (Exception ex)
{
LogException(_eventLog, ex.ToString());
}
finally
{
if (ms != null)
{
ms.Dispose();
}
}
}
}
catch (Exception ex)
{
LogException(_eventLog, ex.ToString());
}
finally
{
if (streamerClient != null)
{
streamerClient.Dispose();
}
}
return(channelIDs);
}
private HashSet <int> UploadAssets(List <SimpleFileInfo> assets)
{
MasterDataMarshallerStreamerClient streamerClient = null;
MemoryStream ms = null;
AssetFileStreamParameterMessage message = null;
HashSet <int> assetIDs = new HashSet <int>();
try
{
streamerClient = new MasterDataMarshallerStreamerClient();
foreach (SimpleFileInfo asset in assets)
{
try
{
ms = EncryptAssetFile(_slidePath + asset.FileNameWithPath, _cryptPassword);
message = new AssetFileStreamParameterMessage();
message.Stream = ms;
message.SystemPassPhrase = _systemPassPhrase;
message.Checksum = ChecksumCalculator.GetChecksum(ms);
message.Filename = asset.FilenameNoPath;
streamerClient.SetAssetFile(message);
assetIDs.Add(asset.FileID);
}
catch (Exception ex)
{
LogException(_eventLog, ex.ToString());
}
finally
{
if (ms != null)
{
ms.Dispose();
}
}
}
}
catch (Exception ex)
{
LogException(_eventLog, ex.ToString());
}
finally
{
if (streamerClient != null)
{
streamerClient.Dispose();
}
}
return(assetIDs);
}
public int Complex_chart_from_DSL(string inputFile)
{
var chartBuilder = new AstronomicalChartBuilder();
var input = File.ReadAllText($".\\{inputFile}.txt");
var chart = chartBuilder.Build(input);
var calculator = new ChecksumCalculator();
var checksum = calculator.GetChecksum(chart);
return(checksum);
}
public void Day6_Part1()
{
var chartBuilder = new AstronomicalChartBuilder();
var input = File.ReadAllText(@".\PuzzleInput.txt");
var chart = chartBuilder.Build(input);
var calculator = new ChecksumCalculator();
var checksum = calculator.GetChecksum(chart);
Assert.AreEqual(154386, checksum);
}
public void Build_a_chart_1_satellite_at_depth_1()
{
var chart = new AstronomicalChart(new AstronomicalObject("com"));
var a = new AstronomicalObject("a");
chart.Root.AddSatellite(a);
var calculator = new ChecksumCalculator();
var checksum = calculator.GetChecksum(chart);
Assert.AreEqual(1, checksum);
}
public LiveIssue(Diagnostic diagnostic, string issueFilePath, string projectGuid, int startLine,
string wholeLineText)
{
Diagnostic = diagnostic;
IssueFilePath = issueFilePath;
ProjectGuid = projectGuid;
StartLine = startLine;
WholeLineText = wholeLineText;
// SonarQube doesn't calculate hash for file-level issues
LineHash = startLine != 0 ? ChecksumCalculator.Calculate(WholeLineText) : "";
}
