james-server-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From adup...@apache.org
Subject [05/13] james-project git commit: JAMES-1733 Remove generics from mailbox API
Date Tue, 17 May 2016 08:14:51 GMT
http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMailboxMapperTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMailboxMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMailboxMapperTest.java
index 50c2972..bd3884a 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMailboxMapperTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMailboxMapperTest.java
@@ -19,6 +19,11 @@
 
 package org.apache.james.mailbox.store.mail.model;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+import java.util.List;
+
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.exception.MailboxNotFoundException;
 import org.apache.james.mailbox.model.MailboxPath;
@@ -28,56 +33,51 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
 /**
  * Generic purpose tests for your implementation MailboxMapper.
  * 
  * You then just need to instantiate your mailbox mapper and an IdGenerator.
  */
-public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
+public abstract class AbstractMailboxMapperTest {
     
     private final static char DELIMITER = ':';
     private final static char WILDCARD = '%';
     private final static long UID_VALIDITY = 42;
 
-    private MapperProvider<Id> mapperProvider;
+    private MapperProvider mapperProvider;
     
-    private MailboxMapper<Id> mailboxMapper;
+    private MailboxMapper mailboxMapper;
 
     private MailboxPath benwaInboxPath;
-    private SimpleMailbox<Id> benwaInboxMailbox;
+    private SimpleMailbox benwaInboxMailbox;
     private MailboxPath benwaWorkPath;
-    private SimpleMailbox<Id> benwaWorkMailbox;
+    private SimpleMailbox benwaWorkMailbox;
     private MailboxPath benwaWorkTodoPath;
-    private SimpleMailbox<Id> benwaWorkTodoMailbox;
+    private SimpleMailbox benwaWorkTodoMailbox;
     private MailboxPath benwaPersoPath;
-    private SimpleMailbox<Id> benwaPersoMailbox;
+    private SimpleMailbox benwaPersoMailbox;
     private MailboxPath benwaWorkDonePath;
-    private SimpleMailbox<Id> benwaWorkDoneMailbox;
+    private SimpleMailbox benwaWorkDoneMailbox;
     private MailboxPath bobInboxPath;
-    private SimpleMailbox<Id> bobyMailbox;
+    private SimpleMailbox bobyMailbox;
     private MailboxPath bobyMailboxPath;
-    private SimpleMailbox<Id> bobInboxMailbox;
+    private SimpleMailbox bobInboxMailbox;
     private MailboxPath esnDevGroupInboxPath;
-    private SimpleMailbox<Id> esnDevGroupInboxMailbox;
+    private SimpleMailbox esnDevGroupInboxMailbox;
     private MailboxPath esnDevGroupHublinPath;
-    private SimpleMailbox<Id> esnDevGroupHublinMailbox;
+    private SimpleMailbox esnDevGroupHublinMailbox;
     private MailboxPath esnDevGroupJamesPath;
-    private SimpleMailbox<Id> esnDevGroupJamesMailbox;
+    private SimpleMailbox esnDevGroupJamesMailbox;
     private MailboxPath obmTeamGroupInboxPath;
-    private SimpleMailbox<Id> obmTeamGroupInboxMailbox;
+    private SimpleMailbox obmTeamGroupInboxMailbox;
     private MailboxPath obmTeamGroupOPushPath;
-    private SimpleMailbox<Id> obmTeamGroupOPushMailbox;
+    private SimpleMailbox obmTeamGroupOPushMailbox;
     private MailboxPath obmTeamGroupRoundCubePath;
-    private SimpleMailbox<Id> obmTeamGroupRoundCubeMailbox;
+    private SimpleMailbox obmTeamGroupRoundCubeMailbox;
     private MailboxPath bobDifferentNamespacePath;
-    private SimpleMailbox<Id> bobDifferentNamespaceMailbox;
+    private SimpleMailbox bobDifferentNamespaceMailbox;
 
-    public AbstractMailboxMapperTest(MapperProvider<Id> mapperProvider) {
+    public AbstractMailboxMapperTest(MapperProvider mapperProvider) {
         this.mapperProvider = mapperProvider;
 
         benwaInboxPath = new MailboxPath("#private", "benwa", "INBOX");
@@ -139,11 +139,10 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         MailboxAssert.assertThat(mailboxMapper.findMailboxByPath(esnDevGroupInboxPath)).isEqualTo(esnDevGroupInboxMailbox);
     }
     
-    @SuppressWarnings("unchecked")
     @Test
     public void listShouldRetrieveAllMailbox() throws MailboxException {
         saveAll();
-        List<Mailbox<Id>> mailboxes = mailboxMapper.list();
+        List<Mailbox> mailboxes = mailboxMapper.list();
         assertThat(mailboxes).contains(benwaInboxMailbox, benwaWorkMailbox, benwaWorkTodoMailbox, benwaPersoMailbox, benwaWorkDoneMailbox, bobInboxMailbox, esnDevGroupInboxMailbox, esnDevGroupHublinMailbox,
             esnDevGroupJamesMailbox, obmTeamGroupInboxMailbox, obmTeamGroupOPushMailbox, obmTeamGroupRoundCubeMailbox);
     }
@@ -178,7 +177,6 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         assertThat(mailboxMapper.hasChildren(bobInboxMailbox, '.')).isFalse();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void findMailboxWithPathLikeShouldBeLimitedToUserAndNamespace() throws MailboxException {
         saveAll();
@@ -208,7 +206,6 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         mailboxMapper.findMailboxByPath(esnDevGroupJamesPath);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void findMailboxWithPathLikeWithChildRegexShouldRetrieveChildren() throws MailboxException {
         saveAll();
@@ -216,7 +213,6 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         assertThat(mailboxMapper.findMailboxWithPathLike(regexPath)).containsOnly(benwaWorkMailbox, benwaWorkTodoMailbox, benwaWorkDoneMailbox);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void findMailboxWithPathLikeWithNullUserWithChildRegexShouldRetrieveChildren() throws MailboxException {
         saveAll();
@@ -224,7 +220,6 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         assertThat(mailboxMapper.findMailboxWithPathLike(regexPath)).contains(obmTeamGroupInboxMailbox, obmTeamGroupOPushMailbox, obmTeamGroupRoundCubeMailbox);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void findMailboxWithPathLikeWithRegexShouldRetrieveCorrespondingMailbox() throws MailboxException {
         saveAll();
@@ -232,7 +227,6 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         assertThat(mailboxMapper.findMailboxWithPathLike(regexPath)).containsOnly(benwaInboxMailbox);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void findMailboxWithPathLikeWithNullUserWithRegexShouldRetrieveCorrespondingMailbox() throws MailboxException {
         saveAll();
@@ -264,8 +258,8 @@ public abstract class AbstractMailboxMapperTest<Id extends MailboxId> {
         mailboxMapper.save(bobInboxMailbox);
     }
 
-    private SimpleMailbox<Id> createMailbox(MailboxPath mailboxPath) {
-        SimpleMailbox<Id> mailbox = new SimpleMailbox<Id>(mailboxPath, UID_VALIDITY);
+    private SimpleMailbox createMailbox(MailboxPath mailboxPath) {
+        SimpleMailbox mailbox = new SimpleMailbox(mailboxPath, UID_VALIDITY);
         mailbox.setMailboxId(mapperProvider.generateId());
         return mailbox;
     }

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMapperTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMapperTest.java
index 923c284..41d04d0 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMapperTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMapperTest.java
@@ -46,7 +46,7 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
+public abstract class AbstractMessageMapperTest {
 
     private final static char DELIMITER = ':';
     private static final int LIMIT = 10;
@@ -54,20 +54,20 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
     public static final int UID_VALIDITY = 42;
     public static final String USER_FLAG = "userFlag";
 
-    private MapperProvider<Id> mapperProvider;
-    private MessageMapper<Id> messageMapper;
+    private MapperProvider mapperProvider;
+    private MessageMapper messageMapper;
 
-    private SimpleMailbox<Id> benwaInboxMailbox;
-    private SimpleMailbox<Id> benwaWorkMailbox;
+    private SimpleMailbox benwaInboxMailbox;
+    private SimpleMailbox benwaWorkMailbox;
     
-    private SimpleMailboxMessage<Id> message1;
-    private SimpleMailboxMessage<Id> message2;
-    private SimpleMailboxMessage<Id> message3;
-    private SimpleMailboxMessage<Id> message4;
-    private SimpleMailboxMessage<Id> message5;
-    private SimpleMailboxMessage<Id> message6;
-
-    public AbstractMessageMapperTest(MapperProvider<Id> mapperProvider) {
+    private SimpleMailboxMessage message1;
+    private SimpleMailboxMessage message2;
+    private SimpleMailboxMessage message3;
+    private SimpleMailboxMessage message4;
+    private SimpleMailboxMessage message5;
+    private SimpleMailboxMessage message6;
+
+    public AbstractMessageMapperTest(MapperProvider mapperProvider) {
         this.mapperProvider = mapperProvider;
     }
 
@@ -148,7 +148,6 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), MessageMapper.FetchType.Metadata, LIMIT)).isEmpty();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void deletingUnExistingMessageShouldHaveNoSideEffect() throws MailboxException, IOException {
         saveMessages();
@@ -172,45 +171,40 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
             .isEqualTo(message1, fetchType);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void messagesCanBeRetrievedInMailboxWithRangeTypeRange() throws MailboxException, IOException{
         saveMessages();
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
                 .findInMailbox(benwaInboxMailbox, MessageRange.range(message1.getUid(), message4.getUid()), MessageMapper.FetchType.Full, LIMIT);
         assertThat(retrievedMessageIterator).containsOnly(message1, message2, message3, message4);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void messagesCanBeRetrievedInMailboxWithRangeTypeRangeContainingAHole() throws MailboxException, IOException {
         saveMessages();
         messageMapper.delete(benwaInboxMailbox, message3);
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
             .findInMailbox(benwaInboxMailbox, MessageRange.range(message1.getUid(), message4.getUid()), MessageMapper.FetchType.Full, LIMIT);
         assertThat(retrievedMessageIterator).containsOnly(message1, message2, message4);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void messagesCanBeRetrievedInMailboxWithRangeTypeFrom() throws MailboxException, IOException {
         saveMessages();
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
                 .findInMailbox(benwaInboxMailbox, MessageRange.from(message3.getUid()), MessageMapper.FetchType.Full, LIMIT);
         assertThat(retrievedMessageIterator).containsOnly(message3, message4, message5);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void messagesCanBeRetrievedInMailboxWithRangeTypeFromContainingAHole() throws MailboxException, IOException {
         saveMessages();
         messageMapper.delete(benwaInboxMailbox, message4);
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
                 .findInMailbox(benwaInboxMailbox, MessageRange.from(message3.getUid()), MessageMapper.FetchType.Full, LIMIT);
         assertThat(retrievedMessageIterator).containsOnly(message3, message5);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void messagesCanBeRetrievedInMailboxWithRangeTypeAll() throws MailboxException, IOException {
         saveMessages();
@@ -218,12 +212,11 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
             .containsOnly(message1, message2, message3, message4, message5);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void messagesCanBeRetrievedInMailboxWithRangeTypeAllContainingHole() throws MailboxException, IOException {
         saveMessages();
         messageMapper.delete(benwaInboxMailbox, message1);
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
                 .findInMailbox(benwaInboxMailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT);
         assertThat(retrievedMessageIterator).containsOnly(message2, message3, message4, message5);
     }
@@ -232,7 +225,7 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
     public void messagesRetrievedUsingFetchTypeMetadataShouldHaveAtLastMetadataDataLoaded() throws MailboxException, IOException{
         saveMessages();
         MessageMapper.FetchType fetchType = MessageMapper.FetchType.Metadata;
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
         MessageAssert.assertThat(retrievedMessageIterator.next()).isEqualTo(message1, fetchType);
         assertThat(retrievedMessageIterator).isEmpty();
     }
@@ -241,7 +234,7 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
     public void messagesRetrievedUsingFetchTypeHeaderShouldHaveHeaderDataLoaded() throws MailboxException, IOException{
         saveMessages();
         MessageMapper.FetchType fetchType = MessageMapper.FetchType.Headers;
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
         MessageAssert.assertThat(retrievedMessageIterator.next()).isEqualTo(message1, fetchType);
         assertThat(retrievedMessageIterator).isEmpty();
     }
@@ -250,7 +243,7 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
     public void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException{
         saveMessages();
         MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body;
-        Iterator<MailboxMessage<Id>> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
+        Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
         MessageAssert.assertThat(retrievedMessageIterator.next()).isEqualTo(message1, fetchType);
         assertThat(retrievedMessageIterator).isEmpty();
     }
@@ -301,7 +294,6 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         assertThat(messageMapper.expungeMarkedForDeletionInMailbox(benwaInboxMailbox, MessageRange.all())).isEmpty();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void expungeMarkedForDeletionInMailboxShouldReturnEmptyResultWhenNoMessageInMailboxIsDeleted() throws MailboxException, IOException {
         saveMessages();
@@ -318,7 +310,6 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
             .containsMetadataForMessages(message1, message4);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void expungeShouldModifyUnderlyingStorageWithRangeAll() throws MailboxException, IOException {
         saveMessages();
@@ -335,7 +326,6 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
             .containsMetadataForMessages(message1);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void expungeShouldModifyUnderlyingStorageWithRangeOne() throws MailboxException, IOException {
         saveMessages();
@@ -352,7 +342,6 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
             .containsMetadataForMessages(message4);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void expungeShouldModifyUnderlyingStorageWithRangeFrom() throws MailboxException, IOException {
         saveMessages();
@@ -369,7 +358,6 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
             .containsMetadataForMessages(message4);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void expungeShouldModifyUnderlyingStorageWithRange() throws MailboxException, IOException {
         saveMessages();
@@ -439,12 +427,12 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
     @Test
     public void copyShouldCreateAMessageInDestination() throws MailboxException, IOException {
         saveMessages();
-        MailboxMessage<Id> message7 = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6);
+        MailboxMessage message7 = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6);
         messageMapper.copy(benwaInboxMailbox, message7);
         message7.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
         assertThat(messageMapper.getLastUid(benwaInboxMailbox)).isGreaterThan(message6.getUid());
 
-        MailboxMessage<Id> result = messageMapper.findInMailbox(benwaInboxMailbox,
+        MailboxMessage result = messageMapper.findInMailbox(benwaInboxMailbox,
             MessageRange.one(messageMapper.getLastUid(benwaInboxMailbox)),
             MessageMapper.FetchType.Full,
             LIMIT)
@@ -565,9 +553,9 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         propBuilder.setProperty(StandardNames.NAMESPACE_RFC_2045, StandardNames.MIME_CONTENT_TRANSFER_ENCODING_NAME, "7bit");
         propBuilder.setProperty(StandardNames.MIME_CONTENT_TYPE_PARAMETER_SPACE, StandardNames.MIME_CONTENT_TYPE_PARAMETER_CHARSET_NAME, "US-ASCII");
 
-        SimpleMailboxMessage<Id> messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStored \n\nBody\n.\n", BODY_START, propBuilder);
+        SimpleMailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStored \n\nBody\n.\n", BODY_START, propBuilder);
         MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties);
-        MailboxMessage<Id> message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
+        MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
         assertThat(message.getProperties()).containsOnlyElementsOf(propBuilder.toProperties());
     }
 
@@ -577,17 +565,17 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         propBuilder.setProperty(StandardNames.MIME_CONTENT_LANGUAGE_SPACE, StandardNames.MIME_CONTENT_LANGUAGE_NAME, "us");
         propBuilder.setProperty(StandardNames.MIME_CONTENT_LANGUAGE_SPACE, StandardNames.MIME_CONTENT_LANGUAGE_NAME, "fr");
 
-        SimpleMailboxMessage<Id> messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
+        SimpleMailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
         MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties);
-        MailboxMessage<Id> message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
+        MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
         assertThat(message.getProperties()).containsOnlyElementsOf(propBuilder.toProperties());
     }
 
     @Test
     public void messagePropertiesShouldBeStoredWhenNoProperty() throws Exception {
-        SimpleMailboxMessage<Id> messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenNoProperty \n\nBody\n.\n", BODY_START, new PropertyBuilder());
+        SimpleMailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenNoProperty \n\nBody\n.\n", BODY_START, new PropertyBuilder());
         MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties);
-        MailboxMessage<Id> message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
+        MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
         assertThat(message.getProperties()).isEmpty();
     }
 
@@ -597,9 +585,9 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         PropertyBuilder propBuilder = new PropertyBuilder();
         propBuilder.setTextualLineCount(textualLineCount);
 
-        SimpleMailboxMessage<Id> messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
+        SimpleMailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
         MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties);
-        MailboxMessage<Id> message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
+        MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
         assertThat(message.getTextualLineCount()).isEqualTo(textualLineCount);
     }
 
@@ -609,9 +597,9 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         PropertyBuilder propBuilder = new PropertyBuilder();
         propBuilder.setMediaType(mediaType);
 
-        SimpleMailboxMessage<Id> messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
+        SimpleMailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
         MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties);
-        MailboxMessage<Id> message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
+        MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
         assertThat(message.getMediaType()).isEqualTo(mediaType);
     }
 
@@ -621,9 +609,9 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         PropertyBuilder propBuilder = new PropertyBuilder();
         propBuilder.setSubType(subType);
 
-        SimpleMailboxMessage<Id> messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
+        SimpleMailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, "Subject: messagePropertiesShouldBeStoredWhenDuplicateEntries \n\nBody\n.\n", BODY_START, propBuilder);
         MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties);
-        MailboxMessage<Id> message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
+        MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
         assertThat(message.getSubType()).isEqualTo(subType);
     }
 
@@ -644,7 +632,7 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
 
     @Test
     public void messagesShouldBeSavedWithTheirUserFlags() throws Exception {
-        MailboxMessage<Id> message = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message1);
+        MailboxMessage message = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message1);
         messageMapper.add(benwaInboxMailbox, message);
         MessageAssert.assertThat(retrieveMessageFromStorage(message)).hasFlags(new Flags(USER_FLAG));
     }
@@ -655,9 +643,9 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         return messageMapper.expungeMarkedForDeletionInMailbox(benwaInboxMailbox, range);
     }
 
-    private SimpleMailbox<Id> createMailbox(MailboxPath mailboxPath) {
-        SimpleMailbox<Id> mailbox = new SimpleMailbox<Id>(mailboxPath, UID_VALIDITY);
-        Id id = mapperProvider.generateId();
+    private SimpleMailbox createMailbox(MailboxPath mailboxPath) {
+        SimpleMailbox mailbox = new SimpleMailbox(mailboxPath, UID_VALIDITY);
+        MailboxId id = mapperProvider.generateId();
         mailbox.setMailboxId(id);
         return mailbox;
     }
@@ -677,11 +665,11 @@ public abstract class AbstractMessageMapperTest<Id extends MailboxId> {
         message6.setModSeq(messageMapper.getHighestModSeq(benwaWorkMailbox));
     }
 
-    private MailboxMessage<Id> retrieveMessageFromStorage(MailboxMessage<Id> message) throws MailboxException {
+    private MailboxMessage retrieveMessageFromStorage(MailboxMessage message) throws MailboxException {
         return messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message.getUid()), MessageMapper.FetchType.Metadata, LIMIT).next();
     }
     
-    private SimpleMailboxMessage<Id> createMessage(Mailbox<Id> mailbox, String content, int bodyStart, PropertyBuilder propertyBuilder) {
-        return new SimpleMailboxMessage<Id>(new Date(), content.length(), bodyStart, new SharedByteArrayInputStream(content.getBytes()), new Flags(), propertyBuilder, mailbox.getMailboxId());
+    private SimpleMailboxMessage createMessage(Mailbox mailbox, String content, int bodyStart, PropertyBuilder propertyBuilder) {
+        return new SimpleMailboxMessage(new Date(), content.length(), bodyStart, new SharedByteArrayInputStream(content.getBytes()), new Flags(), propertyBuilder, mailbox.getMailboxId());
     }
 }

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMoveTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMoveTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMoveTest.java
index 6a44f54..2089cdd 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMoveTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AbstractMessageMoveTest.java
@@ -39,22 +39,22 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-public abstract class AbstractMessageMoveTest<Id extends MailboxId> {
+public abstract class AbstractMessageMoveTest {
 
     private final static char DELIMITER = ':';
     private static final int LIMIT = 10;
     private static final int BODY_START = 16;
     public static final int UID_VALIDITY = 42;
 
-    private MapperProvider<Id> mapperProvider;
-    private MessageMapper<Id> messageMapper;
+    private MapperProvider mapperProvider;
+    private MessageMapper messageMapper;
 
-    private SimpleMailbox<Id> benwaInboxMailbox;
-    private SimpleMailbox<Id> benwaWorkMailbox;
+    private SimpleMailbox benwaInboxMailbox;
+    private SimpleMailbox benwaWorkMailbox;
 
-    private SimpleMailboxMessage<Id> message1;
+    private SimpleMailboxMessage message1;
 
-    public AbstractMessageMoveTest(MapperProvider<Id> mapperProvider) {
+    public AbstractMessageMoveTest(MapperProvider mapperProvider) {
         this.mapperProvider = mapperProvider;
     }
 
@@ -130,18 +130,18 @@ public abstract class AbstractMessageMoveTest<Id extends MailboxId> {
         assertThat(messageMapper.countUnseenMessagesInMailbox(benwaWorkMailbox)).isEqualTo(0);
     }
 
-    private SimpleMailbox<Id> createMailbox(MailboxPath mailboxPath) {
-        SimpleMailbox<Id> mailbox = new SimpleMailbox<Id>(mailboxPath, UID_VALIDITY);
-        Id id = mapperProvider.generateId();
+    private SimpleMailbox createMailbox(MailboxPath mailboxPath) {
+        SimpleMailbox mailbox = new SimpleMailbox(mailboxPath, UID_VALIDITY);
+        MailboxId id = mapperProvider.generateId();
         mailbox.setMailboxId(id);
         return mailbox;
     }
 
-    private MailboxMessage<Id> retrieveMessageFromStorage(Mailbox<Id> mailbox, MailboxMessage<Id> message) throws MailboxException {
+    private MailboxMessage retrieveMessageFromStorage(Mailbox mailbox, MailboxMessage message) throws MailboxException {
         return messageMapper.findInMailbox(mailbox, MessageRange.one(message.getUid()), FetchType.Metadata, LIMIT).next();
     }
     
-    private SimpleMailboxMessage<Id> createMessage(Mailbox<Id> mailbox, String content, int bodyStart, PropertyBuilder propertyBuilder) {
-        return new SimpleMailboxMessage<Id>(new Date(), content.length(), bodyStart, new SharedByteArrayInputStream(content.getBytes()), new Flags(), propertyBuilder, mailbox.getMailboxId());
+    private SimpleMailboxMessage createMessage(Mailbox mailbox, String content, int bodyStart, PropertyBuilder propertyBuilder) {
+        return new SimpleMailboxMessage(new Date(), content.length(), bodyStart, new SharedByteArrayInputStream(content.getBytes()), new Flags(), propertyBuilder, mailbox.getMailboxId());
     }
 }

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/DelegatingMailboxMessageTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/DelegatingMailboxMessageTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/DelegatingMailboxMessageTest.java
index 9832381..1fae5a9 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/DelegatingMailboxMessageTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/DelegatingMailboxMessageTest.java
@@ -19,10 +19,10 @@
 
 package org.apache.james.mailbox.store.mail.model;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import org.apache.james.mailbox.store.MessageBuilder;
-import org.apache.james.mailbox.store.TestId;
 import org.junit.Test;
 
 public class DelegatingMailboxMessageTest {
@@ -30,12 +30,12 @@ public class DelegatingMailboxMessageTest {
     @Test
     public void testShouldReturnPositiveWhenFirstGreaterThanSecond()
             throws Exception {
-        MailboxMessage<TestId> one = buildMessage(100);
-        MailboxMessage<TestId> two = buildMessage(99);
+        MailboxMessage one = buildMessage(100);
+        MailboxMessage two = buildMessage(99);
         assertTrue( one.compareTo(two) > 0);
     }
 
-    private MailboxMessage<TestId> buildMessage(int uid) throws Exception {
+    private MailboxMessage buildMessage(int uid) throws Exception {
         MessageBuilder builder = new MessageBuilder();
         builder.uid = uid;
         return builder.build();
@@ -44,15 +44,15 @@ public class DelegatingMailboxMessageTest {
     @Test
     public void testShouldReturnNegativeWhenFirstLessThanSecond()
             throws Exception {
-        MailboxMessage<TestId> one = buildMessage(98);
-        MailboxMessage<TestId> two = buildMessage(99);
+        MailboxMessage one = buildMessage(98);
+        MailboxMessage two = buildMessage(99);
         assertTrue( one.compareTo(two) < 0);
     }
 
     @Test
     public void testShouldReturnZeroWhenFirstEqualsSecond() throws Exception {
-        MailboxMessage<TestId> one = buildMessage(90);
-        MailboxMessage<TestId> two = buildMessage(90);
+        MailboxMessage one = buildMessage(90);
+        MailboxMessage two = buildMessage(90);
         assertEquals(0, one.compareTo(two));
     }
 }

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssert.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssert.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssert.java
index 6d90e82..5db8837 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssert.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssert.java
@@ -21,16 +21,16 @@ package org.apache.james.mailbox.store.mail.model;
 
 import org.assertj.core.api.AbstractAssert;
 
-public class MailboxAssert extends AbstractAssert<MailboxAssert, Mailbox<?>> {
-    public MailboxAssert(Mailbox<?> actual) {
+public class MailboxAssert extends AbstractAssert<MailboxAssert, Mailbox> {
+    public MailboxAssert(Mailbox actual) {
         super(actual, MailboxAssert.class);
     }
 
-    public static MailboxAssert assertThat(Mailbox<?> actual) {
+    public static MailboxAssert assertThat(Mailbox actual) {
         return new MailboxAssert(actual);
     }
 
-    public MailboxAssert isEqualTo(Mailbox<?> expected) {
+    public MailboxAssert isEqualTo(Mailbox expected) {
         isNotNull();
         if (!equals(actual.getMailboxId(), expected.getMailboxId())) {
             failWithMessage("Expected UUID to be <%s> but was <%s>", expected.getMailboxId(), actual.getMailboxId());

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssertTests.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssertTests.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssertTests.java
index 1abb6b8..ee19390 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssertTests.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxAssertTests.java
@@ -31,8 +31,8 @@ public class MailboxAssertTests {
 
     @Test
     public void isEqualToShouldNotFailWithEqualMailbox() {
-        SimpleMailbox<TestId> mailbox1 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
-        SimpleMailbox<TestId> mailbox2 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox1 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox2 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
         mailbox1.setMailboxId(MAILBOX_ID);
         mailbox2.setMailboxId(MAILBOX_ID);
         MailboxAssert.assertThat(mailbox1).isEqualTo(mailbox2);
@@ -40,8 +40,8 @@ public class MailboxAssertTests {
 
     @Test(expected = AssertionError.class)
     public void isEqualToShouldFailWithNotEqualNamespace() {
-        SimpleMailbox<TestId> mailbox1 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
-        SimpleMailbox<TestId> mailbox2 = new SimpleMailbox<TestId>(new MailboxPath("other_namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox1 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox2 = new SimpleMailbox(new MailboxPath("other_namespace", "user", "name"), UID_VALIDITY);
         mailbox1.setMailboxId(MAILBOX_ID);
         mailbox2.setMailboxId(MAILBOX_ID);
         MailboxAssert.assertThat(mailbox1).isEqualTo(mailbox2);
@@ -49,8 +49,8 @@ public class MailboxAssertTests {
 
     @Test(expected = AssertionError.class)
     public void isEqualToShouldFailWithNotEqualUser() {
-        SimpleMailbox<TestId> mailbox1 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
-        SimpleMailbox<TestId> mailbox2 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "other_user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox1 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox2 = new SimpleMailbox(new MailboxPath("namespace", "other_user", "name"), UID_VALIDITY);
         mailbox1.setMailboxId(MAILBOX_ID);
         mailbox2.setMailboxId(MAILBOX_ID);
         MailboxAssert.assertThat(mailbox1).isEqualTo(mailbox2);
@@ -58,8 +58,8 @@ public class MailboxAssertTests {
 
     @Test(expected = AssertionError.class)
     public void isEqualToShouldFailWithNotEqualName() {
-        SimpleMailbox<TestId> mailbox1 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
-        SimpleMailbox<TestId> mailbox2 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "other_name"), UID_VALIDITY);
+        SimpleMailbox mailbox1 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox2 = new SimpleMailbox(new MailboxPath("namespace", "user", "other_name"), UID_VALIDITY);
         mailbox1.setMailboxId(MAILBOX_ID);
         mailbox2.setMailboxId(MAILBOX_ID);
         MailboxAssert.assertThat(mailbox1).isEqualTo(mailbox2);
@@ -67,8 +67,8 @@ public class MailboxAssertTests {
 
     @Test(expected = AssertionError.class)
     public void isEqualToShouldFailWithNotEqualId() {
-        SimpleMailbox<TestId> mailbox1 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
-        SimpleMailbox<TestId> mailbox2 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox1 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox2 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
         mailbox1.setMailboxId(MAILBOX_ID);
         mailbox2.setMailboxId(TestId.of(MAILBOX_ID.id + 1));
         MailboxAssert.assertThat(mailbox1).isEqualTo(mailbox2);
@@ -76,8 +76,8 @@ public class MailboxAssertTests {
 
     @Test(expected = AssertionError.class)
     public void isEqualToShouldFailWithNotEqualUidValidity() {
-        SimpleMailbox<TestId> mailbox1 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
-        SimpleMailbox<TestId> mailbox2 = new SimpleMailbox<TestId>(new MailboxPath("namespace", "user", "name"), UID_VALIDITY + 1);
+        SimpleMailbox mailbox1 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY);
+        SimpleMailbox mailbox2 = new SimpleMailbox(new MailboxPath("namespace", "user", "name"), UID_VALIDITY + 1);
         mailbox1.setMailboxId(MAILBOX_ID);
         mailbox2.setMailboxId(MAILBOX_ID);
         MailboxAssert.assertThat(mailbox1).isEqualTo(mailbox2);

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMessageAssertTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMessageAssertTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMessageAssertTest.java
index 9e9598a..8626375 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMessageAssertTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMessageAssertTest.java
@@ -19,18 +19,18 @@
 
 package org.apache.james.mailbox.store.mail.model;
 
+import java.io.IOException;
+import java.util.Date;
+
+import javax.mail.Flags;
+import javax.mail.util.SharedByteArrayInputStream;
+
 import org.apache.james.mailbox.store.TestId;
 import org.apache.james.mailbox.store.mail.MessageMapper;
 import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
 import org.junit.Test;
 
-import javax.mail.Flags;
-import javax.mail.util.SharedByteArrayInputStream;
-
-import java.io.IOException;
-import java.util.Date;
-
 public class MailboxMessageAssertTest {
 
     public static final TestId MAILBOX_ID = TestId.of(42L);
@@ -41,10 +41,10 @@ public class MailboxMessageAssertTest {
         String headerString = "name: headerName\n\n";
         String bodyString = "body\n.\n";
         Date date = new Date();
-        SimpleMailboxMessage<TestId> message1 = new SimpleMailboxMessage<TestId>(date, headerString.length() + bodyString.length(),
+        SimpleMailboxMessage message1 = new SimpleMailboxMessage(date, headerString.length() + bodyString.length(),
             headerString.length(), new SharedByteArrayInputStream((headerString + bodyString).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message1.setUid(UID);
-        SimpleMailboxMessage<TestId> message2 = new SimpleMailboxMessage<TestId>(date, headerString.length() + bodyString.length(),
+        SimpleMailboxMessage message2 = new SimpleMailboxMessage(date, headerString.length() + bodyString.length(),
             headerString.length(), new SharedByteArrayInputStream((headerString + bodyString).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message2.setUid(UID);
         MessageAssert.assertThat(message1).isEqualTo(message2, MessageMapper.FetchType.Full);
@@ -55,11 +55,11 @@ public class MailboxMessageAssertTest {
         String headerString = "name: headerName\n\n";
         String bodyString = "body\n.\n";
         Date date = new Date();
-        SimpleMailboxMessage<TestId> message1 = new SimpleMailboxMessage<TestId>(date, headerString.length() + bodyString.length(),
+        SimpleMailboxMessage message1 = new SimpleMailboxMessage(date, headerString.length() + bodyString.length(),
             headerString.length(), new SharedByteArrayInputStream((headerString + bodyString).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message1.setUid(UID);
         bodyString = "work\n.\n";
-        SimpleMailboxMessage<TestId> message2 = new SimpleMailboxMessage<TestId>(date, headerString.length() + bodyString.length(),
+        SimpleMailboxMessage message2 = new SimpleMailboxMessage(date, headerString.length() + bodyString.length(),
             headerString.length(), new SharedByteArrayInputStream((headerString + bodyString).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message2.setUid(UID);
         MessageAssert.assertThat(message1).isEqualTo(message2, MessageMapper.FetchType.Headers);
@@ -70,11 +70,11 @@ public class MailboxMessageAssertTest {
         String headerString = "name: headerName\n\n";
         String bodyString = "body\n.\n";
         Date date = new Date();
-        SimpleMailboxMessage<TestId> message1 = new SimpleMailboxMessage<TestId>(date, headerString.length() + bodyString.length(),
+        SimpleMailboxMessage message1 = new SimpleMailboxMessage(date, headerString.length() + bodyString.length(),
             headerString.length(), new SharedByteArrayInputStream((headerString + bodyString).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message1.setUid(UID);
         bodyString = "work\n.\n";
-        SimpleMailboxMessage<TestId> message2 = new SimpleMailboxMessage<TestId>(date, headerString.length() + bodyString.length(),
+        SimpleMailboxMessage message2 = new SimpleMailboxMessage(date, headerString.length() + bodyString.length(),
             headerString.length(), new SharedByteArrayInputStream((headerString + bodyString).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message2.setUid(UID);
         MessageAssert.assertThat(message1).isEqualTo(message2, MessageMapper.FetchType.Body);

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MapperProvider.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MapperProvider.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MapperProvider.java
index ed09059..91b42a8 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MapperProvider.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MapperProvider.java
@@ -23,12 +23,12 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.store.mail.MailboxMapper;
 import org.apache.james.mailbox.store.mail.MessageMapper;
 
-public interface MapperProvider<Id extends MailboxId> {
-    MailboxMapper<Id> createMailboxMapper() throws MailboxException;
+public interface MapperProvider {
+    MailboxMapper createMailboxMapper() throws MailboxException;
 
-    MessageMapper<Id> createMessageMapper() throws MailboxException;
+    MessageMapper createMessageMapper() throws MailboxException;
 
-    Id generateId();
+    MailboxId generateId();
 
     void clearMapper() throws MailboxException;
 

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageAssert.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageAssert.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageAssert.java
index 1135763..f518ebe 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageAssert.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageAssert.java
@@ -19,26 +19,27 @@
 
 package org.apache.james.mailbox.store.mail.model;
 
+import java.io.IOException;
+
+import javax.mail.Flags;
+
 import org.apache.commons.io.IOUtils;
 import org.apache.james.mailbox.store.mail.MessageMapper;
 import org.assertj.core.api.AbstractAssert;
 
-import javax.mail.Flags;
-import java.io.IOException;
-
 import com.google.common.base.Objects;
 
-public class MessageAssert extends AbstractAssert<MessageAssert, MailboxMessage<?>> {
+public class MessageAssert extends AbstractAssert<MessageAssert, MailboxMessage> {
 
-    public MessageAssert(MailboxMessage<?> actual) {
+    public MessageAssert(MailboxMessage actual) {
         super(actual, MessageAssert.class);
     }
 
-    public static MessageAssert assertThat(MailboxMessage<?> actual) {
+    public static MessageAssert assertThat(MailboxMessage actual) {
         return new MessageAssert(actual);
     }
 
-    public MessageAssert isEqualToWithoutUid(MailboxMessage<?> expected, MessageMapper.FetchType usedFetchType) throws IOException {
+    public MessageAssert isEqualToWithoutUid(MailboxMessage expected, MessageMapper.FetchType usedFetchType) throws IOException {
         isNotNull();
         if (!Objects.equal(actual.getMailboxId(), expected.getMailboxId())) {
             failWithMessage("Expected Mailbox ID to be <%s> but was <%s>", expected.getMailboxId().toString(), actual.getMailboxId().toString());
@@ -76,7 +77,7 @@ public class MessageAssert extends AbstractAssert<MessageAssert, MailboxMessage<
         return this;
     }
 
-    public MessageAssert isEqualTo(MailboxMessage<?> expected, MessageMapper.FetchType usedFetchType) throws IOException {
+    public MessageAssert isEqualTo(MailboxMessage expected, MessageMapper.FetchType usedFetchType) throws IOException {
         isNotNull();
         if (!Objects.equal(actual.getUid(), expected.getUid())) {
             failWithMessage("Expected UID to be <%s> but was <%s>", expected.getUid(), actual.getUid());

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssert.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssert.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssert.java
index 141993a..fc1ba4f 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssert.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssert.java
@@ -19,11 +19,11 @@
 
 package org.apache.james.mailbox.store.mail.model;
 
+import java.util.Map;
+
 import org.apache.james.mailbox.model.MessageMetaData;
 import org.assertj.core.api.AbstractAssert;
 
-import java.util.Map;
-
 public class MetadataMapAssert extends AbstractAssert<MetadataMapAssert, Map<Long, MessageMetaData>> {
 
     public MetadataMapAssert(Map<Long, MessageMetaData> actual) {
@@ -41,7 +41,6 @@ public class MetadataMapAssert extends AbstractAssert<MetadataMapAssert, Map<Lon
         return this;
     }
 
-    @SuppressWarnings("rawtypes") 
     public MetadataMapAssert containsMetadataForMessages(MailboxMessage... messages) {
         for(MailboxMessage message : messages) {
             if (actual.get(message.getUid()).getUid() != message.getUid()) {

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssertTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssertTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssertTest.java
index a44dadc..23dcf9c 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssertTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MetadataMapAssertTest.java
@@ -19,6 +19,13 @@
 
 package org.apache.james.mailbox.store.mail.model;
 
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.mail.Flags;
+import javax.mail.util.SharedByteArrayInputStream;
+
 import org.apache.james.mailbox.model.MessageMetaData;
 import org.apache.james.mailbox.store.SimpleMessageMetaData;
 import org.apache.james.mailbox.store.TestId;
@@ -27,13 +34,6 @@ import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
 import org.junit.Before;
 import org.junit.Test;
 
-import javax.mail.Flags;
-import javax.mail.util.SharedByteArrayInputStream;
-
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-
 public class MetadataMapAssertTest {
 
     private static final Long UID = 18L;
@@ -43,11 +43,11 @@ public class MetadataMapAssertTest {
     private static final String BODY_STRING = "body\\n.\\n";
     private static final TestId MAILBOX_ID = TestId.of(12L);
 
-    private SimpleMailboxMessage<TestId> message1;
+    private SimpleMailboxMessage message1;
 
     @Before
     public void setUp() {
-        message1 = new SimpleMailboxMessage<TestId>(DATE, HEADER_STRING.length() + BODY_STRING.length(),
+        message1 = new SimpleMailboxMessage(DATE, HEADER_STRING.length() + BODY_STRING.length(),
             HEADER_STRING.length(), new SharedByteArrayInputStream((HEADER_STRING + BODY_STRING).getBytes()), new Flags(), new PropertyBuilder(), MAILBOX_ID);
         message1.setUid(UID);
         message1.setModSeq(MODSEQ);

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/impl/SimpleMailboxMessageTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/impl/SimpleMailboxMessageTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/impl/SimpleMailboxMessageTest.java
index 135dac4..1dea1d2 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/impl/SimpleMailboxMessageTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/impl/SimpleMailboxMessageTest.java
@@ -43,8 +43,8 @@ public class SimpleMailboxMessageTest {
     private static final String MESSAGE_CONTENT_SPECIAL_CHAR = "Simple message content with special characters: \"'(§è!çà$*`";
     public static final TestId TEST_ID = TestId.of(1L);
     public static final int BODY_START_OCTET = 0;
-    private SimpleMailboxMessage<TestId> MESSAGE;
-    private SimpleMailboxMessage<TestId> MESSAGE_SPECIAL_CHAR;
+    private SimpleMailboxMessage MESSAGE;
+    private SimpleMailboxMessage MESSAGE_SPECIAL_CHAR;
 
     @Before
     public void setUp() {
@@ -100,7 +100,7 @@ public class SimpleMailboxMessageTest {
         propertyBuilder.setTextualLineCount(textualLineCount);
         propertyBuilder.setMediaType(text);
         propertyBuilder.setSubType(plain);
-        SimpleMailboxMessage<TestId> original = new SimpleMailboxMessage<TestId>(new Date(),
+        SimpleMailboxMessage original = new SimpleMailboxMessage(new Date(),
             MESSAGE_CONTENT.length(),
             BODY_START_OCTET,
             new SharedByteArrayInputStream(MESSAGE_CONTENT.getBytes(MESSAGE_CHARSET)),
@@ -108,7 +108,7 @@ public class SimpleMailboxMessageTest {
             propertyBuilder,
             TEST_ID);
 
-        SimpleMailboxMessage<TestId> copy = SimpleMailboxMessage.copy(TestId.of(1337), original);
+        SimpleMailboxMessage copy = SimpleMailboxMessage.copy(TestId.of(1337), original);
 
         assertThat((Object)copy).isEqualToIgnoringGivenFields(original, "message", "mailboxId").isNotSameAs(original);
         assertThat(copy.getMessage()).usingComparator(new FieldByFieldComparator()).isEqualTo(original.getMessage());
@@ -118,8 +118,8 @@ public class SimpleMailboxMessageTest {
 
     }
 
-    private static SimpleMailboxMessage<TestId> buildMessage(String content) {
-        return new SimpleMailboxMessage<TestId>(Calendar.getInstance().getTime(),
+    private static SimpleMailboxMessage buildMessage(String content) {
+        return new SimpleMailboxMessage(Calendar.getInstance().getTime(),
             content.length(), BODY_START_OCTET, new SharedByteArrayInputStream(
                     content.getBytes(MESSAGE_CHARSET)), new Flags(),
             new PropertyBuilder(), TEST_ID);

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/DefaultQuotaRootResolverTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/DefaultQuotaRootResolverTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/DefaultQuotaRootResolverTest.java
index 8793e26..d9be76e 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/DefaultQuotaRootResolverTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/DefaultQuotaRootResolverTest.java
@@ -20,16 +20,15 @@
 package org.apache.james.mailbox.store.quota;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import com.google.common.collect.Lists;
+import java.util.List;
+
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.MailboxPath;
 import org.apache.james.mailbox.model.QuotaRoot;
 import org.apache.james.mailbox.store.MailboxSessionMapperFactory;
-import org.apache.james.mailbox.store.TestId;
 import org.apache.james.mailbox.store.mail.MailboxMapper;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;
 import org.junit.Before;
@@ -37,21 +36,20 @@ import org.junit.Test;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-import java.util.List;
+import com.google.common.collect.Lists;
 
 public class DefaultQuotaRootResolverTest {
 
     public static final MailboxPath MAILBOX_PATH = new MailboxPath("#private", "benwa", "INBOX");
-    public static final SimpleMailbox<TestId> MAILBOX = new SimpleMailbox<TestId>(MAILBOX_PATH, 10);
+    public static final SimpleMailbox MAILBOX = new SimpleMailbox(MAILBOX_PATH, 10);
     public static final MailboxPath PATH_LIKE = new MailboxPath("#private", "benwa", "%");
     public static final MailboxPath MAILBOX_PATH_2 = new MailboxPath("#private", "benwa", "test");
-    public static final SimpleMailbox<TestId> MAILBOX_2 = new SimpleMailbox<TestId>(MAILBOX_PATH_2, 10);
+    public static final SimpleMailbox MAILBOX_2 = new SimpleMailbox(MAILBOX_PATH_2, 10);
     public static final QuotaRoot QUOTA_ROOT = QuotaRootImpl.quotaRoot("#private&benwa");
 
     private DefaultQuotaRootResolver testee;
-    private MailboxSessionMapperFactory<TestId> mockedFactory;
+    private MailboxSessionMapperFactory mockedFactory;
 
-    @SuppressWarnings("unchecked")
     @Before
     public void setUp() {
         mockedFactory = mock(MailboxSessionMapperFactory.class);
@@ -73,19 +71,18 @@ public class DefaultQuotaRootResolverTest {
         testee.getQuotaRoot(new MailboxPath("#private", "ben&wa", "INBOX"));
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void retrieveAssociatedMailboxesShouldWork() throws Exception {
-        final MailboxMapper<TestId> mockedMapper = (MailboxMapper<TestId>) mock(MailboxMapper.class);
-        when(mockedFactory.getMailboxMapper(null)).thenAnswer(new Answer<MailboxMapper<TestId>>() {
+        final MailboxMapper mockedMapper = mock(MailboxMapper.class);
+        when(mockedFactory.getMailboxMapper(null)).thenAnswer(new Answer<MailboxMapper>() {
             @Override
-            public MailboxMapper<TestId> answer(InvocationOnMock invocationOnMock) throws Throwable {
+            public MailboxMapper answer(InvocationOnMock invocationOnMock) throws Throwable {
                 return mockedMapper;
             }
         });
-        when(mockedMapper.findMailboxWithPathLike(PATH_LIKE)).thenAnswer(new Answer<List<SimpleMailbox<TestId>>>() {
+        when(mockedMapper.findMailboxWithPathLike(PATH_LIKE)).thenAnswer(new Answer<List<SimpleMailbox>>() {
             @Override
-            public List<SimpleMailbox<TestId>> answer(InvocationOnMock invocationOnMock) throws Throwable {
+            public List<SimpleMailbox> answer(InvocationOnMock invocationOnMock) throws Throwable {
                 return Lists.newArrayList(MAILBOX, MAILBOX_2);
             }
         });

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
index a1bba5a..c1a03e3 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
@@ -20,7 +20,6 @@
 package org.apache.james.mailbox.store.quota;
 
 import static org.assertj.core.api.Assertions.assertThat;
-
 import static org.assertj.core.api.Assertions.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -32,7 +31,6 @@ import org.apache.james.mailbox.model.Quota;
 import org.apache.james.mailbox.model.QuotaRoot;
 import org.apache.james.mailbox.quota.QuotaManager;
 import org.apache.james.mailbox.quota.QuotaRootResolver;
-import org.apache.james.mailbox.store.TestId;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;
 import org.junit.Before;
 import org.junit.Test;
@@ -43,7 +41,7 @@ public class QuotaCheckerTest {
 
     public static final QuotaRoot QUOTA_ROOT = QuotaRootImpl.quotaRoot("benwa");
     public static final MailboxPath MAILBOX_PATH = new MailboxPath("#private", "benwa", "INBOX");
-    public static final SimpleMailbox<TestId> MAILBOX = new SimpleMailbox<TestId>(MAILBOX_PATH, 10);
+    public static final SimpleMailbox MAILBOX = new SimpleMailbox(MAILBOX_PATH, 10);
 
     private QuotaRootResolver mockedQuotaRootResolver;
     private QuotaManager mockedQuotaManager;
@@ -74,7 +72,7 @@ public class QuotaCheckerTest {
                 return QuotaImpl.quota(100, 1000);
             }
         });
-        QuotaChecker<TestId> quotaChecker = new QuotaChecker<TestId>(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
+        QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
         assertThat(quotaChecker.tryAddition(0, 0)).isTrue();
     }
 
@@ -98,7 +96,7 @@ public class QuotaCheckerTest {
                 return QuotaImpl.quota(100, 1000);
             }
         });
-        QuotaChecker<TestId> quotaChecker = new QuotaChecker<TestId>(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
+        QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
         assertThat(quotaChecker.tryAddition(89, 899)).isTrue();
     }
 
@@ -122,13 +120,13 @@ public class QuotaCheckerTest {
                 return QuotaImpl.quota(100, 1000);
             }
         });
-        QuotaChecker<TestId> quotaChecker = new QuotaChecker<TestId>(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
+        QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
         assertThat(quotaChecker.tryAddition(90, 900)).isTrue();
     }
 
     @Test(expected = OverQuotaException.class)
     public void quotaCheckerShouldThrowOnExceededMessages() throws MailboxException {
-        QuotaChecker<TestId> quotaChecker;
+        QuotaChecker quotaChecker;
         try {
             when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenAnswer(new Answer<QuotaRoot>() {
                 @Override
@@ -148,7 +146,7 @@ public class QuotaCheckerTest {
                     return QuotaImpl.quota(100, 1000);
                 }
             });
-            quotaChecker = new QuotaChecker<TestId>(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
+            quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
         } catch(Exception e) {
             fail("Exception caught : ", e);
             return;
@@ -158,7 +156,7 @@ public class QuotaCheckerTest {
 
     @Test(expected = OverQuotaException.class)
     public void quotaCheckerShouldThrowOnExceededStorage() throws MailboxException {
-        QuotaChecker<TestId> quotaChecker;
+        QuotaChecker quotaChecker;
         try {
             when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenAnswer(new Answer<QuotaRoot>() {
                 @Override
@@ -178,7 +176,7 @@ public class QuotaCheckerTest {
                     return QuotaImpl.quota(100, 1000);
                 }
             });
-            quotaChecker = new QuotaChecker<TestId>(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
+            quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
         } catch(Exception e) {
             fail("Exception caught : ", e);
             return;

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/tool/src/main/java/org/apache/james/mailbox/indexer/ReIndexerImpl.java
----------------------------------------------------------------------
diff --git a/mailbox/tool/src/main/java/org/apache/james/mailbox/indexer/ReIndexerImpl.java b/mailbox/tool/src/main/java/org/apache/james/mailbox/indexer/ReIndexerImpl.java
index 7efd7d5..6f650fa 100644
--- a/mailbox/tool/src/main/java/org/apache/james/mailbox/indexer/ReIndexerImpl.java
+++ b/mailbox/tool/src/main/java/org/apache/james/mailbox/indexer/ReIndexerImpl.java
@@ -19,8 +19,10 @@
 
 package org.apache.james.mailbox.indexer;
 
-import com.google.common.base.Optional;
-import com.google.common.collect.Iterables;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
 import org.apache.james.mailbox.MailboxManager;
 import org.apache.james.mailbox.MailboxSession;
 import org.apache.james.mailbox.exception.MailboxException;
@@ -34,15 +36,13 @@ import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.store.MailboxSessionMapperFactory;
 import org.apache.james.mailbox.store.mail.MessageMapper;
 import org.apache.james.mailbox.store.mail.model.Mailbox;
-import org.apache.james.mailbox.store.mail.model.MailboxId;
 import org.apache.james.mailbox.store.mail.model.MailboxMessage;
 import org.apache.james.mailbox.store.search.ListeningMessageSearchIndex;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
+import com.google.common.base.Optional;
+import com.google.common.collect.Iterables;
 
 /**
  * Note about live re-indexation handling :
@@ -56,18 +56,18 @@ import java.util.List;
  *  Why only care about updates and deletions ? Additions are already handled by the indexer that behaves normaly. We
  *  should just "adapt" our indexed value to the latest value, if any. The normal indexer will take care of new stuff.
  */
-public class ReIndexerImpl<Id extends MailboxId> implements ReIndexer {
+public class ReIndexerImpl implements ReIndexer {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ReIndexerImpl.class);
     public static final int NO_LIMIT = 0;
 
     private final MailboxManager mailboxManager;
-    private final ListeningMessageSearchIndex<Id> messageSearchIndex;
-    private final MailboxSessionMapperFactory<Id> mailboxSessionMapperFactory;
+    private final ListeningMessageSearchIndex messageSearchIndex;
+    private final MailboxSessionMapperFactory mailboxSessionMapperFactory;
 
     public ReIndexerImpl(MailboxManager mailboxManager,
-                         ListeningMessageSearchIndex<Id> messageSearchIndex,
-                         MailboxSessionMapperFactory<Id> mailboxSessionMapperFactory) {
+                         ListeningMessageSearchIndex messageSearchIndex,
+                         MailboxSessionMapperFactory mailboxSessionMapperFactory) {
         this.mailboxManager = mailboxManager;
         this.messageSearchIndex = messageSearchIndex;
         this.mailboxSessionMapperFactory = mailboxSessionMapperFactory;
@@ -96,7 +96,7 @@ public class ReIndexerImpl<Id extends MailboxId> implements ReIndexer {
     private void reIndex(MailboxPath path, MailboxSession mailboxSession) throws MailboxException {
         MailboxRegistration mailboxRegistration = new MailboxRegistration(path);
         LOGGER.info("Intend to reindex {}",path);
-        Mailbox<Id> mailbox = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession).findMailboxByPath(path);
+        Mailbox mailbox = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession).findMailboxByPath(path);
         messageSearchIndex.deleteAll(mailboxSession, mailbox);
         mailboxManager.addListener(path, mailboxRegistration, mailboxSession);
         try {
@@ -127,9 +127,9 @@ public class ReIndexerImpl<Id extends MailboxId> implements ReIndexer {
         }
     }
 
-    private void handleMailboxIndexingIterations(MailboxSession mailboxSession, MailboxRegistration mailboxRegistration, Mailbox<Id> mailbox, Iterator<MailboxMessage<Id>> iterator) throws MailboxException {
+    private void handleMailboxIndexingIterations(MailboxSession mailboxSession, MailboxRegistration mailboxRegistration, Mailbox mailbox, Iterator<MailboxMessage> iterator) throws MailboxException {
         while (iterator.hasNext()) {
-            MailboxMessage<Id> message = iterator.next();
+            MailboxMessage message = iterator.next();
             ImpactingMessageEvent impactingMessageEvent = findMostRelevant(mailboxRegistration.getImpactingEvents(message.getUid()));
             if (impactingMessageEvent == null) {
                 messageSearchIndex.add(mailboxSession, mailbox, message);

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/tool/src/test/java/org/apache/james/mailbox/copier/MailboxCopierTest.java
----------------------------------------------------------------------
diff --git a/mailbox/tool/src/test/java/org/apache/james/mailbox/copier/MailboxCopierTest.java b/mailbox/tool/src/test/java/org/apache/james/mailbox/copier/MailboxCopierTest.java
index 0b581dc..1737262 100644
--- a/mailbox/tool/src/test/java/org/apache/james/mailbox/copier/MailboxCopierTest.java
+++ b/mailbox/tool/src/test/java/org/apache/james/mailbox/copier/MailboxCopierTest.java
@@ -33,7 +33,6 @@ import org.apache.james.mailbox.acl.SimpleGroupMembershipResolver;
 import org.apache.james.mailbox.acl.UnionMailboxACLResolver;
 import org.apache.james.mailbox.exception.BadCredentialsException;
 import org.apache.james.mailbox.exception.MailboxException;
-import org.apache.james.mailbox.inmemory.InMemoryId;
 import org.apache.james.mailbox.inmemory.InMemoryMailboxSessionMapperFactory;
 import org.apache.james.mailbox.mock.MockMailboxManager;
 import org.apache.james.mailbox.model.MailboxPath;
@@ -101,10 +100,10 @@ public class MailboxCopierTest {
     @Test
     public void testMailboxCopy() throws MailboxException, IOException {
     	 if (srcMemMailboxManager instanceof StoreMailboxManager) {
-             ((StoreMailboxManager<?>) srcMemMailboxManager).init();
+             ((StoreMailboxManager) srcMemMailboxManager).init();
          }
          if (dstMemMailboxManager instanceof StoreMailboxManager) {
-             ((StoreMailboxManager<?>) dstMemMailboxManager).init();
+             ((StoreMailboxManager) dstMemMailboxManager).init();
          }
     
         srcMemMailboxManager = new MockMailboxManager(srcMemMailboxManager).getMockMailboxManager();
@@ -156,7 +155,7 @@ public class MailboxCopierTest {
         MailboxACLResolver aclResolver = new UnionMailboxACLResolver();
         GroupMembershipResolver groupMembershipResolver = new SimpleGroupMembershipResolver();
 
-        return new StoreMailboxManager<InMemoryId>(
+        return new StoreMailboxManager(
             new InMemoryMailboxSessionMapperFactory(), 
             new Authenticator() {
                 public boolean isAuthentic(String userid, CharSequence passwd) {

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/ReIndexerImplTest.java
----------------------------------------------------------------------
diff --git a/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/ReIndexerImplTest.java b/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/ReIndexerImplTest.java
index 6e09361..45ba909 100644
--- a/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/ReIndexerImplTest.java
+++ b/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/ReIndexerImplTest.java
@@ -26,6 +26,8 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
+import java.util.Iterator;
+
 import org.apache.james.mailbox.MailboxListener;
 import org.apache.james.mailbox.MailboxManager;
 import org.apache.james.mailbox.MailboxSession;
@@ -34,7 +36,6 @@ import org.apache.james.mailbox.model.MailboxPath;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.store.MailboxSessionMapperFactory;
 import org.apache.james.mailbox.store.MessageBuilder;
-import org.apache.james.mailbox.store.TestId;
 import org.apache.james.mailbox.store.mail.MailboxMapper;
 import org.apache.james.mailbox.store.mail.MessageMapper;
 import org.apache.james.mailbox.store.mail.model.Mailbox;
@@ -48,28 +49,24 @@ import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.slf4j.Logger;
 
-import java.util.Iterator;
-
 public class ReIndexerImplTest {
 
     public static final MailboxPath INBOX = new MailboxPath("#private", "benwa@apache.org", "INBOX");
     public static final int LIMIT = 0;
     private MailboxManager mailboxManager;
-    private MailboxSessionMapperFactory<TestId> mailboxSessionMapperFactory;
-    private ListeningMessageSearchIndex<TestId> messageSearchIndex;
+    private MailboxSessionMapperFactory mailboxSessionMapperFactory;
+    private ListeningMessageSearchIndex messageSearchIndex;
 
     private ReIndexer reIndexer;
 
-    @SuppressWarnings("unchecked")
     @Before
     public void setUp() {
         mailboxManager = mock(MailboxManager.class);
         mailboxSessionMapperFactory = mock(MailboxSessionMapperFactory.class);
         messageSearchIndex = mock(ListeningMessageSearchIndex.class);
-        reIndexer = new ReIndexerImpl<TestId>(mailboxManager, messageSearchIndex, mailboxSessionMapperFactory);
+        reIndexer = new ReIndexerImpl(mailboxManager, messageSearchIndex, mailboxSessionMapperFactory);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void test() throws Exception {
         final MockMailboxSession mockMailboxSession = new MockMailboxSession("re-indexing");
@@ -79,32 +76,32 @@ public class ReIndexerImplTest {
                 return mockMailboxSession;
             }
         });
-        final MessageMapper<TestId> messageMapper = mock(MessageMapper.class);
-        final MailboxMapper<TestId> mailboxMapper = mock(MailboxMapper.class);
-        when(mailboxSessionMapperFactory.getMessageMapper(any(MailboxSession.class))).thenAnswer(new Answer<MessageMapper<TestId>>() {
+        final MessageMapper messageMapper = mock(MessageMapper.class);
+        final MailboxMapper mailboxMapper = mock(MailboxMapper.class);
+        when(mailboxSessionMapperFactory.getMessageMapper(any(MailboxSession.class))).thenAnswer(new Answer<MessageMapper>() {
             @Override
-            public MessageMapper<TestId> answer(InvocationOnMock invocationOnMock) throws Throwable {
+            public MessageMapper answer(InvocationOnMock invocationOnMock) throws Throwable {
                 return messageMapper;
             }
         });
-        when(mailboxSessionMapperFactory.getMailboxMapper(any(MailboxSession.class))).thenAnswer(new Answer<MailboxMapper<TestId>>() {
+        when(mailboxSessionMapperFactory.getMailboxMapper(any(MailboxSession.class))).thenAnswer(new Answer<MailboxMapper>() {
             @Override
-            public MailboxMapper<TestId> answer(InvocationOnMock invocationOnMock) throws Throwable {
+            public MailboxMapper answer(InvocationOnMock invocationOnMock) throws Throwable {
                 return mailboxMapper;
             }
         });
-        final MailboxMessage<TestId> message = new MessageBuilder().build();
-        final SimpleMailbox<TestId> mailbox = new SimpleMailbox<TestId>(INBOX, 42);
+        final MailboxMessage message = new MessageBuilder().build();
+        final SimpleMailbox mailbox = new SimpleMailbox(INBOX, 42);
         mailbox.setMailboxId(message.getMailboxId());
-        when(mailboxMapper.findMailboxByPath(INBOX)).thenAnswer(new Answer<Mailbox<TestId>>() {
+        when(mailboxMapper.findMailboxByPath(INBOX)).thenAnswer(new Answer<Mailbox>() {
             @Override
-            public Mailbox<TestId> answer(InvocationOnMock invocationOnMock) throws Throwable {
+            public Mailbox answer(InvocationOnMock invocationOnMock) throws Throwable {
                 return mailbox;
             }
         });
-        when(messageMapper.findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT)).thenAnswer(new Answer<Iterator<MailboxMessage<TestId>>>() {
+        when(messageMapper.findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT)).thenAnswer(new Answer<Iterator<MailboxMessage>>() {
             @Override
-            public Iterator<MailboxMessage<TestId>> answer(InvocationOnMock invocationOnMock) throws Throwable {
+            public Iterator<MailboxMessage> answer(InvocationOnMock invocationOnMock) throws Throwable {
                 return Lists.newArrayList(message).iterator();
             }
         });

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/GlobalRegistrationTest.java
----------------------------------------------------------------------
diff --git a/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/GlobalRegistrationTest.java b/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/GlobalRegistrationTest.java
index 92e7bce..6737fa0 100644
--- a/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/GlobalRegistrationTest.java
+++ b/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/GlobalRegistrationTest.java
@@ -21,31 +21,31 @@ package org.apache.james.mailbox.indexer.registrations;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-import com.google.common.base.Optional;
 import org.apache.james.mailbox.MailboxListener;
 import org.apache.james.mailbox.mock.MockMailboxSession;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.store.TestId;
 import org.apache.james.mailbox.store.event.EventFactory;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;
 import org.junit.Before;
 import org.junit.Test;
 
+import com.google.common.base.Optional;
+
 public class GlobalRegistrationTest {
 
     public static final MockMailboxSession SESSION = new MockMailboxSession("test");
     public static final MailboxPath INBOX = new MailboxPath("#private", "btellier@apache.org", "INBOX");
     public static final MailboxPath NEW_PATH = new MailboxPath("#private", "btellier@apache.org", "INBOX.new");
     public static final int UID_VALIDITY = 45;
-    public static final SimpleMailbox<TestId> MAILBOX = new SimpleMailbox<TestId>(INBOX, UID_VALIDITY);
-    public static final SimpleMailbox<TestId> NEW_MAILBOX = new SimpleMailbox<TestId>(NEW_PATH, UID_VALIDITY);
+    public static final SimpleMailbox MAILBOX = new SimpleMailbox(INBOX, UID_VALIDITY);
+    public static final SimpleMailbox NEW_MAILBOX = new SimpleMailbox(NEW_PATH, UID_VALIDITY);
 
     private GlobalRegistration globalRegistration;
-    private EventFactory<TestId> eventFactory;
+    private EventFactory eventFactory;
 
     @Before
     public void setUp() {
-        eventFactory = new EventFactory<TestId>();
+        eventFactory = new EventFactory();
         globalRegistration = new GlobalRegistration();
     }
 

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/MailboxRegistrationTest.java
----------------------------------------------------------------------
diff --git a/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/MailboxRegistrationTest.java b/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/MailboxRegistrationTest.java
index b5982dc..0a84886 100644
--- a/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/MailboxRegistrationTest.java
+++ b/mailbox/tool/src/test/java/org/apache/james/mailbox/indexer/registrations/MailboxRegistrationTest.java
@@ -21,7 +21,11 @@ package org.apache.james.mailbox.indexer.registrations;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-import com.google.common.collect.Lists;
+import java.util.Date;
+import java.util.TreeMap;
+
+import javax.mail.Flags;
+
 import org.apache.james.mailbox.MailboxListener;
 import org.apache.james.mailbox.indexer.events.FlagsMessageEvent;
 import org.apache.james.mailbox.indexer.events.MessageDeletedEvent;
@@ -30,32 +34,29 @@ import org.apache.james.mailbox.model.MailboxPath;
 import org.apache.james.mailbox.model.MessageMetaData;
 import org.apache.james.mailbox.model.UpdatedFlags;
 import org.apache.james.mailbox.store.SimpleMessageMetaData;
-import org.apache.james.mailbox.store.TestId;
 import org.apache.james.mailbox.store.event.EventFactory;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;
 import org.junit.Before;
 import org.junit.Test;
 
-import javax.mail.Flags;
-import java.util.Date;
-import java.util.TreeMap;
+import com.google.common.collect.Lists;
 
 public class MailboxRegistrationTest {
 
     public static final MailboxPath INBOX = new MailboxPath("#private", "btellier@apache.org", "INBOX");
     public static final Long UID = 18L;
     public static final int UID_VALIDITY = 45;
-    public static final SimpleMailbox<TestId> MAILBOX = new SimpleMailbox<TestId>(INBOX, UID_VALIDITY);
+    public static final SimpleMailbox MAILBOX = new SimpleMailbox(INBOX, UID_VALIDITY);
     public static final MockMailboxSession SESSION = new MockMailboxSession("test");
     public static final int MOD_SEQ = 21;
     public static final int SIZE = 41;
     public static final Flags NEW_FLAGS = new Flags(Flags.Flag.ANSWERED);
     private MailboxRegistration mailboxRegistration;
-    private EventFactory<TestId> eventFactory;
+    private EventFactory eventFactory;
 
     @Before
     public void setUp() {
-        eventFactory = new EventFactory<TestId>();
+        eventFactory = new EventFactory();
         mailboxRegistration = new MailboxRegistration(INBOX);
     }
 

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/zoo-seq-provider/src/main/java/org/apache/james/mailbox/store/mail/ZooUidProvider.java
----------------------------------------------------------------------
diff --git a/mailbox/zoo-seq-provider/src/main/java/org/apache/james/mailbox/store/mail/ZooUidProvider.java b/mailbox/zoo-seq-provider/src/main/java/org/apache/james/mailbox/store/mail/ZooUidProvider.java
index 2ff6d59..bdabe05 100644
--- a/mailbox/zoo-seq-provider/src/main/java/org/apache/james/mailbox/store/mail/ZooUidProvider.java
+++ b/mailbox/zoo-seq-provider/src/main/java/org/apache/james/mailbox/store/mail/ZooUidProvider.java
@@ -18,6 +18,11 @@
  ****************************************************************/
 package org.apache.james.mailbox.store.mail;
 
+import org.apache.james.mailbox.MailboxSession;
+import org.apache.james.mailbox.exception.MailboxException;
+import org.apache.james.mailbox.store.mail.model.Mailbox;
+import org.apache.james.mailbox.store.mail.model.MailboxId;
+
 import com.google.common.base.Preconditions;
 import com.netflix.curator.RetryPolicy;
 import com.netflix.curator.framework.CuratorFramework;
@@ -26,15 +31,10 @@ import com.netflix.curator.framework.recipes.atomic.AtomicValue;
 import com.netflix.curator.framework.recipes.atomic.DistributedAtomicLong;
 import com.netflix.curator.retry.RetryOneTime;
 
-import org.apache.james.mailbox.MailboxSession;
-import org.apache.james.mailbox.exception.MailboxException;
-import org.apache.james.mailbox.store.mail.model.MailboxId;
-import org.apache.james.mailbox.store.mail.model.Mailbox;
-
 /**
  * ZooKeeper based implementation of a distributed sequential UID generator.
  */
-public class ZooUidProvider<E extends MailboxId> implements UidProvider<E> {
+public class ZooUidProvider implements UidProvider {
     // TODO: use ZK paths to store uid and modSeq, etc.
 
     public static final String UID_PATH_SUFFIX = "-uid";
@@ -53,7 +53,7 @@ public class ZooUidProvider<E extends MailboxId> implements UidProvider<E> {
     }
 
     @Override
-    public long nextUid(MailboxSession session, Mailbox<E> mailbox) throws MailboxException {
+    public long nextUid(MailboxSession session, Mailbox mailbox) throws MailboxException {
         if (client.getState() == CuratorFrameworkState.STARTED) {
             DistributedAtomicLong uid = new DistributedAtomicLong(client, pathForMailbox(mailbox), retryPolicy);
             try {
@@ -70,7 +70,7 @@ public class ZooUidProvider<E extends MailboxId> implements UidProvider<E> {
     }
 
     @Override
-    public long lastUid(MailboxSession session, Mailbox<E> mailbox) throws MailboxException {
+    public long lastUid(MailboxSession session, Mailbox mailbox) throws MailboxException {
         if (client.getState() == CuratorFrameworkState.STARTED) {
             DistributedAtomicLong uid = new DistributedAtomicLong(client, pathForMailbox(mailbox), retryPolicy);
             try {
@@ -85,7 +85,7 @@ public class ZooUidProvider<E extends MailboxId> implements UidProvider<E> {
         throw new MailboxException("Curator client is closed.");
     }
 
-    public static <E extends MailboxId> String pathForMailbox(Mailbox<E> mailbox) {
+    public static <E extends MailboxId> String pathForMailbox(Mailbox mailbox) {
         return mailbox.getMailboxId().serialize() + UID_PATH_SUFFIX;
     }
 }

http://git-wip-us.apache.org/repos/asf/james-project/blob/7015d946/mailbox/zoo-seq-provider/src/test/java/org/apache/james/mailbox/store/mail/ZooUidProviderTest.java
----------------------------------------------------------------------
diff --git a/mailbox/zoo-seq-provider/src/test/java/org/apache/james/mailbox/store/mail/ZooUidProviderTest.java b/mailbox/zoo-seq-provider/src/test/java/org/apache/james/mailbox/store/mail/ZooUidProviderTest.java
index a9018f7..046ee4f 100644
--- a/mailbox/zoo-seq-provider/src/test/java/org/apache/james/mailbox/store/mail/ZooUidProviderTest.java
+++ b/mailbox/zoo-seq-provider/src/test/java/org/apache/james/mailbox/store/mail/ZooUidProviderTest.java
@@ -129,10 +129,10 @@ public class ZooUidProviderTest {
 	    private static final int ZOO_TEST_PORT = 3123;
 	    private final RetryPolicy retryPolicy = new RetryOneTime(1);
 	    private CuratorFramework client;
-	    private ZooUidProvider<UUIDId> uuidProvider;
-	    private ZooUidProvider<LongId> longProvider;
-	    private SimpleMailbox<UUIDId> mailboxUUID;
-	    private SimpleMailbox<LongId> mailboxLong;
+	    private ZooUidProvider uuidProvider;
+	    private ZooUidProvider longProvider;
+	    private SimpleMailbox mailboxUUID;
+	    private SimpleMailbox mailboxLong;
 	    private UUID randomUUID = UUID.randomUUID();
 	
 	    @Before
@@ -141,13 +141,13 @@ public class ZooUidProviderTest {
 	        client = CuratorFrameworkFactory.builder().connectString("localhost:" + ZOO_TEST_PORT).retryPolicy(retryPolicy).
 	                namespace("JAMES").build();
 	        client.start();
-	        uuidProvider = new ZooUidProvider<UUIDId>(client, retryPolicy);
-	        longProvider = new ZooUidProvider<LongId>(client, retryPolicy);
+	        uuidProvider = new ZooUidProvider(client, retryPolicy);
+	        longProvider = new ZooUidProvider(client, retryPolicy);
 	        MailboxPath path1 = new MailboxPath("namespacetest", "namespaceuser", "UUID");
 	        MailboxPath path2 = new MailboxPath("namespacetest", "namespaceuser", "Long");
-	        mailboxUUID = new SimpleMailbox<UUIDId>(path1, 1L);
+	        mailboxUUID = new SimpleMailbox(path1, 1L);
 	        mailboxUUID.setMailboxId(UUIDId.of(randomUUID));
-	        mailboxLong = new SimpleMailbox<LongId>(path2, 2L);
+	        mailboxLong = new SimpleMailbox(path2, 2L);
 	        mailboxLong.setMailboxId(new LongId(123L));
 	    }
 	


---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org


Mime
View raw message