Example #1
0
        private void SaveJson(JsonConfigurationProvider provider, JObject json)
        {
            lock (_locker)
            {
                if (provider.Source.FileProvider is PhysicalFileProvider physicalFileProvider)
                {
                    var jsonFilePath = Path.Combine(physicalFileProvider.Root, provider.Source.Path);

                    try
                    {
                        using (var sw = new StreamWriter(jsonFilePath, false))
                            using (var jsonTextWriter = new JsonTextWriter(sw)
                            {
                                Formatting = Formatting.Indented,
                            })
                            {
                                json?.WriteTo(jsonTextWriter);
                            }
                    }
                    catch (IOException exception)
                    {
                        _logger.LogWarning(exception, "JSON configuration could not be written: {path}", jsonFilePath);
                    }
                }
            }
        }
Example #2
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            Department department = (Department)value;

            JObject o = new JObject();
            o["DepartmentId"] = new JValue(department.DepartmentId.ToString());
            o["Name"] = new JValue(new string(department.Name.Reverse().ToArray()));

            o.WriteTo(writer);
        }
Example #3
0
 public void WriteRuntimeFile(string filePath, RuntimeFile runtimeFile)
 {
     using (var fileStream = new FileStream(filePath, FileMode.Create))
     {
         using (var textWriter = new StreamWriter(fileStream))
         {
             using (var jsonWriter = new JsonTextWriter(textWriter))
             {
                 jsonWriter.Formatting = Formatting.Indented;
                 var json = new JObject();
                 WriteRuntimeFile(json, runtimeFile);
                 json.WriteTo(jsonWriter);
             }
         }
     }
 }
Example #4
0
        protected void editButton_Click(object sender, EventArgs e)
        {
            string dirstr     = HttpContext.Current.Server.MapPath("~/Json/");
            string jsonDirstr = string.Format("history.json");
            string fullDirstr = Path.Combine(dirstr, jsonDirstr);
            string value1     = history.Text;
            //string value2 = HttpUtility.HtmlDecode(value1);
            JObject j = new JObject(new JProperty("1", value1));

            File.WriteAllText(fullDirstr, j.ToString());
            using (StreamWriter file = File.CreateText(fullDirstr))
                using (JsonTextWriter writer = new JsonTextWriter(file))
                {
                    j.WriteTo(writer);
                }
        }
Example #5
0
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        Node    node = (Node)value;
        JObject jo   = new JObject();

        jo.Add("name", node.Name);
        if (node.Children.Count == 0)
        {
            jo.Add("leaf", true);
        }
        else
        {
            jo.Add("children", JArray.FromObject(node.Children, serializer));
        }
        jo.WriteTo(writer);
    }
Example #6
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var obj        = new JObject();
            var enumerable = (IEnumerable)value;

            foreach (object kvp in enumerable)
            {
                // TODO: caching
                var keyProp  = kvp.GetType().GetProperty("Key");
                var keyValue = keyProp.GetValue(kvp, null);

                obj.Add(keyValue.ToString(), JArray.FromObject((IEnumerable)kvp));
            }

            obj.WriteTo(writer);
        }
Example #7
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JToken t = JToken.FromObject(value);

            if (t.Type != JTokenType.Object)
            {
                t.WriteTo(writer);
            }
            else
            {
                JObject o = (JObject)t;
                DelimitedLogRecordBase record = value as DelimitedLogRecordBase;
                o.AddFirst(new JProperty("Timestamp", record.TimeStamp));
                o.WriteTo(writer);
            }
        }
Example #8
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var parameter = value as ArmParameter;

            if (parameter == null)
            {
                return;
            }

            JObject jo = new JObject();
            var     propertiesToken = JToken.FromObject(parameter.Properties);

            jo.Add(parameter.Name, propertiesToken);

            jo.WriteTo(writer);
        }
Example #9
0
        private void Save(JObject json)
        {
            if (!FileSystemHelpers.FileExists(_path))
            {
                FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(_path));
            }

            // opens file for FileAccess.Write but does allow other dirty read (FileShare.Read).
            // it is the most optimal where write is infrequent and dirty read is acceptable.
            using (var writer = new JsonTextWriter(new StreamWriter(FileSystemHelpers.OpenFile(_path, FileMode.Create, FileAccess.Write, FileShare.Read))))
            {
                // prefer indented-readable format
                writer.Formatting = Formatting.Indented;
                json.WriteTo(writer);
            }
        }
Example #10
0
        public void SaveTraceResult(TextWriter textWriter, TracerResult traceResult)
        {
            var jtokens = from threadTracerResult in traceResult.dThreadTracerResults.Values
                          select SaveThreads(threadTracerResult);

            JObject traceResultJSON = new JObject
            {
                { "Thread", new JArray(jtokens) }
            };

            using (var jsonWriter = new JsonTextWriter(textWriter))
            {
                jsonWriter.Formatting = Formatting.Indented;
                traceResultJSON.WriteTo(jsonWriter);
            }
        }
Example #11
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var img = (ImageField)value;

            JObject jo = new JObject();

            jo.Add(new JProperty("HasValue", img.HasValue));

            if (img.HasValue)
            {
                var url = ((string)img).Substring(1);
                jo.Add(new JProperty("Url", url));
            }

            jo.WriteTo(writer);
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var room = (Room2D)value;

            var o = new JObject
            {
                new JProperty(nameof(room.Identifier), new JValue(room.Identifier)),
                new JProperty(nameof(room.IsTopExposed), new JValue(room.IsTopExposed)),
                new JProperty(nameof(room.IsGroundContact), new JValue(room.IsGroundContact)),
                new JProperty(nameof(room.FloorToCeilingHeight), new JValue(room.FloorToCeilingHeight)),
                new JProperty(nameof(room.Properties.Energy.ConstructionSet), new JValue(room.Properties.Energy.ConstructionSet.Identifier)),
                new JProperty(nameof(room.Properties.Energy.ProgramType), new JValue(room.Properties.Energy.ProgramType.Identifier)),
            };

            o.WriteTo(writer);
        }
Example #13
0
        private void WriteRuntimeConfig(LibraryExporter exporter)
        {
            if (!_context.TargetFramework.IsDesktop())
            {
                // TODO: Suppress this file if there's nothing to write? RuntimeOutputFiles would have to be updated
                // in order to prevent breaking incremental compilation...

                var json           = new JObject();
                var runtimeOptions = new JObject();
                json.Add("runtimeOptions", runtimeOptions);

                var redistPackage = _context.RootProject.Dependencies
                                    .Where(r => r.Type.Equals(LibraryDependencyType.Platform))
                                    .ToList();
                if (redistPackage.Count > 0)
                {
                    if (redistPackage.Count > 1)
                    {
                        throw new InvalidOperationException("Multiple packages with type: \"platform\" were specified!");
                    }
                    var packageName = redistPackage.Single().Name;

                    var redistExport = exporter.GetAllExports()
                                       .FirstOrDefault(e => e.Library.Identity.Name.Equals(packageName));
                    if (redistExport == null)
                    {
                        throw new InvalidOperationException($"Platform package '{packageName}' was not present in the graph.");
                    }
                    else
                    {
                        var framework = new JObject(
                            new JProperty("name", redistExport.Library.Identity.Name),
                            new JProperty("version", redistExport.Library.Identity.Version.ToNormalizedString()));
                        runtimeOptions.Add("framework", framework);
                    }
                }

                var runtimeConfigJsonFile =
                    Path.Combine(_runtimeOutputPath, _compilerOptions.OutputName + FileNameSuffixes.RuntimeConfigJson);

                using (var writer = new JsonTextWriter(new StreamWriter(File.Create(runtimeConfigJsonFile))))
                {
                    writer.Formatting = Formatting.Indented;
                    json.WriteTo(writer);
                }
            }
        }
        private IFileSystem GetMockFileSystem(string path, params KeyValuePair <string, string>[] values)
        {
            MemoryStream mem        = null;
            var          fileSystem = new Mock <IFileSystem>();
            var          file       = new Mock <FileBase>();
            var          directory  = new Mock <DirectoryBase>();

            // Arrange
            file.Setup(f => f.Open(path, FileMode.Create, FileAccess.Write, FileShare.Read)).Returns(() =>
            {
                mem = new MemoryStream();
                return(mem);
            });
            file.Setup(f => f.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)).Returns(() =>
            {
                if (mem == null)
                {
                    throw new FileNotFoundException(path + " does not exist.");
                }

                byte[] bytes = mem.GetBuffer();
                mem          = new MemoryStream(bytes, 0, bytes.Length, writable: false, publiclyVisible: true);
                return(mem);
            });

            if (values.Length > 0)
            {
                JObject json = new JObject();
                foreach (KeyValuePair <string, string> pair in values)
                {
                    json[pair.Key] = pair.Value;
                }

                mem = new MemoryStream();
                using (var writer = new JsonTextWriter(new StreamWriter(mem)))
                {
                    json.WriteTo(writer);
                }
            }

            file.Setup(f => f.Exists(path)).Returns(() => mem != null);

            fileSystem.Setup(fs => fs.File).Returns(file.Object);
            fileSystem.Setup(fs => fs.Directory).Returns(directory.Object);

            return(fileSystem.Object);
        }
Example #15
0
        /// <inheritdoc />
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (writer == null)
            {
                throw new ArgumentNullException(nameof(writer));
            }

            DirectedGraph <TVertex, TEdge> graph = (DirectedGraph <TVertex, TEdge>)value;

            int count = 0;
            Dictionary <TVertex, int> vertices = graph.Vertices.ToDictionary(v => v, v => count++);

            writer.WriteStartObject();

            // write edges
            writer.WritePropertyName("Edges");
            writer.WriteStartArray();
            foreach (TEdge edge in graph.Edges)
            {
                JObject jo = JObject.FromObject(edge, serializer);
                jo.AddFirst(new JProperty(
                                "$type",
                                DirectedGraphJsonConverter <TGraph, TVertex, TEdge> .RemoveAssemblyDetails(edge.GetType().AssemblyQualifiedName)));
                jo.AddFirst(new JProperty(
                                "$path",
                                string.Join(DirectedGraphJsonConverter <TGraph, TVertex, TEdge> .EdgeSeparator, vertices[edge.Source], vertices[edge.Target])));
                jo.WriteTo(writer);
            }

            writer.WriteEnd();

            // write vertices
            writer.WritePropertyName("Vertices");
            writer.WriteStartArray();
            foreach (TVertex vertex in vertices.Keys)
            {
                JObject jo = JObject.FromObject(vertex, serializer);
                jo.AddFirst(new JProperty(
                                "$type",
                                DirectedGraphJsonConverter <TGraph, TVertex, TEdge> .RemoveAssemblyDetails(vertex.GetType().AssemblyQualifiedName)));
                jo.WriteTo(writer);
            }

            writer.WriteEnd();

            writer.WriteEndObject();
        }
Example #16
0
        public void Parse(JObject data)
        {
            JToken tableNameJToken;

            if (!data.TryGetValue("table", out tableNameJToken))
            {
                _logger.Warning($"Table attribute is not present in data");
                return;
            }

            var tableName = tableNameJToken.Value <string>();

            _store.LastUpdateTime = DateTime.Now;

            if (tableName == SymbolTables.OrderBookL2)
            {
                new OrderBookL2Parser(_orderBookUpdator, _logger).Parse(data);
            }
            else if (tableName == SystemTables.Order)
            {
                new OrdersTableParser(_ordersTableUpdator, _logger).Parse(data);
            }
            else if (tableName == SystemTables.Execution)
            {
                new ExecutionTableParser(_executionTableUpdator, _logger).Parse(data);
            }
            else
            {
                _logger.Error($"Not supported table {tableName}");
            }

            if (_logInFile)
            {
                var path = $"C:\\BitMex\\logs\\{tableName}";

                if (Directory.Exists(path) == false)
                {
                    Directory.CreateDirectory(path);
                }

                using (var sw = File.CreateText($"{path}\\{Guid.NewGuid()}.json"))
                {
                    using (var writer = new JsonTextWriter(sw))
                        data.WriteTo(writer);
                }
            }
        }
Example #17
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var location = value as Point;

            if (location == null)
            {
                throw new ArgumentException($"Excepted: MapElement, got: {value.GetType()}");
            }
            JObject o = JObject.FromObject(
                new LatLng
            {
                Lat = location.Coordinates[0].X,
                Lng = location.Coordinates[0].Y
            });

            o.WriteTo(writer);
        }
Example #18
0
        public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
        {
            string rowBatchSize    = request.DataStore.GetValue("RowBatchSize");
            string sapClient       = request.DataStore.GetValue("SapClient");
            string sapHost         = request.DataStore.GetValue("SapHost");
            string sapLanguage     = request.DataStore.GetValue("SapLanguage");
            string sapRouterString = request.DataStore.GetValue("SapRouterString");
            string sapSystemId     = request.DataStore.GetValue("SapSystemId");
            string sapSystemNumber = request.DataStore.GetValue("SapSystemNumber");

            var    sqlConnectionStrings = request.DataStore.GetAllValues("SqlConnectionString");
            string sqlConnectionString  = sqlConnectionStrings != null ? sqlConnectionStrings[0] : string.Empty;

            if (!string.IsNullOrEmpty(sqlConnectionString))
            {
                SqlCredentials sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString);
                sqlCredentials.Username = string.Empty;
                sqlCredentials.Password = string.Empty;
                sqlConnectionString     = SqlUtility.GetConnectionString(sqlCredentials);
            }

            string jsonDestination = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), JSON_PATH);

            (new FileInfo(jsonDestination)).Directory.Create();

            JObject config = new JObject(
                new JProperty("RowBatchSize", rowBatchSize),
                new JProperty("SapClient", sapClient),
                new JProperty("SapHost", sapHost),
                new JProperty("SapLanguage", sapLanguage),
                new JProperty("SapRouterString", sapRouterString),
                new JProperty("SapSystemId", sapSystemId),
                new JProperty("SapSystemNumber", sapSystemNumber),
                new JProperty("SqlConnectionString", sqlConnectionString)
                );

            using (StreamWriter file = File.CreateText(jsonDestination))
            {
                using (JsonTextWriter writer = new JsonTextWriter(file))
                {
                    config.WriteTo(writer);
                }
            }

            return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject()));
        }
Example #19
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var suggester = Factory.GetConfigNode("suggesters");

            if (suggester?.Attributes == null)
            {
                return;
            }
            _suggesterName = suggester.Attributes["name"].Value;

            if (!_suggesterName.Any())
            {
                return;
            }
            _suggesterSearchMode = suggester.Attributes["searchMode"].Value;

            _sugesterFields =
                (Factory.GetConfigNodes("suggesters/sourceFields/suggesterField")
                 .Cast <XmlNode>()
                 .Select(node => XmlUtil.GetAttribute("suggesterFieldName", node))).ToList();

            if (!_sugesterFields.Any())
            {
                return;
            }

            var suggesters = new List <Suggester>
            {
                new Suggester(_suggesterName, _suggesterSearchMode, _sugesterFields)
            };

            IEnumerable <JToken> suggjtokens = suggesters.Select(f => JToken.FromObject((object)f, serializer));

            IndexDefinition indexDefinition = value as IndexDefinition;

            if (indexDefinition == null)
            {
                return;
            }
            JObject jobject = JObject.FromObject((object)indexDefinition.AnalyzerDefinitions, serializer) ?? new JObject();
            IEnumerable <JToken> jtokens = indexDefinition.Fields.Select <IndexedField, JToken>((Func <IndexedField, JToken>)(f => JToken.FromObject((object)f, serializer)));

            jobject.AddFirst((object)new JProperty("fields", (object)new JArray((object)jtokens)));
            jobject.AddFirst((object)new JProperty("suggesters", (object)new JArray((object)suggjtokens)));
            jobject.WriteTo(writer, Array.Empty <JsonConverter>());
        }
Example #20
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JToken jToken = JToken.FromObject(value);

            if (jToken.Type != JTokenType.Object)
            {
                jToken.WriteTo(writer);
                return;
            }
            JObject        jObject = (JObject)jToken;
            IList <string> content = (from p in jObject.Properties()
                                      where p.Name == "w" || p.Name == "x" || p.Name == "y" || p.Name == "z"
                                      select p.Name).ToList();

            jObject.AddFirst(new JProperty("Keys", new JArray(content)));
            jObject.WriteTo(writer);
        }
Example #21
0
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        Composite composite = (Composite)value;
        // Need to use reflection here because Elements is private
        PropertyInfo   prop     = typeof(Composite).GetProperty("Elements", BindingFlags.NonPublic | BindingFlags.Instance);
        List <Element> children = (List <Element>)prop.GetValue(composite);
        JArray         array    = new JArray();

        foreach (Element e in children)
        {
            array.Add(JToken.FromObject(e, serializer));
        }
        JObject obj = new JObject();

        obj.Add(composite.Name, array);
        obj.WriteTo(writer);
    }
Example #22
0
        public override void WriteJson(JsonWriter writer, TPlugin value, JsonSerializer serializer)
        {
            var pluginType = value.GetType();
            var config     = pluginType.GetProperty("Config")?.GetValue(value, null);

            var o = new JObject
            {
                { "Type", JToken.FromObject(pluginType.Name) }
            };

            if (config != null)
            {
                o.Add("Config", JToken.FromObject(config));
            }

            o.WriteTo(writer);
        }
Example #23
0
        private static void CreateJsonFile(ObjFields objFileds)
        {
            JObject jsonFile = JObject.Parse(File.ReadAllText(objFileds.path));

            JObject appConfiguration = (JObject)jsonFile["AppConfiguration"];

            appConfiguration["DevelopmentConnection"] = objFileds.StringConn;

            FileStream   fsOverwrite = new FileStream(objFileds.path, FileMode.Create);
            StreamWriter swOverwrite = new StreamWriter(fsOverwrite);

            using (JsonTextWriter writer = new JsonTextWriter(swOverwrite))
            {
                writer.Formatting = Newtonsoft.Json.Formatting.Indented;
                jsonFile.WriteTo(writer);
            }
        }
Example #24
0
        public GlobalSettings GetGlobalSettings(JObject json)
        {
            using (var stream = new MemoryStream())
            {
                using (var sw = new StreamWriter(stream, Encoding.UTF8, 256, true))
                {
                    using (var writer = new JsonTextWriter(sw))
                    {
                        writer.Formatting = Formatting.Indented;
                        json.WriteTo(writer);
                    }

                    stream.Position = 0;
                    return(GlobalSettings.GetGlobalSettings(stream, SomePath));
                }
            }
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var notifyEntry = value as NotifyEntry;

            if (notifyEntry == null)
            {
                return;
            }

            var o = new JObject();

            // Write all well-known properties
            o.Add(new JProperty(nameof(NotifyEntry.Type), notifyEntry.Type.ToString()));
            o.Add(new JProperty(nameof(NotifyEntry.Message), notifyEntry.Message.ToString()));

            o.WriteTo(writer);
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            ImportMultiAddress.ScriptPubKeyObject req = (ImportMultiAddress.ScriptPubKeyObject)value;
            JToken t = JToken.FromObject(value);

            if (req.IsAddress)
            {
                // Serialize as a complex object (i.e., { "address": "XYZasASDFASDasdfasdfasdfsd" } )
                JObject jo = (JObject)t;
                jo.WriteTo(writer);
            }
            else
            {
                // Serialize as a simple string value (i.e., "035cd888286d39e64c7c52a49561b323c732fc5cfa48d73faedcf5c40d99747474"
                writer.WriteValue(req.ScriptPubKey.ToHex());
            }
        }
Example #27
0
        public static void EnsureConfig(string path)
        {
            if (!File.Exists(path))
            {
                Console.WriteLine("No config.json");

                JObject robberyConfig = new JObject();
                robberyConfig.Add("interval", 600);

                using (StreamWriter file = File.CreateText(path))
                    using (JsonTextWriter writer = new JsonTextWriter(file))
                    {
                        robberyConfig.WriteTo(writer);
                        Console.WriteLine("Generated Robbery config");
                    }
            }
        }
Example #28
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JObject jo = new JObject();

            foreach (PropertyInfo prop in value.GetType().GetProperties())
            {
                if (prop.CanRead)
                {
                    object propValue = prop.GetValue(value, null);
                    if (propValue != null)
                    {
                        jo.Add(prop.Name.ToUnderscoreLower(), JToken.FromObject(propValue, serializer));
                    }
                }
            }
            jo.WriteTo(writer);
        }
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     if (value != null)
     {
         Vector3 vector = (Vector3)value;
         JObject obj    = new JObject(
             new JProperty("x", vector.x),
             new JProperty("y", vector.y),
             new JProperty("z", vector.z)
             );
         obj.WriteTo(writer);
     }
     else
     {
         JValue.CreateNull().WriteTo(writer);
     }
 }
Example #30
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var type    = value.GetType().GetCustomAttribute <TypeNameAttribute>().Type;
            var jObject = new JObject();

            jObject.Add("type", new JValue(type));
            foreach (var prop in value.GetType().GetProperties())
            {
                var propValue = prop.GetValue(value);
                var name      = prop.GetCustomAttribute <JsonPropertyAttribute>()?.PropertyName ?? prop.Name;
                if (propValue != null)
                {
                    jObject.Add(camelCaseContractResolver.GetResolvedPropertyName(name), JToken.FromObject(propValue, serializer));
                }
            }
            jObject.WriteTo(writer);
        }
        public override void WriteJson(JsonWriter writer,
                                       object value,
                                       JsonSerializer serializer)
        {
            JToken jt = JToken.FromObject(value);

            if (jt.Type != JTokenType.Object)
            {
                jt.WriteTo(writer);
            }
            else
            {
                JObject o = (JObject)jt;
                o.AddFirst(new JProperty("ObjectType", value.GetType().Name));
                o.WriteTo(writer);
            }
        }
        public void Example()
        {
            #region Usage
            JObject videogameRatings = new JObject(
                new JProperty("Halo", 9),
                new JProperty("Starcraft", 9),
                new JProperty("Call of Duty", 7.5));

            File.WriteAllText(@"c:\videogames.json", videogameRatings.ToString());

            // write JSON directly to a file
            using (StreamWriter file = File.CreateText(@"c:\videogames.json"))
            using (JsonTextWriter writer = new JsonTextWriter(file))
            {
                videogameRatings.WriteTo(writer);
            }
            #endregion
        }
        public void Example()
        {
            #region Usage
            JObject o = new JObject
            {
                { "name1", "value1" },
                { "name2", "value2" }
            };

            MemoryStream ms = new MemoryStream();
            using (BsonWriter writer = new BsonWriter(ms))
            {
                o.WriteTo(writer);
            }

            string data = Convert.ToBase64String(ms.ToArray());

            Console.WriteLine(data);
            // KQAAAAJuYW1lMQAHAAAAdmFsdWUxAAJuYW1lMgAHAAAAdmFsdWUyAAA=
            #endregion
        }
    public void Utf8Text()
    {
      string badText =System.IO.File.ReadAllText(@"PoisonText.txt");
      var j = new JObject();
      j["test"] = badText;

      var memoryStream = new MemoryStream();
      var bsonWriter = new BsonWriter(memoryStream);
      j.WriteTo(bsonWriter);
      bsonWriter.Flush();

      memoryStream.Position = 0;
      JObject o = JObject.Load(new BsonReader(memoryStream));

      Assert.AreEqual(badText, (string)o["test"]);
    }