public void NullValueReading() { var writer = new JsonBufferWriter(); writer.WriteNull(); AssertBufferedValueScalarOrNull(JsonToken.Null(), writer); }
static JsonBuffer() { JsonBuffer buffer = new JsonBufferStorage(5) // [null,true,false] .Write(JsonToken.Array()) .Write(JsonToken.Null(), JsonToken.True(), JsonToken.False()) .Write(JsonToken.EndArray()) .ToBuffer(); _null = buffer.Slice(1, 2); _true = buffer.Slice(2, 3); _false = buffer.Slice(3, 4); }
private JsonToken Parse() { char c = NextClean(); if (c == '"' || c == '\'') { return(Yield(JsonToken.String(NextString(c)))); } switch (c) { case '{': _reader.Back(); return(ParseObject()); case '[': _reader.Back(); return(ParseArray()); default: { StringBuilder stringBuilder = new StringBuilder(); char c2 = c; while (c >= ' ' && ",:]}/\\\"[{;=#".IndexOf(c) < 0) { stringBuilder.Append(c); c = _reader.Next(); } _reader.Back(); string text = stringBuilder.ToString().Trim(); if (text.Length == 0) { throw new JsonException("Missing value."); } if (text == "true" || text == "false") { return(Yield(JsonToken.Boolean(text == "true"))); } if (text == "null") { return(Yield(JsonToken.Null())); } if ((c2 >= '0' && c2 <= '9') || c2 == '.' || c2 == '-' || c2 == '+') { if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double _)) { throw new JsonException($"The text '{text}' has the incorrect syntax for a number."); } return(Yield(JsonToken.Number(text))); } return(Yield(JsonToken.String(text))); } } }
public void JsonTokenString() { Assert.AreEqual("String:hello", JsonToken.String("hello").ToString()); Assert.AreEqual("Number:123", JsonToken.Number("123").ToString()); Assert.AreEqual("Boolean:true", JsonToken.Boolean(true).ToString()); Assert.AreEqual("Boolean:false", JsonToken.Boolean(false).ToString()); Assert.AreEqual("Null:null", JsonToken.Null().ToString()); Assert.AreEqual("Array", JsonToken.Array().ToString()); Assert.AreEqual("EndArray", JsonToken.EndArray().ToString()); Assert.AreEqual("Object", JsonToken.Object().ToString()); Assert.AreEqual("EndObject", JsonToken.EndObject().ToString()); Assert.AreEqual("Member:test", JsonToken.Member("test").ToString()); Assert.AreEqual("BOF", JsonToken.BOF().ToString()); Assert.AreEqual("EOF", JsonToken.EOF().ToString()); }
/// <summary> /// Parses the next token from the input and returns it. /// </summary> private JsonToken Parse() { char ch = NextClean(); // // String // if (ch == '"' || ch == '\'') { return(Yield(JsonToken.String(NextString(ch)))); } // // Object // if (ch == '{') { _reader.Back(); return(ParseObject()); } // // Array // if (ch == '[') { _reader.Back(); return(ParseArray()); } // // Handle unquoted text. This could be the values true, false, or // null, or it can be a number. An implementation (such as this one) // is allowed to also accept non-standard forms. // // Accumulate characters until we reach the end of the text or a // formatting character. // StringBuilder sb = new StringBuilder(); char b = ch; while (ch >= ' ' && ",:]}/\\\"[{;=#".IndexOf(ch) < 0) { sb.Append(ch); ch = _reader.Next(); } _reader.Back(); string s = sb.ToString().Trim(); if (s.Length == 0) { throw SyntaxError("Missing value."); } // // Boolean // if (s == JsonBoolean.TrueText || s == JsonBoolean.FalseText) { return(Yield(JsonToken.Boolean(s == JsonBoolean.TrueText))); } // // Null // if (s == JsonNull.Text) { return(Yield(JsonToken.Null())); } // // Number // // Try converting it. We support the 0- and 0x- conventions. // If a number cannot be produced, then the value will just // be a string. Note that the 0-, 0x-, plus, and implied // string conventions are non-standard, but a JSON text parser // is free to accept non-JSON text forms as long as it accepts // all correct JSON text forms. // if ((b >= '0' && b <= '9') || b == '.' || b == '-' || b == '+') { if (b == '0' && s.Length > 1) { if (s.Length > 2 && (s[1] == 'x' || s[1] == 'X')) { string parsed = TryParseHex(s); if (!ReferenceEquals(parsed, s)) { return(Yield(JsonToken.Number(parsed))); } } else { string parsed = TryParseOctal(s); if (!ReferenceEquals(parsed, s)) { return(Yield(JsonToken.Number(parsed))); } } } else { double unused; if ((b == '-' && s.Length >= 2 && s[1] == 'I') || // rule out -Infinity that double parsing allows !double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out unused)) { throw SyntaxError(string.Format("The text '{0}' has the incorrect syntax for a number.", s)); } return(Yield(JsonToken.Number(s))); } } // // Treat as String in all other cases, e.g. when unquoted. // return(Yield(JsonToken.String(s))); }
protected override void WriteNullImpl() { Write(JsonToken.Null()); }
/// <summary> /// Parses the next token from the input and returns it. /// </summary> private JsonToken Parse() { char ch = NextClean(); // // String // if (ch == '"' || ch == '\'') { return(Yield(JsonToken.String(NextString(ch)))); } // // Object // if (ch == '{') { _reader.Back(); return(ParseObject()); } // // Array // if (ch == '[') { _reader.Back(); return(ParseArray()); } // // Handle unquoted text. This could be the values true, false, or // null, or it can be a number. An implementation (such as this one) // is allowed to also accept non-standard forms. // // Accumulate characters until we reach the end of the text or a // formatting character. // StringBuilder sb = new StringBuilder(); char b = ch; while (ch >= ' ' && ",:]}/\\\"[{;=#".IndexOf(ch) < 0) { sb.Append(ch); ch = _reader.Next(); } _reader.Back(); string s = sb.ToString().Trim(); if (s.Length == 0) { throw new JsonException("Missing value."); } // // Boolean // if (s == JsonBoolean.TrueText || s == JsonBoolean.FalseText) { return(Yield(JsonToken.Boolean(s == JsonBoolean.TrueText))); } // // Null // if (s == JsonNull.Text) { return(Yield(JsonToken.Null())); } // // Number // if ((b >= '0' && b <= '9') || b == '.' || b == '-' || b == '+') { double unused; if (!double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out unused)) { throw new JsonException(string.Format("The text '{0}' has the incorrect syntax for a number.", s)); } return(Yield(JsonToken.Number(s))); } // // Treat as String in all other cases, e.g. when unquoted. // return(Yield(JsonToken.String(s))); }
public void StringRepresentationForNull() { Assert.AreEqual("null", JsonBuffer.From(JsonToken.Null()).ToString()); }
protected override JsonToken ReadTokenImpl() { var baseReader = _reader; var index = _index; if (index < 0) { // // If the base reader was never started then do it now. // Check for zero depth is the same as BOF. // if (baseReader.Depth == 0) { baseReader.ReadToken(JsonTokenClass.Object); _innerDepth = baseReader.Depth; } _index = 0; return(JsonToken.Object()); } // // Buffered members, if any, get served first. // var bufferedMembers = _bufferedMembers; if (bufferedMembers != null && index < bufferedMembers.Count) { // // Is there a value to serve? // var value = _memberValue; if (!value.IsEmpty) { if (value.IsStructured) // JSON Array or Object { // // Get a reader on the structured (array or // object) value if not already acquired. // var valueReader = _memberStructuredValueReader ?? (_memberStructuredValueReader = value.CreateReader()); // // Serve tokens from the value reader until OEF. // if (valueReader.Read()) { return(valueReader.Token); } // // Proceed with next. // _memberValue = JsonBuffer.Empty; _memberStructuredValueReader = null; _index++; return(ReadTokenImpl()); } else // JSON Null, Boolean, Number or String { Debug.Assert(value.IsNull || value.IsScalar); // // Establish state to proceed with next and // serve token pertaining to scalar value. // _memberValue = JsonBuffer.Empty; _index++; return(value.IsNull ? JsonToken.Null() : value.CreateReader().Token); } } // // Serve buffered member name and establish state so // that the value will be served next. // var member = bufferedMembers[index]; _memberValue = member.Buffer; return(JsonToken.Member(member.Name)); } // // Done with buffered members so now move on to remaining // members from the underlying reader. // if (baseReader == null) { return(JsonToken.EOF()); // Done with serving } // // If base reader is on the object end at the same depth as // on entry then serve the last end token. The reader is // released so that on next read, the above will signal EOF. // if (baseReader.Depth == _innerDepth && baseReader.TokenClass == JsonTokenClass.EndObject) { _reader = null; } // // Move through the base reader. // var token = baseReader.Token; baseReader.Read(); return(token); }
public void NullToken() { Assert.AreEqual(JsonTokenClass.Null, JsonToken.Null().Class); }
public void InEqualityWithAnotherType() { Assert.IsFalse(JsonToken.Null().Equals(123)); }
public void InEqualityWithNull() { Assert.IsFalse(JsonToken.Null().Equals(null)); }
public MockedJsonReader Null() { return(Append(JsonToken.Null())); }