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);
}
