PageRenderTime 44ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/mcs/class/System.Data.Linq/src/DbLinq/Test/EntitySetTest.cs

https://github.com/ekovalenko-softheme/mono
C# | 438 lines | 369 code | 59 blank | 10 comment | 1 complexity | 66fbdb4b385d7ae9a53399975ae8c199 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0, Unlicense
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.ComponentModel;
  5. using System.Linq;
  6. #if MONO_STRICT
  7. using System.Data.Linq;
  8. #else
  9. using DbLinq.Data.Linq;
  10. #endif
  11. using NUnit.Framework;
  12. namespace DbLinqTest
  13. {
  14. [TestFixture]
  15. public class EntitySetTest
  16. {
  17. [Test]
  18. public void Ctor_OnAddAndOnRemoveCanBeNull()
  19. {
  20. new EntitySet<Person>(null, null);
  21. }
  22. [Test, ExpectedException(typeof(ArgumentNullException))]
  23. public void Add_EntityNull()
  24. {
  25. var people = new EntitySet<Person>();
  26. people.Add(null);
  27. }
  28. [Test]
  29. public void Add_IgnoreRepeats()
  30. {
  31. var people = new EntitySet<Person>();
  32. var p = new Person { FirstName = "A", LastName = "B" };
  33. people.Add(p);
  34. people.Add(p);
  35. Assert.AreEqual(1, people.Count);
  36. }
  37. [Test, ExpectedException(typeof(InvalidOperationException))]
  38. public void Add_ThenSetSourceIsInvalid()
  39. {
  40. var people = new EntitySet<Person>();
  41. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  42. people.Add(new Person { FirstName = "A", LastName = "B" });
  43. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  44. people.SetSource(new[]{
  45. new Person { FirstName = "1", LastName = "2" }
  46. });
  47. }
  48. [Test]
  49. public void Assign()
  50. {
  51. var people = new EntitySet<Person>();
  52. people.SetSource(new[]{
  53. new Person { FirstName = "A", LastName = "B" },
  54. });
  55. Assert.IsTrue(people.IsDeferred);
  56. people.Load();
  57. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  58. Assert.IsFalse(people.IsDeferred);
  59. people.Assign(new[]{
  60. new Person { FirstName = "1", LastName = "2" },
  61. });
  62. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  63. Assert.AreEqual(1, people.Count);
  64. Assert.IsFalse(people.IsDeferred);
  65. }
  66. [Test, ExpectedException(typeof(InvalidOperationException))]
  67. public void Clear_DoesNotResetSource()
  68. {
  69. var people = new EntitySet<Person>();
  70. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  71. people.Add(new Person { FirstName = "A", LastName = "B" });
  72. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  73. people.Clear();
  74. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  75. people.SetSource(new[]{
  76. new Person { FirstName = "1", LastName = "2" },
  77. });
  78. }
  79. [Test]
  80. public void Contains_KillsDeferred()
  81. {
  82. var people = new EntitySet<Person>();
  83. var p = new Person { FirstName = "A", LastName = "B" };
  84. people.SetSource(new[]{
  85. p
  86. });
  87. Assert.IsTrue(people.IsDeferred);
  88. Assert.IsTrue(people.Contains(p));
  89. Assert.IsFalse(people.IsDeferred);
  90. }
  91. [Test]
  92. public void HasLoadedOrAssignedValues()
  93. {
  94. var people = new EntitySet<Person>();
  95. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  96. people.SetSource(new[]{
  97. new Person { FirstName = "A", LastName = "B" },
  98. });
  99. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  100. Assert.IsTrue(people.IsDeferred);
  101. people.Load();
  102. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  103. Assert.IsFalse(people.IsDeferred);
  104. }
  105. [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
  106. public void IList_Add_WrongType()
  107. {
  108. var people = new EntitySet<Person>();
  109. System.Collections.IList list = people;
  110. list.Add("WrongType");
  111. }
  112. [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
  113. public void IList_Add_DuplicateItem()
  114. {
  115. var people = new EntitySet<Person>();
  116. var p = new Person { FirstName = "A", LastName = "B" };
  117. people.Add(p);
  118. System.Collections.IList list = people;
  119. list.Add(p);
  120. }
  121. [Test]
  122. public void IList_Remove_WrongTypeIsIgnored()
  123. {
  124. var people = new EntitySet<Person>();
  125. System.Collections.IList list = people;
  126. list.Remove("DoesNotExist");
  127. }
  128. [Test]
  129. public void IndexOf_KillsDeferred()
  130. {
  131. var people = new EntitySet<Person>();
  132. var p = new Person { FirstName = "A", LastName = "B" };
  133. people.SetSource(new[]{
  134. p
  135. });
  136. Assert.IsTrue(people.IsDeferred);
  137. Assert.AreEqual(0, people.IndexOf(p));
  138. Assert.IsFalse(people.IsDeferred);
  139. }
  140. [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
  141. public void Insert_RepeatValue()
  142. {
  143. var people = new EntitySet<Person>();
  144. var p = new Person { FirstName = "A", LastName = "B" };
  145. people.Add(p);
  146. people.Insert(0, p);
  147. }
  148. [Test]
  149. public void Item_IsDeferredSourceLoaded()
  150. {
  151. var people = new EntitySet<Person>();
  152. people.SetSource(new[]{
  153. new Person { FirstName = "A", LastName = "B" },
  154. });
  155. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  156. Assert.IsTrue(people.IsDeferred);
  157. var p = people[0];
  158. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  159. Assert.IsFalse(people.IsDeferred);
  160. }
  161. [Test]
  162. public void ListChanged_NoSource()
  163. {
  164. // When is ListChanged emitted?
  165. // It's not always when you think it would be.
  166. // It depends on whether there's a Source present.
  167. var people = new EntitySet<Person>();
  168. var events = new List<ListChangedEventArgs> ();
  169. people.ListChanged += (o, e) => events.Add(e);
  170. people.Add(new Person { FirstName = "A", LastName = "B" });
  171. AssertEqual(events);
  172. events.Clear();
  173. people.Clear();
  174. AssertEqual(events, new ListChangedEventArgs(ListChangedType.Reset, 0, -1));
  175. events.Clear();
  176. people.AddRange(new[]{
  177. new Person { FirstName = "1", LastName = "2" },
  178. new Person { FirstName = "<", LastName = ">" },
  179. });
  180. AssertEqual(events);
  181. events.Clear();
  182. var p = new Person { FirstName = "{", LastName = "}" };
  183. people.Insert(1, p);
  184. AssertEqual(events, new ListChangedEventArgs(ListChangedType.ItemAdded, 1, -1));
  185. events.Clear();
  186. Assert.IsTrue(people.Remove(p));
  187. AssertEqual(events);
  188. events.Clear();
  189. people.RemoveAt(0);
  190. AssertEqual(events, new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1));
  191. events.Clear();
  192. people[0] = p;
  193. AssertEqual(events,
  194. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1),
  195. new ListChangedEventArgs(ListChangedType.ItemAdded, 0, -1));
  196. }
  197. static void AssertEqual(List<ListChangedEventArgs> actual, params ListChangedEventArgs[] expected)
  198. {
  199. Assert.AreEqual(expected.Length, actual.Count);
  200. for (int i = 0; i < expected.Length; ++i)
  201. {
  202. Assert.AreEqual(expected[i].ListChangedType, actual[i].ListChangedType, "ListChangedEventArgs.ListChangedType");
  203. Assert.AreEqual(expected[i].NewIndex, actual[i].NewIndex, "ListChangedEventArgs.NewIndex");
  204. Assert.AreEqual(expected[i].OldIndex, actual[i].OldIndex, "ListChangedEventArgs.OldIndex");
  205. }
  206. }
  207. [Test]
  208. public void ListChanged_WithSource()
  209. {
  210. // When is ListChanged emitted?
  211. // It's not always when you think it would be.
  212. var people = new EntitySet<Person>();
  213. var events = new List<ListChangedEventArgs>();
  214. people.ListChanged += (o, e) => events.Add(e);
  215. // This is also true if Enumerable.Empty<Person>() is used here.
  216. people.SetSource(new[]{
  217. new Person { FirstName = "(", LastName = ")" },
  218. });
  219. AssertEqual(events);
  220. Assert.IsTrue(people.IsDeferred);
  221. // *Initial* Add()/AddRange() is ignored.
  222. people.Add(new Person { FirstName = "A", LastName = "B" });
  223. people.AddRange(new[]{
  224. new Person { FirstName = "1", LastName = "2" },
  225. new Person { FirstName = "<", LastName = ">" },
  226. });
  227. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  228. Assert.IsTrue(people.IsDeferred);
  229. AssertEqual(events);
  230. events.Clear();
  231. people.Clear();
  232. AssertEqual(events,
  233. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1),
  234. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1),
  235. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1),
  236. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1),
  237. new ListChangedEventArgs(ListChangedType.Reset, 0, -1));
  238. Assert.IsFalse(people.IsDeferred);
  239. // Add()/AddRange() after a Clear has events.
  240. events.Clear();
  241. people.Add(new Person { FirstName = "A", LastName = "B" });
  242. people.AddRange(new[]{
  243. new Person { FirstName = "1", LastName = "2" },
  244. new Person { FirstName = "<", LastName = ">" },
  245. });
  246. AssertEqual(events,
  247. new ListChangedEventArgs(ListChangedType.ItemAdded, 0, -1),
  248. new ListChangedEventArgs(ListChangedType.ItemAdded, 1, -1),
  249. new ListChangedEventArgs(ListChangedType.ItemAdded, 2, -1));
  250. events.Clear();
  251. var p = new Person { FirstName = "{", LastName = "}" };
  252. people.Insert(1, p);
  253. AssertEqual(events, new ListChangedEventArgs(ListChangedType.ItemAdded, 1, -1));
  254. events.Clear();
  255. Assert.IsTrue(people.Remove(p));
  256. AssertEqual(events, new ListChangedEventArgs(ListChangedType.ItemDeleted, 1, -1));
  257. events.Clear();
  258. people.RemoveAt(0);
  259. AssertEqual(events, new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1));
  260. events.Clear();
  261. people[0] = p;
  262. AssertEqual(events,
  263. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1),
  264. new ListChangedEventArgs(ListChangedType.ItemAdded, 0, -1));
  265. }
  266. [Test]
  267. public void Remove()
  268. {
  269. var people = new EntitySet<Person>();
  270. var events = new List<ListChangedEventArgs>();
  271. people.ListChanged += (o, e) => events.Add(e);
  272. people.SetSource(new[]{
  273. new Person { FirstName = "(", LastName = ")" },
  274. });
  275. Assert.IsTrue(people.IsDeferred);
  276. Assert.IsFalse(people.Remove(null));
  277. AssertEqual(events);
  278. events.Clear();
  279. Assert.IsTrue(people.IsDeferred);
  280. var p = people[0];
  281. Assert.IsTrue(people.Remove(p));
  282. Assert.IsFalse(people.IsDeferred);
  283. Assert.AreEqual(0, people.Count);
  284. AssertEqual(events,
  285. new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, -1));
  286. }
  287. [Test]
  288. public void SanityChecking()
  289. {
  290. var people = new EntitySet<Person>();
  291. bool changed = false;
  292. people.ListChanged += (o, e) => {
  293. changed = true;
  294. };
  295. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  296. Assert.AreEqual(0, people.Count);
  297. Assert.IsFalse(people.IsDeferred);
  298. people.Add(new Person { FirstName = "A", LastName = "B" });
  299. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  300. Assert.AreEqual(1, people.Count);
  301. Assert.IsFalse(people.IsDeferred);
  302. // WTF?!
  303. Assert.IsFalse(changed);
  304. changed = false;
  305. people.Add(new Person { FirstName = "1", LastName = "2" });
  306. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  307. Assert.AreEqual(2, people.Count);
  308. // WTF?!
  309. Assert.IsFalse(changed);
  310. changed = false;
  311. people.RemoveAt(0);
  312. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  313. Assert.AreEqual(1, people.Count);
  314. Assert.IsFalse(people.IsDeferred);
  315. Assert.IsTrue(changed);
  316. }
  317. [Test]
  318. public void SetSource_EntitySourceCanBeNull()
  319. {
  320. var entities = new EntitySet<Person>();
  321. entities.SetSource(null);
  322. }
  323. [Test]
  324. public void SetSource_HasLoadedOrAssignedValues_Is_False_Until_Enumeration()
  325. {
  326. var people = new EntitySet<Person>();
  327. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  328. people.SetSource(new[]{
  329. new Person { FirstName = "1", LastName = "2" }
  330. });
  331. Assert.IsTrue(people.IsDeferred);
  332. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  333. Assert.AreEqual(1, people.Count());
  334. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  335. Assert.IsFalse(people.IsDeferred);
  336. }
  337. [Test]
  338. public void SetSource_HasLoadedOrAssignedValues_Is_False_Until_Count()
  339. {
  340. var people = new EntitySet<Person>();
  341. people.SetSource(new[]{
  342. new Person { FirstName = "1", LastName = "2" }
  343. });
  344. Assert.IsTrue(people.IsDeferred);
  345. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  346. Assert.AreEqual(1, people.Count);
  347. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  348. Assert.IsFalse(people.IsDeferred);
  349. }
  350. [Test]
  351. public void SetSource_ThenAddIsFine()
  352. {
  353. var people = new EntitySet<Person>();
  354. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  355. people.SetSource(new[]{
  356. new Person { FirstName = "1", LastName = "2" }
  357. });
  358. Assert.IsTrue(people.IsDeferred);
  359. Assert.IsFalse(people.HasLoadedOrAssignedValues);
  360. people.Add(new Person { FirstName = "A", LastName = "B" });
  361. Assert.IsTrue(people.HasLoadedOrAssignedValues);
  362. Assert.IsTrue(people.IsDeferred);
  363. Assert.AreEqual(2, people.Count);
  364. }
  365. [Test]
  366. public void SetSource_ThenSetSourceIsValid()
  367. {
  368. var people = new EntitySet<Person>();
  369. people.SetSource(new[]{
  370. new Person { FirstName = "1", LastName = "2" }
  371. });
  372. Assert.IsTrue(people.IsDeferred);
  373. people.SetSource(new[]{
  374. new Person { FirstName = "A", LastName = "B" }
  375. });
  376. Assert.IsTrue(people.IsDeferred);
  377. }
  378. }
  379. }