public static void CopyTo() { JsonNode node1 = 1; JsonNode node2 = 2; IList <JsonNode?> jArray = new JsonArray(node1, node2, null); var arr = new JsonNode[4]; jArray.CopyTo(arr, 0); Assert.Same(node1, arr[0]); Assert.Same(node2, arr[1]); Assert.Null(arr[2]); arr = new JsonNode[5]; jArray.CopyTo(arr, 1); Assert.Null(arr[0]); Assert.Same(node1, arr[1]); Assert.Same(node2, arr[2]); Assert.Null(arr[3]); Assert.Null(arr[4]); arr = new JsonNode[3]; Assert.Throws <ArgumentException>(() => jArray.CopyTo(arr, 1)); Assert.Throws <ArgumentOutOfRangeException>(() => jArray.CopyTo(arr, -1)); }
internal IEnumerable <JsonValue> Find(JsonArray json, JsonValue root) { if (Index.HasValue) { return(Index.Value < 0 || json.Count <= Index.Value ? Enumerable.Empty <JsonValue>() : new[] { json[Index.Value] }); } var start = _ResolveIndex(_start ?? 0, json.Count); var end = _ResolveIndex(_end ?? json.Count, json.Count); var step = Math.Max(_step ?? 1, 1); // quick copy if (start == 0 && end == json.Count && step == 1) { return(new List <JsonValue>(json)); } if (step == 1) { var result = new JsonValue[end - start]; json.CopyTo(start, result, 0, end - start); return(result); } else { return(_FindSlow(json, start, end, step)); } }
public void CompareJsonArrays(JsonArray aryOne, JsonArray aryTwo) { var loopLength = GetLoopLength(aryOne.Count, aryTwo.Count); if (CompareItemLengths(aryOne.Count, aryTwo.Count) != string.Empty) { _builder.Append($"Array Lengths: {CompareItemLengths(aryOne.Count, aryTwo.Count)}"); } for (var i = 0; i < loopLength; i++) { var objOne = aryOne[i] as JsonObject; var objTwo = aryTwo[i] as JsonObject; CompareJsonObjects(objOne, objTwo); } var valueArray1 = new JsonValue[aryOne.Count]; aryOne.CopyTo(valueArray1, 0); var valueArray2 = new JsonValue[aryTwo.Count]; aryTwo.CopyTo(valueArray2, 0); _builder.Append(GetRemainingItems(ValueToString(valueArray1), ValueToString(valueArray2))); }
public void JsonArrayCopytoFunctionalTest() { int seed = 1; for (int i = 0; i < iterationCount / 10; i++) { seed++; Log.Info("Seed: {0}", seed); Random rndGen = new Random(seed); bool retValue = true; JsonArray sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength); JsonValue[] destJson = new JsonValue[arrayLength]; sourceJson.CopyTo(destJson, 0); for (int k = 0; k < destJson.Length; k++) { if (destJson[k] != sourceJson[k]) { retValue = false; } } if (!retValue) { Assert.Fail("[JsonArrayCopytoFunctionalTest] JsonArray.CopyTo() failed to function properly. destJson.GetLength(0) = " + destJson.GetLength(0)); } } }
public void CopyToTest() { JsonValue item1 = AnyInstance.AnyJsonValue1; JsonValue item2 = AnyInstance.AnyJsonValue2; JsonArray target = new JsonArray(item1, item2); JsonValue[] array = new JsonValue[target.Count + 1]; target.CopyTo(array, 0); Assert.AreEqual(item1, array[0]); Assert.AreEqual(item2, array[1]); target.CopyTo(array, 1); Assert.AreEqual(item1, array[1]); Assert.AreEqual(item2, array[2]); ExceptionTestHelper.ExpectException <ArgumentNullException>(() => target.CopyTo(null, 0)); ExceptionTestHelper.ExpectException <ArgumentOutOfRangeException>(() => target.CopyTo(array, -1)); ExceptionTestHelper.ExpectException <ArgumentException>(() => target.CopyTo(array, array.Length - target.Count + 1)); }
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 void CopyTo(int arrayIndex) { JsonArray array = new JsonArray(new JsonPrimitive(true)); JsonValue[] copy = new JsonValue[array.Count + arrayIndex]; array.CopyTo(copy, arrayIndex); for (int i = 0; i < arrayIndex; i++) { Assert.Null(copy[i]); } for (int i = arrayIndex; i < copy.Length; i++) { Assert.Same(array[i - arrayIndex], copy[i]); } }
internal IEnumerable <JsonValue> Find(JsonArray json, JsonValue root) { if (Index.HasValue) { var index = Index.Value; if (index < 0) { index += json.Count; } return(index < 0 || json.Count <= index ? Enumerable.Empty <JsonValue>() : new[] { json[index] }); } var start = Math.Max(_ResolveIndex(_start ?? 0, json.Count), 0); var end = _ResolveIndex(_end ?? json.Count, json.Count); if (start == end) { return(Enumerable.Empty <JsonValue>()); } //var step = _step ?? (start < end ? 1 : -1); var step = _step ?? 1; if (start == 0 && end == json.Count && step == 1) { return(json); } if (step > 0 && end <= start) { return(Enumerable.Empty <JsonValue>()); } if (step == 1) { var result = new JsonValue[end - start]; json.CopyTo(start, result, 0, end - start); return(result); } return(_FindSlow(json, start, end, step)); }