public void ReadSingleQuoteInsideDoubleQuoteString()
{
string json = @"{""NameOfStore"":""Forest's Bakery And Cafe""}";
JsonTextReader jsonTextReader = new JsonTextReader(new StringReader(json));
jsonTextReader.Read();
jsonTextReader.Read();
jsonTextReader.Read();
Assert.AreEqual(@"Forest's Bakery And Cafe", jsonTextReader.Value);
}
public void FloatParseHandling()
{
string json = "[1.0,1,9.9,1E-06]";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
reader.FloatParseHandling = Json.FloatParseHandling.Decimal;
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(1.0m, reader.Value);
Assert.AreEqual(typeof(decimal), reader.ValueType);
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(1L, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(9.9m, reader.Value);
Assert.AreEqual(typeof(decimal), reader.ValueType);
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(Convert.ToDecimal(1E-06), reader.Value);
Assert.AreEqual(typeof(decimal), reader.ValueType);
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
}
public void SurrogatePairValid()
{
string json = @"{ ""MATHEMATICAL ITALIC CAPITAL ALPHA"": ""\uD835\uDEE2"" }";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
Assert.IsTrue(reader.Read());
Assert.IsTrue(reader.Read());
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
string s = reader.Value.ToString();
Assert.AreEqual(2, s.Length);
StringInfo stringInfo = new StringInfo(s);
Assert.AreEqual(1, stringInfo.LengthInTextElements);
}
public DumperStats Import(string file)
{
var stopwatch = Stopwatch.StartNew();
using (var streamReader =
new StreamReader(new GZipStream(File.OpenRead(file), CompressionMode.Decompress)))
{
var jsonReader = new JsonTextReader(streamReader);
if (jsonReader.Read() == false)
return new DumperStats();
if (jsonReader.TokenType != JsonToken.StartObject)
throw new InvalidDataException("StartObject was expected");
var indexes = new Dictionary<string, IndexDefinition>();
var indexCount = 0;
Read(jsonReader,
"Indexes",
index =>
{
indexCount++;
var indexName = index.Value<string>("name");
if (!indexName.StartsWith("Raven/"))
{
indexes[indexName] = index.Value<RavenJObject>("definition").JsonDeserialization<IndexDefinition>();
}
});
foreach (var index in indexes)
{
_documentDatabase.PutIndex(index.Key, index.Value);
}
var total = 0;
var batch = new List<RavenJObject>();
Read(jsonReader,
"Docs",
document =>
{
total++;
batch.Add((RavenJObject)document);
if (batch.Count >= 128)
{
FlushBatch(batch);
}
});
FlushBatch(batch);
stopwatch.Stop();
return new DumperStats
{
Attachments = 0,
Documents = total,
Indexes = indexCount,
Elapsed = stopwatch.Elapsed
};
}
}
private static void ParseAndValidate(string text, int expectedLength)
{
var reader = new StringReader(text);
var jsonTextReader = new JsonTextReader(reader);
Assert.True(jsonTextReader.Read());
Assert.Equal(JsonToken.StartObject, jsonTextReader.TokenType);
Assert.True(jsonTextReader.Read());
Assert.Equal(JsonToken.PropertyName, jsonTextReader.TokenType);
Assert.Equal("Data", jsonTextReader.Value);
var memoryStream = jsonTextReader.ReadBytesAsStream();
Assert.Equal(expectedLength, memoryStream.Length);
Assert.True(jsonTextReader.Read());
Assert.Equal(JsonToken.PropertyName, jsonTextReader.TokenType);
Assert.Equal("Metadata", jsonTextReader.Value);
Assert.True(jsonTextReader.Read());
Assert.Equal(JsonToken.Null, jsonTextReader.TokenType);
Assert.True(jsonTextReader.Read());
Assert.Equal(JsonToken.EndObject, jsonTextReader.TokenType);
Assert.False(jsonTextReader.Read());
}
public void ReadMultilineString()
{
string json = @"""first line
second line
third line""";
JsonTextReader jsonTextReader = new JsonTextReader(new StringReader(json));
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.String, jsonTextReader.TokenType);
Assert.AreEqual(@"first line
second line
third line", jsonTextReader.Value);
}
public void ThrowErrorWhenParsingUnquoteStringThatStartsWithNE()
{
const string json = @"{ ""ItemName"": ""value"", ""u"":netanelsalinger,""r"":9 }";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
ExceptionAssert.Throws<JsonReaderException>("Unexpected content while parsing JSON. Path 'u', line 1, position 27.",
() =>
{
reader.Read();
});
}
public void ReadSingleValueAsStreamShouldWork(int size)
{
var random = new Random(size);
var buffer = new byte[size];
random.NextBytes(buffer);
var d = new Data
{
Foo = buffer
};
var jsonObj = RavenJToken.FromObject(d);
var jsonObjAsString = jsonObj.ToString();
using (var textReader = new StringReader(jsonObjAsString))
using (var jsonReader = new JsonTextReader(textReader))
{
jsonReader.Read(); // start object
jsonReader.Read(); // property name
var actual = new byte[buffer.Length];
using (var objectStream = jsonReader.ReadBytesAsStream())
{
objectStream.Read(actual, 0, actual.Length);
for (int a = 0; a < actual.Length; a++)
{
if (buffer[a] != actual[a])
{
Assert.True(false, "not equal on byte " + a);
}
}
}
}
}
public void ReadBytesNoStartWithUnexpectedEnd()
{
JsonReader reader = new JsonTextReader(new StringReader(@"[ "));
Assert.IsTrue(reader.Read());
Assert.IsNull(reader.ReadAsBytes());
Assert.AreEqual(JsonToken.None, reader.TokenType);
}
public void UnexpectedEndOfControlCharacter()
{
JsonReader reader = new JsonTextReader(new StringReader(@"'h\"));
ExceptionAssert.Throws<JsonReaderException>(
"Unterminated string. Expected delimiter: '. Path '', line 1, position 3.",
() =>
{
reader.Read();
});
}
public void UnexpectedEndOfHex()
{
JsonReader reader = new JsonTextReader(new StringReader(@"'h\u123"));
ExceptionAssert.Throws<JsonReaderException>(
"Unexpected end while parsing unicode character. Path '', line 1, position 4.",
() =>
{
reader.Read();
});
}
public void ReadNullTerminatorStrings()
{
JsonReader reader = new JsonTextReader(new StringReader("'h\0i'"));
Assert.IsTrue(reader.Read());
Assert.AreEqual("h\0i", reader.Value);
}
public void AppendCharsWhileReadingNewLine()
{
string json = @"
{
""description"": ""A person"",
""type"": ""object"",
""properties"":
{
""name"": {""type"":""string""},
""hobbies"": {
""type"": ""array"",
""items"": {""type"":""string""}
}
}
}
";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
#if DEBUG
reader.SetCharBuffer(new char[129]);
#endif
for (int i = 0; i < 14; i++)
{
Assert.IsTrue(reader.Read());
}
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.AreEqual("type", reader.Value);
}
public void ReadInt64Overflow_Negative()
{
BigInteger i = new BigInteger(long.MinValue);
JsonTextReader reader = new JsonTextReader(new StringReader(i.ToString(CultureInfo.InvariantCulture)));
reader.Read();
Assert.AreEqual(typeof(long), reader.ValueType);
for (int j = 1; j < 1000; j++)
{
BigInteger total = i + -j;
reader = new JsonTextReader(new StringReader(total.ToString(CultureInfo.InvariantCulture)));
reader.Read();
Assert.AreEqual(typeof(BigInteger), reader.ValueType);
}
}
public void ReadingIndented()
{
string input = @"{
CPU: 'Intel',
Drives: [
'DVD read/writer',
""500 gigabyte hard drive""
]
}";
StringReader sr = new StringReader(input);
using (JsonTextReader jsonReader = new JsonTextReader(sr))
{
#if DEBUG
jsonReader.SetCharBuffer(new char[5]);
#endif
Assert.AreEqual(jsonReader.TokenType, JsonToken.None);
Assert.AreEqual(0, jsonReader.LineNumber);
Assert.AreEqual(0, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.StartObject);
Assert.AreEqual(1, jsonReader.LineNumber);
Assert.AreEqual(1, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(jsonReader.Value, "CPU");
Assert.AreEqual(2, jsonReader.LineNumber);
Assert.AreEqual(7, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(JsonToken.String, jsonReader.TokenType);
Assert.AreEqual("Intel", jsonReader.Value);
Assert.AreEqual(2, jsonReader.LineNumber);
Assert.AreEqual(15, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(jsonReader.Value, "Drives");
Assert.AreEqual(3, jsonReader.LineNumber);
Assert.AreEqual(10, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);
Assert.AreEqual(3, jsonReader.LineNumber);
Assert.AreEqual(12, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.String);
Assert.AreEqual(jsonReader.Value, "DVD read/writer");
Assert.AreEqual(jsonReader.QuoteChar, '\'');
Assert.AreEqual(4, jsonReader.LineNumber);
Assert.AreEqual(22, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.String);
Assert.AreEqual(jsonReader.Value, "500 gigabyte hard drive");
Assert.AreEqual(jsonReader.QuoteChar, '"');
Assert.AreEqual(5, jsonReader.LineNumber);
Assert.AreEqual(30, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);
Assert.AreEqual(6, jsonReader.LineNumber);
Assert.AreEqual(4, jsonReader.LinePosition);
jsonReader.Read();
Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);
Assert.AreEqual(7, jsonReader.LineNumber);
Assert.AreEqual(2, jsonReader.LinePosition);
Assert.IsFalse(jsonReader.Read());
}
}
public async virtual Task ImportData(Stream stream, SmugglerOptions options)
{
options = options ?? SmugglerOptions;
if (options == null)
throw new ArgumentNullException("options");
await DetectServerSupportedFeatures();
await EnsureDatabaseExists();
Stream sizeStream;
var sw = Stopwatch.StartNew();
// Try to read the stream compressed, otherwise continue uncompressed.
JsonTextReader jsonReader;
try
{
sizeStream = new CountingStream(new GZipStream(stream, CompressionMode.Decompress));
var streamReader = new StreamReader(sizeStream);
jsonReader = new JsonTextReader(streamReader);
if (jsonReader.Read() == false)
return;
}
catch (Exception e)
{
if (e is InvalidDataException == false
#if SILVERLIGHT
&& e is ZlibException == false
#endif
)
throw;
stream.Seek(0, SeekOrigin.Begin);
sizeStream = new CountingStream(new GZipStream(stream, CompressionMode.Decompress));
var streamReader = new StreamReader(stream);
jsonReader = new JsonTextReader(streamReader);
if (jsonReader.Read() == false)
return;
}
if (jsonReader.TokenType != JsonToken.StartObject)
throw new InvalidDataException("StartObject was expected");
ShowProgress("Begin reading indexes");
var indexCount = await ImportIndexes(jsonReader, options);
ShowProgress(string.Format("Done with reading indexes, total: {0}", indexCount));
ShowProgress("Begin reading documents");
var documentCount = await ImportDocuments(jsonReader, options);
ShowProgress(string.Format("Done with reading documents, total: {0}", documentCount));
ShowProgress("Begin reading attachments");
var attachmentCount = await ImportAttachments(jsonReader, options);
ShowProgress(string.Format("Done with reading attachments, total: {0}", attachmentCount));
ShowProgress("Begin reading transformers");
var transformersCount = await ImportTransformers(jsonReader, options);
ShowProgress(string.Format("Done with reading transformers, total: {0}", transformersCount));
sw.Stop();
ShowProgress("Imported {0:#,#;;0} documents and {1:#,#;;0} attachments in {2:#,#;;0} ms", documentCount, attachmentCount, sw.ElapsedMilliseconds);
}
public void NullCharReading()
{
string json = "\0{\0'\0h\0i\0'\0:\0[\01\0,\0'\0'\0\0,\0null\0]\0,\0do\0:true\0}\0\0/*\0sd\0f\0*/\0/*\0sd\0f\0*/ \0";
JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Null, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
Assert.AreEqual("\0sd\0f\0", reader.Value);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
Assert.AreEqual("\0sd\0f\0", reader.Value);
Assert.IsFalse(reader.Read());
}
public void ReadLongJsonArray()
{
int valueCount = 10000;
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
writer.WriteStartArray();
for (int i = 0; i < valueCount; i++)
{
writer.WriteValue(i);
}
writer.WriteEndArray();
string json = sw.ToString();
JsonTextReader reader = new JsonTextReader(new StringReader(json));
Assert.IsTrue(reader.Read());
for (int i = 0; i < valueCount; i++)
{
Assert.IsTrue(reader.Read());
Assert.AreEqual((long)i, reader.Value);
}
Assert.IsTrue(reader.Read());
Assert.IsFalse(reader.Read());
}
public void ReadLongString()
{
string s = new string('a', 10000);
JsonReader reader = new JsonTextReader(new StringReader("'" + s + "'"));
reader.Read();
Assert.AreEqual(s, reader.Value);
}
public void Depth()
{
string input = @"{
value:'Purple',
array:[1,2,new Date(1)],
subobject:{prop:1,proparray:[1]}
}";
StringReader sr = new StringReader(input);
using (JsonReader reader = new JsonTextReader(sr))
{
Assert.AreEqual(0, reader.Depth);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.StartObject);
Assert.AreEqual(0, reader.Depth);
Assert.AreEqual("", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("value", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.String);
Assert.AreEqual(reader.Value, @"Purple");
Assert.AreEqual(reader.QuoteChar, '\'');
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("value", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("array", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.StartArray);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("array", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
Assert.AreEqual(1L, reader.Value);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("array[0]", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
Assert.AreEqual(2L, reader.Value);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("array[1]", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.StartConstructor);
Assert.AreEqual("Date", reader.Value);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("array[2]", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
Assert.AreEqual(1L, reader.Value);
Assert.AreEqual(3, reader.Depth);
Assert.AreEqual("array[2][0]", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.EndConstructor);
Assert.AreEqual(null, reader.Value);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("array[2]", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.EndArray);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("array", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("subobject", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.StartObject);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("subobject", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("subobject.prop", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("subobject.prop", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("subobject.proparray", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.StartArray);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("subobject.proparray", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
Assert.AreEqual(3, reader.Depth);
Assert.AreEqual("subobject.proparray[0]", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.EndArray);
Assert.AreEqual(2, reader.Depth);
Assert.AreEqual("subobject.proparray", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.EndObject);
Assert.AreEqual(1, reader.Depth);
Assert.AreEqual("subobject", reader.Path);
reader.Read();
Assert.AreEqual(reader.TokenType, JsonToken.EndObject);
Assert.AreEqual(0, reader.Depth);
Assert.AreEqual("", reader.Path);
}
}
public void UnexpectedEndWhenParsingUnquotedProperty()
{
JsonReader reader = new JsonTextReader(new StringReader(@"{aww"));
Assert.IsTrue(reader.Read());
ExceptionAssert.Throws<JsonReaderException>(
"Unexpected end while parsing unquoted property name. Path '', line 1, position 4.",
() =>
{
reader.Read();
});
}
public void ParseAdditionalContent_Whitespace()
{
string json = @"[
""Small"",
""Medium"",
""Large""
]
";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
while (reader.Read())
{
}
}
private async Task<int> ImportAttachments(JsonTextReader jsonReader, SmugglerOptions options)
{
var count = 0;
if (jsonReader.Read() == false || jsonReader.TokenType == JsonToken.EndObject)
return count;
if (jsonReader.TokenType != JsonToken.PropertyName)
throw new InvalidDataException("PropertyName was expected");
if (Equals("Attachments", jsonReader.Value) == false)
throw new InvalidDataException("Attachment property was expected");
if (jsonReader.Read() == false)
return count;
if (jsonReader.TokenType != JsonToken.StartArray)
throw new InvalidDataException("StartArray was expected");
while (jsonReader.Read() && jsonReader.TokenType != JsonToken.EndArray)
{
var item = RavenJToken.ReadFrom(jsonReader);
if ((options.OperateOnTypes & ItemType.Attachments) != ItemType.Attachments)
continue;
var attachmentExportInfo =
new JsonSerializer
{
Converters =
{
new JsonToJsonConverter()
}
}.Deserialize<AttachmentExportInfo>(new RavenJTokenReader(item));
ShowProgress("Importing attachment {0}", attachmentExportInfo.Key);
await PutAttachment(attachmentExportInfo);
count++;
}
await PutAttachment(null); // force flush
return count;
}
public void ParseAdditionalContent_WhitespaceThenText()
{
string json = @"'hi' a";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
ExceptionAssert.Throws<JsonReaderException>(
"Additional text encountered after finished reading JSON content: a. Path '', line 1, position 5.",
() =>
{
while (reader.Read())
{
}
});
}
private async Task<int> ImportTransformers(JsonTextReader jsonReader, SmugglerOptions options)
{
var count = 0;
if (jsonReader.Read() == false || jsonReader.TokenType == JsonToken.EndObject)
return count;
if (jsonReader.TokenType != JsonToken.PropertyName)
throw new InvalidDataException("PropertyName was expected");
if (Equals("Transformers", jsonReader.Value) == false)
throw new InvalidDataException("Transformers property was expected");
if (jsonReader.Read() == false)
return count;
if (jsonReader.TokenType != JsonToken.StartArray)
throw new InvalidDataException("StartArray was expected");
while (jsonReader.Read() && jsonReader.TokenType != JsonToken.EndArray)
{
var transformer = RavenJToken.ReadFrom(jsonReader);
if ((options.OperateOnTypes & ItemType.Transformers) != ItemType.Transformers)
continue;
var transformerName = transformer.Value<string>("name");
await PutTransformer(transformerName, transformer);
count++;
}
await PutTransformer(null, null); // force flush
return count;
}
private static void JsonBodyToSoapXml(Stream json, Stream xml)
{
Raven.Imports.Newtonsoft.Json.JsonSerializerSettings settings = new Raven.Imports.Newtonsoft.Json.JsonSerializerSettings();
settings.Converters.Add(new Raven.Imports.Newtonsoft.Json.Converters.XmlNodeConverter());
Raven.Imports.Newtonsoft.Json.JsonSerializer serializer = Raven.Imports.Newtonsoft.Json.JsonSerializer.Create(settings);
using (Newtonsoft.Json.JsonTextReader reader = new Raven.Imports.Newtonsoft.Json.JsonTextReader(new System.IO.StreamReader(json)))
{
XmlDocument doc = (XmlDocument)serializer.Deserialize(reader, typeof(XmlDocument));
if (reader.Read() && reader.TokenType != JsonToken.Comment)
throw new JsonSerializationException("Additional text found in JSON string after finishing deserializing object.");
using (XmlWriter writer = XmlWriter.Create(xml))
{
doc.Save(writer);
}
}
}
private async Task<int> ImportDocuments(JsonTextReader jsonReader, SmugglerOptions options)
{
var count = 0;
if (jsonReader.Read() == false)
return count;
if (jsonReader.TokenType != JsonToken.PropertyName)
throw new InvalidDataException("PropertyName was expected");
if (Equals("Docs", jsonReader.Value) == false)
throw new InvalidDataException("Docs property was expected");
if (jsonReader.Read() == false)
return count;
if (jsonReader.TokenType != JsonToken.StartArray)
throw new InvalidDataException("StartArray was expected");
while (jsonReader.Read() && jsonReader.TokenType != JsonToken.EndArray)
{
var document = (RavenJObject)RavenJToken.ReadFrom(jsonReader);
var size = GetRoughSize(document);
if (size > 1024 * 1024)
{
Console.WriteLine("Large document warning: {0:#,#.##;;0} kb - {1}",
(double)size / 1024,
document["@metadata"].Value<string>("@id"));
}
if ((options.OperateOnTypes & ItemType.Documents) != ItemType.Documents)
continue;
if (options.MatchFilters(document) == false)
continue;
if (!string.IsNullOrEmpty(options.TransformScript))
document = await TransformDocument(document, options.TransformScript);
if (document == null)
continue;
await PutDocument(document);
count++;
if (count % options.BatchSize == 0)
{
ShowProgress("Read {0} documents", count);
}
}
await PutDocument(null); // force flush
return count;
}
public void AppendCharsWhileReadingNull()
{
string json = @"[
{
""$id"": ""1"",
""Name"": ""e1"",
""Manager"": null
},
{
""$id"": ""2"",
""Name"": ""e2"",
""Manager"": null
},
{
""$ref"": ""1""
},
{
""$ref"": ""2""
}
]";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
#if DEBUG
reader.SetCharBuffer(new char[129]);
#endif
for (int i = 0; i < 15; i++)
{
reader.Read();
}
reader.Read();
Assert.AreEqual(JsonToken.Null, reader.TokenType);
}
private XmlNode DeserializeXmlNode(string json, string deserializeRootElementName)
{
JsonTextReader reader;
reader = new JsonTextReader(new StringReader(json));
reader.Read();
XmlNodeConverter converter = new XmlNodeConverter();
if (deserializeRootElementName != null)
converter.DeserializeRootElementName = deserializeRootElementName;
XmlNode node = (XmlNode)converter.ReadJson(reader, typeof (XmlDocument), null, new JsonSerializer());
#if !NET20
string xmlText = node.OuterXml;
reader = new JsonTextReader(new StringReader(json));
reader.Read();
XDocument d = (XDocument) converter.ReadJson(reader, typeof (XDocument), null, new JsonSerializer());
string linqXmlText = d.ToString(SaveOptions.DisableFormatting);
if (d.Declaration != null)
linqXmlText = d.Declaration + linqXmlText;
Assert.AreEqual(xmlText, linqXmlText);
#endif
return node;
}
public void ReadInt32Overflow_Negative()
{
long i = int.MinValue;
JsonTextReader reader = new JsonTextReader(new StringReader(i.ToString(CultureInfo.InvariantCulture)));
reader.Read();
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.AreEqual(i, reader.Value);
for (int j = 1; j < 1000; j++)
{
long total = -j + i;
ExceptionAssert.Throws<OverflowException>(
"Arithmetic operation resulted in an overflow.",
() =>
{
reader = new JsonTextReader(new StringReader(total.ToString(CultureInfo.InvariantCulture)));
reader.ReadAsInt32();
});
}
}
