jcs.org
git clone of logicmail with some fixes/features added
1/*-
2 * Copyright (c) 2010, Derek Konigsberg
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of the project nor the names of its
15 * contributors may be used to endorse or promote products derived
16 * from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
29 * OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31package org.logicprobe.LogicMail.model;
32
33import java.util.Calendar;
34
35import org.logicprobe.LogicMail.mail.FakeMessageToken;
36import org.logicprobe.LogicMail.mail.FolderTreeItem;
37import org.logicprobe.LogicMail.message.FolderMessage;
38import org.logicprobe.LogicMail.message.MessageEnvelope;
39
40import j2meunit.framework.Test;
41import j2meunit.framework.TestCase;
42import j2meunit.framework.TestMethod;
43import j2meunit.framework.TestSuite;
44
45public class FolderMessageCacheTest extends TestCase {
46 private FolderTreeItem folder1;
47 private FolderMessage message1a;
48 private FolderMessage message1b;
49 private FolderTreeItem folder2;
50 private FolderMessage message2a;
51 private FolderMessage message2b;
52
53 public FolderMessageCacheTest() {
54 }
55
56 public FolderMessageCacheTest(String testName, TestMethod testMethod) {
57 super(testName, testMethod);
58 }
59
60 protected void setUp() throws Exception {
61 FolderMessageCache instance = new TestFolderMessageCache();
62 instance.destroy();
63
64 folder1 = new FolderTreeItem("INBOX", "INBOX", ".");
65 message1a = new FolderMessage(new FakeMessageToken(1), createEnvelope(), 1, 11, -1);
66 message1b = new FolderMessage(new FakeMessageToken(2), createEnvelope(), 2, 12, -1);
67
68 folder2 = new FolderTreeItem("Misc", "INBOX.Misc", ".");
69 message2a = new FolderMessage(new FakeMessageToken(3), createEnvelope(), 1, 21, -1);
70 message2b = new FolderMessage(new FakeMessageToken(4), createEnvelope(), 2, 22, -1);
71 }
72
73 private static MessageEnvelope createEnvelope() {
74 MessageEnvelope envelope = new MessageEnvelope();
75 envelope.from = new String[] { "John Doe <jdoe@generic.org>" };
76 envelope.to = new String[] { "Jane Doe <jane.doe@generic.net>" };
77 envelope.replyTo = new String[0];
78 envelope.sender = new String[0];
79 envelope.subject = "The Subject";
80 envelope.date = Calendar.getInstance().getTime();
81 envelope.inReplyTo = "";
82 envelope.messageId = "<" + Long.toString(envelope.getUniqueId()) + "@generic.org>";
83 return envelope;
84 }
85
86 protected void tearDown() throws Exception {
87 folder1 = null;
88 message1a = null;
89 message1b = null;
90 folder2 = null;
91 message2a = null;
92 message2b = null;
93
94 FolderMessageCache instance = new TestFolderMessageCache();
95 instance.destroy();
96 }
97
98 public void testGetFolders() {
99 FolderMessageCache instance = new TestFolderMessageCache();
100 FolderTreeItem[] folders = instance.getFolders();
101 assertNotNull("Empty", folders);
102 assertEquals("Empty", 0, folders.length);
103
104 instance.addFolderMessage(folder1, message1a);
105 folders = instance.getFolders();
106 assertNotNull("One folder", folders);
107 assertEquals("One folder", 1, folders.length);
108 assertEquals("One folder", folder1, folders[0]);
109
110 instance.addFolderMessage(folder2, message2a);
111 folders = instance.getFolders();
112 assertNotNull("Two folders", folders);
113 assertEquals("Two folders", 2, folders.length);
114 assertContains("Two folders", folder1, folders);
115 assertContains("Two folders", folder2, folders);
116 }
117
118 public void testGetFoldersPersistence() {
119 FolderMessageCache instance = new TestFolderMessageCache();
120 instance.addFolderMessage(folder1, message1a);
121 instance.addFolderMessage(folder2, message2a);
122
123 instance.commit();
124 instance = null;
125
126 instance = new TestFolderMessageCache();
127 instance.restore();
128
129 FolderTreeItem[] folders = instance.getFolders();
130 assertNotNull("Two folders restored", folders);
131 assertEquals("Two folders restored", 2, folders.length);
132 assertContains("Two folders restored", folder1, folders);
133 assertContains("Two folders restored", folder2, folders);
134 }
135
136 public void testAddFolderMessage() {
137 FolderMessageCache instance = new TestFolderMessageCache();
138 FolderMessage[] messages = instance.getFolderMessages(folder1);
139 assertNotNull("Empty", messages);
140 assertEquals("Empty", 0, messages.length);
141
142 instance.addFolderMessage(folder1, message1a);
143 messages = instance.getFolderMessages(folder1);
144 assertNotNull("One message", messages);
145 assertEquals("One message", 1, messages.length);
146 assertEquals("One message", message1a, messages[0]);
147
148 instance.addFolderMessage(folder1, message1b);
149 messages = instance.getFolderMessages(folder1);
150 assertNotNull("Two messages", messages);
151 assertEquals("Two messages", 2, messages.length);
152 assertContains("Two messages", message1a, messages);
153 assertContains("Two messages", message1b, messages);
154
155 instance.addFolderMessage(folder2, message2a);
156 instance.addFolderMessage(folder2, message2b);
157
158 messages = instance.getFolderMessages(folder1);
159 assertNotNull("Two messages, two folders", messages);
160 assertEquals("Two messages, two folders", 2, messages.length);
161 assertContains("Two messages, two folders", message1a, messages);
162 assertContains("Two messages, two folders", message1b, messages);
163
164 messages = instance.getFolderMessages(folder2);
165 assertNotNull("Two messages, two folders", messages);
166 assertEquals("Two messages, two folders", 2, messages.length);
167 assertContains("Two messages, two folders", message2a, messages);
168 assertContains("Two messages, two folders", message2b, messages);
169 }
170
171 public void testAddFolderMessagePersistence() {
172 FolderMessageCache instance = new TestFolderMessageCache();
173 instance.addFolderMessage(folder1, message1a);
174 instance.addFolderMessage(folder1, message1b);
175 instance.addFolderMessage(folder2, message2a);
176 instance.addFolderMessage(folder2, message2b);
177
178 instance.commit();
179 instance = null;
180
181 instance = new TestFolderMessageCache();
182 instance.restore();
183
184 FolderMessage[] messages = instance.getFolderMessages(folder1);
185 assertNotNull("Two messages, two folders, restored", messages);
186 assertEquals("Two messages, two folders, restored", 2, messages.length);
187 assertContains("Two messages, two folders, restored", message1a, messages);
188 assertContains("Two messages, two folders, restored", message1b, messages);
189
190 messages = instance.getFolderMessages(folder2);
191 assertNotNull("Two messages, two folders, restored", messages);
192 assertEquals("Two messages, two folders, restored", 2, messages.length);
193 assertContains("Two messages, two folders, restored", message2a, messages);
194 assertContains("Two messages, two folders, restored", message2b, messages);
195 }
196
197 public void testRemoveFolderMessage() {
198 FolderMessageCache instance = new TestFolderMessageCache();
199 instance.addFolderMessage(folder1, message1a);
200 instance.addFolderMessage(folder1, message1b);
201 instance.addFolderMessage(folder2, message2a);
202 instance.addFolderMessage(folder2, message2b);
203
204 instance.removeFolderMessage(folder1, message1a);
205 FolderMessage[] messages = instance.getFolderMessages(folder1);
206 assertLacks("Remove one", message1a, messages);
207 assertContains("Remove one", message1b, messages);
208 messages = instance.getFolderMessages(folder2);
209 assertContains("Remove one", message2a, messages);
210 assertContains("Remove one", message2b, messages);
211
212 instance.removeFolderMessage(folder2, message2b);
213 messages = instance.getFolderMessages(folder1);
214 assertLacks("Remove two", message1a, messages);
215 assertContains("Remove two", message1b, messages);
216 messages = instance.getFolderMessages(folder2);
217 assertContains("Remove two", message2a, messages);
218 assertLacks("Remove two", message2b, messages);
219
220 instance.removeFolderMessage(folder1, message1b);
221 FolderTreeItem folders[] = instance.getFolders();
222 assertLacks("Remove whole folder", folder1, folders);
223 assertContains("Remove whole folder", folder2, folders);
224 }
225
226 public void testRemoveFolderMessagePersistence() {
227 FolderMessageCache instance = new TestFolderMessageCache();
228 instance.addFolderMessage(folder1, message1a);
229 instance.addFolderMessage(folder1, message1b);
230 instance.addFolderMessage(folder2, message2a);
231 instance.addFolderMessage(folder2, message2b);
232
233 instance.commit();
234 instance = new TestFolderMessageCache();
235 instance.restore();
236
237 instance.removeFolderMessage(folder1, message1a);
238
239 instance.commit();
240 instance = new TestFolderMessageCache();
241 instance.restore();
242
243 FolderMessage[] messages = instance.getFolderMessages(folder1);
244 assertLacks("Remove one, restored", message1a, messages);
245 assertContains("Remove one, restored", message1b, messages);
246 messages = instance.getFolderMessages(folder2);
247 assertContains("Remove one, restored", message2a, messages);
248 assertContains("Remove one, restored", message2b, messages);
249
250 instance.removeFolderMessage(folder1, message1b);
251
252 instance.commit();
253 instance = new TestFolderMessageCache();
254 instance.restore();
255
256 FolderTreeItem folders[] = instance.getFolders();
257 assertLacks("Remove whole folder, restored", folder1, folders);
258 assertContains("Remove whole folder, restored", folder2, folders);
259 }
260
261 public void testUpdateFolderMessage() {
262 FolderMessageCache instance = new TestFolderMessageCache();
263 instance.addFolderMessage(folder1, message1a);
264 instance.addFolderMessage(folder1, message1b);
265 instance.addFolderMessage(folder2, message2a);
266 instance.addFolderMessage(folder2, message2b);
267
268 FolderMessage updatedMessage1b = new FolderMessage(new FakeMessageToken(2), new MessageEnvelope(), 10, 12, -1);
269 updatedMessage1b.setFlagged(true);
270 instance.updateFolderMessage(folder1, updatedMessage1b);
271
272 FolderMessage[] messages = instance.getFolderMessages(folder1);
273 assertContains("Update one", message1a, messages);
274 assertContains("Update one", message1b, messages);
275 for(int i=0; i<messages.length; i++) {
276 if(messages[i] != null && messages[i].equals(message1b)) {
277 assertEquals("Update one", 10, messages[i].getIndex());
278 assertTrue("Update one", messages[i].isFlagged());
279 }
280 }
281 }
282
283 public void testUpdateFolderMessagePersistence() {
284 FolderMessageCache instance = new TestFolderMessageCache();
285 instance.addFolderMessage(folder1, message1a);
286 instance.addFolderMessage(folder1, message1b);
287 instance.addFolderMessage(folder2, message2a);
288 instance.addFolderMessage(folder2, message2b);
289
290 instance.commit();
291 instance = new TestFolderMessageCache();
292 instance.restore();
293
294 FolderMessage updatedMessage1b = new FolderMessage(new FakeMessageToken(2), new MessageEnvelope(), 10, 12, -1);
295 updatedMessage1b.setFlagged(true);
296 instance.updateFolderMessage(folder1, updatedMessage1b);
297
298 instance.commit();
299 instance = new TestFolderMessageCache();
300 instance.restore();
301
302 FolderMessage[] messages = instance.getFolderMessages(folder1);
303 assertContains("Update one, restored", message1a, messages);
304 assertContains("Update one, restored", message1b, messages);
305 for(int i=0; i<messages.length; i++) {
306 if(messages[i] != null && messages[i].equals(message1b)) {
307 assertEquals("Update one, restored", 10, messages[i].getIndex());
308 assertTrue("Update one, restored", messages[i].isFlagged());
309 }
310 }
311 }
312
313 public void testRemoveFolder() {
314 FolderMessageCache instance = new TestFolderMessageCache();
315 instance.addFolderMessage(folder1, message1a);
316 instance.addFolderMessage(folder1, message1b);
317 instance.addFolderMessage(folder2, message2a);
318 instance.addFolderMessage(folder2, message2b);
319
320 FolderTreeItem[] folders = instance.getFolders();
321 assertContains("Initial state", folder1, folders);
322 assertContains("Initial state", folder2, folders);
323
324 instance.removeFolder(folder1);
325 folders = instance.getFolders();
326 assertLacks("Remove one", folder1, folders);
327 assertContains("Remove one", folder2, folders);
328
329 instance.removeFolder(folder2);
330 folders = instance.getFolders();
331 assertLacks("Remove two", folder1, folders);
332 assertLacks("Remove two", folder2, folders);
333 }
334
335 public void testRemoveFolderPersistence() {
336 FolderMessageCache instance = new TestFolderMessageCache();
337 instance.addFolderMessage(folder1, message1a);
338 instance.addFolderMessage(folder1, message1b);
339 instance.addFolderMessage(folder2, message2a);
340 instance.addFolderMessage(folder2, message2b);
341
342 instance.commit();
343 instance = new TestFolderMessageCache();
344 instance.restore();
345
346 instance.removeFolder(folder1);
347 instance.commit();
348 instance = new TestFolderMessageCache();
349 instance.restore();
350
351 FolderTreeItem[] folders = instance.getFolders();
352 assertLacks("Remove one, restored", folder1, folders);
353 assertContains("Remove one, restored", folder2, folders);
354
355 instance.removeFolder(folder2);
356 instance.commit();
357 instance = new TestFolderMessageCache();
358 instance.restore();
359
360 folders = instance.getFolders();
361 assertLacks("Remove two, restored", folder1, folders);
362 assertLacks("Remove two, restored", folder2, folders);
363 }
364
365 public void assertContains(String message, Object expected, Object[] array) {
366 for(int i=0; i<array.length; i++) {
367 if(array[i] != null && array[i].equals(expected)) {
368 return;
369 }
370 }
371 fail(message);
372 }
373
374 public void assertLacks(String message, Object expected, Object[] array) {
375 for(int i=0; i<array.length; i++) {
376 if(array[i] != null && array[i].equals(expected)) {
377 fail(message);
378 }
379 }
380 }
381
382 public Test suite() {
383 TestSuite suite = new TestSuite("FolderMessageCache");
384
385 suite.addTest(new FolderMessageCacheTest("getFolders", new TestMethod()
386 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testGetFolders(); } }));
387 suite.addTest(new FolderMessageCacheTest("getFoldersPersistence", new TestMethod()
388 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testGetFoldersPersistence(); } }));
389 suite.addTest(new FolderMessageCacheTest("addFolderMessage", new TestMethod()
390 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testAddFolderMessage(); } }));
391 suite.addTest(new FolderMessageCacheTest("addFolderMessagePersistence", new TestMethod()
392 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testAddFolderMessagePersistence(); } }));
393 suite.addTest(new FolderMessageCacheTest("removeFolderMessage", new TestMethod()
394 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testRemoveFolderMessage(); } }));
395 suite.addTest(new FolderMessageCacheTest("removeFolderMessagePersistence", new TestMethod()
396 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testRemoveFolderMessagePersistence(); } }));
397 suite.addTest(new FolderMessageCacheTest("updateFolderMessage", new TestMethod()
398 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testUpdateFolderMessage(); } }));
399 suite.addTest(new FolderMessageCacheTest("updateFolderMessagePersistence", new TestMethod()
400 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testUpdateFolderMessagePersistence(); } }));
401 suite.addTest(new FolderMessageCacheTest("removeFolder", new TestMethod()
402 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testRemoveFolder(); } }));
403 suite.addTest(new FolderMessageCacheTest("removeFolderPersistence", new TestMethod()
404 { public void run(TestCase tc) {((FolderMessageCacheTest)tc).testRemoveFolderPersistence(); } }));
405
406 return suite;
407 }
408
409 private class TestFolderMessageCache extends FolderMessageCache {
410 public TestFolderMessageCache() {
411 //"org.logicprobe.LogicMail.model.TestFolderMessageCacheObject"
412 super(0x50eb4d81a1fe479bL);
413 }
414 }
415}