/tests/com/google/appengine/datanucleus/jdo/JDOOneToManyListTest.java

http://datanucleus-appengine.googlecode.com/ · Java · 858 lines · 749 code · 83 blank · 26 comment · 12 complexity · 54cc8dac252467da9376eda2891dad0a MD5 · raw file 

    

  1. /**********************************************************************

    2. 

  2. Copyright (c) 2009 Google Inc.

    3. 

  3. 

    4. 

  4. Licensed under the Apache License, Version 2.0 (the "License");

    5. 

  5. you may not use this file except in compliance with the License.

    6. 

  6. You may obtain a copy of the License at

    7. 

  7. 

    8. 

  8. http://www.apache.org/licenses/LICENSE-2.0

    9. 

  9. 

    10. 

  10. Unless required by applicable law or agreed to in writing, software

    11. 

  11. distributed under the License is distributed on an "AS IS" BASIS,

    12. 

  12. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    13. 

  13. See the License for the specific language governing permissions and

    14. 

  14. limitations under the License.

    15. 

  15. **********************************************************************/

    16. 

  16. package com.google.appengine.datanucleus.jdo;

    17. 

  17. 

    18. 

  18. import com.google.appengine.api.datastore.Entity;

    19. 

  19. import com.google.appengine.api.datastore.EntityNotFoundException;

    20. 

  20. import com.google.appengine.api.datastore.KeyFactory;

    21. 

  21. import com.google.appengine.datanucleus.StorageVersion;

    22. 

  22. import com.google.appengine.datanucleus.TestUtils;

    23. 

  23. import com.google.appengine.datanucleus.Utils;

    24. 

  24. import com.google.appengine.datanucleus.test.jdo.BidirectionalChildJDO;

    25. 

  25. import com.google.appengine.datanucleus.test.jdo.BidirectionalChildListJDO;

    26. 

  26. import com.google.appengine.datanucleus.test.jdo.BidirectionalChildLongPkListJDO;

    27. 

  27. import com.google.appengine.datanucleus.test.jdo.BidirectionalChildStringPkListJDO;

    28. 

  28. import com.google.appengine.datanucleus.test.jdo.BidirectionalChildUnencodedStringPkListJDO;

    29. 

  29. import com.google.appengine.datanucleus.test.jdo.Flight;

    30. 

  30. import com.google.appengine.datanucleus.test.jdo.HasChildWithSeparateNameFieldJDO;

    31. 

  31. import com.google.appengine.datanucleus.test.jdo.HasEncodedStringPkSeparateNameFieldJDO;

    32. 

  32. import com.google.appengine.datanucleus.test.jdo.HasKeyPkJDO;

    33. 

  33. import com.google.appengine.datanucleus.test.jdo.HasLongPkOneToManyBidirChildrenJDO;

    34. 

  34. import com.google.appengine.datanucleus.test.jdo.HasMultipleBidirChildrenJDO;

    35. 

  35. import com.google.appengine.datanucleus.test.jdo.HasOneToManyChildAtMultipleLevelsJDO;

    36. 

  36. import com.google.appengine.datanucleus.test.jdo.HasOneToManyKeyPkListJDO;

    37. 

  37. import com.google.appengine.datanucleus.test.jdo.HasOneToManyListJDO;

    38. 

  38. import com.google.appengine.datanucleus.test.jdo.HasOneToManyListWithOrderByJDO;

    39. 

  39. import com.google.appengine.datanucleus.test.jdo.HasOneToManyLongPkListJDO;

    40. 

  40. import com.google.appengine.datanucleus.test.jdo.HasOneToManyStringPkListJDO;

    41. 

  41. import com.google.appengine.datanucleus.test.jdo.HasOneToManyUnencodedStringPkListJDO;

    42. 

  42. import com.google.appengine.datanucleus.test.jdo.HasUnencodedStringPkOneToManyBidirChildrenJDO;

    43. 

  43. import com.google.appengine.repackaged.com.google.common.collect.Lists;

    44. 

  44. 

    45. 

  45. import static com.google.appengine.datanucleus.TestUtils.assertKeyParentEquals;

    46. 

  46. 

    47. 

  47. import java.util.Collection;

    48. 

  48. 

    49. 

  49. /**

    50. 

  50.  * @author Max Ross <maxr@google.com>

    51. 

  51.  */

    52. 

  52. public class JDOOneToManyListTest extends JDOOneToManyTestCase {

    53. 

  53. 

    54. 

  54.   public void testInsertNewParentAndChild() throws EntityNotFoundException {

    55. 

  55.     testInsertNewParentAndChild(TXN_START_END);

    56. 

  56.   }

    57. 

  57.   public void testInsertNewParentAndChild_NoTxn() throws EntityNotFoundException {

    58. 

  58.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    59. 

  59.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    60. 

  60.     testInsertNewParentAndChild(NEW_PM_START_END);

    61. 

  61.   }

    62. 

  62.   private void testInsertNewParentAndChild(StartEnd startEnd) throws EntityNotFoundException {

    63. 

  63.     HasOneToManyListJDO parent = new HasOneToManyListJDO();

    64. 

  64.     BidirectionalChildListJDO bidirChild = new BidirectionalChildListJDO();

    65. 

  65.     testInsert_NewParentAndChild(parent, bidirChild, startEnd);

    66. 

  66.   }

    67. 

  67. 

    68. 

  68.   public void testInsertExistingParentNewChild() throws EntityNotFoundException {

    69. 

  69.     testInsertExistingParentNewChild(TXN_START_END);

    70. 

  70.   }

    71. 

  71.   public void testInsertExistingParentNewChild_NoTxn() throws EntityNotFoundException {

    72. 

  72.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    73. 

  73.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    74. 

  74.     testInsertExistingParentNewChild(NEW_PM_START_END);

    75. 

  75.   }

    76. 

  76.   private void testInsertExistingParentNewChild(StartEnd startEnd) throws EntityNotFoundException {

    77. 

  77.     HasOneToManyListJDO parent = new HasOneToManyListJDO();

    78. 

  78.     BidirectionalChildListJDO bidirChild = new BidirectionalChildListJDO();

    79. 

  79.     testInsert_ExistingParentNewChild(parent, bidirChild, startEnd);

    80. 

  80.   }

    81. 

  81. 

    82. 

  82.   public void testSwapAtPosition() throws EntityNotFoundException {

    83. 

  83.     testSwapAtPosition(TXN_START_END);

    84. 

  84.   }

    85. 

  85.   public void testSwapAtPosition_NoTxn() throws EntityNotFoundException {

    86. 

  86.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    87. 

  87.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    88. 

  88.     testSwapAtPosition(NEW_PM_START_END);

    89. 

  89.   }

    90. 

  90.   private void testSwapAtPosition(StartEnd startEnd) throws EntityNotFoundException {

    91. 

  91.     HasOneToManyListJDO parent = new HasOneToManyListJDO();

    92. 

  92.     BidirectionalChildListJDO bidirChild = new BidirectionalChildListJDO();

    93. 

  93.     BidirectionalChildListJDO bidirChild2 = new BidirectionalChildListJDO();

    94. 

  94.     testSwapAtPosition(parent, bidirChild, bidirChild2, startEnd);

    95. 

  95.   }

    96. 

  96. 

    97. 

  97.   public void testRemoveAtPosition() throws EntityNotFoundException {

    98. 

  98.     testRemoveAtPosition(TXN_START_END);

    99. 

  99.   }

    100. 

  100.   public void testRemoveAtPosition_NoTxn() throws EntityNotFoundException {

    101. 

  101.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    102. 

  102.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    103. 

  103.     testRemoveAtPosition(NEW_PM_START_END);

    104. 

  104.   }

    105. 

  105.   private void testRemoveAtPosition(StartEnd startEnd) throws EntityNotFoundException {

    106. 

  106.     HasOneToManyListJDO parent = new HasOneToManyListJDO();

    107. 

  107.     BidirectionalChildListJDO bidirChild = new BidirectionalChildListJDO();

    108. 

  108.     BidirectionalChildListJDO bidirChild2 = new BidirectionalChildListJDO();

    109. 

  109.     BidirectionalChildListJDO bidirChild3 = new BidirectionalChildListJDO();

    110. 

  110.     testRemoveAtPosition(parent, bidirChild, bidirChild2, bidirChild3, startEnd);

    111. 

  111.   }

    112. 

  112. 

    113. 

  113.   public void testAddAtPosition() throws EntityNotFoundException {

    114. 

  114.     testAddAtPosition(TXN_START_END);

    115. 

  115.   }

    116. 

  116.   public void testAddAtPosition_NoTxn() throws EntityNotFoundException {

    117. 

  117.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    118. 

  118.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    119. 

  119.     testAddAtPosition(NEW_PM_START_END);

    120. 

  120.   }

    121. 

  121.   private void testAddAtPosition(StartEnd startEnd) throws EntityNotFoundException {

    122. 

  122.     HasOneToManyListJDO parent = new HasOneToManyListJDO();

    123. 

  123.     BidirectionalChildListJDO bidirChild = new BidirectionalChildListJDO();

    124. 

  124.     BidirectionalChildListJDO bidirChild2 = new BidirectionalChildListJDO();

    125. 

  125.     testAddAtPosition(parent, bidirChild, bidirChild2, startEnd);

    126. 

  126.   }

    127. 

  127. 

    128. 

  128.   public void testUpdateUpdateChildWithMerge() throws EntityNotFoundException {

    129. 

  129.     testUpdateUpdateChildWithMerge(TXN_START_END);

    130. 

  130.   }

    131. 

  131.   public void testUpdateUpdateChildWithMerge_NoTxn() throws EntityNotFoundException {

    132. 

  132.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    133. 

  133.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    134. 

  134.     testUpdateUpdateChildWithMerge(NEW_PM_START_END);

    135. 

  135.   }

    136. 

  136.   private void testUpdateUpdateChildWithMerge(StartEnd startEnd) throws EntityNotFoundException {

    137. 

  137.     HasOneToManyListJDO pojo = new HasOneToManyListJDO();

    138. 

  138.     BidirectionalChildListJDO bidir = new BidirectionalChildListJDO();

    139. 

  139.     testUpdate_UpdateChildWithMerge(pojo, bidir, startEnd);

    140. 

  140.   }

    141. 

  141. 

    142. 

  142.   public void testUpdateUpdateChild() throws EntityNotFoundException {

    143. 

  143.     testUpdateUpdateChild(TXN_START_END);

    144. 

  144.   }

    145. 

  145.   public void testUpdateUpdateChild_NoTxn() throws EntityNotFoundException {

    146. 

  146.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    147. 

  147.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    148. 

  148.     testUpdateUpdateChild(NEW_PM_START_END);

    149. 

  149.   }

    150. 

  150.   private void testUpdateUpdateChild(StartEnd startEnd) throws EntityNotFoundException {

    151. 

  151.     HasOneToManyListJDO pojo = new HasOneToManyListJDO();

    152. 

  152.     BidirectionalChildListJDO bidir = new BidirectionalChildListJDO();

    153. 

  153.     testUpdate_UpdateChild(pojo, bidir, startEnd);

    154. 

  154.   }

    155. 

  155. 

    156. 

  156.   public void testUpdateNullOutChildren() throws EntityNotFoundException {

    157. 

  157.     testUpdateNullOutChildren(TXN_START_END);

    158. 

  158.   }

    159. 

  159.   public void testUpdateNullOutChildren_NoTxn() throws EntityNotFoundException {

    160. 

  160.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    161. 

  161.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    162. 

  162.     testUpdateNullOutChildren(NEW_PM_START_END);

    163. 

  163.   }

    164. 

  164.   private void testUpdateNullOutChildren(StartEnd startEnd) throws EntityNotFoundException {

    165. 

  165.     HasOneToManyListJDO pojo = new HasOneToManyListJDO();

    166. 

  166.     BidirectionalChildListJDO bidir = new BidirectionalChildListJDO();

    167. 

  167.     testUpdate_NullOutChildren(pojo, bidir, startEnd);

    168. 

  168.   }

    169. 

  169. 

    170. 

  170.   public void testUpdateClearOutChildren() throws EntityNotFoundException {

    171. 

  171.     testUpdateClearOutChildren(TXN_START_END);

    172. 

  172.   }

    173. 

  173.   public void testUpdateClearOutChildren_NoTxn() throws EntityNotFoundException {

    174. 

  174.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    175. 

  175.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    176. 

  176.     testUpdateClearOutChildren(NEW_PM_START_END);

    177. 

  177.   }

    178. 

  178.   private void testUpdateClearOutChildren(StartEnd startEnd) throws EntityNotFoundException {

    179. 

  179.     HasOneToManyListJDO pojo = new HasOneToManyListJDO();

    180. 

  180.     BidirectionalChildListJDO bidir = new BidirectionalChildListJDO();

    181. 

  181.     testUpdate_ClearOutChildren(pojo, bidir, startEnd);

    182. 

  182.   }

    183. 

  183. 

    184. 

  184.   public void testFindWithOrderBy() throws EntityNotFoundException {

    185. 

  185.     testFindWithOrderBy(TXN_START_END);

    186. 

  186.   }

    187. 

  187.   public void testFindWithOrderBy_NoTxn() throws EntityNotFoundException {

    188. 

  188.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    189. 

  189.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    190. 

  190.     testFindWithOrderBy(NEW_PM_START_END);

    191. 

  191.   }

    192. 

  192.   private void testFindWithOrderBy(StartEnd startEnd) throws EntityNotFoundException {

    193. 

  193.     testFindWithOrderBy(HasOneToManyListWithOrderByJDO.class, startEnd);

    194. 

  194.   }

    195. 

  195. 

    196. 

  196.   public void testSaveWithOrderBy() throws EntityNotFoundException {

    197. 

  197.     testSaveWithOrderBy(TXN_START_END);

    198. 

  198.   }

    199. 

  199.   public void testSaveWithOrderBy_NoTxn() throws EntityNotFoundException {

    200. 

  200.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    201. 

  201.     testSaveWithOrderBy(NEW_PM_START_END);

    202. 

  202.   }

    203. 

  203.   private void testSaveWithOrderBy(StartEnd startEnd) throws EntityNotFoundException {

    204. 

  204.     testSaveWithOrderBy(new HasOneToManyListWithOrderByJDO(), startEnd);

    205. 

  205.   }

    206. 

  206. 

    207. 

  207.   public void testFind() throws EntityNotFoundException {

    208. 

  208.     testFind(TXN_START_END);

    209. 

  209.   }

    210. 

  210.   public void testFind_NoTxn() throws EntityNotFoundException {

    211. 

  211.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    212. 

  212.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    213. 

  213.     testFind(NEW_PM_START_END);

    214. 

  214.   }

    215. 

  215.   private void testFind(StartEnd startEnd) throws EntityNotFoundException {

    216. 

  216.     testFind(HasOneToManyListJDO.class, BidirectionalChildListJDO.class, startEnd);

    217. 

  217.   }

    218. 

  218. 

    219. 

  219.   public void testQuery() throws EntityNotFoundException {

    220. 

  220.     testQuery(TXN_START_END);

    221. 

  221.   }

    222. 

  222.   public void testQuery_NoTxn() throws EntityNotFoundException {

    223. 

  223.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    224. 

  224.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    225. 

  225.     testQuery(NEW_PM_START_END);

    226. 

  226.   }

    227. 

  227.   private void testQuery(StartEnd startEnd) throws EntityNotFoundException {

    228. 

  228.     testQuery(HasOneToManyListJDO.class, BidirectionalChildListJDO.class, startEnd);

    229. 

  229.   }

    230. 

  230. 

    231. 

  231.   public void testChildFetchedLazily() throws Exception {

    232. 

  232.     testChildFetchedLazily(HasOneToManyListJDO.class, BidirectionalChildListJDO.class);

    233. 

  233.   }

    234. 

  234. 

    235. 

  235.   public void testDeleteParentDeletesChild() throws Exception {

    236. 

  236.     testDeleteParentDeletesChild(TXN_START_END);

    237. 

  237.   }

    238. 

  238.   public void testDeleteParentDeletesChild_NoTxn() throws Exception {

    239. 

  239.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    240. 

  240.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    241. 

  241.     testDeleteParentDeletesChild(NEW_PM_START_END);

    242. 

  242.   }

    243. 

  243.   private void testDeleteParentDeletesChild(StartEnd startEnd) throws Exception {

    244. 

  244.     testDeleteParentDeletesChild(HasOneToManyListJDO.class, BidirectionalChildListJDO.class, startEnd);

    245. 

  245.   }

    246. 

  246. 

    247. 

  247.   public void testIndexOf() throws Exception {

    248. 

  248.     testIndexOf(TXN_START_END);

    249. 

  249.   }

    250. 

  250.   public void testIndexOf_NoTxn() throws Exception {

    251. 

  251.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    252. 

  252.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    253. 

  253.     testIndexOf(NEW_PM_START_END);

    254. 

  254.   }

    255. 

  255.   public void testIndexOf(StartEnd startEnd) throws Exception {

    256. 

  256.     HasOneToManyListJDO pojo = new HasOneToManyListJDO();

    257. 

  257.     BidirectionalChildListJDO bidir1 = new BidirectionalChildListJDO();

    258. 

  258.     BidirectionalChildListJDO bidir2 = new BidirectionalChildListJDO();

    259. 

  259. 

    260. 

  260.     Flight f1 = newFlight();

    261. 

  261.     Flight f2 = newFlight();

    262. 

  262. 

    263. 

  263.     HasKeyPkJDO hasKeyPk1 = new HasKeyPkJDO();

    264. 

  264.     HasKeyPkJDO hasKeyPk2 = new HasKeyPkJDO();

    265. 

  265. 

    266. 

  266.     pojo.addBidirChild(bidir1);

    267. 

  267.     pojo.addBidirChild(bidir2);

    268. 

  268.     pojo.addFlight(f1);

    269. 

  269.     pojo.addFlight(f2);

    270. 

  270.     pojo.addHasKeyPk(hasKeyPk1);

    271. 

  271.     pojo.addHasKeyPk(hasKeyPk2);

    272. 

  272. 

    273. 

  273.     startEnd.start();

    274. 

  274.     pm.makePersistent(pojo);

    275. 

  275.     startEnd.end();

    276. 

  276. 

    277. 

  277.     startEnd.start();

    278. 

  278.     pojo = pm.getObjectById(HasOneToManyListJDO.class, pojo.getId());

    279. 

  279.     bidir1 = pm.getObjectById(bidir1.getClass(), bidir1.getId());

    280. 

  280.     bidir2 = pm.getObjectById(bidir2.getClass(), bidir2.getId());

    281. 

  281.     f1 = pm.getObjectById(f1.getClass(), f1.getId());

    282. 

  282.     f2 = pm.getObjectById(f2.getClass(), f2.getId());

    283. 

  283.     hasKeyPk1 = pm.getObjectById(hasKeyPk1.getClass(), hasKeyPk1.getKey());

    284. 

  284.     hasKeyPk2 = pm.getObjectById(hasKeyPk2.getClass(), hasKeyPk2.getKey());

    285. 

  285.     assertEquals(0, pojo.getBidirChildren().indexOf(bidir1));

    286. 

  286.     assertEquals(1, pojo.getBidirChildren().indexOf(bidir2));

    287. 

  287.     assertEquals(0, pojo.getFlights().indexOf(f1));

    288. 

  288.     assertEquals(1, pojo.getFlights().indexOf(f2));

    289. 

  289.     assertEquals(0, pojo.getHasKeyPks().indexOf(hasKeyPk1));

    290. 

  290.     assertEquals(1, pojo.getHasKeyPks().indexOf(hasKeyPk2));

    291. 

  291.     startEnd.end();

    292. 

  292.   }

    293. 

  293. 

    294. 

  294.   public void testRemoveAll() throws EntityNotFoundException {

    295. 

  295.     testRemoveAll(TXN_START_END);

    296. 

  296.   }

    297. 

  297.   public void testRemoveAll_NoTxn() throws EntityNotFoundException {

    298. 

  298.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    299. 

  299.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    300. 

  300.     testRemoveAll(NEW_PM_START_END);

    301. 

  301.   }

    302. 

  302.   private void testRemoveAll(StartEnd startEnd) throws EntityNotFoundException {

    303. 

  303.     testRemoveAll(new HasOneToManyListJDO(), new BidirectionalChildListJDO(),

    304. 

  304.                   new BidirectionalChildListJDO(), new BidirectionalChildListJDO(), startEnd);

    305. 

  305.   }

    306. 

  306. 

    307. 

  307.   public void testRemoveAll_LongPkOnParent() throws EntityNotFoundException {

    308. 

  308.     testRemoveAll_LongPkOnParent(TXN_START_END);

    309. 

  309.   }

    310. 

  310.   public void testRemoveAll_LongPkOnParent_NoTxn() throws EntityNotFoundException {

    311. 

  311.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    312. 

  312.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    313. 

  313.     testRemoveAll_LongPkOnParent(NEW_PM_START_END);

    314. 

  314.   }

    315. 

  315.   private void testRemoveAll_LongPkOnParent(StartEnd startEnd) throws EntityNotFoundException {

    316. 

  316.     testRemoveAll_LongPkOnParent(new HasOneToManyLongPkListJDO(), new BidirectionalChildLongPkListJDO(),

    317. 

  317.                   new BidirectionalChildLongPkListJDO(), new BidirectionalChildLongPkListJDO(),

    318. 

  318.                   startEnd);

    319. 

  319.   }

    320. 

  320. 

    321. 

  321.   public void testRemoveAll_UnencodedStringPkOnParent() throws EntityNotFoundException {

    322. 

  322.     testRemoveAll_UnencodedStringPkOnParent(TXN_START_END);

    323. 

  323.   }

    324. 

  324.   public void testRemoveAll_UnencodedStringPkOnParent_NoTxn() throws EntityNotFoundException {

    325. 

  325.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    326. 

  326.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    327. 

  327.     testRemoveAll_UnencodedStringPkOnParent(NEW_PM_START_END);

    328. 

  328.   }

    329. 

  329.   private void testRemoveAll_UnencodedStringPkOnParent(StartEnd startEnd) throws EntityNotFoundException {

    330. 

  330.     HasOneToManyUnencodedStringPkListJDO parent = new HasOneToManyUnencodedStringPkListJDO();

    331. 

  331.     parent.setId("parent id");

    332. 

  332.     testRemoveAll_UnencodedStringPkOnParent(parent, new BidirectionalChildUnencodedStringPkListJDO(),

    333. 

  333.                   new BidirectionalChildUnencodedStringPkListJDO(), new BidirectionalChildUnencodedStringPkListJDO(),

    334. 

  334.                   startEnd);

    335. 

  335.   }

    336. 

  336. 

    337. 

  337.   public void testChangeParent() {

    338. 

  338.     testChangeParent(TXN_START_END);

    339. 

  339.   }

    340. 

  340.   public void testChangeParent_NoTxn() {

    341. 

  341.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    342. 

  342.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    343. 

  343.     testChangeParent(NEW_PM_START_END);

    344. 

  344.   }

    345. 

  345.   private void testChangeParent(StartEnd startEnd) {

    346. 

  346.     testChangeParent(new HasOneToManyListJDO(), new HasOneToManyListJDO(), startEnd);

    347. 

  347.   }

    348. 

  348. 

    349. 

  349.   public void testNewParentNewChild_NamedKeyOnChild() throws EntityNotFoundException {

    350. 

  350.     testNewParentNewChild_NamedKeyOnChild(TXN_START_END);

    351. 

  351.   }

    352. 

  352.   public void testNewParentNewChild_NamedKeyOnChild_NoTxn() throws EntityNotFoundException {

    353. 

  353.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    354. 

  354.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    355. 

  355.     testNewParentNewChild_NamedKeyOnChild(NEW_PM_START_END);

    356. 

  356.   }

    357. 

  357.   private void testNewParentNewChild_NamedKeyOnChild(StartEnd startEnd) throws EntityNotFoundException {

    358. 

  358.     testNewParentNewChild_NamedKeyOnChild(new HasOneToManyListJDO(), startEnd);

    359. 

  359.   }

    360. 

  360. 

    361. 

  361.   public void testInsert_NewParentAndChild_LongPk() throws EntityNotFoundException {

    362. 

  362.     testInsert_NewParentAndChild_LongPk(TXN_START_END);

    363. 

  363.   }

    364. 

  364.   public void testInsert_NewParentAndChild_LongPk_NoTxn() throws EntityNotFoundException {

    365. 

  365.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    366. 

  366.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    367. 

  367.     testInsert_NewParentAndChild_LongPk(NEW_PM_START_END);

    368. 

  368.   }

    369. 

  369.   private void testInsert_NewParentAndChild_LongPk(StartEnd startEnd) throws EntityNotFoundException {

    370. 

  370.     BidirectionalChildLongPkListJDO bidirChild = new BidirectionalChildLongPkListJDO();

    371. 

  371.     bidirChild.setChildVal("yam");

    372. 

  372. 

    373. 

  373.     Flight f = newFlight();

    374. 

  374. 

    375. 

  375.     HasKeyPkJDO hasKeyPk = new HasKeyPkJDO();

    376. 

  376.     hasKeyPk.setStr("yag");

    377. 

  377. 

    378. 

  378.     HasOneToManyLongPkListJDO parent = new HasOneToManyLongPkListJDO();

    379. 

  379.     parent.addBidirChild(bidirChild);

    380. 

  380.     bidirChild.setParent(parent);

    381. 

  381.     parent.addFlight(f);

    382. 

  382.     parent.addHasKeyPk(hasKeyPk);

    383. 

  383.     parent.setVal("yar");

    384. 

  384. 

    385. 

  385.     startEnd.start();

    386. 

  386.     pm.makePersistent(parent);

    387. 

  387.     startEnd.end();

    388. 

  388. 

    389. 

  389.     assertNotNull(bidirChild.getId());

    390. 

  390.     assertNotNull(f.getId());

    391. 

  391.     assertNotNull(hasKeyPk.getKey());

    392. 

  392. 

    393. 

  393.     Entity bidirChildEntity = ds.get(KeyFactory.stringToKey(bidirChild.getId()));

    394. 

  394.     assertNotNull(bidirChildEntity);

    395. 

  395.     assertEquals("yam", bidirChildEntity.getProperty("childVal"));

    396. 

  396.     assertEquals(KeyFactory.stringToKey(bidirChild.getId()), bidirChildEntity.getKey());

    397. 

  397.     assertKeyParentEquals(parent.getClass(), parent.getId(), bidirChildEntity, bidirChild.getId());

    398. 

  398. 

    399. 

  399.     // TODO This is only for older storage versions; check owner relation List positions for current

    400. 

  400.     if (isIndexed() && 

    401. 

  401.         getStorageVersion(pm).ordinal() < StorageVersion.READ_OWNED_CHILD_KEYS_FROM_PARENTS.ordinal()) {

    402. 

  402.       assertEquals(0L, bidirChildEntity.getProperty("bidirChildren_INTEGER_IDX"));

    403. 

  403.     }

    404. 

  404. 

    405. 

  405.     Entity flightEntity = ds.get(KeyFactory.stringToKey(f.getId()));

    406. 

  406.     assertNotNull(flightEntity);

    407. 

  407.     assertEquals("bos", flightEntity.getProperty("origin"));

    408. 

  408.     assertEquals("mia", flightEntity.getProperty("dest"));

    409. 

  409.     assertEquals("jimmy", flightEntity.getProperty("name"));

    410. 

  410.     assertEquals(KeyFactory.stringToKey(f.getId()), flightEntity.getKey());

    411. 

  411.     assertKeyParentEquals(parent.getClass(), parent.getId(), flightEntity, f.getId());

    412. 

  412.     if (isIndexed() && 

    413. 

  413.         getStorageVersion(pm).ordinal() < StorageVersion.READ_OWNED_CHILD_KEYS_FROM_PARENTS.ordinal()) {

    414. 

  414.       assertEquals(0L, flightEntity.getProperty("flights_INTEGER_IDX_longpk"));

    415. 

  415.     }

    416. 

  416. 

    417. 

  417.     Entity hasKeyPkEntity = ds.get(hasKeyPk.getKey());

    418. 

  418.     assertNotNull(hasKeyPkEntity);

    419. 

  419.     assertEquals("yag", hasKeyPkEntity.getProperty("str"));

    420. 

  420.     assertEquals(hasKeyPk.getKey(), hasKeyPkEntity.getKey());

    421. 

  421.     assertKeyParentEquals(parent.getClass(), parent.getId(), hasKeyPkEntity, hasKeyPk.getKey());

    422. 

  422.     if (isIndexed() && 

    423. 

  423.         getStorageVersion(pm).ordinal() < StorageVersion.READ_OWNED_CHILD_KEYS_FROM_PARENTS.ordinal()) {

    424. 

  424.       assertEquals(0L, hasKeyPkEntity.getProperty("hasKeyPks_INTEGER_IDX_longpk"));

    425. 

  425.     }

    426. 

  426. 

    427. 

  427.     Entity parentEntity = ds.get(TestUtils.createKey(parent, parent.getId()));

    428. 

  428.     assertNotNull(parentEntity);

    429. 

  429.     assertEquals(4, parentEntity.getProperties().size());

    430. 

  430.     assertEquals("yar", parentEntity.getProperty("val"));

    431. 

  431.     assertEquals(Lists.newArrayList(bidirChildEntity.getKey()), parentEntity.getProperty("bidirChildren"));

    432. 

  432.     assertEquals(Lists.newArrayList(flightEntity.getKey()), parentEntity.getProperty("flights"));

    433. 

  433.     assertEquals(Lists.newArrayList(hasKeyPkEntity.getKey()), parentEntity.getProperty("hasKeyPks"));

    434. 

  434. 

    435. 

  435.     assertEquals(HasOneToManyLongPkListJDO.class.getName(), 1, countForClass(HasOneToManyLongPkListJDO.class));

    436. 

  436.     assertEquals(BidirectionalChildLongPkListJDO.class.getName(), 1, countForClass(

    437. 

  437.         BidirectionalChildLongPkListJDO.class));

    438. 

  438.     assertEquals(Flight.class.getName(), 1, countForClass(Flight.class));

    439. 

  439.     assertEquals(HasKeyPkJDO.class.getName(), 1, countForClass(HasKeyPkJDO.class));

    440. 

  440.   }

    441. 

  441. 

    442. 

  442.   public void testInsert_NewParentAndChild_StringPk() throws EntityNotFoundException {

    443. 

  443.     testInsert_NewParentAndChild_StringPk(TXN_START_END);

    444. 

  444.   }

    445. 

  445.   public void testInsert_NewParentAndChild_StringPk_NoTxn() throws EntityNotFoundException {

    446. 

  446.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    447. 

  447.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    448. 

  448.     testInsert_NewParentAndChild_StringPk(NEW_PM_START_END);

    449. 

  449.   }

    450. 

  450.   private void testInsert_NewParentAndChild_StringPk(StartEnd startEnd) throws EntityNotFoundException {

    451. 

  451.     BidirectionalChildStringPkListJDO bidirChild = new BidirectionalChildStringPkListJDO();

    452. 

  452.     bidirChild.setChildVal("yam");

    453. 

  453. 

    454. 

  454.     Flight f = newFlight();

    455. 

  455. 

    456. 

  456.     HasKeyPkJDO hasKeyPk = new HasKeyPkJDO();

    457. 

  457.     hasKeyPk.setStr("yag");

    458. 

  458. 

    459. 

  459.     HasOneToManyStringPkListJDO parent = new HasOneToManyStringPkListJDO();

    460. 

  460.     parent.setId("yar");

    461. 

  461.     parent.addBidirChild(bidirChild);

    462. 

  462.     bidirChild.setParent(parent);

    463. 

  463.     parent.addFlight(f);

    464. 

  464.     parent.addHasKeyPk(hasKeyPk);

    465. 

  465.     parent.setVal("yar");

    466. 

  466. 

    467. 

  467.     startEnd.start();

    468. 

  468.     pm.makePersistent(parent);

    469. 

  469.     startEnd.end();

    470. 

  470. 

    471. 

  471.     assertNotNull(bidirChild.getId());

    472. 

  472.     assertNotNull(f.getId());

    473. 

  473.     assertNotNull(hasKeyPk.getKey());

    474. 

  474. 

    475. 

  475.     Entity bidirChildEntity = ds.get(KeyFactory.stringToKey(bidirChild.getId()));

    476. 

  476.     assertNotNull(bidirChildEntity);

    477. 

  477.     assertEquals("yam", bidirChildEntity.getProperty("childVal"));

    478. 

  478.     assertEquals(KeyFactory.stringToKey(bidirChild.getId()), bidirChildEntity.getKey());

    479. 

  479.     assertKeyParentEquals(parent.getClass(), parent.getId(), bidirChildEntity, bidirChild.getId());

    480. 

  480. 

    481. 

  481.     // TODO This is only for older storage versions; check owner relation List positions for current

    482. 

  482.     if (isIndexed() && 

    483. 

  483.         getStorageVersion(pm).ordinal() < StorageVersion.READ_OWNED_CHILD_KEYS_FROM_PARENTS.ordinal()) {

    484. 

  484.       assertEquals(0L, bidirChildEntity.getProperty("bidirChildren_INTEGER_IDX"));

    485. 

  485.     }

    486. 

  486. 

    487. 

  487.     Entity flightEntity = ds.get(KeyFactory.stringToKey(f.getId()));

    488. 

  488.     assertNotNull(flightEntity);

    489. 

  489.     assertEquals("bos", flightEntity.getProperty("origin"));

    490. 

  490.     assertEquals("mia", flightEntity.getProperty("dest"));

    491. 

  491.     assertEquals("jimmy", flightEntity.getProperty("name"));

    492. 

  492.     assertEquals(KeyFactory.stringToKey(f.getId()), flightEntity.getKey());

    493. 

  493.     assertKeyParentEquals(parent.getClass(), parent.getId(), flightEntity, f.getId());

    494. 

  494.     if (isIndexed() && 

    495. 

  495.         getStorageVersion(pm).ordinal() < StorageVersion.READ_OWNED_CHILD_KEYS_FROM_PARENTS.ordinal()) {

    496. 

  496.       assertEquals(0L, flightEntity.getProperty("flights_INTEGER_IDX"));

    497. 

  497.     }

    498. 

  498. 

    499. 

  499.     Entity hasKeyPkEntity = ds.get(hasKeyPk.getKey());

    500. 

  500.     assertNotNull(hasKeyPkEntity);

    501. 

  501.     assertEquals("yag", hasKeyPkEntity.getProperty("str"));

    502. 

  502.     assertEquals(hasKeyPk.getKey(), hasKeyPkEntity.getKey());

    503. 

  503.     assertKeyParentEquals(parent.getClass(), parent.getId(), hasKeyPkEntity, hasKeyPk.getKey());

    504. 

  504.     if (isIndexed() && 

    505. 

  505.         getStorageVersion(pm).ordinal() < StorageVersion.READ_OWNED_CHILD_KEYS_FROM_PARENTS.ordinal()) {

    506. 

  506.       assertEquals(0L, hasKeyPkEntity.getProperty("hasKeyPks_INTEGER_IDX"));

    507. 

  507.     }

    508. 

  508. 

    509. 

  509.     Entity parentEntity = ds.get(TestUtils.createKey(parent, parent.getId()));

    510. 

  510.     assertNotNull(parentEntity);

    511. 

  511.     assertEquals(4, parentEntity.getProperties().size());

    512. 

  512.     assertEquals("yar", parentEntity.getProperty("val"));

    513. 

  513.     assertEquals(Lists.newArrayList(bidirChildEntity.getKey()), parentEntity.getProperty("bidirChildren"));

    514. 

  514.     assertEquals(Lists.newArrayList(flightEntity.getKey()), parentEntity.getProperty("flights"));

    515. 

  515.     assertEquals(Lists.newArrayList(hasKeyPkEntity.getKey()), parentEntity.getProperty("hasKeyPks"));

    516. 

  516. 

    517. 

  517.     assertEquals(HasOneToManyStringPkListJDO.class.getName(), 1, countForClass(

    518. 

  518.         HasOneToManyStringPkListJDO.class));

    519. 

  519.     assertEquals(BidirectionalChildStringPkListJDO.class.getName(), 1, countForClass(

    520. 

  520.         BidirectionalChildStringPkListJDO.class));

    521. 

  521.     assertEquals(Flight.class.getName(), 1, countForClass(Flight.class));

    522. 

  522.     assertEquals(HasKeyPkJDO.class.getName(), 1, countForClass(HasKeyPkJDO.class));

    523. 

  523.   }

    524. 

  524. 

    525. 

  525.   public void testAddAlreadyPersistedChildToParent_NoTxnSamePm() {

    526. 

  526.     testAddAlreadyPersistedChildToParent_NoTxnSamePm(new HasOneToManyListJDO());

    527. 

  527.   }

    528. 

  528. 

    529. 

  529.   public void testAddAlreadyPersistedChildToParent_NoTxnDifferentPm() {

    530. 

  530.     testAddAlreadyPersistedChildToParent_NoTxnDifferentPm(new HasOneToManyListJDO());

    531. 

  531.   }

    532. 

  532. 

    533. 

  533.   public void testLongPkOneToManyBidirChildren() {

    534. 

  534.     testLongPkOneToManyBidirChildren(TXN_START_END);

    535. 

  535.   }

    536. 

  536.   public void testLongPkOneToManyBidirChildren_NoTxn() {

    537. 

  537.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    538. 

  538.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    539. 

  539.     testLongPkOneToManyBidirChildren(NEW_PM_START_END);

    540. 

  540.   }

    541. 

  541.   private void testLongPkOneToManyBidirChildren(StartEnd startEnd) {

    542. 

  542.     HasLongPkOneToManyBidirChildrenJDO pojo = new HasLongPkOneToManyBidirChildrenJDO();

    543. 

  543.     HasLongPkOneToManyBidirChildrenJDO.ChildA

    544. 

  544.         a = new HasLongPkOneToManyBidirChildrenJDO.ChildA();

    545. 

  545.     pojo.setChildAList(Utils.newArrayList(a));

    546. 

  546.     startEnd.start();

    547. 

  547.     pm.makePersistent(pojo);

    548. 

  548.     startEnd.end();

    549. 

  549.     startEnd.start();

    550. 

  550.     pojo = pm.getObjectById(HasLongPkOneToManyBidirChildrenJDO.class, pojo.getId());

    551. 

  551.     assertEquals(1, pojo.getChildAList().size());

    552. 

  552.     assertEquals(pojo, pojo.getChildAList().get(0).getParent());

    553. 

  553.     startEnd.end();

    554. 

  554.   }

    555. 

  555. 

    556. 

  556.   public void testUnencodedStringPkOneToManyBidirChildren() {

    557. 

  557.     testUnencodedStringPkOneToManyBidirChildren(TXN_START_END);

    558. 

  558.   }

    559. 

  559.   public void testUnencodedStringPkOneToManyBidirChildren_NoTxn() {

    560. 

  560.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    561. 

  561.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    562. 

  562.     testUnencodedStringPkOneToManyBidirChildren(NEW_PM_START_END);

    563. 

  563.   }

    564. 

  564.   private void testUnencodedStringPkOneToManyBidirChildren(StartEnd startEnd) {

    565. 

  565.     HasUnencodedStringPkOneToManyBidirChildrenJDO pojo = new HasUnencodedStringPkOneToManyBidirChildrenJDO();

    566. 

  566.     pojo.setId("yar");

    567. 

  567.     HasUnencodedStringPkOneToManyBidirChildrenJDO.ChildA

    568. 

  568.         a = new HasUnencodedStringPkOneToManyBidirChildrenJDO.ChildA();

    569. 

  569.     pojo.setChildAList(Utils.newArrayList(a));

    570. 

  570.     startEnd.start();

    571. 

  571.     pm.makePersistent(pojo);

    572. 

  572.     startEnd.end();

    573. 

  573.     startEnd.start();

    574. 

  574.     pojo = pm.getObjectById(HasUnencodedStringPkOneToManyBidirChildrenJDO.class, pojo.getId());

    575. 

  575.     assertEquals(1, pojo.getChildAList().size());

    576. 

  576.     assertEquals(pojo, pojo.getChildAList().get(0).getParent());

    577. 

  577.     startEnd.end();

    578. 

  578.   }

    579. 

  579. 

    580. 

  580.   public void testFetchOfOneToManyParentWithKeyPk() {

    581. 

  581.     testFetchOfOneToManyParentWithKeyPk(TXN_START_END);

    582. 

  582.   }

    583. 

  583.   public void testFetchOfOneToManyParentWithKeyPk_NoTxn() {

    584. 

  584.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    585. 

  585.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    586. 

  586.     testFetchOfOneToManyParentWithKeyPk(NEW_PM_START_END);

    587. 

  587.   }

    588. 

  588.   private void testFetchOfOneToManyParentWithKeyPk(StartEnd startEnd) {

    589. 

  589.     testFetchOfOneToManyParentWithKeyPk(new HasOneToManyKeyPkListJDO(), startEnd);

    590. 

  590.   }

    591. 

  591. 

    592. 

  592.   public void testFetchOfOneToManyParentWithLongPk() {

    593. 

  593.     testFetchOfOneToManyParentWithLongPk(TXN_START_END);

    594. 

  594.   }

    595. 

  595.   public void testFetchOfOneToManyParentWithLongPk_NoTxn() {

    596. 

  596.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    597. 

  597.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    598. 

  598.     testFetchOfOneToManyParentWithLongPk(NEW_PM_START_END);

    599. 

  599.   }

    600. 

  600.   private void testFetchOfOneToManyParentWithLongPk(StartEnd startEnd) {

    601. 

  601.     testFetchOfOneToManyParentWithLongPk(new HasOneToManyLongPkListJDO(), startEnd);

    602. 

  602.   }

    603. 

  603. 

    604. 

  604.   public void testFetchOfOneToManyParentWithUnencodedStringPk() {

    605. 

  605.     testFetchOfOneToManyParentWithUnencodedStringPk(TXN_START_END);

    606. 

  606.   }

    607. 

  607.   public void testFetchOfOneToManyParentWithUnencodedStringPk_NoTxn() {

    608. 

  608.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    609. 

  609.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    610. 

  610.     testFetchOfOneToManyParentWithUnencodedStringPk(NEW_PM_START_END);

    611. 

  611.   }

    612. 

  612.   private void testFetchOfOneToManyParentWithUnencodedStringPk(StartEnd startEnd) {

    613. 

  613.     testFetchOfOneToManyParentWithUnencodedStringPk(

    614. 

  614.         new HasOneToManyUnencodedStringPkListJDO(), startEnd);

    615. 

  615.   }

    616. 

  616. 

    617. 

  617.   public void testAddChildToOneToManyParentWithLongPk() throws EntityNotFoundException {

    618. 

  618.     testAddChildToOneToManyParentWithLongPk(TXN_START_END);

    619. 

  619.   }

    620. 

  620.   public void testAddChildToOneToManyParentWithLongPk_NoTxn() throws EntityNotFoundException {

    621. 

  621.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    622. 

  622.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    623. 

  623.     testAddChildToOneToManyParentWithLongPk(NEW_PM_START_END);

    624. 

  624.   }

    625. 

  625.   private void testAddChildToOneToManyParentWithLongPk(StartEnd startEnd) throws EntityNotFoundException {

    626. 

  626.     testAddChildToOneToManyParentWithLongPk(

    627. 

  627.         new HasOneToManyLongPkListJDO(), new BidirectionalChildLongPkListJDO(), startEnd);

    628. 

  628.   }

    629. 

  629. 

    630. 

  630.   public void testAddChildToOneToManyParentWithUnencodedStringPk() throws EntityNotFoundException {

    631. 

  631.     testAddChildToOneToManyParentWithUnencodedStringPk(TXN_START_END);

    632. 

  632.   }

    633. 

  633.   public void testAddChildToOneToManyParentWithUnencodedStringPk_NoTxn() throws EntityNotFoundException {

    634. 

  634.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    635. 

  635.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    636. 

  636.     testAddChildToOneToManyParentWithUnencodedStringPk(NEW_PM_START_END);

    637. 

  637.   }

    638. 

  638.   private void testAddChildToOneToManyParentWithUnencodedStringPk(StartEnd startEnd) throws EntityNotFoundException {

    639. 

  639.     testAddChildToOneToManyParentWithUnencodedStringPk(

    640. 

  640.         new HasOneToManyUnencodedStringPkListJDO(), new BidirectionalChildUnencodedStringPkListJDO(),

    641. 

  641.         startEnd);

    642. 

  642.   }

    643. 

  643. 

    644. 

  644.   public void testOneToManyChildAtMultipleLevels() {

    645. 

  645.     testOneToManyChildAtMultipleLevels(TXN_START_END);

    646. 

  646.   }

    647. 

  647.   public void testOneToManyChildAtMultipleLevels_NoTxn() {

    648. 

  648.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    649. 

  649.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    650. 

  650.     testOneToManyChildAtMultipleLevels(NEW_PM_START_END);

    651. 

  651.   }

    652. 

  652.   public void testOneToManyChildAtMultipleLevels(StartEnd startEnd) {

    653. 

  653.     HasOneToManyChildAtMultipleLevelsJDO pojo = new HasOneToManyChildAtMultipleLevelsJDO();

    654. 

  654.     Flight f1 = new Flight();

    655. 

  655.     pojo.setFlights(Utils.newArrayList(f1));

    656. 

  656.     HasOneToManyChildAtMultipleLevelsJDO child = new HasOneToManyChildAtMultipleLevelsJDO();

    657. 

  657.     Flight f2 = new Flight();

    658. 

  658.     child.setFlights(Utils.newArrayList(f2));

    659. 

  659.     pojo.setChild(child);

    660. 

  660.     startEnd.start();

    661. 

  661.     pm.makePersistent(pojo);

    662. 

  662.     startEnd.end();

    663. 

  663.     startEnd.start();

    664. 

  664.     assertEquals(2, countForClass(Flight.class));

    665. 

  665.     pojo = pm.getObjectById(HasOneToManyChildAtMultipleLevelsJDO.class, pojo.getId());

    666. 

  666.     assertEquals(child.getId(), pojo.getChild().getId());

    667. 

  667.     assertEquals(1, pojo.getFlights().size());

    668. 

  668.     assertTrue(pojo.getFlights().get(0).customEquals(f1));

    669. 

  669.     assertTrue(child.getFlights().get(0).customEquals(f2));

    670. 

  670.     assertEquals(1, child.getFlights().size());

    671. 

  671.     startEnd.end();

    672. 

  672.   }

    673. 

  673. 

    674. 

  674.   public void testAddQueriedParentToBidirChild() throws EntityNotFoundException {

    675. 

  675.     testAddQueriedParentToBidirChild(TXN_START_END);

    676. 

  676.   }

    677. 

  677.   public void testAddQueriedParentToBidirChild_NoTxn() throws EntityNotFoundException {

    678. 

  678.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    679. 

  679.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    680. 

  680.     testAddQueriedParentToBidirChild(NEW_PM_START_END);

    681. 

  681.   }

    682. 

  682.   private void testAddQueriedParentToBidirChild(StartEnd startEnd) throws EntityNotFoundException {

    683. 

  683.     testAddQueriedParentToBidirChild(

    684. 

  684.         new HasOneToManyListJDO(), new BidirectionalChildListJDO(), startEnd);

    685. 

  685.   }

    686. 

  686. 

    687. 

  687.   public void testAddFetchedParentToBidirChild() throws EntityNotFoundException {

    688. 

  688.     testAddFetchedParentToBidirChild(TXN_START_END);

    689. 

  689.   }

    690. 

  690.   public void testAddFetchedParentToBidirChild_NoTxn() throws EntityNotFoundException {

    691. 

  691.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    692. 

  692.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    693. 

  693.     testAddFetchedParentToBidirChild(NEW_PM_START_END);

    694. 

  694.   }

    695. 

  695.   private void testAddFetchedParentToBidirChild(StartEnd startEnd) throws EntityNotFoundException {

    696. 

  696.     testAddFetchedParentToBidirChild(

    697. 

  697.         new HasOneToManyListJDO(), new BidirectionalChildListJDO(), startEnd);

    698. 

  698.   }

    699. 

  699. 

    700. 

  700.   public void testMultipleBidirChildren() {

    701. 

  701.     testMultipleBidirChildren(TXN_START_END);

    702. 

  702.   }

    703. 

  703.   public void testMultipleBidirChildren_NoTxn() {

    704. 

  704.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    705. 

  705.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    706. 

  706.     testMultipleBidirChildren(NEW_PM_START_END);

    707. 

  707.   }

    708. 

  708.   private void testMultipleBidirChildren(StartEnd startEnd) {

    709. 

  709.     HasMultipleBidirChildrenJDO pojo = new HasMultipleBidirChildrenJDO();

    710. 

  710. 

    711. 

  711.     HasMultipleBidirChildrenJDO.BidirChild1 c1 = new HasMultipleBidirChildrenJDO.BidirChild1();

    712. 

  712.     HasMultipleBidirChildrenJDO.BidirChild2 c2 = new HasMultipleBidirChildrenJDO.BidirChild2();

    713. 

  713. 

    714. 

  714.     pojo.getChild1().add(c1);

    715. 

  715.     pojo.getChild2().add(c2);

    716. 

  716. 

    717. 

  717.     startEnd.start();

    718. 

  718.     pm.makePersistent(pojo);

    719. 

  719.     startEnd.end();

    720. 

  720.     startEnd.start();

    721. 

  721.     pojo = pm.getObjectById(HasMultipleBidirChildrenJDO.class, pojo.getId());

    722. 

  722.     assertEquals(1, pojo.getChild1().size());

    723. 

  723.     assertEquals(1, pojo.getChild2().size());

    724. 

  724.     startEnd.end();

    725. 

  725.   }

    726. 

  726. 

    727. 

  727.   public void testReplaceBidirColl() {

    728. 

  728.     testReplaceBidirColl(TXN_START_END);

    729. 

  729.   }

    730. 

  730.   public void testReplaceBidirColl_NoTxn() {

    731. 

  731.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    732. 

  732.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    733. 

  733.     testReplaceBidirColl(NEW_PM_START_END);

    734. 

  734.   }

    735. 

  735.   private void testReplaceBidirColl(StartEnd startEnd) {

    736. 

  736.     Collection<BidirectionalChildJDO> childList = Utils.<BidirectionalChildJDO>newArrayList(

    737. 

  737.         new BidirectionalChildListJDO(), new BidirectionalChildListJDO());

    738. 

  738.     testReplaceBidirColl(

    739. 

  739.         new HasOneToManyListJDO(), new BidirectionalChildListJDO(), childList, startEnd);

    740. 

  740.   }

    741. 

  741. 

    742. 

  742.   public void testDeleteChildWithSeparateNameField() {

    743. 

  743.     testDeleteChildWithSeparateNameField(TXN_START_END);

    744. 

  744.   }

    745. 

  745.   public void testDeleteChildWithSeparateNameField_NoTxn() {

    746. 

  746.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    747. 

  747.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    748. 

  748.     testDeleteChildWithSeparateNameField(NEW_PM_START_END);

    749. 

  749.   }

    750. 

  750.   private void testDeleteChildWithSeparateNameField(StartEnd startEnd) {

    751. 

  751.     HasChildWithSeparateNameFieldJDO parent = new HasChildWithSeparateNameFieldJDO();

    752. 

  752.     HasEncodedStringPkSeparateNameFieldJDO child = new HasEncodedStringPkSeparateNameFieldJDO();

    753. 

  753.     child.setName("the name");

    754. 

  754.     parent.getChildren().add(child);

    755. 

  755.     startEnd.start();

    756. 

  756.     pm.makePersistent(parent);

    757. 

  757.     startEnd.end();

    758. 

  758.     startEnd.start();

    759. 

  759.     parent = pm.getObjectById(HasChildWithSeparateNameFieldJDO.class, parent.getId());

    760. 

  760.     pm.deletePersistent(parent);

    761. 

  761.     startEnd.end();

    762. 

  762.   }

    763. 

  763. 

    764. 

  764.   public void testOnlyOneParentPutOnParentAndChildUpdate() throws Throwable {

    765. 

  765.     testOnlyOneParentPutOnParentAndChildUpdate(TXN_START_END);

    766. 

  766.   }

    767. 

  767.   public void testOnlyOneParentPutOnParentAndChildUpdate_NoTxn() throws Throwable {

    768. 

  768.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    769. 

  769.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    770. 

  770.     testOnlyOneParentPutOnParentAndChildUpdate(NEW_PM_START_END);

    771. 

  771.   }

    772. 

  772.   private void testOnlyOneParentPutOnParentAndChildUpdate(StartEnd startEnd) throws Throwable {

    773. 

  773.     testOnlyOneParentPutOnParentAndChildUpdate(

    774. 

  774.         new HasOneToManyListJDO(), new BidirectionalChildListJDO(), startEnd);

    775. 

  775.   }

    776. 

  776. 

    777. 

  777.   public void testOnlyOnePutOnChildUpdate() throws Throwable {

    778. 

  778.     testOnlyOnePutOnChildUpdate(TXN_START_END);

    779. 

  779.   }

    780. 

  780.   public void testOnlyOnePutOnChildUpdate_NoTxn() throws Throwable {

    781. 

  781.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    782. 

  782.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    783. 

  783.     testOnlyOnePutOnChildUpdate(NEW_PM_START_END);

    784. 

  784.   }

    785. 

  785.   private void testOnlyOnePutOnChildUpdate(StartEnd startEnd) throws Throwable {

    786. 

  786.     testOnlyOnePutOnChildUpdate(

    787. 

  787.         new HasOneToManyListJDO(), new BidirectionalChildListJDO(), startEnd);

    788. 

  788.   }

    789. 

  789. 

    790. 

  790.   public void testOnlyOneParentPutOnChildDelete() throws Throwable {

    791. 

  791.     testOnlyOneParentPutOnChildDelete(TXN_START_END);

    792. 

  792.   }

    793. 

  793.   public void testOnlyOneParentPutOnChildDelete_NoTxn() throws Throwable {

    794. 

  794.     switchDatasource(PersistenceManagerFactoryName.nontransactional);

    795. 

  795.     getExecutionContext().setProperty(PROP_DETACH_ON_CLOSE, true);

    796. 

  796.     testOnlyOneParentPutOnChildDelete(NEW_PM_START_END);

    797. 

  797.   }

    798. 

  798.   private void testOnlyOneParentPutOnChildDelete(StartEnd startEnd) throws Throwable {

    799. 

  799.     testOnlyOneParentPutOnChildDelete(

    800. 

  800.         new HasOneToManyListJDO(), new BidirectionalChildListJDO(), startEnd);

    801. 

  801.   }

    802. 

  802. 

    803. 

  803.   public void testNonTxnAddOfChildToParentFailsPartwayThrough() throws Throwable {

    804. 

  804.     testNonTxnAddOfChildToParentFailsPartwayThrough(new HasOneToManyListJDO());

    805. 

  805.   }

    806. 

  806. 

    807. 

  807.   public void xtestRemove2ObjectsAtIndex() {

    808. 

  808.     testRemove2ObjectsAtIndex(TXN_START_END);

    809. 

  809.   }

    810. 

  810.   public void xtestRemove2ObjectsAtIndex_NoTxn() {

    811. 

  811.     testRemove2ObjectsAtIndex(NEW_PM_START_END);

    812. 

  812.   }

    813. 

  813.   private void testRemove2ObjectsAtIndex(StartEnd startEnd) {

    814. 

  814.     BidirectionalChildListJDO bidirChild1 = new BidirectionalChildListJDO();

    815. 

  815.     BidirectionalChildListJDO bidirChild2 = new BidirectionalChildListJDO();

    816. 

  816.     Flight f1 = newFlight();

    817. 

  817.     Flight f2 = newFlight();

    818. 

  818. 

    819. 

  819.     HasKeyPkJDO hasKeyPk1 = new HasKeyPkJDO();

    820. 

  820.     HasKeyPkJDO hasKeyPk2 = new HasKeyPkJDO();

    821. 

  821. 

    822. 

  822.     HasOneToManyListJDO parent = new HasOneToManyListJDO();

    823. 

  823.     parent.addBidirChild(bidirChild1);

    824. 

  824.     bidirChild1.setParent(parent);

    825. 

  825.     parent.addBidirChild(bidirChild2);

    826. 

  826.     bidirChild2.setParent(parent);

    827. 

  827.     parent.addFlight(f1);

    828. 

  828.     parent.addFlight(f2);

    829. 

  829.     parent.addHasKeyPk(hasKeyPk1);

    830. 

  830.     parent.addHasKeyPk(hasKeyPk2);

    831. 

  831. 

    832. 

  832.     startEnd.start();

    833. 

  833.     pm.makePersistent(parent);

    834. 

  834.     startEnd.end();

    835. 

  835. 

    836. 

  836.     startEnd.start();

    837. 

  837.     parent = pm.getObjectById(parent.getClass(), parent.getId());

    838. 

  838.     parent.getFlights().remove(0);

    839. 

  839.     parent.getFlights().remove(0);

    840. 

  840. //    parent.getBidirChildren().remove(0);

    841. 

  841. //    parent.getBidirChildren().remove(0);

    842. 

  842. //    parent.getHasKeyPks().remove(0);

    843. 

  843. //    parent.getHasKeyPks().remove(0);

    844. 

  844.     startEnd.end();

    845. 

  845. 

    846. 

  846.     startEnd.start();

    847. 

  847.     parent = pm.getObjectById(parent.getClass(), parent.getId());

    848. 

  848.     assertTrue(parent.getFlights().isEmpty());

    849. 

  849. //    assertTrue(parent.getBidirChildren().isEmpty());

    850. 

  850. //    assertTrue(parent.getHasKeyPks().isEmpty());

    851. 

  851.     startEnd.end();

    852. 

  852.   }

    853. 

  853. 

    854. 

  854.   @Override

    855. 

  855.   boolean isIndexed() {

    856. 

  856.     return true;

    857. 

  857.   }

    858. 

  858. }
    859.