static void TestValue(object expected, JsonReader reader, string path) { if (JsonNull.LogicallyEquals(expected)) { Assert.AreEqual(JsonTokenClass.Null, reader.TokenClass, path); } else { var expectedType = Type.GetTypeCode(expected.GetType()); if (expectedType == TypeCode.Object) { if (expected.GetType().IsArray) { TestArray((Array)expected, reader, path); } else { TestObject((JsonObject)expected, reader, path); } } else { switch (expectedType) { case TypeCode.String: Assert.AreEqual(expected, reader.ReadString(), path); break; case TypeCode.Int32: Assert.AreEqual(expected, (int)reader.ReadNumber(), path); break; default: Assert.Fail("Don't know how to handle {0} values.", expected.GetType()); break; } } } }
public virtual void Export(object value, JsonWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } if (JsonNull.LogicallyEquals(value)) { writer.WriteNull(); } else { IExporter exporter = FindExporter(value.GetType()); if (exporter != null) { exporter.Export(this, value, writer); } else { writer.WriteString(value.ToString()); } } }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); if (_properties.Count == 0) { writer.WriteString(value.ToString()); return; } ObjectReferenceTracker objectReferenceTracker = null; try { writer.WriteStartObject(); foreach (PropertyDescriptor property in _properties) { object value2 = property.GetValue(value); if (!JsonNull.LogicallyEquals(value2)) { writer.WriteMember(property.Name); if (objectReferenceTracker == null) { objectReferenceTracker = TrackObject(context, value); } context.Export(value2, writer); } } writer.WriteEndObject(); } finally { objectReferenceTracker?.Pop(value); } }
public void Export(ExportContext context, JsonWriter writer, object source) { if (context == null) { throw new ArgumentNullException("context"); } if (writer == null) { throw new ArgumentNullException("writer"); } if (source == null) { throw new ArgumentNullException("source"); } object value = _property.GetValue(source); if (JsonNull.LogicallyEquals(value) || value.Equals(_defaultValue)) { return; } writer.WriteMember(_property.Name); context.Export(value, writer); }
public void ItConvertsNulls() { var json = new JsonNull(); var xml = ToXml.Convert(json).Stringify(); Assert.AreEqual("<null/>", xml); }
public void JsonNullConstructorTest() { var target = new JsonNull(); Assert.IsNull(target.Value); Assert.AreEqual("null", target.ToString()); }
public static JsonNull GetInstance() { if (instance_ == null) { instance_ = new JsonNull(); } return(instance_); }
public void ToStringTest() { var target = new JsonNull(); const string expected = "null"; string actual = target.ToString(); Assert.AreEqual(expected, actual); }
public static void TestEquals() { var jsonNull1 = new JsonNull(); var jsonNull2 = new JsonNull(); Assert.True(jsonNull1.Equals(jsonNull2)); Assert.True(jsonNull1 == jsonNull2); Assert.False(jsonNull1 != jsonNull2); JsonNode jsonNodeJsonNull = new JsonNull(); Assert.True(jsonNull1.Equals(jsonNodeJsonNull)); Assert.True(jsonNodeJsonNull.Equals(jsonNull1)); IEquatable <JsonNull> jsonNullIEquatable = jsonNull2; Assert.True(jsonNullIEquatable.Equals(jsonNull1)); Assert.True(jsonNull1.Equals(jsonNullIEquatable)); object jsonNullCopy = jsonNull1; Assert.True(jsonNullCopy.Equals(jsonNull1)); Assert.True(jsonNull1.Equals(jsonNullCopy)); object jsonNullObject = new JsonNull(); Assert.True(jsonNullObject.Equals(jsonNull1)); Assert.True(jsonNull1.Equals(jsonNullObject)); Assert.False(jsonNull1.Equals(new JsonString("null"))); Assert.False(jsonNull1.Equals(new Exception())); // Null comparisons behave this way because of implicit conversion from null to JsonNull: Assert.True(jsonNull1.Equals(null)); Assert.True(jsonNull1 == null); Assert.False(jsonNull1 != null); JsonNull jsonNullNull = null; Assert.True(jsonNull1.Equals(jsonNullNull)); Assert.True(jsonNull1 == jsonNullNull); Assert.False(jsonNull1 != jsonNullNull); JsonNull otherJsonNullNull = null; Assert.True(jsonNullNull == otherJsonNullNull); // Only for null JsonNode / different derived type this will return false: JsonNode jsonNodeNull = null; Assert.False(jsonNull1.Equals(jsonNodeNull)); JsonArray jsonArrayNull = null; Assert.False(jsonNull1.Equals(jsonArrayNull)); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); if (_properties.Count == 0) { writer.WriteString(value.ToString()); } else { ObjectReferenceTracker tracker = null; try { writer.WriteStartObject(); foreach (PropertyDescriptor property in _properties) { object propertyValue = property.GetValue(value); if (!JsonNull.LogicallyEquals(propertyValue)) { writer.WriteMember(property.Name); if (tracker == null) { // // We are about to enter a deeper scope so // start tracking the current object being // exported. This will help to detect // recursive references that may occur // through this exporter deeper in the tree. // tracker = TrackObject(context, value); } context.Export(propertyValue, writer); } } writer.WriteEndObject(); } finally { if (tracker != null) { tracker.Pop(value); } } } }
void AssertTableValues(Table t) { Assert.AreEqual(DataType.Number, t.Get("aNumber").Type); Assert.AreEqual(1, t.Get("aNumber").Number); Assert.AreEqual(DataType.String, t.Get("aString").Type); Assert.AreEqual("2", t.Get("aString").String); Assert.AreEqual(DataType.Table, t.Get("anObject").Type); Assert.AreEqual(DataType.Table, t.Get("anArray").Type); Assert.AreEqual(DataType.String, t.Get("slash").Type); Assert.AreEqual("a/b", t.Get("slash").String); Table o = t.Get("anObject").Table; Assert.AreEqual(DataType.Number, o.Get("aNumber").Type); Assert.AreEqual(3, o.Get("aNumber").Number); Assert.AreEqual(DataType.String, o.Get("aString").Type); Assert.AreEqual("4", o.Get("aString").String); Table a = t.Get("anArray").Table; // 'anArray' : [ 5, '6', true, null, { 'aNumber' : 7, 'aString' : '8' } ] Assert.AreEqual(DataType.Number, a.Get(1).Type); Assert.AreEqual(5, a.Get(1).Number); Assert.AreEqual(DataType.String, a.Get(2).Type); Assert.AreEqual("6", a.Get(2).String); Assert.AreEqual(DataType.Boolean, a.Get(3).Type); Assert.IsTrue(a.Get(3).Boolean); Assert.AreEqual(DataType.Boolean, a.Get(3).Type); Assert.IsTrue(a.Get(3).Boolean); Assert.AreEqual(DataType.UserData, a.Get(4).Type); Assert.IsTrue(JsonNull.IsJsonNull(a.Get(4))); Assert.AreEqual(DataType.Table, a.Get(5).Type); Table s = a.Get(5).Table; Assert.AreEqual(DataType.Number, s.Get("aNumber").Type); Assert.AreEqual(7, s.Get("aNumber").Number); Assert.AreEqual(DataType.String, s.Get("aString").Type); Assert.AreEqual("8", s.Get("aString").String); Assert.AreEqual(DataType.Number, t.Get("aNegativeNumber").Type); Assert.AreEqual(-9, t.Get("aNegativeNumber").Number); }
public static void JsonArrayMethodsTest() { var arr = new JsonArray(); var list = new List <JsonValue>(); JsonValue value; Assert.False(arr.IsReadOnly); value = "aloha oe"; arr.Add(value); list.Add(value); value = 4242; arr.Add(value); list.Add(value); value = false; arr.Add(value); list.Add(value); value = new JsonNull(); arr.Add(value); list.Add(value); Assert.Equal(4, arr.Count); var varr = new JsonValue[4]; arr.CopyTo(varr, 0); Assert.Equal(list, varr); int ptr = 0; foreach (var v in arr) { Assert.Equal(list[ptr++], v); } value = 43.3336; arr[2] = value; Assert.Equal(value, arr[2]); Assert.Equal(2, arr.IndexOf(value)); Assert.Contains(value, arr); Assert.True(arr.Remove(value)); arr.RemoveAt(2); Assert.Equal(2, arr.Count); arr.Insert(2, value); Assert.Equal(value, arr[2]); arr.Clear(); Assert.Empty(arr); }
public virtual void Export(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (writer == null) throw new ArgumentNullException("writer"); if (JsonNull.LogicallyEquals(value)) writer.WriteNull(); else ExportValue(context, value, writer); }
public static void JsonNullMethodsTest() { JsonNull nullA = new JsonNull(), nullB = new JsonNull(); Assert.True(nullA.Equals(nullB)); Assert.True(nullA.Equals((object)null)); Assert.True(nullA.Equals((object)nullB)); Assert.True(nullA == nullB); Assert.False(nullA != nullB); Assert.Equal(0, nullA.GetHashCode()); }
public static object GetResult(IDictionary response, Type resultType) { if (response == null) { throw new ArgumentNullException("response"); } object errorObject = response["error"]; if (errorObject != null) { IDictionary error = errorObject as IDictionary; string message = null; if (!JsonNull.LogicallyEquals(error)) { object messageObject = error["message"]; if (!JsonNull.LogicallyEquals(messageObject)) { message = messageObject.ToString(); } } else { message = error.ToString(); } throw new JsonRpcException(message); } if (!response.Contains("result")) { throw new ArgumentException("Response object is not valid because it does not contain the expected 'result' member.", "response"); } object result = response["result"]; if (resultType == null) { return(result); } JsonRecorder recorder = new JsonRecorder(); // FIXME: Allow the context to be passed in. JsonConvert.Export(result, recorder); return(JsonConvert.Import(resultType, recorder.CreatePlayer())); }
public void ShouldParseNullLowercaseSucceed( string jsonFragment ) { IJsonElement parser = new JsonNull(); string jsonRemainder; Assert.IsTrue( parser.Parse( jsonFragment, out jsonRemainder ) ); }
public void Export(ExportContext context, object value, JsonWriter writer) { var properties = value.GetType().GetProperties(); writer.WriteStartObject(); foreach (var property in properties) { var propertyValue = property.GetValue(value, null); if (!JsonNull.LogicallyEquals(propertyValue)) { writer.WriteMember(property.Name); context.Export(propertyValue, writer); } } writer.WriteEndObject(); }
public virtual JsonValue Get(string key) { if (!IsObject()) { return(JsonNull.GetInstance()); } Dictionary <string, object> m_val = value_ as Dictionary <string, object>; if (!m_val.ContainsKey(key)) { return(JsonNull.GetInstance()); } return(new JsonValue(m_val[key])); }
public ReadResults ReadAny(out IJsonArgument result) { result = new JsonNull(); SkipWhitespace(); if (!StringReader.CanRead()) { return(ReadResults.Success()); } ReadResults readResults; switch (StringReader.Peek()) { case OBJECT_OPEN_CHARACTER: readResults = ReadObject(out JsonObject objectResult); if (readResults.Successful) { result = objectResult; } return(readResults); case ARRAY_OPEN_CHARACTER: readResults = ReadArray(out JsonArray arrayResult); if (readResults.Successful) { result = arrayResult; } return(readResults); case STRING_CHARACTER: readResults = ReadString(out JsonString stringResult); if (readResults.Successful) { result = stringResult; } return(readResults); default: return(ReadSpecial(out result)); } }
public virtual void Export(ExportContext context, object value, JsonWriter writer) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } if (JsonNull.LogicallyEquals(value)) { writer.WriteNull(); } else { ExportValue(context, value, writer); } }
// all path here should be absolute!!! private void instantiate(InterProcessMessage msg) { var args = msg.Args; JsonValue dirmap = new JsonNull(); JsonValue error = new JsonNull(); if (!args.TryGetJsonObject(RootKey, out var root) || !args.TryGetJsonString(TargetKey, out var target)) { error = "invalid params"; } else { dirmap = new JsonArray(instantiateNode(root, new DirectoryInfo(target), ".").Select(m => new JsonObject(new[] { new JsonObjectKeyValuePair(DockerKey, m.Docker), new JsonObjectKeyValuePair(HostKey, m.Host), new JsonObjectKeyValuePair(ReadonlyKey, m.Readonly) }))); } SendMessage(InterProcessMessage.GetResultMessage(ModuleName, msg.Token, new JsonObject( dirmap is JsonNull ? new[] { new JsonObjectKeyValuePair(DirMapKey, dirmap), new JsonObjectKeyValuePair(ErrorKey, error) } : new[] { new JsonObjectKeyValuePair(DirMapKey, dirmap) } ))); }
public static void TestGetHashCode() { var jsonNull = new JsonNull(); Assert.Equal(jsonNull.GetHashCode(), new JsonNull().GetHashCode()); JsonNode jsonNodeNull = new JsonNull(); Assert.Equal(jsonNull.GetHashCode(), jsonNodeNull.GetHashCode()); IEquatable <JsonNull> jsonNullIEquatable = new JsonNull(); Assert.Equal(jsonNull.GetHashCode(), jsonNullIEquatable.GetHashCode()); object jsonNullCopy = jsonNull; object jsonNullObject = new JsonNull(); Assert.Equal(jsonNull.GetHashCode(), jsonNullCopy.GetHashCode()); Assert.Equal(jsonNull.GetHashCode(), jsonNullObject.GetHashCode()); Assert.Equal(-1, jsonNull.GetHashCode()); }
private JsonElement ParseKeyword() { JsonElement element; string test; switch (_source.Current) { case 't': test = "true"; element = new JsonBool { Value = true }; break; case 'f': test = "false"; element = new JsonBool { Value = false }; break; case 'n': test = "null"; element = new JsonNull(); break; default: throw new Exception("Unknown keyword in JSON."); } // Compares the subsequent values from _source against the matching // character of the test string. if (test.Any(t => _source.Next() != t)) { throw new Exception("Unknown keyword in JSON."); } return(element); }
public static DynValue @null(ScriptExecutionContext executionContext, CallbackArguments args) { return(JsonNull.Create()); }
public JsonValue Read() { JsonValue cur = null; string lastPropName = null; Stack<JsonValue> stack = new Stack<JsonValue> (); Stack<string> propNameStack = new Stack<string> (); JsonReader reader = _reader; while (reader.Read ()) { switch (reader.Token) { case JsonToken.ArrayStart: case JsonToken.ObjectStart: if (cur != null) { stack.Push (cur); if (cur is JsonObject) { propNameStack.Push (lastPropName); lastPropName = null; } } if (reader.Token == JsonToken.ArrayStart) cur = new JsonArray (new List<JsonValue> ()); else cur = new JsonObject (new Dictionary<string,JsonValue> ()); break; case JsonToken.ObjectEnd: case JsonToken.ArrayEnd: if (stack.Count == 0) return cur; JsonValue parent = stack.Pop (); if (parent is JsonArray) { (parent as JsonArray).Value.Add (cur); } else if (parent is JsonObject) { lastPropName = propNameStack.Pop (); if (lastPropName == null) throw new JsonException (); (parent as JsonObject).Value.Add (lastPropName, cur); lastPropName = null; } cur = parent; break; case JsonToken.PropertyName: if (lastPropName != null) throw new JsonException (); lastPropName = (string)reader.Value; break; case JsonToken.Boolean: case JsonToken.Null: case JsonToken.Number: case JsonToken.String: JsonValue value; switch (reader.Token) { case JsonToken.Boolean: value = new JsonBoolean ((bool)reader.Value); break; case JsonToken.Null: value = new JsonNull (); break; case JsonToken.Number: value = new JsonNumber (Convert (reader.NumberType), (double)reader.Value, reader.ValueSignedInteger, reader.ValueUnsignedInteger); break; case JsonToken.String: value = new JsonString ((string)reader.Value); break; default: throw new JsonException (); } if (cur == null) return value; if (cur is JsonArray) { (cur as JsonArray).Value.Add (value); } else if (cur is JsonObject) { if (lastPropName == null) throw new JsonException (); (cur as JsonObject).Value.Add (lastPropName, value); lastPropName = null; } break; } } if (cur == null) return null; throw new JsonException (); }
/* TODO: Add async processing. * * IAsyncResult BeginProcess(JsonReader input, JsonWriter output, AsyncCallback callback, object asyncState); * void BeginProcess(IAsyncResult asyncResult); */ public virtual IDictionary Invoke(IDictionary request, bool authorised) { if (request == null) { throw new ArgumentNullException(); } // // Get the ID of the request. // object id = request["id"]; // // If the ID is not there or was not set then this is a notification // request from the client that does not expect any response. Right // now, we don't support this. // bool isNotification = JsonNull.LogicallyEquals(id); if (isNotification) { throw new NotSupportedException("Notification are not yet supported."); } if (JsonRpcTrace.TraceInfo) { JsonRpcTrace.Info("Received request with the ID {0}.", id.ToString()); } // // Get the method name and arguments. // string methodName = Mask.NullString((string)request["method"]); if (methodName.Length == 0) { throw new JsonRpcException("No method name supplied for this request."); } //TODO2: change RE authorisation options deny setclientname - just remove it entirely?!? if (!authorised && (methodName != "Authenticate" && methodName != "SetClientName")) { throw new JsonRpcException("Not authorised."); } if (JsonRpcTrace.Switch.TraceInfo) { JsonRpcTrace.Info("Invoking method {1} on service {0}.", ServiceName, methodName); } // // Invoke the method on the service and handle errors. // object error = null; object result = null; try { IService service = Service; Method method = service.GetClass().GetMethodByName(methodName); if (RequireIdempotency && !method.Idempotent) { throw new JsonRpcException(string.Format("Method {1} on service {0} is not allowed for idempotent type of requests.", ServiceName, methodName)); } object[] args; string[] names = null; object argsObject = request["params"]; IDictionary argByName = argsObject as IDictionary; if (argByName != null) { names = new string[argByName.Count]; argByName.Keys.CopyTo(names, 0); args = new object[argByName.Count]; argByName.Values.CopyTo(args, 0); } else { args = CollectionHelper.ToArray((ICollection)argsObject); } result = method.Invoke(service, names, args); } catch (MethodNotFoundException e) { error = OnError(e, request); } catch (InvocationException e) { error = OnError(e, request); } catch (TargetMethodException e) { error = OnError(e.InnerException, request); } catch (Exception e) { if (JsonRpcTrace.Switch.TraceError) { JsonRpcTrace.Error(e); } throw; } // // Setup and return the response object. // return(CreateResponse(request, result, error)); }
public static DynValue isnull(ScriptExecutionContext executionContext, CallbackArguments args) { DynValue vs = args[0]; return(DynValue.NewBoolean((JsonNull.IsJsonNull(vs)) || (vs.IsNil()))); }
public static XmlElement Convert(JsonNull n) { return(new XmlElement("null", false)); }
public void ValueTest() { var target = new JsonNull(); Assert.IsNull(target.Value); }
static void Main(string[] args) { dynamic test = new JsonNull(); Fails(test); }
public static JsonDocument Load(JsonReader reader) { var nodeStack = new Stack <JsonNode>(); var doc = new JsonDocument(); nodeStack.Push(doc); var propertyStack = new Stack <string>(); JsonNode node = null; while (reader.Read()) { switch (reader.SyntaxKind) { case SyntaxKind.Comment: case SyntaxKind.None: continue; case SyntaxKind.ArrayStart: var arr = new JsonArray(); arr.Start = reader.Start; nodeStack.Push(arr); continue; case SyntaxKind.ObjectStart: var obj = new JsonObject(); obj.Start = reader.Start; nodeStack.Push(obj); continue; case SyntaxKind.PropertyName: propertyStack.Push(reader.PropertyName); continue; case SyntaxKind.ArrayEnd: case SyntaxKind.ObjectEnd: node = nodeStack.Pop(); node.End = reader.End; break; case SyntaxKind.StringValue: node = new JsonString(reader.StringValue); SetLocation(reader, node); break; case SyntaxKind.DoubleValue: node = new JsonNumber(reader.FloatValue); SetLocation(reader, node); break; case SyntaxKind.IntegerValue: node = new JsonNumber(reader.IntegerValue); SetLocation(reader, node); break; case SyntaxKind.NullValue: node = new JsonNull(); SetLocation(reader, node); break; case SyntaxKind.TrueValue: node = new JsonBoolean(true); SetLocation(reader, node); break; case SyntaxKind.FalseValue: node = new JsonBoolean(false); SetLocation(reader, node); break; } var parent = nodeStack.Peek(); if (parent is JsonArray a) { a.Add(node); } else if (parent is JsonObject o) { var propertyName = propertyStack.Pop(); o.Add(propertyName, node); } else if (parent is JsonDocument d) { d.RootNode = node; break; } } if (doc.RootNode != null) { doc.Start = doc.RootNode.Start; doc.End = doc.RootNode.End; } return(doc); }