public void Clear()
{
JsonArray array = new JsonArray(new JsonValue[3]);
array.Clear();
Assert.Equal(0, array.Count);
array.Clear();
Assert.Equal(0, array.Count);
}
public void TestClear()
{
var obj = new JsonArray(0, 1, 2);
Assert.Equal(3, obj.Count);
Assert.Same(obj, obj.Clear());
Assert.Equal(0, obj.Count);
Assert.Same(obj, obj.Clear());
Assert.Equal(0, obj.Count);
}
public static void Parent_Array()
{
var child = JsonValue.Create(42);
Assert.Null(child.Options);
var parent = new JsonArray();
Assert.Null(parent.Options);
parent.Add(child);
Assert.Null(child.Options);
parent.Clear();
parent = new JsonArray(new JsonNodeOptions {
PropertyNameCaseInsensitive = true
});
Assert.NotNull(parent.Options);
parent.Add(child);
Assert.NotNull(child.Options);
Assert.True(child.Options.Value.PropertyNameCaseInsensitive);
// The indexer unparents existing node.
parent[0] = JsonValue.Create(43);
Assert.Null(child.Parent);
parent.Clear();
Assert.True(child.Options.Value.PropertyNameCaseInsensitive);
// Adding to a new parent does not affect options previously obtained from a different parent.
parent = new JsonArray(new JsonNodeOptions {
PropertyNameCaseInsensitive = false
});
parent.Add(child);
Assert.True(child.Options.Value.PropertyNameCaseInsensitive);
}
public void ClearArray()
{
var array = new JsonArray(new [] { 1, 2, 3 });
Assert.AreEqual(array.Count, 3);
array.Clear();
Assert.IsTrue(array.IsEmpty());
}
public void ClearTest()
{
JsonArray target = new JsonArray(AnyInstance.AnyJsonValue1, AnyInstance.AnyJsonValue2);
Assert.AreEqual(2, target.Count);
target.Clear();
Assert.AreEqual(0, target.Count);
}
private void _clearData()
{
_jsonArr.Clear();
_downloadInfos.Clear();
save();
#if UNITY_ANDROID
_javaObj.Call("clearDownLoad", "asd");
#endif
}
public void Clear()
{
JsonArray a = new JsonArray {
1
};
Assert.AreEqual(1, a.Count);
a.Clear();
Assert.AreEqual(0, a.Count);
}
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 static void Clear()
{
var jArray = new JsonArray(42, 43);
Assert.Equal(2, jArray.Count);
JsonNode node = jArray[0];
jArray.Clear();
Assert.Equal(0, jArray.Count);
jArray.Add(node);
Assert.Equal(1, jArray.Count);
}
public static void TestClean()
{
var jsonArray = new JsonArray {
1, 2, 3
};
Assert.Equal(3, jsonArray.Count);
Assert.Equal((JsonNumber)1, jsonArray[0]);
Assert.Equal((JsonNumber)2, jsonArray[1]);
Assert.Equal((JsonNumber)3, jsonArray[2]);
jsonArray.Clear();
Assert.Equal(0, jsonArray.Count);
}
public static void TestClear()
{
var jsonArray = new JsonArray {
1, 2, 3
};
Assert.Equal(3, jsonArray.Count);
Assert.Equal(1, ((JsonNumber)jsonArray[0]).GetInt32());
Assert.Equal(2, ((JsonNumber)jsonArray[1]).GetInt32());
Assert.Equal(3, ((JsonNumber)jsonArray[2]).GetInt32());
jsonArray.Clear();
Assert.Equal(0, jsonArray.Count);
}
/// <summary>
/// 保存を行う.
/// </summary>
/// <param name="traceRecorder"></param>
/// <returns></returns>
public async Task SerializeAsync(InputTraceRecorder traceRecorder)
{
await Task.Run(async() =>
{
var file = await this.TargetFolder.CreateFileAsync("play.log", CreationCollisionOption.ReplaceExisting);
if (file == null)
{
return;
}
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var writer = new DataWriter(stream))
{
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf16LE;
JsonArray jsonArray = new JsonArray();
foreach (var trace in traceRecorder.Traces)
{
if (IsTraceWithFile(trace))
{
if (!await SaveFileForTraceAsync(trace as IInputTraceWithFile))
{
continue;
}
}
jsonArray.Clear();
trace.SaveAsJson(jsonArray);
writer.WriteString(jsonArray.Stringify());
writer.WriteString(Environment.NewLine);
}
await writer.StoreAsync();
await writer.FlushAsync();
}
}
});
}
public void JsonArrayAddRemoveFunctionalTest()
{
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[] cloneJson = SpecialJsonValueHelper.CreatePrePopulatedJsonValueArray(seed, 3);
// JsonArray.AddRange(JsonValue[])
sourceJson.AddRange(cloneJson);
if (sourceJson.Count != arrayLength + cloneJson.Length)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue[]) failed to function properly.");
retValue = false;
}
else
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue[]) passed test.");
}
// JsonArray.RemoveAt(int)
int count = sourceJson.Count;
for (int j = 0; j < count; j++)
{
sourceJson.RemoveAt(0);
}
if (sourceJson.Count > 0)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.RemoveAt(int) failed to function properly.");
retValue = false;
}
else
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.RemoveAt(int) passed test.");
}
// JsonArray.JsonType
if (sourceJson.JsonType != JsonType.Array)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.JsonType failed to function properly.");
retValue = false;
}
// JsonArray.Clear()
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
sourceJson.Clear();
if (sourceJson.Count > 0)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.Clear() failed to function properly.");
retValue = false;
}
else
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.Clear() passed test.");
}
// JsonArray.AddRange(JsonValue)
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
// adding one additional value to the array
sourceJson.AddRange(SpecialJsonValueHelper.GetRandomJsonPrimitives(seed));
if (sourceJson.Count != arrayLength + 1)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue) failed to function properly.");
retValue = false;
}
else
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(JsonValue) passed test.");
}
// JsonArray.AddRange(IEnumerable<JsonValue> items)
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
MyJsonValueCollection <JsonValue> myCols = new MyJsonValueCollection <JsonValue>();
myCols.Add(new JsonPrimitive(PrimitiveCreator.CreateInstanceOfUInt32(rndGen)));
string str;
do
{
str = PrimitiveCreator.CreateInstanceOfString(rndGen);
} while (str == null);
myCols.Add(new JsonPrimitive(str));
myCols.Add(new JsonPrimitive(PrimitiveCreator.CreateInstanceOfDateTime(rndGen)));
// adding 3 additional value to the array
sourceJson.AddRange(myCols);
if (sourceJson.Count != arrayLength + 3)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(IEnumerable<JsonValue> items) failed to function properly.");
retValue = false;
}
else
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.AddRange(IEnumerable<JsonValue> items) passed test.");
}
// JsonArray[index].set_Item
sourceJson = SpecialJsonValueHelper.CreatePrePopulatedJsonArray(seed, arrayLength);
string temp;
do
{
temp = PrimitiveCreator.CreateInstanceOfString(rndGen);
} while (temp == null);
sourceJson[1] = temp;
if ((string)sourceJson[1] != temp)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray[index].set_Item failed to function properly.");
retValue = false;
}
else
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray[index].set_Item passed test.");
}
// JsonArray.Remove(JsonValue)
count = sourceJson.Count;
for (int j = 0; j < count; j++)
{
sourceJson.Remove(sourceJson[0]);
}
if (sourceJson.Count > 0)
{
Log.Info("[JsonArrayAddRemoveFunctionalTest] JsonArray.Remove(JsonValue) failed to function properly.");
retValue = false;
}
if (!retValue)
{
Assert.Fail("[JsonArrayAddRemoveFunctionalTest] Test failed!");
}
}
}
