/mcs/class/Managed.Windows.Forms/Test/System.Windows.Forms/ListControlTest.cs

https://bitbucket.org/danipen/mono · C# · 586 lines · 449 code · 102 blank · 35 comment · 10 complexity · 804a7b12640531684b9a44bfc29b70f1 MD5 · raw file

  1. //
  2. // ListControlTest.cs: Tests for ListControl abstract class.
  3. //
  4. // Permission is hereby granted, free of charge, to any person obtaining
  5. // a copy of this software and associated documentation files (the
  6. // "Software"), to deal in the Software without restriction, including
  7. // without limitation the rights to use, copy, modify, merge, publish,
  8. // distribute, sublicense, and/or sell copies of the Software, and to
  9. // permit persons to whom the Software is furnished to do so, subject to
  10. // the following conditions:
  11. //
  12. // The above copyright notice and this permission notice shall be
  13. // included in all copies or substantial portions of the Software.
  14. //
  15. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19. // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20. // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22. //
  23. // Copyright (c) 2006 Novell, Inc. (http://www.novell.com)
  24. //
  25. // Authors:
  26. // Carlos Alberto Cortez <calberto.cortez@gmail.com>
  27. //
  28. using System;
  29. using System.Collections;
  30. #if NET_2_0
  31. using System.ComponentModel;
  32. #endif
  33. using System.IO;
  34. using System.Data;
  35. using System.Globalization;
  36. using System.Windows.Forms;
  37. using NUnit.Framework;
  38. namespace MonoTests.System.Windows.Forms
  39. {
  40. [TestFixture]
  41. public class ListControlTest : TestHelper
  42. {
  43. private int dataSourceChanged;
  44. [SetUp]
  45. protected override void SetUp () {
  46. dataSourceChanged = 0;
  47. base.SetUp ();
  48. }
  49. [Test]
  50. // Bug 80794
  51. public void DataBindingsTest ()
  52. {
  53. string table =
  54. @"<?xml version=""1.0"" standalone=""yes""?>
  55. <DOK>
  56. <DOK>
  57. <klient>287</klient>
  58. </DOK>
  59. </DOK>
  60. ";
  61. string lookup =
  62. @"<?xml version=""1.0"" standalone=""yes""?>
  63. <klient>
  64. <klient>
  65. <nimi>FAILED</nimi>
  66. <kood>316</kood>
  67. </klient>
  68. <klient>
  69. <nimi>SUCCESS</nimi>
  70. <kood>287</kood>
  71. </klient>
  72. </klient>";
  73. using (Form frm = new Form ()) {
  74. frm.ShowInTaskbar = false;
  75. DataSet dsTable = new DataSet ();
  76. dsTable.ReadXml (new StringReader (table));
  77. DataSet dsLookup = new DataSet ();
  78. dsLookup.ReadXml (new StringReader (lookup));
  79. ComboBox cb = new ComboBox ();
  80. cb.DataSource = dsLookup.Tables [0];
  81. cb.DisplayMember = "nimi";
  82. cb.ValueMember = "kood";
  83. cb.DataBindings.Add ("SelectedValue", dsTable.Tables [0], "klient");
  84. frm.Controls.Add (cb);
  85. Assert.AreEqual ("", cb.Text, "#01");
  86. frm.Show ();
  87. Assert.AreEqual ("SUCCESS", cb.Text, "#02");
  88. }
  89. }
  90. [Test]
  91. public void GetItemText ()
  92. {
  93. MockItem itemA = new MockItem ("A", 1);
  94. MockItem itemB = new MockItem ("B", 2);
  95. object itemC = new object ();
  96. ListControlChild lc = new ListControlChild ();
  97. lc.DisplayMember = "Text";
  98. // No DataSource available
  99. Assert.AreEqual ("A", lc.GetItemText (itemA), "#A1");
  100. Assert.AreEqual ("B", lc.GetItemText (itemB), "#A2");
  101. Assert.AreEqual (itemC.GetType ().FullName, lc.GetItemText (itemC), "#A3");
  102. lc.DisplayMember = String.Empty;
  103. Assert.AreEqual (itemA.GetType ().FullName, lc.GetItemText (itemA), "#B1");
  104. Assert.AreEqual (itemB.GetType ().FullName, lc.GetItemText (itemB), "#B2");
  105. Assert.AreEqual (itemC.GetType ().FullName, lc.GetItemText (itemC), "#B3");
  106. // DataSource available
  107. object [] objects = new object [] {itemA, itemB, itemC};
  108. lc.DisplayMember = "Text";
  109. lc.DataSource = objects;
  110. Assert.AreEqual ("A", lc.GetItemText (itemA), "#C1");
  111. Assert.AreEqual ("B", lc.GetItemText (itemB), "#C2");
  112. Assert.AreEqual (itemC.GetType ().FullName, lc.GetItemText (itemC), "#C3");
  113. lc.DisplayMember = String.Empty;
  114. Assert.AreEqual (itemA.GetType ().FullName, lc.GetItemText (itemA), "#D1");
  115. Assert.AreEqual (itemB.GetType ().FullName, lc.GetItemText (itemB), "#D2");
  116. Assert.AreEqual (itemC.GetType ().FullName, lc.GetItemText (itemC), "#D3");
  117. }
  118. [Test]
  119. public void FilterItemOnProperty ()
  120. {
  121. MockItem itemA = new MockItem ("A", 1);
  122. MockItem itemB = new MockItem ("B", 2);
  123. object itemC = new object ();
  124. ListControlChild lc = new ListControlChild ();
  125. lc.DisplayMember = "Text";
  126. // No DataSource available
  127. Assert.AreEqual ("A", lc.FilterItem (itemA, lc.DisplayMember), "#A1");
  128. Assert.AreEqual ("B", lc.FilterItem (itemB, lc.DisplayMember), "#A2");
  129. Assert.AreEqual (itemC, lc.FilterItem (itemC, lc.DisplayMember), "#A3");
  130. lc.DisplayMember = String.Empty;
  131. Assert.AreEqual (itemA, lc.FilterItem (itemA, lc.DisplayMember), "#B1");
  132. Assert.AreEqual (itemB, lc.FilterItem (itemB, lc.DisplayMember), "#B2");
  133. Assert.AreEqual (itemC, lc.FilterItem (itemC, lc.DisplayMember), "#B3");
  134. // DataSource available
  135. object [] objects = new object [] {itemA, itemB, itemC};
  136. lc.DisplayMember = "Text";
  137. lc.DataSource = objects;
  138. Assert.AreEqual ("A", lc.FilterItem (itemA, lc.DisplayMember), "#C1");
  139. Assert.AreEqual ("B", lc.FilterItem (itemB, lc.DisplayMember), "#C2");
  140. Assert.AreEqual (itemC, lc.FilterItem (itemC, lc.DisplayMember), "#C3");
  141. lc.DisplayMember = String.Empty;
  142. Assert.AreEqual (itemA, lc.FilterItem (itemA, lc.DisplayMember), "#D1");
  143. Assert.AreEqual (itemB, lc.FilterItem (itemB, lc.DisplayMember), "#D2");
  144. Assert.AreEqual (itemC, lc.FilterItem (itemC, lc.DisplayMember), "#D3");
  145. }
  146. [Test]
  147. public void DisplayMemberNullTest ()
  148. {
  149. ListControlChild lc = new ListControlChild ();
  150. lc.DisplayMember = null;
  151. Assert.AreEqual (String.Empty, lc.DisplayMember, "#1");
  152. }
  153. [Test]
  154. [ExpectedException (typeof (Exception))]
  155. public void DataSourceWrongArgumentType ()
  156. {
  157. ListControlChild lc = new ListControlChild ();
  158. lc.DataSource = new object ();
  159. }
  160. [Test]
  161. public void DataSource1 ()
  162. {
  163. ArrayList list1 = new ArrayList ();
  164. list1.Add ("item 1");
  165. ArrayList list2 = new ArrayList ();
  166. ListControlChild lc = new ListControlChild ();
  167. lc.DataSourceChanged += new EventHandler (ListControl_DataSourceChanged);
  168. lc.DataSource = list1;
  169. Assert.AreEqual (1, dataSourceChanged, "#A1");
  170. Assert.AreSame (list1, lc.DataSource, "#A2");
  171. Form form = new Form ();
  172. form.Controls.Add (lc);
  173. Assert.AreEqual (1, dataSourceChanged, "#B1");
  174. Assert.AreSame (list1, lc.DataSource, "#B2");
  175. lc.DataSource = list1;
  176. Assert.AreEqual (1, dataSourceChanged, "#B3");
  177. Assert.AreSame (list1, lc.DataSource, "#B4");
  178. lc.DataSource = list2;
  179. Assert.AreEqual (2, dataSourceChanged, "#B5");
  180. Assert.AreSame (list2, lc.DataSource, "#B6");
  181. lc.DataSource = null;
  182. Assert.AreEqual (3, dataSourceChanged, "#B7");
  183. Assert.IsNull (lc.DataSource, "#B8");
  184. list1.Add ("whatever");
  185. list2.Add ("whatever");
  186. list1.Clear ();
  187. list2.Clear ();
  188. form.Dispose ();
  189. }
  190. [Test]
  191. public void DataSource2 ()
  192. {
  193. ArrayList list1 = new ArrayList ();
  194. list1.Add ("item 1");
  195. ArrayList list2 = new ArrayList ();
  196. ListControlChild lc = new ListControlChild ();
  197. lc.DataSourceChanged += new EventHandler (ListControl_DataSourceChanged);
  198. Form form = new Form ();
  199. form.Controls.Add (lc);
  200. Assert.AreEqual (0, dataSourceChanged, "#1");
  201. Assert.IsNull (lc.DataSource, "#2");
  202. lc.DataSource = list1;
  203. Assert.AreEqual (1, dataSourceChanged, "#3");
  204. Assert.AreSame (list1, lc.DataSource, "#4");
  205. lc.DataSource = list2;
  206. Assert.AreEqual (2, dataSourceChanged, "#5");
  207. Assert.AreSame (list2, lc.DataSource, "#6");
  208. lc.DataSource = null;
  209. Assert.AreEqual (3, dataSourceChanged, "#7");
  210. Assert.IsNull (lc.DataSource, "#8");
  211. list1.Add ("whatever");
  212. list2.Add ("whatever");
  213. list1.Clear ();
  214. list2.Clear ();
  215. form.Dispose ();
  216. }
  217. [Test]
  218. public void SelectedValue ()
  219. {
  220. Form f = new Form ();
  221. f.ShowInTaskbar = false;
  222. ListControlChild lc = new ListControlChild ();
  223. f.Controls.Add (lc);
  224. ArrayList list = new ArrayList ();
  225. list.Add (new MockItem ("TextA", 1));
  226. list.Add (new MockItem (String.Empty, 4));
  227. list.Add (new MockItem ("TextC", 9));
  228. lc.ValueMember = "Text";
  229. lc.DataSource = list;
  230. f.Show ();
  231. lc.SelectedValue = "TextC";
  232. Assert.AreEqual (2, lc.SelectedIndex, "#B1");
  233. Assert.AreEqual ("TextC", lc.SelectedValue, "#B2");
  234. lc.SelectedValue = String.Empty;
  235. Assert.AreEqual (1, lc.SelectedIndex, "#C1");
  236. Assert.AreEqual (String.Empty, lc.SelectedValue, "#C2");
  237. lc.SelectedValue = "TextA";
  238. Assert.AreEqual (0, lc.SelectedIndex, "#D1");
  239. Assert.AreEqual ("TextA", lc.SelectedValue, "#D2");
  240. try {
  241. lc.SelectedValue = null;
  242. Assert.Fail ("#E1");
  243. } catch (ArgumentNullException) {
  244. }
  245. f.Dispose ();
  246. }
  247. [Test]
  248. public void SelectedValue2 ()
  249. {
  250. Form f = new Form ();
  251. f.ShowInTaskbar = false;
  252. ListControlChild child = new ListControlChild ();
  253. ArrayList list = new ArrayList ();
  254. list.Add (new MockItem ("A", 0));
  255. list.Add (new MockItem ("B", 1));
  256. list.Add (new MockItem ("C", 2));
  257. child.DataSource = list;
  258. child.ValueMember = "Text";
  259. MockItem item = new MockItem (String.Empty, 0);
  260. child.DataBindings.Add ("SelectedValue", item, "Text");
  261. Assert.AreEqual (-1, child.SelectedIndex, "#A1");
  262. f.Controls.Add (child);
  263. Assert.AreEqual (-1, child.SelectedIndex, "#B1");
  264. // When the form is shown, normally the SelectedIndex is the
  265. // CurrencyManager.Position (0 in this case), but it should remain as -1
  266. // since SelectedValue is bound to a String.Empty value. See #324286
  267. f.Show ();
  268. CurrencyManager manager = (CurrencyManager)f.BindingContext [list];
  269. Assert.AreEqual (-1, child.SelectedIndex, "#C1");
  270. Assert.AreEqual (0, manager.Position, "#C2");
  271. f.Dispose ();
  272. }
  273. #if NET_2_0
  274. [Test] // bug #81771
  275. public void DataSource_BindingList1 ()
  276. {
  277. BindingList<string> list1 = new BindingList<string> ();
  278. list1.Add ("item 1");
  279. BindingList<string> list2 = new BindingList<string> ();
  280. ListControlChild lc = new ListControlChild ();
  281. lc.DataSourceChanged += new EventHandler (ListControl_DataSourceChanged);
  282. lc.DataSource = list1;
  283. Assert.AreEqual (1, dataSourceChanged, "#A1");
  284. Assert.AreSame (list1, lc.DataSource, "#A2");
  285. Form form = new Form ();
  286. form.Controls.Add (lc);
  287. Assert.AreEqual (1, dataSourceChanged, "#B1");
  288. Assert.AreSame (list1, lc.DataSource, "#B2");
  289. lc.DataSource = list2;
  290. Assert.AreEqual (2, dataSourceChanged, "#B3");
  291. Assert.AreSame (list2, lc.DataSource, "#B4");
  292. lc.DataSource = null;
  293. Assert.AreEqual (3, dataSourceChanged, "#B5");
  294. Assert.IsNull (lc.DataSource, "#B6");
  295. list1.Add ("item");
  296. list1.Clear ();
  297. form.Dispose ();
  298. }
  299. [Test] // bug #81771
  300. public void DataSource_BindingList2 ()
  301. {
  302. BindingList<string> list1 = new BindingList<string> ();
  303. list1.Add ("item 1");
  304. BindingList<string> list2 = new BindingList<string> ();
  305. ListControlChild lc = new ListControlChild ();
  306. lc.DataSourceChanged += new EventHandler (ListControl_DataSourceChanged);
  307. Form form = new Form ();
  308. form.Controls.Add (lc);
  309. Assert.AreEqual (0, dataSourceChanged, "#1");
  310. Assert.IsNull (lc.DataSource, "#2");
  311. lc.DataSource = list1;
  312. Assert.AreEqual (1, dataSourceChanged, "#3");
  313. Assert.AreSame (list1, lc.DataSource, "#4");
  314. lc.DataSource = list2;
  315. Assert.AreEqual (2, dataSourceChanged, "#5");
  316. Assert.AreSame (list2, lc.DataSource, "#6");
  317. lc.DataSource = null;
  318. Assert.AreEqual (3, dataSourceChanged, "#7");
  319. Assert.IsNull (lc.DataSource, "#8");
  320. list1.Add ("item");
  321. list1.Clear ();
  322. form.Dispose ();
  323. }
  324. [Test]
  325. public void AllowSelection ()
  326. {
  327. ListControlChild lc = new ListControlChild ();
  328. Assert.IsTrue (lc.allow_selection);
  329. }
  330. [Test]
  331. public void BehaviorFormatting ()
  332. {
  333. ListControl lc = new ListControlChild ();
  334. DateTime dt = new DateTime (1, 2, 3, 4, 5, 6);
  335. Assert.AreEqual (false, lc.FormattingEnabled, "A1");
  336. Assert.AreEqual (null, lc.FormatInfo, "A2");
  337. Assert.AreEqual (string.Empty, lc.FormatString, "A3");
  338. Assert.AreEqual (dt.ToString (), lc.GetItemText (dt), "A4");
  339. lc.FormattingEnabled = true;
  340. lc.FormatString = "MM/dd";
  341. Assert.AreEqual ("02/03", lc.GetItemText (dt), "A5");
  342. lc.Format += new ListControlConvertEventHandler (lc_Format);
  343. Assert.AreEqual ("Monkey!", lc.GetItemText (dt), "A6");
  344. }
  345. void lc_Format (object sender, ListControlConvertEventArgs e)
  346. {
  347. e.Value = "Monkey!";
  348. }
  349. [Test]
  350. public void FormattingChanges ()
  351. {
  352. bool refresh_items_called = false;
  353. ListControlChild lc = new ListControlChild ();
  354. lc.RefreshingItems += delegate
  355. {
  356. refresh_items_called = true;
  357. };
  358. lc.FormattingEnabled = !lc.FormattingEnabled;
  359. Assert.AreEqual (true, refresh_items_called, "A1");
  360. refresh_items_called = false;
  361. lc.FormatInfo = CultureInfo.CurrentCulture;
  362. Assert.AreEqual (true, refresh_items_called, "B1");
  363. refresh_items_called = false;
  364. lc.FormatString = CultureInfo.CurrentCulture.NumberFormat.ToString ();
  365. Assert.AreEqual (true, refresh_items_called, "C1");
  366. }
  367. #endif
  368. void ListControl_DataSourceChanged (object sender, EventArgs e)
  369. {
  370. dataSourceChanged++;
  371. }
  372. [Test]
  373. public void FormatEventValueType ()
  374. {
  375. string event_log = null;
  376. ComboBox comboBox = new ComboBox ();
  377. comboBox.FormattingEnabled = true;
  378. comboBox.Format += delegate(object sender, ListControlConvertEventArgs e)
  379. {
  380. event_log = e.Value.GetType ().Name;
  381. };
  382. int [] objects = new int [] { 1, 2, 3 };
  383. comboBox.DataSource = objects;
  384. comboBox.GetItemText (1);
  385. Assert.AreEqual (typeof (int).Name, event_log, "#A0");
  386. }
  387. public class ListControlChild : ListControl
  388. {
  389. int selected_index = -1;
  390. public override int SelectedIndex {
  391. get {
  392. return selected_index;
  393. }
  394. set {
  395. selected_index = value;
  396. }
  397. }
  398. #if NET_2_0
  399. public bool allow_selection {
  400. get { return base.AllowSelection; }
  401. }
  402. #endif
  403. public object FilterItem (object obj, string field)
  404. {
  405. return FilterItemOnProperty (obj, field);
  406. }
  407. protected override void RefreshItem (int index)
  408. {
  409. }
  410. #if NET_2_0
  411. protected override void RefreshItems ()
  412. {
  413. base.RefreshItems ();
  414. if (RefreshingItems != null)
  415. RefreshingItems (this, EventArgs.Empty);
  416. }
  417. public event EventHandler RefreshingItems;
  418. #endif
  419. protected override void SetItemsCore (IList items)
  420. {
  421. }
  422. }
  423. }
  424. public class MockItem
  425. {
  426. public MockItem (string text, int value)
  427. {
  428. _text = text;
  429. _value = value;
  430. }
  431. public MockItem ()
  432. {
  433. _text = String.Empty;
  434. _value = -1;
  435. }
  436. public string Text {
  437. get { return _text; }
  438. set {
  439. if (_text == value)
  440. return;
  441. _text = value;
  442. OnTextChanged (EventArgs.Empty);
  443. }
  444. }
  445. public int Value {
  446. get { return _value; }
  447. set {
  448. if (_value == value)
  449. return;
  450. _value = value;
  451. OnValueChanged (EventArgs.Empty);
  452. }
  453. }
  454. protected virtual void OnTextChanged (EventArgs args)
  455. {
  456. if (TextChanged != null)
  457. TextChanged (this, args);
  458. }
  459. protected virtual void OnValueChanged (EventArgs args)
  460. {
  461. if (ValueChanged != null)
  462. ValueChanged (this, args);
  463. }
  464. public event EventHandler TextChanged;
  465. public event EventHandler ValueChanged;
  466. private string _text;
  467. private int _value;
  468. }
  469. public class MockContainer
  470. {
  471. MockItem item;
  472. public MockItem Item
  473. {
  474. get
  475. {
  476. return item;
  477. }
  478. set
  479. {
  480. item = value;
  481. }
  482. }
  483. }
  484. }