private void GetFiles_Result(RequestResult result)
{
if (this.InvokeRequired)
{
this.Invoke(new Action <RequestResult>(GetFiles_Result), result);
return;
}
if (result.StatusCode == 200)
{
listBox1.Items.Clear();
listBox1.DisplayMember = "path";
foreach (UniValue file in result["contents"])
{
listBox1.Items.Add(file);
}
if (this.CurrentPath != "/")
{
listBox1.Items.Insert(0, UniValue.ParseJson("{path: '..'}"));
}
}
else
{
MessageBox.Show("Error...");
}
}
private void GetFiles_Result(RequestResult result)
{
if (this.InvokeRequired)
{
this.Invoke(new Action <RequestResult>(GetFiles_Result), result);
return;
}
this.Cursor = Cursors.Default;
if (result.StatusCode == 200)
{
listBox1.Items.Clear();
listBox1.DisplayMember = "name";
foreach (UniValue file in result["_embedded"]["items"])
{
listBox1.Items.Add(file);
}
if (this.CurrentPath != "/")
{
listBox1.Items.Insert(0, UniValue.ParseJson("{name: '..'}"));
}
}
else
{
this.ShowErrorMessage(result);
}
}
private void GetFilesSearch_Result(RequestResult result)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke(new Action <RequestResult>(GetFilesSearch_Result), result);
return;
}
if (result.StatusCode == 200)
{
this.MyListBox.Items.Clear();
this.MyListBox.DisplayMemberPath = "metadata";
foreach (UniValue file in result["matches"])
{
MyListBox.Items.Add(file);
}
if (!String.IsNullOrEmpty(this.CurrentPath))
{
this.MyListBox.Items.Insert(0, UniValue.ParseJson("{path_display: '..'}"));
}
}
else
{
MessageBox.Show(result.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void GetFiles_Result(RequestResult result)
{
if (this.InvokeRequired)
{
this.Invoke(new Action <RequestResult>(this.GetFiles_Result), result);
return;
}
if (result.StatusCode == 200)
{
this.listBox1.Items.Clear();
this.listBox1.DisplayMember = "path_display";
foreach (UniValue file in result["entries"])
{
listBox1.Items.Add(file);
}
if (!String.IsNullOrEmpty(this.CurrentPath))
{
this.listBox1.Items.Insert(0, UniValue.ParseJson("{path_display: '..'}"));
}
}
else
{
MessageBox.Show(result.ToString(), "Cannot find files or folders", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void ToStringTest()
{
UniValue value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
Assert.Equal("{ \"response\": { \"item\": [\"1\", \"2\", \"3\"] } }", value.ToString());
value["response"]["item"]["test"] = "123";
Assert.Equal("{ \"response\": { \"item\": { \"0\": \"1\", \"1\": \"2\", \"2\": \"3\", \"test\": \"123\" } } }", value.ToString());
value = UniValue.ParseJson("{\"data\": [{\"id\": 1, \"name\": \"test\"}, {\"id\": 2, \"name\": \"test2\"}, {\"id\": 3, \"name\": \"test3\", \"list\": [{\"x\":1,\"y\":\"hi\"}, {\"x\":2, \"y\":\"hello\"}] }] }");
Assert.Equal("{ \"data\": [{ \"id\": 1, \"name\": \"test\" }, { \"id\": 2, \"name\": \"test2\" }, { \"id\": 3, \"name\": \"test3\", \"list\": [{ \"x\": 1, \"y\": \"hi\" }, { \"x\": 2, \"y\": \"hello\" }] }] }", value.ToString());
Assert.Equal("[{ \"id\": 1, \"name\": \"test\" }, { \"id\": 2, \"name\": \"test2\" }, { \"id\": 3, \"name\": \"test3\", \"list\": [{ \"x\": 1, \"y\": \"hi\" }, { \"x\": 2, \"y\": \"hello\" }] }]", value["data"].ToString());
Assert.Equal("test2", value["data"][1]["name"].ToString());
value = UniValue.ParseXml("<response><item id='1' style='bold' color='white' /><item id='2' style='italic' color='red'>123</item></response>");
Assert.True(value == "{ \"response\": { \"item\": [{ \"@id\": \"1\", \"@style\": \"bold\", \"@color\": \"white\" }, { \"value\": \"123\", \"@id\": \"2\", \"@style\": \"italic\", \"@color\": \"red\" }] } }");
Assert.True(value["response"] == "{ \"item\": [{ \"@id\": \"1\", \"@style\": \"bold\", \"@color\": \"white\" }, { \"value\": \"123\", \"@id\": \"2\", \"@style\": \"italic\", \"@color\": \"red\" }] }");
Assert.True(value["response"]["item"] == "[{ \"@id\": \"1\", \"@style\": \"bold\", \"@color\": \"white\" }, { \"value\": \"123\", \"@id\": \"2\", \"@style\": \"italic\", \"@color\": \"red\" }]");
Assert.True(String.IsNullOrEmpty(value["response"]["item"][0].ToString()));
Assert.True(value["response"]["item"][0].ToString() == "");
Assert.False(UniValue.IsNullOrEmpty(value["response"]["item"][0]));
Assert.True(value["response"]["item"][1] == "123");
Assert.True(value["response"]["item"][1] == 123);
Assert.True(value["response"]["item"][0]["@id"] == 1);
Assert.True(value["response"]["item"][0]["style"] == "bold");
value = UniValue.ParseXml("<response><item id='1' style='bold' color='white'><vvalue abc='test' avalue='1234567'></vvalue></item><item id='2' style='italic' color='red'><v>456</v></item></response>");
Assert.Equal("{ \"response\": { \"item\": [{ \"value\": { \"vvalue\": { \"@abc\": \"test\", \"@avalue\": \"1234567\" } }, \"@id\": \"1\", \"@style\": \"bold\", \"@color\": \"white\" }, { \"value\": { \"v\": \"456\" }, \"@id\": \"2\", \"@style\": \"italic\", \"@color\": \"red\" }] } }", value.ToString());
Assert.Equal("[{ \"value\": { \"vvalue\": { \"@abc\": \"test\", \"@avalue\": \"1234567\" } }, \"@id\": \"1\", \"@style\": \"bold\", \"@color\": \"white\" }, { \"value\": { \"v\": \"456\" }, \"@id\": \"2\", \"@style\": \"italic\", \"@color\": \"red\" }]", value["response"]["item"].ToString());
Assert.Equal("{ \"vvalue\": { \"@abc\": \"test\", \"@avalue\": \"1234567\" } }", value["response"]["item"][0].ToString());
value = UniValue.ParseJson("{data: [{id: 1, name: null}, {id: 2, name: 'test2\r\n123'}, {id: 3, name: 'test3', list: [{x:1,y:'hi'}, {x:2, y:'hello'}] }] }");
Assert.Equal("{ \"data\": [{ \"id\": 1, \"name\": null }, { \"id\": 2, \"name\": \"test2\\r\\n123\" }, { \"id\": 3, \"name\": \"test3\", \"list\": [{ \"x\": 1, \"y\": \"hi\" }, { \"x\": 2, \"y\": \"hello\" }] }] }", value.ToString());
value = "test\r\ntest";
Assert.Equal("test\r\ntest", value.ToString());
}
/// <summary>
/// Parses the source to the <see cref="Result"/>.
/// </summary>
private void ParseSource()
{
if (this.Source == null || this.Source.Length <= 0)
{
return;
}
switch (this.ContentType.ToLower())
{
case "text/json":
case "text/javascript":
case "application/json":
case "application/javascript":
this.Data = UniValue.ParseJson(Encoding.UTF8.GetString(this.Source)).Data;
break;
case "text/xml":
case "application/xml":
case "application/atom+xml":
case "application/atomsvc+xml":
this.Data = UniValue.ParseXml(Encoding.UTF8.GetString(this.Source)).Data;
break;
case "text/html":
case "text/plain":
case "application/x-www-form-urlencoded": // for some cases
UniValue r = UniValue.Empty;
if (UniValue.TryParseParameters(Encoding.UTF8.GetString(this.Source), out r))
{
this.Data = r.Data;
}
else
{
this.Data = UniValue.Create(Encoding.UTF8.GetString(this.Source)).Data;
}
break;
default:
this.Data = UniValue.Create(this.Source).Data;
break;
}
}
public void UniValue_Compatibility()
{
Console.WriteLine("Test 1");
UniValue r = UniValue.ParseJson("{ response: [{ uid: 489, first_name: 'Aleksandr', last_name: '', nickname: '', online: 1, user_id: 484, lists: [1] }, { uid: 546, first_name: 'Oksana', last_name: '', deactivated: 'deleted', online: 0, user_id: 546 }, { uid: 845, first_name: 'Sergey', last_name: '', nickname: '', online: 0, user_id: 845 }] }");
Console.WriteLine(@"foreach (Dictionary<string, object> itm in (Array)r[""response""])
Replace Dictionary<string, object> to ResultValue");
foreach (UniValue itm in (Array)r["response"])
{
Console.WriteLine("{0} = {1}", itm["uid"], itm["first_name"]);
}
Console.WriteLine("OK");
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 2: Binary");
r = UniValue.Create(new byte[] { 1, 2, 3, 4, 5 });
var b = (byte[])r;
Console.WriteLine(Convert.ToBase64String(b));
Console.WriteLine("OK");
}
public void Compatibility()
{
int i = 0;
var uid = new int[] { 489, 546, 845 };
var firstName = new string[] { "Aleksandr", "Oksana", "Sergey" };
UniValue r = UniValue.ParseJson("{ response: [{ uid: 489, first_name: 'Aleksandr', last_name: '', nickname: '', online: 1, user_id: 484, lists: [1] }, { uid: 546, first_name: 'Oksana', last_name: '', deactivated: 'deleted', online: 0, user_id: 546 }, { uid: 845, first_name: 'Sergey', last_name: '', nickname: '', online: 0, user_id: 845 }] }");
foreach (UniValue itm in (Array)r["response"])
{
Assert.Equal(uid[i], itm["uid"]);
Assert.Equal(firstName[i], itm["first_name"]);
i++;
}
var bytes = new byte[] { 1, 2, 3, 4, 5 };
r = UniValue.Create(bytes);
Assert.Equal(bytes, (byte[])r);
}
private void GetFiles_Result(RequestResult result)
{
if (InvokeRequired)
{
Invoke(new Action <RequestResult>(GetFiles_Result), result);
return;
}
if (result.StatusCode == 200)
{
listView2.Items.Clear();
imageList1.Images.Clear();
int imageIndex = 0;
ResourceManager rm = Resources.ResourceManager;
foreach (UniValue file in result["contents"])
{
//MessageBox.Show(file.ToString());
Bitmap myImage = (Bitmap)rm.GetObject(file["icon"].ToString() + "48");
imageList1.Images.Add(myImage);
ListViewItem item = new ListViewItem(file["path"].ToString());
item.Tag = file;
item.ImageIndex = imageIndex;
listView2.Items.Add(item);
imageIndex++;
}
if (CurrentPath != "/")
{
ListViewItem item = new ListViewItem("Back to previous");
item.Tag = UniValue.ParseJson("{path: '..'}");
listView2.Items.Insert(0, item);
}
}
else
{
MessageBox.Show("error");
}
loadingProgressBar.Visible = false;
}
public void UniValue_Json()
{
int i = 0; int j = 0;
var testValue = new string[] { "1", "2", "3" };
var testValue2 = new string[] { "test", "test2", "test3" };
var testValue3 = new string[] { "1", "2" };
var testValue4 = new string[] { "hi", "hello" };
Console.WriteLine("Test 1");
UniValue value = UniValue.ParseJson("{data: [{id: 1, name: 'test'}, {id: 2, name: 'test2'}, {id: 3, name: 'test3', list: [{x:1,y:'hi'}, {x:2, y:'hello'}] }] }");
foreach (UniValue itm in value["data"])
{
Console.WriteLine("-- {0} = {1}", itm["id"], itm["name"]);
if (itm["list"].HasValue)
{
foreach (UniValue itm2 in itm["list"])
{
Console.WriteLine("---- {0} = {1}", itm2["x"], itm2["y"]);
if (testValue3[j] != itm2["x"] && testValue4[j] != itm2["y"])
{
Assert.Fail();
}
j++;
}
}
else
{
Console.WriteLine("---- no list");
}
if (testValue[i] != itm["id"] && testValue2[i] != itm["name"])
{
Assert.Fail();
}
i++;
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 2");
value = UniValue.ParseJson
(
@"{
array: [1, 2, 3, 4, 5, 6, 7, 8, 9],
array2: ['a', 'b', 1, 2, 3],
data:
[
{id: 1, name: 'test'},
{id: 2, name: 'test2'},
{
id: 3, name: 'test3', list:
[
{x:1,y:'hi'},
{x:2, y:'hello'},
{
x:3, y:'test',
array: [1,2,3],
sub:
[
{id: 123, text: 'tesssst'},
{id: 124, text: 'xyz'},
{id: 125, text: 'aaaa', list: [{sid: 1}, {sid: 2}]},
{id: 127, text: 'zyx', arr: ['a', 'b', 'c']}
]
}
]
}
]
}"
);
Console.WriteLine("-- Array");
var array = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
i = j = 0;
foreach (UniValue itm in value["array"])
{
Console.WriteLine("---- {0}", itm);
if (array[i] != itm)
{
Assert.Fail();
}
i++;
}
Console.WriteLine("-- Array2");
var array2 = new object[] { "a", "b", 1, 2, 3 };
i = j = 0;
foreach (UniValue itm in value["array2"])
{
Console.WriteLine("---- {0}", itm);
if (!itm.Equals(array2[i]))
{
Assert.Fail();
}
i++;
}
Console.WriteLine("-- Data");
foreach (UniValue itm in value["data"])
{
Console.WriteLine("---- {0} = {1}", itm["id"], itm["name"]);
if (itm["list"].HasValue)
{
foreach (UniValue itm2 in itm["list"])
{
Console.WriteLine("------ {0} = {1}", itm2["x"], itm2["y"]);
if (itm2["array"].HasValue)
{
foreach (UniValue itm3 in itm2["array"])
{
Console.WriteLine("-------- {0}", itm3);
}
}
if (itm2["sub"].HasValue)
{
foreach (UniValue itm3 in itm2["sub"])
{
Console.WriteLine("-------- {0} = {1}", itm3["id"], itm3["text"]);
if (itm3["arr"].HasValue)
{
foreach (UniValue itm4 in itm3["arr"])
{
Console.WriteLine("---------- {0}", itm4);
}
}
if (itm3["list"].HasValue)
{
foreach (UniValue itm4 in itm3["list"])
{
Console.WriteLine("---------- {0}", itm4["sid"]);
}
}
}
}
}
}
else
{
Console.WriteLine("------ no list");
}
}
Console.WriteLine("-------------------------------------");
}
public void UniValue_Binding()
{
var list = new ListBox();
var v = UniValue.ParseJson("[{text: 'test', value: 1, any: 'aaaa'},{text: '123', value: 2, any: 'bbbb'},{text: 'xyz', value: 3, any: 'cccc'}]");
list.DisplayMember = "text";
list.ValueMember = "value";
list.DataSource = v;
var form = new Form();
form.Controls.Add(list);
var list2 = new ListBox()
{
Left = list.Left + list.Width
};
list2.DisplayMember = "text";
list2.ValueMember = "value";
foreach (UniValue item in v)
{
list2.Items.Add(item);
}
form.Controls.Add(list2);
var list3 = new ListBox()
{
Left = list2.Left + list2.Width
};
list3.DisplayMember = "text";
list3.ValueMember = "value";
v = UniValue.ParseJson("{items: [{text: 'test', value: 1, any: 'aaaa'},{text: '123', value: 2, any: 'bbbb'},{text: 'xyz', value: 3, any: 'cccc'}]}");
foreach (UniValue item in v["items"])
{
list3.Items.Add(item);
}
form.Controls.Add(list3);
form.Show();
list.SelectedIndex = 0;
Assert.IsTrue(list.Text == "test");
form.Close();
list.SelectedIndex = 1;
if (list.Text != "123")
{
Assert.Fail();
}
if (list.SelectedValue.ToString() != "2")
{
Assert.Fail();
}
if (((UniValue)list.SelectedItem)["any"] != "bbbb")
{
Assert.Fail();
}
list2.SelectedIndex = 1;
if (list2.Text != "123")
{
Assert.Fail();
}
if (((UniValue)list2.SelectedItem)["value"] != "2")
{
Assert.Fail();
}
list3.SelectedIndex = 2;
if (list3.Text != "xyz")
{
Assert.Fail();
}
if (((UniValue)list3.SelectedItem)["value"] != "3")
{
Assert.Fail();
}
form.Close();
}
public void Parents()
{
UniValue value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
Assert.Equal("root", value["response"].Parent.Key);
// ???
#if NET35 || NET40
Assert.True(value["response"]["item"].Parent.Equals(value["response"]));
#else
Assert.Equal(value["response"]["item"].Parent, value["response"]);
#endif
value = UniValue.ParseXml("<response><item><id>1</id></item><item><id>2</id></item><item><id>3</id></item></response>");
#if NET35 || NET40
Assert.True(value["response"]["item"][0]["id"].Parent.Equals(value["response"]["item"][0]));
Assert.True(value["response"]["item"][0].Parent.Equals(value["response"]["item"]));
#else
Assert.Equal(value["response"]["item"][0]["id"].Parent, value["response"]["item"][0]);
Assert.Equal(value["response"]["item"][0].Parent, value["response"]["item"]);
#endif
value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
#if NET35 || NET40
Assert.True(value["response"]["item"].First().Parent.Equals(value["response"]["item"]));
Assert.True(value["response"]["item"].Last().Parent.Equals(value["response"]["item"]));
Assert.True(value["response"]["item"]["0"].Parent.Equals(value["response"]["item"]));
Assert.True(value["response"]["item"][1].Parent.Equals(value["response"]["item"]));
Assert.True(value["response"][0][1].Parent.Equals(value["response"]["item"]));
Assert.True(value["response"]["item"][2]["test"].Parent.Key.Equals(value["response"]["item"][2].Key));
Assert.True(value["response"]["item"][2]["test"].Parent.Equals(value["response"]["item"][2]));
Assert.True(value["response"]["item"][2]["test"]["a"].Parent.Key.Equals(value["response"]["item"][2]["test"].Key));
Assert.True(value["response"]["item"][2][5].Parent.Equals(value["response"]["item"][2]));
#else
Assert.Equal(value["response"]["item"].First().Parent, value["response"]["item"]);
Assert.Equal(value["response"]["item"].Last().Parent, value["response"]["item"]);
Assert.Equal(value["response"]["item"]["0"].Parent, value["response"]["item"]);
Assert.Equal(value["response"]["item"][1].Parent, value["response"]["item"]);
Assert.Equal(value["response"][0][1].Parent, value["response"]["item"]);
Assert.Equal(value["response"]["item"][2]["test"].Parent.Key, value["response"]["item"][2].Key);
Assert.Equal(value["response"]["item"][2]["test"].Parent, value["response"]["item"][2]);
Assert.Equal(value["response"]["item"][2]["test"]["a"].Parent.Key, value["response"]["item"][2]["test"].Key);
Assert.Equal(value["response"]["item"][2][5].Parent, value["response"]["item"][2]);
#endif
value = UniValue.ParseJson("{data: [{id: 1, name: 'test'}, {id: 2, name: 'test2'}, {id: 3, name: 'test3', list: [{x:1,y:'hi'}, {x:2, y:'hello'}] }] }");
#if NET35 || NET40
Assert.True("root".Equals(value["data"].Parent.Key));
Assert.True(value["data"][0].Parent.Equals(value["data"]));
Assert.True(value["data"][1]["name"].Parent.Equals(value["data"][1]));
Assert.True(value["data"][0][1].Parent.Equals(value["data"][0]));
#else
Assert.Equal("root", value["data"].Parent.Key);
Assert.Equal(value["data"][0].Parent, value["data"]);
Assert.Equal(value["data"][1]["name"].Parent, value["data"][1]);
Assert.Equal(value["data"][0][1].Parent, value["data"][0]);
#endif
}
public void UniValue_ToString()
{
Console.WriteLine("Test 1");
UniValue value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
Console.WriteLine(value);
Console.WriteLine("-------------------------------------");
if (value != "{ \"response\": { \"item\": [\"1\", \"2\", \"3\"] } }")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
value["response"]["item"]["test"] = "123";
Console.WriteLine(value);
if (value != "{ \"response\": { \"item\": { \"0\": \"1\", \"1\": \"2\", \"2\": \"3\", \"test\": \"123\" } } }")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 2");
value = UniValue.ParseJson("{\"data\": [{\"id\": 1, \"name\": \"test\"}, {\"id\": 2, \"name\": \"test2\"}, {\"id\": 3, \"name\": \"test3\", \"list\": [{\"x\":1,\"y\":\"hi\"}, {\"x\":2, \"y\":\"hello\"}] }] }");
Console.WriteLine("-------------------------------------");
Console.WriteLine("[] = {0}", value);
if (value != "{ \"data\": [{ \"id\": 1, \"name\": \"test\" }, { \"id\": 2, \"name\": \"test2\" }, { \"id\": 3, \"name\": \"test3\", \"list\": [{ \"x\": 1, \"y\": \"hi\" }, { \"x\": 2, \"y\": \"hello\" }] }] }")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[data] = {0}", value["data"]);
if (value["data"] != "[{ \"id\": 1, \"name\": \"test\" }, { \"id\": 2, \"name\": \"test2\" }, { \"id\": 3, \"name\": \"test3\", \"list\": [{ \"x\": 1, \"y\": \"hi\" }, { \"x\": 2, \"y\": \"hello\" }] }]")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[data][1][name] = {0}", value["data"][1]["name"]);
if (value["data"][1]["name"] != "test2")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 3");
value = UniValue.ParseXml("<response><item id='1' style='bold' color='white' /><item id='2' style='italic' color='red'>123</item></response>");
Console.WriteLine("[]");
Console.WriteLine(value);
Console.WriteLine();
Console.WriteLine("[response]");
Console.WriteLine(value["response"]);
Console.WriteLine();
Console.WriteLine("[response][item]");
Console.WriteLine(value["response"]["item"]);
Console.WriteLine();
Console.WriteLine("[response][item][0]");
Console.WriteLine(value["response"]["item"][0]);
Console.WriteLine();
Console.WriteLine("[response][item][1]");
Console.WriteLine(value["response"]["item"][1]);
Console.WriteLine();
Console.WriteLine("[response][item][0][@id]");
Console.WriteLine(value["response"]["item"][0]["@id"]);
Console.WriteLine();
Console.WriteLine("[response][item][0][@style]");
Console.WriteLine(value["response"]["item"][0]["style"]);
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 4");
value = UniValue.ParseXml("<response><item id='1' style='bold' color='white'><vvalue abc='test' avalue='1234567'></vvalue></item><item id='2' style='italic' color='red'><v>456</v></item></response>");
Console.WriteLine("[]");
Console.WriteLine(value);
Console.WriteLine();
Console.WriteLine("[response]");
Console.WriteLine(value["response"]);
Console.WriteLine();
Console.WriteLine("[response][item]");
Console.WriteLine(value["response"]["item"]);
if (value["response"]["item"] != "[{ \"value\": { \"vvalue\": { \"@abc\": \"test\", \"@avalue\": \"1234567\" } }, \"@id\": \"1\", \"@style\": \"bold\", \"@color\": \"white\" }, { \"value\": { \"v\": \"456\" }, \"@id\": \"2\", \"@style\": \"italic\", \"@color\": \"red\" }]")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine();
Console.WriteLine("[response][item][0]");
Console.WriteLine(value["response"]["item"][0]);
if (value["response"]["item"][0] != "{ \"vvalue\": { \"@abc\": \"test\", \"@avalue\": \"1234567\" } }")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 5");
value = UniValue.ParseJson("{data: [{id: 1, name: null}, {id: 2, name: 'test2\r\n123'}, {id: 3, name: 'test3', list: [{x:1,y:'hi'}, {x:2, y:'hello'}] }] }");
Console.WriteLine(value);
Assert.AreEqual(value.ToString(), "{ \"data\": [{ \"id\": 1, \"name\": null }, { \"id\": 2, \"name\": \"test2\\r\\n123\" }, { \"id\": 3, \"name\": \"test3\", \"list\": [{ \"x\": 1, \"y\": \"hi\" }, { \"x\": 2, \"y\": \"hello\" }] }] }");
value = "test\r\ntest";
Console.WriteLine(value);
Assert.AreEqual(value.ToString(), "test\r\ntest");
Console.WriteLine("-------------------------------------");
}
private void button2_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return;
}
using (var file = openFileDialog1.OpenFile())
using (var reader = new BinaryReader(file))
{
//reader.ReadBytes(fi
var client = new WebClient();
// handlers
client.UploadProgressChanged += (s, ce) =>
{
// you can create progress here
Console.WriteLine("Uploading: {0}", ce.ProgressPercentage);
};
client.UploadFileCompleted += (s, ce) =>
{
// exception
if (ce.Error != null)
{
MessageBox.Show(ce.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// parse success result
var result = UniValue.ParseJson(Encoding.UTF8.GetString(ce.Result));
if (result["error"].HasValue)
{
MessageBox.Show(result["error"].ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show(result.ToString(), "Result", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
};
var url = new UriBuilder("https://api-content.dropbox.com/1/files_put/auto/");
url.Query = String.Format("access_token={0}", Properties.Settings.Default.AccessToken) + // your access token here
String.Format("&path={0}", Path.Combine(this.CurrentPath, Path.GetFileName(openFileDialog1.FileName)).Replace("\\", "/")) +
String.Format("&overwrite={0}", "true") +
String.Format("&autorename={0}", "true");
client.UploadFileAsync
(
url.Uri,
"PUT",
openFileDialog1.FileName,
null
);
}
// small files
if (false)
{
OAuthUtility.PutAsync
(
"https://api-content.dropbox.com/1/files_put/auto/",
new HttpParameterCollection
{
{ "access_token", Properties.Settings.Default.AccessToken },
{ "path", Path.Combine(this.CurrentPath, Path.GetFileName(openFileDialog1.FileName)).Replace("\\", "/") },
{ "overwrite", "true" },
{ "autorename", "true" },
{ openFileDialog1.OpenFile() }
},
callback: Upload_Result
);
}
}
public void UniValue_Common()
{
Console.WriteLine("Test 1: Types");
var test = new Dictionary <string, UniValue>();
test.Add("a", 123);
test.Add("b", "test");
test.Add("c", DateTime.Now);
test.Add("d", 4.2);
test.Add("e", new byte[] { 1, 2, 3 });
test.Add("f", UniValue.Create(new Uri("http://localhost")));
test.Add("g", UniValue.Create(new { id = 123, name = "tester", date = DateTime.Now, obj = new { a = 1, b = 2, c = 3, d = new int[] { 1, 2, 3 } } }));
test.Add("h", new int[] { 1, 2, 3 });
test.Add("i", new string[] { "a", "b", "c" });
StringBuilder sb = new StringBuilder(); sb.Append("xyz");
test.Add("j", sb);
/*ResultValue a = 123;
* ResultValue b = "test";
* ResultValue c = DateTime.Now;
* ResultValue d = 4.2;
* ResultValue e = new byte[] { 1, 2, 3 };
* ResultValue f = new Uri("http://localhost");*/
foreach (var key in test.Keys)
{
Console.WriteLine("{0} = {1}", key, test[key]);
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 2: Parse");
Console.WriteLine("JSON");
try
{
var r = UniValue.ParseJson("test,1,#2,$3");
Assert.Fail("Invalid parse: ERROR");
}
catch
{
Console.WriteLine("Invalid parse: OK");
}
try
{
UniValue r = UniValue.Empty;
if (!UniValue.TryParseJson("test,1,#2,$3", out r))
{
Console.WriteLine("Try parse #1: OK");
}
else
{
Assert.Fail("Try parse #1: ERROR");
}
if (UniValue.TryParseJson("[1,2,3]", out r))
{
Console.WriteLine("Try parse #2: OK / {0}", r);
}
else
{
Assert.Fail("Try parse #2: ERROR");
}
}
catch
{
Assert.Fail("Try parse: ERROR");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("XML");
try
{
var r = UniValue.ParseXml("test,1,#2,$3");
Assert.Fail("Invalid parse: ERROR");
}
catch
{
Console.WriteLine("Invalid parse: OK");
}
try
{
UniValue r = UniValue.Empty;
if (!UniValue.TryParseXml("test,1,#2,$3", out r))
{
Console.WriteLine("Try parse #1: OK");
}
else
{
Assert.Fail("Try parse #1: ERROR");
}
if (UniValue.TryParseXml("<items><item>1</item><item>2</item><item>3</item></items>", out r))
{
Console.WriteLine("Try parse #2: OK / {0}", r);
}
else
{
Assert.Fail("Try parse #2: ERROR");
}
}
catch
{
Assert.Fail("Try parse: ERROR");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("PARAMETERS");
try
{
var r = UniValue.ParseParameters("test,1,#2,$3\r\n");
Assert.Fail("Invalid parse: ERROR");
}
catch
{
Console.WriteLine("Invalid parse: OK");
}
try
{
UniValue r = UniValue.Empty;
if (!UniValue.TryParseParameters("test,1,#2,$3\r\n", out r))
{
Console.WriteLine("Try parse #1: OK");
}
else
{
Assert.Fail("Try parse #1: ERROR");
}
if (UniValue.TryParseParameters("a=1&b=2&c=3", out r))
{
Console.WriteLine("Try parse #2: OK / {0}", r);
}
else
{
Assert.Fail("Try parse #2: ERROR");
}
}
catch
{
Assert.Fail("Try parse: ERROR");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 3");
Console.WriteLine("ToString");
UniValue r2 = "world!";
string ttt = "Hello, " + r2;
Console.WriteLine("IsString: {0}", r2.IsString);
if (!r2.IsString)
{
Assert.Fail();
}
Console.WriteLine(ttt);
Console.WriteLine("OK");
Console.WriteLine("ToInt32");
r2 = 123;
int num = (int)r2;
num = Convert.ToInt32(r2);
r2 = "ff";
num = Convert.ToInt32(r2.ToString(), 16);
r2 = "123";
num = (int)r2;
r2 = 123.123;
num = (int)r2;
r2 = "123.123";
num = (int)r2;
r2 = "123,123";
num = (int)r2;
try
{
r2 = "abc";
num = (int)r2;
Assert.Fail();
}
catch
{
}
Console.WriteLine("OK");
Console.WriteLine("ToDouble");
r2 = 123;
double num2 = (double)r2;
r2 = "123";
num2 = (double)r2;
r2 = "123.123";
num2 = (double)r2;
r2 = "123,123";
num2 = (double)r2;
try
{
r2 = "abc";
num2 = (double)r2;
Assert.Fail();
}
catch
{
}
Console.WriteLine("OK");
Console.WriteLine("ToDateTime");
r2 = "Thu Dec 04, 2014";
Convert.ToDateTime(r2);
Console.WriteLine("OK");
}
public void UniValue_Parents()
{
Console.WriteLine("Test 1");
UniValue value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
Console.WriteLine(value);
Console.WriteLine("-------------------------------------");
Console.WriteLine("[response] = {0}", value["response"].Parent.Key);
if (value["response"].Parent.Key != "root")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[response][item] = {0}", value["response"]["item"].Parent.Key);
if (value["response"]["item"].Parent != value["response"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 2");
value = UniValue.ParseXml("<response><item><id>1</id></item><item><id>2</id></item><item><id>3</id></item></response>");
Console.WriteLine(value);
Console.WriteLine("-------------------------------------");
Console.WriteLine("[response][item][id] = {0}", value["response"]["item"][0]["id"].Parent.Key);
if (value["response"]["item"][0]["id"].Parent != value["response"]["item"][0])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
if (value["response"]["item"][0].Parent != value["response"]["item"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 3");
value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
Console.WriteLine(value);
Console.WriteLine("-------------------------------------");
Console.WriteLine("[response][item][1] = {0}", value["response"]["item"][1].Parent.Key);
if (value["response"]["item"].First().Parent != value["response"]["item"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
if (value["response"]["item"].Last().Parent != value["response"]["item"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
if (value["response"]["item"]["0"].Parent != value["response"]["item"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
if (value["response"]["item"][1].Parent != value["response"]["item"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[response][0][1] = {0}", value["response"][0][1].Parent.Key);
if (value["response"][0][1].Parent != value["response"]["item"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[response][item][2][test] = {0}", value["response"]["item"][2]["test"].Parent);
if (value["response"]["item"][2]["test"].Parent.Key != value["response"]["item"][2].Key)
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[response][item][2][test] = {0}", value["response"]["item"][2]["test"].Parent);
if (value["response"]["item"][2]["test"].Parent != value["response"]["item"][2])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[response][item][2][test][a] = {0}", value["response"]["item"][2]["test"]["a"].Parent);
if (value["response"]["item"][2]["test"]["a"].Parent.Key != value["response"]["item"][2]["test"].Key)
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[response][item][2][5] = {0}", value["response"]["item"][2][5].Parent);
if (value["response"]["item"][2][5].Parent != value["response"]["item"][2])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 2");
value = UniValue.ParseJson("{data: [{id: 1, name: 'test'}, {id: 2, name: 'test2'}, {id: 3, name: 'test3', list: [{x:1,y:'hi'}, {x:2, y:'hello'}] }] }");
Console.WriteLine(value);
Console.WriteLine("-------------------------------------");
Console.WriteLine("[data] = {0}", value["data"].Parent.Key);
if (value["data"].Parent.Key != "root")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[data][0] = {0}", value["data"][0].Parent.Key);
if (value["data"][0].Parent != value["data"])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[data][1][name] = {0}", value["data"][1]["name"].Parent.Key);
if (value["data"][1]["name"].Parent != value["data"][1])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
Console.WriteLine("[data][0][1] = {0}", value["data"][0][1].Parent.Key);
if (value["data"][0][1].Parent != value["data"][0])
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
}
public void Index()
{
UniValue r = UniValue.Empty;
Assert.True(r["test"] == null);
Assert.True(r[10] == null);
Assert.True(r["test"][12] == null);
Assert.True(r["test"].First() == r["test"][12]);
Assert.Equal(r["test"].First(), r["test"][12]);
Assert.True(r["xyz"][3]["qwer"][1]["abc"] == null);
r = UniValue.ParseJson("[1, 2, 3]");
for (int i = 0; i < 5; i++)
{
if (i + 1 <= 3)
{
Assert.True(r[i] == i + 1);
}
else
{
Assert.True(r[i] == null);
}
}
UniValue value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
Assert.True(value[0].Key == "response");
Assert.Equal("response", value[0].Key);
Assert.True(value["response"].Key == "response");
Assert.Equal("response", value["response"].Key);
Assert.True(value[0][0].Key == "item");
Assert.Equal("item", value[0][0].Key);
Assert.True(value["response"][0].Key == "item");
Assert.Equal("item", value["response"][0].Key);
Assert.True(value["response"]["item"][2] == 3);
Assert.Equal(3, (int)value["response"]["item"][2]);
Assert.True(value[0][0][1] == 2);
Assert.Equal(2, (int)value[0][0][1]);
r = UniValue.Empty;
r["test"] = "123";
Assert.Equal("123", r["test"]);
r = UniValue.Empty;
r["test"]["a"] = "abc";
Assert.Equal("abc", r["test"]["a"]);
r = UniValue.Empty;
r["a"][0]["test"][2] = "aaa";
Assert.Equal("aaa", r["a"][0]["test"][2]);
r = UniValue.Empty;
r.Add("test", "123");
Assert.Equal("123", r["test"]);
r["test"].Add("a", "abc");
Assert.Equal("abc", r["test"]["a"]);
r[0][1][2][3][4][5][6][7]["a"]["b"]["c"] = 123;
Assert.Equal(123, (int)r[0][1][2][3][4][5][6][7]["a"]["b"]["c"]);
}
public void UniValue_Index()
{
bool ok = true;
Console.WriteLine("Test 1");
UniValue r = UniValue.Empty;
Console.WriteLine("Key: {0}", r["test"]);
if (r["test"] == null)
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
Console.WriteLine(r);
Console.WriteLine("-------------------------------------");
Console.WriteLine("Index: {0}", r[10]);
if (r[10] == null)
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
Console.WriteLine(r);
Console.WriteLine("-------------------------------------");
Console.WriteLine("Key + Index: {0}", r["test"][12]);
if (r["test"][12] == null)
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
if (r["test"].First() == r["test"][12])
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
Console.WriteLine(r);
Console.WriteLine("-------------------------------------");
Console.WriteLine("All: {0}", r["xyz"][3]["qwer"][1]["abc"]);
if (r["xyz"][3]["qwer"][1]["abc"] == null)
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
Console.WriteLine(r);
Console.WriteLine("-------------------------------------");
ok = true;
Console.WriteLine("Test 2");
r = UniValue.ParseJson("[1, 2, 3]");
for (int i = 0; i < 5; i++)
{
Console.WriteLine("{0}: {1}", i, r[i]);
if (ok)
{
if (i + 1 <= 3)
{
ok = (r[i] == i + 1);
}
else
{
ok = r[i] == null;
}
}
}
if (ok)
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
Console.WriteLine("-------------------------------------");
Console.WriteLine("Test 3");
ok = true;
UniValue value = UniValue.ParseXml("<response><item>1</item><item>2</item><item>3</item></response>");
if (ok)
{
ok = value[0].Key == "response";
}
if (ok)
{
ok = value["response"].Key == "response";
}
if (ok)
{
ok = value[0][0].Key == "item";
}
if (ok)
{
ok = value["response"][0].Key == "item";
}
if (ok)
{
ok = value["response"]["item"][2] == 3;
}
if (ok)
{
ok = value[0][0][1] == 2;
}
if (ok)
{
Console.WriteLine("OK");
}
else
{
Assert.Fail();
}
Console.WriteLine("-------------------------------------");
// UniValue.Create().Add("test", 123);
Console.WriteLine("Test 4");
r = UniValue.Empty;
r["test"] = "123";
if (r["test"] != "123")
{
Assert.Fail();
}
r = UniValue.Empty;
r["test"]["a"] = "abc";
if (r["test"]["a"] != "abc")
{
Assert.Fail();
}
r = UniValue.Empty;
r["a"][0]["test"][2] = "aaa";
if (r["a"][0]["test"][2] != "aaa")
{
Assert.Fail();
}
r = UniValue.Empty;
r.Add("test", "123");
if (r["test"] != "123")
{
Assert.Fail();
}
r["test"].Add("a", "abc");
if (r["test"]["a"] != "abc")
{
Assert.Fail();
}
//value["response"]["item"][2]["test"] = "hello, world!";
//var rr = value["response"]["item"][2];
//rr["test"] = "123";
r[0][1][2][3][4][5][6][7]["a"]["b"]["c"] = 123;
if (r[0][1][2][3][4][5][6][7]["a"]["b"]["c"] != 123)
{
Assert.Fail();
}
}
public void Json()
{
#if NET35
Assert.Throws <ArgumentException>(() => UniValue.ParseJson("test,1,#2,$3"));
#elif NET40
Assert.Throws <ArgumentException>(() => UniValue.ParseJson("test,1,#2,$3"));
#else
Assert.ThrowsAny <ArgumentException>(() => UniValue.ParseJson("test,1,#2,$3"));
#endif
UniValue r = UniValue.Empty;
Assert.False(UniValue.TryParseJson("test,1,#2,$3", out r));
Assert.True(UniValue.TryParseJson("[1,2,3]", out r));
int i = 0;
int j = 0;
var testValue = new string[] { "1", "2", "3" };
var testValue2 = new string[] { "test", "test2", "test3" };
var testValue3 = new string[] { "1", "2" };
var testValue4 = new string[] { "hi", "hello" };
UniValue value = UniValue.ParseJson("{data: [{id: 1, name: 'test'}, {id: 2, name: 'test2'}, {id: 3, name: 'test3', list: [{x:1,y:'hi'}, {x:2, y:'hello'}] }] }");
foreach (UniValue itm in value["data"])
{
if (itm["list"].HasValue)
{
foreach (UniValue itm2 in itm["list"])
{
Assert.True(testValue3[j] == itm2["x"] && testValue4[j] == itm2["y"]);
j++;
}
}
Assert.True(testValue[i] == itm["id"] && testValue2[i] == itm["name"]);
i++;
}
value = UniValue.ParseJson
(
@"{
array: [1, 2, 3, 4, 5, 6, 7, 8, 9],
array2: ['a', 'b', 1, 2, 3],
data:
[
{id: 1, name: 'test'},
{id: 2, name: 'test2'},
{
id: 3, name: 'test3', list:
[
{x:1,y:'hi'},
{x:2, y:'hello'},
{
x:3, y:'test',
array: [1,2,3],
sub:
[
{id: 123, text: 'tesssst'},
{id: 124, text: 'xyz'},
{id: 125, text: 'aaaa', list: [{sid: 1}, {sid: 2}]},
{id: 127, text: 'zyx', arr: ['a', 'b', 'c']}
]
}
]
}
]
}"
);
var array = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
i = j = 0;
foreach (UniValue itm in value["array"])
{
Assert.True(itm == array[i]);
Assert.True(itm.Equals(array[i]));
Assert.Equal(array[i], (int)itm);
i++;
}
var array2 = new object[] { "a", "b", 1, 2, 3 };
i = j = 0;
foreach (UniValue itm in value["array2"])
{
Assert.True(itm.Equals(array2[i]));
Assert.Equal(array2[i].ToString(), itm.ToString());
i++;
}
var names = new string[] { "test", "test2", "test3" };
i = j = 0;
foreach (UniValue itm in value["data"])
{
Assert.Equal(names[i], itm["name"].ToString());
if (itm["list"].HasValue)
{
foreach (UniValue itm2 in itm["list"])
{
if (itm2["array"].HasValue)
{
j = 0;
foreach (UniValue itm3 in itm2["array"])
{
Assert.Equal <int>(j + 1, (int)itm3);
Assert.True(itm3 == j + 1);
Assert.True(itm3.Equals(j + 1));
j++;
}
}
if (itm2["sub"].HasValue)
{
foreach (UniValue itm3 in itm2["sub"])
{
if (itm3["arr"].HasValue)
{
var arr = new string[] { "a", "b", "c" };
j = 0;
foreach (UniValue itm4 in itm3["arr"])
{
Assert.Equal(arr[j], itm4);
Assert.True(itm4 == arr[j]);
Assert.True(itm4.Equals(arr[j]));
j++;
}
}
if (itm3["list"].HasValue)
{
j = 0;
foreach (UniValue itm4 in itm3["list"])
{
Assert.Equal(j + 1, (int)itm4["sid"]);
Assert.True(itm4["sid"] == j + 1);
Assert.True(itm4["sid"].Equals(j + 1));
j++;
}
}
}
}
}
}
i++;
}
}
