/// <summary> /// Registers file extension mapping. /// </summary> /// <param name="json">The source.</param> /// <param name="overrideIfExist">true if override the existed one; otherwise, false.</param> /// <returns>The count of item added or changed.</returns> public static int RegisterFileExtensionMapping(JsonArrayNode json, bool overrideIfExist = false) { var mapping = FileExtensionMapping; if (json == null || mapping == null) { return(0); } var i = 0; foreach (var item in json) { if (item is not JsonObjectNode ele) { continue; } var ext = ele.TryGetStringValue("extension") ?? ele.TryGetStringValue("ext"); var mime = ele.TryGetStringValue("mime"); if (mapping.Set(mime, ext, overrideIfExist)) { i++; } } return(i); }
public void ToObject_Collection_Custom() { // Arrange var arrayNode = new JsonArrayNode(); arrayNode.Add(new JsonIntegerNode(1)); arrayNode.Add(new JsonIntegerNode(2)); arrayNode.Add(new JsonIntegerNode(4)); arrayNode.Add(new JsonIntegerNode(8)); arrayNode.Add(new JsonIntegerNode(16)); // Act var categorySet = arrayNode.ConvertTo <CategorySet>(); // Assert Assert.IsNotNull(categorySet); Assert.AreEqual(5, categorySet.Count); Assert.IsTrue(categorySet.Contains(1)); Assert.IsTrue(categorySet.Contains(2)); Assert.IsTrue(categorySet.Contains(4)); Assert.IsTrue(categorySet.Contains(8)); Assert.IsTrue(categorySet.Contains(16)); Assert.IsFalse(categorySet.Contains(0)); Assert.IsFalse(categorySet.Contains(-1)); Assert.IsFalse(categorySet.Contains(-2)); Assert.IsFalse(categorySet.Contains(3)); }
public void FromCollection_ArrayList_Mixed() { // Arrange var mixed = new ArrayList(new object[] { "A", 1, "C", 2, "E", 3 }); // Act var arrayNode = JsonArrayNode.FromCollection(mixed); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(6, arrayNode.Count); for (int i = 0; i < mixed.Count; ++i) { var elementNode = arrayNode[i]; if (elementNode is JsonIntegerNode) { var integerNode = elementNode as JsonIntegerNode; Assert.AreEqual(mixed[i], (int)integerNode.Value); } else if (elementNode is JsonStringNode) { var stringNode = elementNode as JsonStringNode; Assert.AreEqual(mixed[i], stringNode.Value); } else { Assert.Fail("Invalid node type."); } } }
public void FromArray_MixedElements() { // Arrange object[] mixed = { "A", 1, "C", 2, "E", 3 }; // Act var arrayNode = JsonArrayNode.FromArray(mixed); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(mixed.Length, arrayNode.Count); for (int i = 0; i < mixed.Length; ++i) { var elementNode = arrayNode[i]; if (elementNode is JsonIntegerNode) { var integerNode = elementNode as JsonIntegerNode; Assert.AreEqual(mixed[i], (int)integerNode.Value); } else if (elementNode is JsonStringNode) { var stringNode = elementNode as JsonStringNode; Assert.AreEqual(mixed[i], stringNode.Value); } else { Assert.Fail("Invalid node type."); } } }
public void FromCollection_Null() { // Arrange ICollection collection = null; // Act JsonArrayNode.FromCollection(collection); }
public static JsonArrayNode CreateIdentityCardArray() { var cards = new JsonArrayNode(); cards.Add(CreateIdentityCard("Bob")); cards.Add(CreateIdentityCard("Jessica")); return(cards); }
public void FromArray_Null() { // Arrange object[] array = null; // Act JsonArrayNode.FromArray(array); }
public void ToObject_Null() { // Arrange var arrayNode = new JsonArrayNode(); Type type = null; // Act arrayNode.ConvertTo(type); }
public void Create_Array_InitialLength() { // Arrange // Act var arrayNode = new JsonArrayNode(10); // Assert Assert.AreEqual(10, arrayNode.Count); }
public void Create_Array() { // Arrange // Act var arrayNode = new JsonArrayNode(); // Assert Assert.AreEqual(0, arrayNode.Count); }
public void Create_List_Empty() { // Arrange var list = new List <JsonNode>(); // Act var arrayNode = new JsonArrayNode(list); // Assert Assert.AreEqual(0, arrayNode.Count); }
public void Create_Array_Empty() { // Arrange JsonNode[] array = { }; // Act var arrayNode = new JsonArrayNode(new JsonNode[0]); // Assert Assert.AreEqual(0, arrayNode.Count); }
public static JsonArrayNode CreateNumericArrayWithEvenNumbers() { var arr = new JsonArrayNode(); arr.Add(new JsonIntegerNode(0)); arr.Add(new JsonIntegerNode(2)); arr.Add(new JsonIntegerNode(4)); arr.Add(new JsonIntegerNode(6)); arr.Add(new JsonIntegerNode(8)); arr.Add(new JsonIntegerNode(10)); return(arr); }
public void FromArray_Empty() { // Arrange object[] array = { }; // Act var arrayNode = JsonArrayNode.FromArray(array); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(0, arrayNode.Count); }
public void FromCollection_List_Empty() { // Arrange var list = new List <int>(); // Act var arrayNode = JsonArrayNode.FromCollection(list); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(0, arrayNode.Count); }
public void ToString_Empty() { // Arrange var arrayNode = new JsonArrayNode(); // Act string result = arrayNode.ToString(); string expectedResult = "[]"; // Assert Assert.AreEqual(expectedResult, result); }
public void ToString_StringArray() { // Arrange var arrayNode = JsonArrayNode.FromArray(new string[] { "A", "B" }); // Act string result = arrayNode.ToString(); string expectedResult = File.ReadAllText("ToString_StringArray.json"); // Assert Assert.AreEqual(expectedResult, result); }
public void Clone_Empty() { // Arrange var arrayNode = new JsonArrayNode(); // Act var cloneNode = arrayNode.Clone() as JsonArrayNode; // Assert Assert.IsNotNull(cloneNode); Assert.AreNotSame(arrayNode, cloneNode); Assert.AreEqual(0, cloneNode.Count); }
static EmbeddedDiagnostic?CheckArray(JsonArrayNode node) { foreach (var child in node.Sequence) { if (child.Kind == JsonKind.Property) { return(new EmbeddedDiagnostic( FeaturesResources.Properties_not_allowed_in_an_array, ((JsonPropertyNode)child).ColonToken.GetSpan())); } } return(null); }
public void WriteTo_Empty() { // Arrange var arrayNode = new JsonArrayNode(); var writer = JsonWriter.Create(); // Act arrayNode.Write(writer); // Assert string result = writer.ToString(); string expectedResult = "[]"; Assert.AreEqual(expectedResult, result); }
public void WriteTo_StringArray() { // Arrange var arrayNode = JsonArrayNode.FromArray(new string[] { "A", "B" }); var writer = JsonWriter.Create(); // Act arrayNode.Write(writer); // Assert string result = writer.ToString(); string expectedResult = File.ReadAllText("ToString_StringArray.json"); Assert.AreEqual(expectedResult, result); }
public void Clone_NumberElementsWithNullElement() { // Arrange var arrayNode = JsonArrayNode.FromArray(new object[] { 1, null, 5 }); // Act var cloneNode = arrayNode.Clone() as JsonArrayNode; // Assert Assert.IsNotNull(cloneNode); Assert.AreNotSame(arrayNode, cloneNode); Assert.AreEqual(3, cloneNode.Count); Assert.AreEqual(1, (int)(cloneNode[0] as JsonIntegerNode).Value); Assert.IsNull(cloneNode[1]); Assert.AreEqual(5, (int)(cloneNode[2] as JsonIntegerNode).Value); }
public void Create_List_WitherIntegerNodes() { // Arrange var list = new List <JsonNode>(); list.Add(new JsonIntegerNode(1)); list.Add(new JsonIntegerNode(2)); list.Add(new JsonIntegerNode(3)); // Act var arrayNode = new JsonArrayNode(list); // Assert Assert.AreEqual(3, arrayNode.Count); Assert.AreEqual(1, (int)(arrayNode[0] as JsonIntegerNode).Value); Assert.AreEqual(2, (int)(arrayNode[1] as JsonIntegerNode).Value); Assert.AreEqual(3, (int)(arrayNode[2] as JsonIntegerNode).Value); }
public void Create_Array_WithIntegerNodes() { // Arrange JsonNode[] nodes = { new JsonIntegerNode(1), new JsonIntegerNode(2), new JsonIntegerNode(3) }; // Act var arrayNode = new JsonArrayNode(nodes); // Assert Assert.AreEqual(3, arrayNode.Count); Assert.AreEqual(1, (int)(arrayNode[0] as JsonIntegerNode).Value); Assert.AreEqual(2, (int)(arrayNode[1] as JsonIntegerNode).Value); Assert.AreEqual(3, (int)(arrayNode[2] as JsonIntegerNode).Value); }
public void FromArray_StringElements() { // Arrange string[] strings = { "A", "B", "C", "D", "E" }; // Act var arrayNode = JsonArrayNode.FromArray(strings); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(strings.Length, arrayNode.Count); for (int i = 0; i < strings.Length; ++i) { var elementNode = arrayNode[i] as JsonStringNode; Assert.IsNotNull(elementNode); Assert.AreEqual(strings[i], elementNode.Value); } }
public void FromCollection_List_Numbers() { // Arrange var numbers = new List <int>(new int[] { 2, 4, 6, 8, 10 }); // Act var arrayNode = JsonArrayNode.FromCollection(numbers); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(5, arrayNode.Count); for (int i = 0; i < numbers.Count; ++i) { var elementNode = arrayNode[i] as JsonIntegerNode; Assert.IsNotNull(elementNode); Assert.AreEqual(numbers[i], (int)elementNode.Value); } }
public void FromCollection_List_Strings() { // Arrange var strings = new List <string>(new string[] { "A", "B", "C", "D", "E" }); // Act var arrayNode = JsonArrayNode.FromCollection(strings); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(5, arrayNode.Count); for (int i = 0; i < strings.Count; ++i) { var elementNode = arrayNode[i] as JsonStringNode; Assert.IsNotNull(elementNode); Assert.AreEqual(strings[i], elementNode.Value); } }
public void FromArray_NumericElements() { // Arrange int[] numbers = { 2, 4, 6, 8, 10 }; // Act var arrayNode = JsonArrayNode.FromArray(numbers); // Assert Assert.IsNotNull(arrayNode); Assert.AreEqual(numbers.Length, arrayNode.Count); for (int i = 0; i < numbers.Length; ++i) { var elementNode = arrayNode[i] as JsonIntegerNode; Assert.IsNotNull(elementNode); Assert.AreEqual(numbers[i], (int)elementNode.Value); } }
public void Clone_NumberElements() { // Arrange var arrayNode = JsonArrayNode.FromArray(new int[] { 1, 2, 3, 4, 5 }); // Act var cloneNode = arrayNode.Clone() as JsonArrayNode; // Assert Assert.IsNotNull(cloneNode); Assert.AreNotSame(arrayNode, cloneNode); Assert.AreEqual(5, cloneNode.Count); Assert.AreEqual(1, (int)(cloneNode[0] as JsonIntegerNode).Value); Assert.AreEqual(2, (int)(cloneNode[1] as JsonIntegerNode).Value); Assert.AreEqual(3, (int)(cloneNode[2] as JsonIntegerNode).Value); Assert.AreEqual(4, (int)(cloneNode[3] as JsonIntegerNode).Value); Assert.AreEqual(5, (int)(cloneNode[4] as JsonIntegerNode).Value); }
private JsonArrayNode ProduceJsonArray(JsonTokenizer tokenizer) { var lsq = NextAndGetType(tokenizer); // pop the leading [. if (lsq != TokenType.LSQUARE) { // this cannot happen. throw new InvalidJsonTokenException("JSON array should start with [.", GetTailCharStream(tokenizer), PeekCharStream(tokenizer)); } IList <object> list = new List <object>(); var type = PeekAndGetType(tokenizer); if (type == TokenType.RSQUARE) { // empty array tokenizer.Next(); // discard the trailing ]. } else { IList <JsonNode> elements = ProduceJsonArrayElements(tokenizer); var rsq = NextAndGetType(tokenizer); // discard the trailing ]. if (rsq == TokenType.RSQUARE) { // Done ((List <object>)list).AddRange(elements); } else { // ??? throw new InvalidJsonTokenException("JSON array should end with ].", GetTailCharStream(tokenizer), PeekCharStream(tokenizer)); } } JsonArrayNode jArray = (JsonArrayNode)jsonTypeFactory.CreateArray(list); //if (log.isLoggable(Level.FINE)) { // log.fine("jArray = " + jArray); //} return(jArray); }