public void TestParseHexStringEmpty() { byte[] expected = new byte[0]; var actual = BsonUtils.ParseHexString(string.Empty); Assert.AreEqual(expected, actual); }
private BsonValue PreprocessHex(BsonValue value) { var array = value as BsonArray; if (array != null) { for (var i = 0; i < array.Count; i++) { array[i] = PreprocessHex(array[i]); } return(array); } var document = value as BsonDocument; if (document != null) { if (document.ElementCount == 1 && document.GetElement(0).Name == "$hex" && document[0].IsString) { var hex = document[0].AsString; var bytes = BsonUtils.ParseHexString(hex); return(new BsonBinaryData(bytes)); } for (var i = 0; i < document.ElementCount; i++) { document[i] = PreprocessHex(document[i]); } return(document); } return(value); }
private object ParseExpectedValue(object value) { var stringValue = value as string; if (stringValue != null) { if (stringValue.StartsWith("DateTime:")) { var styles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal; return(DateTime.Parse(stringValue.Substring(9), CultureInfo.InvariantCulture, styles)); } if (stringValue.StartsWith("Guid:")) { return(Guid.Parse(stringValue.Substring(5))); } if (stringValue.StartsWith("Hex:")) { return(BsonUtils.ParseHexString(stringValue.Substring(4))); } } return(value); }
public void ParseHexString_should_throw_when_string_is_null() { var exception = Record.Exception(() => BsonUtils.ParseHexString(null)); var argumentNullException = exception.Should().BeOfType <ArgumentNullException>().Subject; argumentNullException.ParamName.Should().Be("s"); }
public void TestParseHexString() { var expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 255 }; var value = "000102030405060708090a0b0c0d0e0f10ff"; var actual = BsonUtils.ParseHexString(value); Assert.AreEqual(expected, actual); }
public void TestParseHexStringOdd() { var expected = new byte[] { 0, 15 }; var value = "00f"; var actual = BsonUtils.ParseHexString(value); Assert.AreEqual(expected, actual); }
public void WriteJson_should_have_expected_result_when_using_wrapped_json_writer(string nullableHexBytes, BsonBinarySubType subType, string expectedResult, GuidRepresentation resultGuidRepresentation) { var subject = new BsonBinaryDataConverter(); var value = nullableHexBytes == null ? null : new BsonBinaryData(BsonUtils.ParseHexString(nullableHexBytes), subType, resultGuidRepresentation); var result = WriteJsonUsingWrappedJsonWriter(subject, value); result.Should().Be(expectedResult); }
public void WriteJson_should_have_expected_result_when_using_native_bson_writer(string nullableHexBytes, BsonBinarySubType subType, string expectedResult, GuidRepresentation resultGuidRepresentation) { var subject = new BsonBinaryDataConverter(); var value = nullableHexBytes == null ? null : new BsonBinaryData(BsonUtils.ParseHexString(nullableHexBytes), subType); var result = WriteJsonUsingNativeBsonWriter(subject, value, mustBeNested: true); result.Should().Equal(ToBson(expectedResult, resultGuidRepresentation)); }
public void BsonBinaryData_constructor_with_a_Guid_and_a_representation_should_return_expected_result(GuidRepresentation guidRepresentation, BsonBinarySubType expectedSubType, string expectedBytes) { GuidMode.Set(GuidRepresentationMode.V3); var guid = new Guid("00112233445566778899aabbccddeeff"); var result = new BsonBinaryData(guid, guidRepresentation); result.SubType.Should().Be(expectedSubType); result.Bytes.Should().Equal(BsonUtils.ParseHexString(expectedBytes)); }
public void TestUtf16LittleEndianAutoDetect() { var bytes = BsonUtils.ParseHexString("fffe7b00200022007800220020003a002000310020007d00"); using (var memoryStream = new MemoryStream(bytes)) using (var streamReader = new StreamReader(memoryStream, true)) { var document = BsonSerializer.Deserialize <BsonDocument>(streamReader); Assert.Equal(1, document["x"].AsInt32); } }
public void TestUtf8AutoDetect() { var bytes = BsonUtils.ParseHexString("7b20227822203a2031207d"); using (var memoryStream = new MemoryStream(bytes)) using (var streamReader = new StreamReader(memoryStream, true)) { var document = BsonSerializer.Deserialize <BsonDocument>(streamReader); Assert.Equal(1, document["x"].AsInt32); } }
private string UnescapeUnicodeCharacters(string value) { var pattern = @"\\u[0-9a-fA-F]{4}"; var unescaped = Regex.Replace(value, pattern, match => { var bytes = BsonUtils.ParseHexString(match.Value.Substring(2, 4)); var c = (char)(bytes[0] << 8 | bytes[1]); return(c < 0x20 ? match.Value : new string(c, 1)); }); return(unescaped); }
public void ReadBsonType_should_throw_when_bson_type_is_invalid(string hexBytes, string expectedElementName) { var bytes = BsonUtils.ParseHexString(hexBytes.Replace(" ", "")); var expectedMessage = $"Detected unknown BSON type \"\\xf0\" for fieldname \"{expectedElementName}\". Are you using the latest driver version?"; using (var memoryStream = new MemoryStream(bytes)) using (var subject = new BsonBinaryReader(memoryStream)) { Action action = () => BsonSerializer.Deserialize <BsonDocument>(subject); action.ShouldThrow <FormatException>().WithMessage(expectedMessage); } }
public void TestUtf8() { var encoding = Utf8Encodings.Strict; var bytes = BsonUtils.ParseHexString("7b20227822203a2031207d"); using (var memoryStream = new MemoryStream(bytes)) using (var streamReader = new StreamReader(memoryStream, encoding)) { var document = BsonSerializer.Deserialize <BsonDocument>(streamReader); Assert.AreEqual(1, document["x"].AsInt32); } }
public void TestUtf16LittleEndian() { var encoding = new UnicodeEncoding(false, false, true); var bytes = BsonUtils.ParseHexString("7b00200022007800220020003a002000310020007d00"); using (var memoryStream = new MemoryStream(bytes)) using (var streamReader = new StreamReader(memoryStream, encoding)) { var document = BsonSerializer.Deserialize <BsonDocument>(streamReader); Assert.Equal(1, document["x"].AsInt32); } }
public static string Unescape(string value) { var index = 0; while ((index = value.IndexOf("\\u", index)) != -1) { var hex = value.Substring(index + 2, 4); var bytes = BsonUtils.ParseHexString(hex); var c = (char)((bytes[0] << 8) | bytes[1]); var s = new string(c, 1); value = value.Substring(0, index) + s + value.Substring(index + 6); index = index + 1; } return(value); }
private void RunDecodeErrorsTest(BsonDocument test) { JsonDrivenHelper.EnsureAllFieldsAreValid(test, "type", "description", "bson"); var bson = BsonUtils.ParseHexString(test["bson"].AsString); var exception = Record.Exception(() => { using (var stream = new MemoryStream(bson)) using (var reader = new BsonBinaryReader(stream)) { while (!reader.IsAtEndOfFile()) { _ = BsonSerializer.Deserialize <BsonDocument>(reader); } } }); AssertException(exception); }
public void Explicit_decoding_with_python_legacy_representation_should_work_as_expected() { GuidMode.Set(GuidRepresentationMode.V3); var bytes = BsonUtils.ParseHexString("00112233445566778899aabbccddeeff"); var binaryData = new BsonBinaryData(bytes, BsonBinarySubType.UuidLegacy); var exception = Record.Exception(() => binaryData.ToGuid()); exception.Should().BeOfType <InvalidOperationException>(); exception = Record.Exception(() => binaryData.ToGuid(GuidRepresentation.Standard)); exception.Should().BeOfType <InvalidOperationException>(); exception = Record.Exception(() => binaryData.ToGuid(GuidRepresentation.Unspecified)); exception.Should().BeOfType <ArgumentException>(); var result = binaryData.ToGuid(GuidRepresentation.PythonLegacy); result.Should().Be(new Guid("00112233445566778899aabbccddeeff")); }
public UnifiedGridFsUploadOperation Build(string targetBucketId, BsonDocument arguments) { var bucket = _entityMap.GetBucket(targetBucketId); string filename = null; GridFSUploadOptions options = null; byte[] source = null; foreach (var argument in arguments) { switch (argument.Name) { case "chunkSizeBytes": options = options ?? new GridFSUploadOptions(); options.ChunkSizeBytes = argument.Value.AsInt32; break; case "filename": filename = argument.Value.AsString; break; case "source": var sourceDocument = argument.Value.AsBsonDocument; JsonDrivenHelper.EnsureAllFieldsAreValid(sourceDocument, "$$hexBytes"); var sourceString = sourceDocument["$$hexBytes"].AsString; if (sourceString.Length % 2 != 0) { throw new FormatException("$$hexBytes must have an even number of bytes."); } source = BsonUtils.ParseHexString(sourceString); break; default: throw new FormatException($"Invalid GridFsUploadOperation argument name: '{argument.Name}'."); } } return(new UnifiedGridFsUploadOperation(bucket, filename, source, options)); }
// private methods private BsonBinaryData ReadExtendedJson(Newtonsoft.Json.JsonReader reader, Newtonsoft.Json.JsonSerializer serializer) { ReadExpectedPropertyName(reader, "$binary"); var bytes = Convert.FromBase64String(ReadStringValue(reader)); ReadExpectedPropertyName(reader, "$type"); BsonBinarySubType subType; ReadToken(reader); switch (reader.TokenType) { case Newtonsoft.Json.JsonToken.Integer: subType = (BsonBinarySubType)(reader.Value is int?(int)reader.Value : Convert.ToInt32(reader.Value, NumberFormatInfo.InvariantInfo)); break; case Newtonsoft.Json.JsonToken.String: subType = (BsonBinarySubType)BsonUtils.ParseHexString((string)reader.Value).Single(); break; default: var message = string.Format("Cannot read BsonBinarySubType from token: {0}.", reader.TokenType); throw new Newtonsoft.Json.JsonReaderException(message); } ReadEndObject(reader); GuidRepresentation guidRepresentation; switch (subType) { case BsonBinarySubType.UuidLegacy: guidRepresentation = GuidRepresentation.CSharpLegacy; break; case BsonBinarySubType.UuidStandard: guidRepresentation = GuidRepresentation.Standard; break; default: guidRepresentation = GuidRepresentation.Unspecified; break; } return(new BsonBinaryData(bytes, subType, guidRepresentation)); }
public void Implicit_encoding_with_pyton_legacy_representation_should_work_as_expected() { GuidMode.Set(GuidRepresentationMode.V3); var collection = GetCollection <ClassWithGuidIdUsingPythonLegacyRepresentation>(); var guid = Guid.Parse("00112233445566778899aabbccddeeff"); var document = new ClassWithGuidIdUsingPythonLegacyRepresentation { Id = guid }; DropCollection(collection); collection.InsertOne(document); var insertedDocument = FindSingleDocument(collection); insertedDocument.Id.Should().Be(guid); var insertedDocumentAsBsonDocument = FindSingleDocumentAsBsonDocument(collection); var binaryData = (BsonBinaryData)insertedDocumentAsBsonDocument["_id"]; binaryData.SubType.Should().Be(BsonBinarySubType.UuidLegacy); binaryData.Bytes.Should().Equal(BsonUtils.ParseHexString("00112233445566778899aabbccddeeff")); }
public void TestParseHexStringNull() { Assert.Throws <ArgumentNullException>(() => BsonUtils.ParseHexString(null)); }
public void ReadJson_should_return_expected_result_when_using_wrapped_bson_reader(string json, GuidRepresentation guidRepresentation, string nullableHexBytes, BsonBinarySubType subType) { var subject = new BsonBinaryDataConverter(); var expectedResult = nullableHexBytes == null ? null : new BsonBinaryData(BsonUtils.ParseHexString(nullableHexBytes), subType); var result = ReadJsonUsingWrappedBsonReader <BsonBinaryData>(subject, ToBson(json, guidRepresentation), mustBeNested: true, guidRepresentation: guidRepresentation); result.Should().Be(expectedResult); }
public void TestParseHexStringNull() { var actual = BsonUtils.ParseHexString(null); }
public void TestParseHexStringInvalid2() { var actual = BsonUtils.ParseHexString("00 1"); }
public void ParseHexString_should_return_expected_result(string s, byte[] expectedResult) { var result = BsonUtils.ParseHexString(s); result.Should().Equal(expectedResult); }
private BsonValue ParseExtendedJson(BsonDocument document) { if (document.ElementCount > 0) { switch (document.GetElement(0).Name) { case "$binary": if (document.ElementCount == 2 && document.GetElement(1).Name == "$type") { var bytes = Convert.FromBase64String(document[0].AsString); var subType = (BsonBinarySubType)(int)BsonUtils.ParseHexString(document[1].AsString)[0]; return(new BsonBinaryData(bytes, subType)); } break; case "$code": if (document.ElementCount == 1) { var code = document[0].AsString; return(new BsonJavaScript(code)); } else if (document.ElementCount == 2 && document.GetElement(1).Name == "$scope") { var code = document[0].AsString; var scope = document[1].AsBsonDocument; return(new BsonJavaScriptWithScope(code, scope)); } break; case "$date": if (document.ElementCount == 1) { switch (document[0].BsonType) { case BsonType.DateTime: return(document[0].AsBsonDateTime); case BsonType.Document: { var dateDocument = document[0].AsBsonDocument; if (dateDocument.ElementCount == 1 && dateDocument.GetElement(0).Name == "$numberLong") { var formattedString = dateDocument[0].AsString; var millisecondsSinceEpoch = long.Parse(formattedString, NumberFormatInfo.InvariantInfo); return(new BsonDateTime(millisecondsSinceEpoch)); } } break; case BsonType.Double: case BsonType.Int32: case BsonType.Int64: { var millisecondsSinceEpoch = document[0].ToInt64(); return(new BsonDateTime(millisecondsSinceEpoch)); } case BsonType.String: { var formattedString = document[0].AsString; var dateTime = DateTime.Parse(formattedString, DateTimeFormatInfo.InvariantInfo); return(new BsonDateTime(dateTime)); } } } break; case "$maxKey": if (document.ElementCount == 1) { return(BsonMaxKey.Value); } break; case "$minKey": if (document.ElementCount == 1) { return(BsonMinKey.Value); } break; case "$oid": if (document.ElementCount == 1) { var hexBytes = document[0].AsString; var objectId = ObjectId.Parse(hexBytes); return(new BsonObjectId(objectId)); } break; case "$regex": if (document.ElementCount == 2 && document.GetElement(1).Name == "$options") { var pattern = document[0].AsString; var options = document[1].AsString; return(new BsonRegularExpression(pattern, options)); } break; case "$symbol": if (document.ElementCount == 1) { var name = document[0].AsString; return(BsonSymbolTable.Lookup(name)); } break; case "$timestamp": if (document.ElementCount == 1) { var timestampDocument = document[0].AsBsonDocument; var timestamp = timestampDocument[0].ToInt32(); var increment = timestampDocument[1].ToInt32(); return(new BsonTimestamp(timestamp, increment)); } break; } } return(document); }
private void RunValid(BsonDocument definition) { // see the pseudo code in the specification var B = BsonUtils.ParseHexString(((string)definition["bson"]).ToLowerInvariant()); var E = ((string)definition["extjson"]).Replace(" ", ""); byte[] cB; if (definition.Contains("canonical_bson")) { cB = BsonUtils.ParseHexString(((string)definition["canonical_bson"]).ToLowerInvariant()); } else { cB = B; } string cE; if (definition.Contains("canonical_extjson")) { cE = ((string)definition["canonical_extjson"]).Replace(" ", ""); } else { cE = E; } EncodeBson(DecodeBson(B)).Should().Equal(cB, "B -> cB"); if (B != cB) { EncodeBson(DecodeBson(cB)).Should().Equal(cB, "cB -> cB"); } if (definition.Contains("extjson")) { EncodeExtjson(DecodeBson(B)).Should().Be(cE, "B -> cE"); EncodeExtjson(DecodeExtjson(E)).Should().Be(cE, "E -> cE"); if (B != cB) { EncodeExtjson(DecodeBson(cB)).Should().Be(cE, "cB -> cE"); } if (E != cE) { EncodeExtjson(DecodeExtjson(cE)).Should().Be(cE, "cE -> cE"); } if (!definition.GetValue("lossy", false).ToBoolean()) { EncodeBson(DecodeExtjson(E)).Should().Equal(cB, "E -> cB"); if (E != cE) { EncodeBson(DecodeExtjson(cE)).Should().Equal(cB, "cE -> cB"); } } } }
[InlineData("G")] // character just after "F" public void ParseHexString_should_throw_when_string_is_invalid(string s) { var exception = Record.Exception(() => BsonUtils.ParseHexString(s)); exception.Should().BeOfType <FormatException>(); }
public void TestParseHexStringInvalid2() { Assert.Throws <FormatException>(() => BsonUtils.ParseHexString("00 1")); }