private bool ValidateBinary(BinaryString binary)
{
bool valid = false;
List <string> prefixes = GeneratePrefixes(binary.Name);
var countCero = binary.Name.Count(x => x == '0');
var countOne = binary.Name.Count(x => x == '1');
var validPrefixes = true;
foreach (var prefix in prefixes)
{
var prefixCountCero = prefix.Count(x => x == '0');
var prefixCountOne = prefix.Count(x => x == '1');
if (prefixCountOne < prefixCountCero)
{
validPrefixes = false;
}
}
if ((countCero == countOne) && validPrefixes)
{
valid = true;
}
return(valid);
}
public void FindEndOfLine_ContainsBoth_ShouldReturnFirstIndex(int length, int position)
{
// Arrange.
var data = new byte[length];
data[position + 0] = Character.CarriageReturn;
data[position + 1] = Character.LineFeed;
switch (length - position)
{
case 4:
data[position + 3] = Character.LineFeed;
goto case 3;
case 3:
data[position + 2] = Character.CarriageReturn;
break;
}
var subject = new BinaryString(data);
// Assert.
subject.FindEndOfLine().Should().Be((position, EndOfLine.Both));
subject.FindEndOfLine(position).Should().Be((position, EndOfLine.Both));
}
public string Assemble(string hexString)
{
var binary = new HexString(hexString).ToBinaryString();
var instruction = GetInstruction(binary);
var bitIndex = 0;
var syntax = instruction.Syntax.First();
foreach (var instructionArg in instruction.Args)
{
var argBinary = new BinaryString(binary.Value
.Substring(bitIndex, instructionArg.Size));
var syntaxArg = GetSyntaxArgByBinary(instructionArg.Value, argBinary);
if (syntaxArg != null)
{
syntax = syntax.Replace(instructionArg.Value, syntaxArg);
}
bitIndex += instructionArg.Size;
}
return(syntax.ToLower());
}
public void GetEnumerator_WithNonNullInstance_ShouldReturnEnumeratorWithCorrectOrder(int length)
{
// Arrange.
var data = new byte[length];
using (var random = RandomNumberGenerator.Create())
{
random.GetBytes(data);
}
var subject = new BinaryString(data);
// Assert.
Assert(subject.GetEnumerator());
Assert(((IEnumerable)subject).GetEnumerator());
void Assert(IEnumerator enumerator)
{
foreach (var b in data)
{
enumerator.MoveNext().Should().BeTrue();
enumerator.Current.Should().Be(b);
}
enumerator.MoveNext().Should().BeFalse();
}
}
private string Encode()
{
byte[] bytes = Encoding.UTF8.GetBytes(String);
BinaryString binaryStr = BinaryString.FromString(String, Encoding.UTF8);
BinaryString invertedBinaryStr = binaryStr.InvertBinaries();
BinaryString reversedBinaryStr = invertedBinaryStr.ReverseBinaries();
StringBuilder buffer = new StringBuilder();
int index;
foreach (char c in reversedBinaryStr.ToString())
{
if (c == '0')
{
index = _random.Next(_charsForZero.Length);
buffer.Append(_charsForZero[index]);
}
else
{
index = _random.Next(_charsForOne.Length);
buffer.Append(_charsForOne[index]);
}
if (_random.Next(100) > 100 - InMiddleCharsStrength)
{
index = _random.Next(_charsInTheMiddle.Length);
buffer.Append(_charsInTheMiddle[index]);
}
}
return(buffer.ToString());
}
private string Decode()
{
StringBuilder buffer = new StringBuilder();
foreach (char c in String.Where(x => !_charsInTheMiddle.Contains(x)))
{
if (_charsForZero.Contains(c))
{
buffer.Append('0');
}
else if (_charsForOne.Contains(c))
{
buffer.Append('1');
}
else
{
throw new ArgumentException(string.Format("Invalid character '{0}'", c));
}
}
BinaryString binaryStr = BinaryString.FromBinaryString(buffer.ToString());
BinaryString reversedBinaryStr = binaryStr.ReverseBinaries();
BinaryString invertedBinaryStr = reversedBinaryStr.InvertBinaries();
return(invertedBinaryStr.OriginalString);
}
void TestBothNullEquality(bool expected, Func <BinaryString, BinaryString, bool> test)
{
var first = new BinaryString(null);
var second = new BinaryString(null);
test(first, second).Should().Be(expected);
}
void TestBothZeroLengthEquality(bool expected, Func <BinaryString, BinaryString, bool> test)
{
var first = new BinaryString(new byte[0]);
var second = new BinaryString(new byte[0]);
test(first, second).Should().Be(expected);
}
static BinaryString[] GetCentroids(List <List <DBSCANElement> > clusterDetails)
{
BinaryString[] centroids = new BinaryString[clusterDetails.Count];
for (int i = 0; i < clusterDetails.Count; i++)
{
BinaryString centroid = clusterDetails[i][0].Value;
double cost = double.MaxValue;
for (int j = 0; j < clusterDetails[i].Count; j++)
{
double tempCost = 0;
for (int k = 0; k < clusterDetails[i].Count; k++)
{
if (j != k)
{
tempCost += MatchingMachine.GetHammingDis(clusterDetails[i][j].Value, clusterDetails[i][k].Value);
}
}
if (tempCost < cost)
{
centroid = clusterDetails[i][j].Value;
cost = tempCost;
}
}
centroids[i] = centroid;
}
return(centroids);
}
//Gets the type of hitobject specified at index
static public HitObjectType GetHitObjectType(string hitobject)
{
//Get the hitobject type
string type = GetProperty(hitobject, "type");
BinaryString typeid = new BinaryString(Convert.ToInt32(type));
//Binary 1
if (typeid.GetBit(0) == 1)
{
return(HitObjectType.Circle);
}
//Binary 2
else if (typeid.GetBit(1) == 1)
{
return(HitObjectType.Slider);
}
//Binary 8
else if (typeid.GetBit(3) == 1)
{
return(HitObjectType.Spinner);
}
else
{
throw new ArgumentException("Hitobject type is not valid");
}
}
/// <summary>
/// Converts the given object to the type of this converter, using the specified context and culture information.
/// </summary>
/// <param name="context">An <see cref="ITypeDescriptorContext"/> that provides a format context.</param>
/// <param name="culture">A <see cref="CultureInfo"/>. If null is passed, the current culture is assumed.</param>
/// <param name="value">The <see cref="object"/> to convert.</param>
/// <returns>An <see cref="object"/> that represents the converted value.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
return(BinaryString.CreateFromBase64String((string)value));
}
return(base.ConvertFrom(context, culture, value));
}
/// <summary>
/// Converts Binary back to original string.
/// </summary>
/// <returns>Non-binary string</returns>
public override string ToString()
{
if (String.IsNullOrWhiteSpace(OriginalString))
{
OriginalString = BinaryString.BinaryStrToStr(this.BitArchitecture);
}
return(OriginalString);
}
public ResultStatus Upload(string fname, byte[] buff)
{
if (this.BeginFileProgress != null)
{
this.BeginFileProgress(this, new FileProgressEventArgs(fname, buff.Length, 0));
}
this.WriteLine($"f=open('{fname}', 'wb')");
this.ReadLine();
int count = 0;
string rec = "";
for (int i = 0; i < buff.Length;)
{
int len = Math.Min(32, buff.Length - i);
this.WriteLine($"f.write({ BinaryString.BinToString(buff, i, len)})");
i += len;
rec = this.ReadLine();
rec = this.ReadLine();
int c = 0;
if (int.TryParse(rec, out c))
{
count += c;
}
else
{
string error = this.ReadAllLines();
if (this.EndFileProgress != null)
{
this.EndFileProgress(this, new FileProgressEventArgs(fname, buff.Length, 0));
}
return(new ResultStatus(ResultStatus.Statuses.Error, error));
}
if (this.FileProgress != null)
{
this.FileProgress(this, new FileProgressEventArgs(fname, buff.Length, count));
}
//Globals.Terminal.UpdateTerminal("", count.ToString(">>> # bytes written"));
//Application.DoEvents();
}
this.WriteLine("f.flush()");
rec = this.ReadLine();
this.WriteLine("f.close()");
rec = this.ReadLine();
if (this.EndFileProgress != null)
{
this.EndFileProgress(this, new FileProgressEventArgs(fname, buff.Length, count));
}
return(new ResultStatus(ResultStatus.Statuses.Success, count.ToString("# bytes written")));
}
public void IsEndOfLine_WithInvalidPosition_ShouldThrow(int length, int position)
{
var data = new byte[length];
var subject = new BinaryString(data);
subject.Invoking(s => s.IsEndOfLine(position))
.Should().ThrowExactly <ArgumentOutOfRangeException>()
.And.ParamName.Should().Be("position");
}
public void FindEndOfLine_WithInvalidStart_ShouldThrow(int length)
{
var subject = new BinaryString(new byte[length]);
subject.Invoking(s => s.FindEndOfLine(length))
.Should().ThrowExactly <ArgumentOutOfRangeException>();
subject.Invoking(s => s.FindEndOfLine(-1))
.Should().ThrowExactly <ArgumentOutOfRangeException>();
}
public void TestAddBinaryCase2()
{
// Arrange
CreateTestData();
// Act
var result = BinaryString.AddBinary(testDataSet2[0], testDataSet2[1]);
// Act
}
public void TestMethod1()
{
Random r = new Random();
for (int i = 0; i < 12; i++)
{
int x = r.Next(0, 1024);
Assert.AreEqual(Convert.ToString(x, 2), BinaryString.intToBinary(x));
}
}
public void TestAddBinaryCase1()
{
// Arrange
CreateTestData();
// Act
var result = BinaryString.AddBinary(testDataSet1[0], testDataSet1[1]);
// Act
Assert.AreEqual("10001", result, "Different Value Expected");
}
public string Disassemble(string operationString)
{
var operation = SplitOperationString(operationString);
var instruction = LanguageDefinition.Instructions.Find(i => {
return(i.TextDisplay.ToLower() == operation[0].ToLower());
});
if (instruction == null)
{
throw new Exception("The operation supplied does not match any known instruction definition.");
}
var binary = new BinaryString(instruction.Binary);
var syntaxDefinition = new string[0];
var isMatch = false;
foreach (var syntax in instruction.Syntax)
{
syntaxDefinition = SplitOperationString(syntax);
if (operation.Length == syntaxDefinition.Length)
{
isMatch = true;
break;
}
}
if (!isMatch)
{
throw new Exception($"The operation does not match any known syntax definition for instruction {instruction.TextDisplay}");
}
var bitIndex = 0;
foreach (var arg in instruction.Args)
{
var definitionIndex = Array.FindIndex(syntaxDefinition, def => def == arg.Value);
if (definitionIndex != -1)
{
var argBinary = GetArgByValue(arg.Value, operation[definitionIndex]);
if (argBinary != null)
{
binary.Insert(bitIndex, argBinary.Value);
}
}
bitIndex += arg.Size;
}
return(binary.ToHexString().Value);
}
private static long ProcessPacket(BinaryString b, List <long> versions)
{
long version = b.ReadBits(3);
long type = b.ReadBits(3);
versions.Add(version);
if (type == 4)
{
// Base case. Literals contain no sub packets, so just calculate the value they represent and return
return(ProcessLiteral(b));
}
List <long> subResults = new();
// Operator case. Determine how to read the sub packets
long lengthTypeId = b.ReadBits(1);
if (lengthTypeId == 0)
{
// Sub packet section is defined by the number of bits
long subPacketBitLength = b.ReadBits(15);
long positionBefore = b.Position;
long goalPosition = positionBefore + subPacketBitLength;
while (b.Position < goalPosition)
{
long subResult = ProcessPacket(b, versions);
subResults.Add(subResult);
}
}
else if (lengthTypeId == 1)
{
// Sub packet section is defined by the number of packets
long numberOfSubPackets = b.ReadBits(11);
for (int i = 0; i < numberOfSubPackets; i++)
{
long subResult = ProcessPacket(b, versions);
subResults.Add(subResult);
}
}
// Evaluate the different operators against the sub packet results
return(type switch
{
0 => subResults.Sum(),
1 => subResults.Aggregate(1L, (acc, x) => acc * x),
2 => subResults.Min(),
3 => subResults.Max(),
5 => subResults[0] > subResults[1] ? 1 : 0,
6 => subResults[0] < subResults[1] ? 1 : 0,
7 => subResults[0] == subResults[1] ? 1 : 0,
_ => throw new NotSupportedException(type.ToString()),
});
public async Task <bool> Update(BinaryString binary)
{
binary.Valid = ValidateBinary(binary);
ReplaceOneResult updateResult = await _context.BinaryStrings
.ReplaceOneAsync(
filter : g => g.Id == binary.Id,
replacement : binary);
return(updateResult.IsAcknowledged &&
updateResult.ModifiedCount > 0);
}
private void TextBoxBinary_TextChanged(object sender, TextChangedEventArgs e)
{
if (NumberBase != NumberBase.Binary)
{
return;
}
long value;
if (BinaryString.ParseBinaryString(IsSigned, SizeInBits, out value))
{
CurrentValue = value;
}
}
static void Main(string[] args)
{
//AppendToFile("test.txt", "Hello world!");
//var primes = new Primes();
//var primeCount = 1;
//foreach( var prime in primes)
//{
// Console.WriteLine($"{primeCount++}: {prime}");
//}
var binary = new BinaryString("11111111111111111111111111111111");
Console.WriteLine(binary.ToDouble());
Console.ReadKey();
}
public async Task <IActionResult> Put(string name, [FromBody] BinaryString binary)
{
var binaryFromDb = await _binaryRepository.GetBinaryString(name);
if (binaryFromDb == null)
{
return(new NotFoundResult());
}
binary.Id = binaryFromDb.Id;
await _binaryRepository.Update(binary);
return(new OkObjectResult(binary));
}
public void IsEndOfLine_WithNonMarker_ShouldReturnNull(int position)
{
var data = new byte[]
{
0x00,
Character.LineFeed,
0x00,
Character.CarriageReturn,
Character.LineFeed,
0x00
};
var subject = new BinaryString(data);
subject.IsEndOfLine(position).Should().BeNull();
}
public void IsEndOfLine_WithSingleCarriageReturn_ShouldIdentifyAsCarriageReturn(int length, int position)
{
// Arrange.
var data = new byte[length];
if (position > 0)
{
data[position - 1] = Character.LineFeed;
}
data[position] = Character.CarriageReturn;
var subject = new BinaryString(data);
// Assert.
subject.IsEndOfLine(position).Should().Be(EndOfLine.CarriageReturn);
}
protected UserHeaderType BuildUser(BasicHeaderType header)
{
if (header == null)
{
throw new ArgumentNullException("header");
}
using (var sha = SHA512.Create())
{
BinaryString signatureSource = header.RequestId + header.Timestamp.ToUniversalTime().ToString("yyyyMMddHHmmss") + secretKey;
HexString sig = sha.ComputeHash(signatureSource);
return(new UserHeaderType
{
PasswordHash = passwordHash,
User = username,
VATNumber = vatNumber,
RequestSignature = sig
});
}
}
public void BinaryStringTest()
{
BinaryString str = BinaryString.FromString("hello world");
BinaryString str2 = BinaryString.FromString("hello world");
Assert.AreEqual(str, str2);
Assert.AreEqual("0110100001100101011011000110110001101111001000000111011101101111011100100110110001100100", str.ToString());
BinaryString str3 = BinaryString.FromString("a");
Assert.AreEqual("01100001", str3.ToString());
BinaryString invertedStr3 = str3.InvertBinaries();
Assert.AreEqual("10011110", invertedStr3.ToString());
BinaryString reversedStr3 = str3.ReverseBinaries();
Assert.AreEqual("10000110", reversedStr3.ToString());
}
public Instruction GetInstruction(BinaryString binaryString)
{
return(LanguageDefinition.Instructions.Find(instruction =>
{
var isMatch = true;
for (var i = 0; i < 32; i++)
{
if (instruction.Mask[i] == '1' &&
instruction.Binary[i]
!= binaryString.Value[i])
{
isMatch = false;
break;
}
}
return isMatch;
}));
}
public void FindEndOfLine_NoMarker_ShouldReturnMinusOne(int length, int position)
{
// Arrange.
var data = new byte[length];
if (position == 1)
{
data[0] = Character.LineFeed;
}
else if (position > 1)
{
data[position - 2] = Character.CarriageReturn;
data[position - 1] = Character.LineFeed;
}
var subject = new BinaryString(data);
// Assert.
subject.FindEndOfLine(position).Should().Be((-1, default(EndOfLine)));
}
