james-server-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From matth...@apache.org
Subject [10/27] james-project git commit: MAILBOX-310 Mailbox query refactoring: Create dedicated packages for Mailbox search related classes
Date Thu, 05 Oct 2017 18:02:22 GMT
http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedRegexTest.java
----------------------------------------------------------------------
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedRegexTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedRegexTest.java
new file mode 100644
index 0000000..03a8351
--- /dev/null
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedRegexTest.java
@@ -0,0 +1,1058 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ ****************************************************************/
+
+package org.apache.james.mailbox.model.search;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class PrefixedRegexTest {
+    private static final char PATH_DELIMITER = '.';
+    private static final String PREFIX = "name";
+    private static final String EMPTY_PREFIX = "";
+
+    @Test
+    public void isWildShouldReturnTrueWhenOnlyFreeWildcard() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "*", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenOnlyLocalWildcard() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "%", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenFreeWildcardAtBeginning() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "*One", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenLocalWildcardAtBeginning() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "%One", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "A*A", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "A%A", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenFreeWildcardAtEnd() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "One*", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnTrueWhenLocalWildcardAtEnd() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "One%", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isWildShouldReturnFalseWhenEmptyExpression() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isWildShouldReturnFalseWhenNullExpression() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, null, PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isWildShouldReturnFalseWhenNoWildcard() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "ONE", PATH_DELIMITER);
+
+        boolean actual = prefixedRegex.isWild();
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void getCombinedNameShouldWork() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "mailbox", PATH_DELIMITER);
+
+        String actual = prefixedRegex.getCombinedName();
+
+        assertThat(actual).isEqualTo("name.mailbox");
+    }
+
+    @Test
+    public void getCombinedNameShouldWorkWhenEmptyExpression() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "", PATH_DELIMITER);
+
+        String actual = prefixedRegex.getCombinedName();
+
+        assertThat(actual).isEqualTo("name");
+    }
+
+    @Test
+    public void getCombinedNameShouldReturnEmptyStringWhenNullMailboxPathAndExpression() throws Exception {
+        String prefix = null;
+        String regex = null;
+        PrefixedRegex prefixedRegex = new PrefixedRegex(prefix, regex, PATH_DELIMITER);
+
+        String actual = prefixedRegex.getCombinedName();
+
+        assertThat(actual).isEmpty();
+    }
+
+    @Test
+    public void getCombinedNameShouldIgnoreDelimiterWhenPresentAtBeginningOfExpression() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, ".mailbox", PATH_DELIMITER);
+
+        String actual = prefixedRegex.getCombinedName();
+
+        assertThat(actual).isEqualTo("name.mailbox");
+    }
+
+    @Test
+    public void getCombinedNameShouldIgnoreDelimiterWhenPresentAtEndOfMailboxName() throws Exception {
+        PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX + ".", ".mailbox", PATH_DELIMITER);
+
+        String actual = prefixedRegex.getCombinedName();
+
+        assertThat(actual).isEqualTo("name.mailbox");
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenNullExpression() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(PREFIX, null, PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("folder");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenNameBeginsWithDelimiter() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch(".mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenNameEndsWithDelimiter() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWithExpandedEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox123");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolder() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.123");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenEmptyNameAndExpression() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyExpressionAndNameBeginsWithDelimiter() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch(".123");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenEmptyExpression() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("folder");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenEmptyNameAndOnlyLocalWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenOnlyLocalWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("folder");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenOnlyLocalWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenEmptyNameAndOnlyFreeWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenOnlyFreeWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenOnlyFreeWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.sub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalWildcardAtEnd() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenLocalWildcardAtEndAndNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenLocalWildcardAtEndNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenLocalWildcardAtEndUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailboxsub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardAtEnd() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalWildcardAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenLocalWildcardAtBeginningAndNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenLocalWildcardAtBeginningNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenLocalWildcardAtBeginningUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenLocalWildcardAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenLocalWildcardInMiddleAndMissingEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenLocalWildcardInMiddleAndMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub123mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardInMiddleAndExpandedMiddleName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.123mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenLocalWildcardInMiddleAndMissingBeginningName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardAtEnd() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.sub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeWildcardAtEnd() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenFreeWildcardAtEndAndNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtEndNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtEndUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox123");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeWildcardAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenFreeWildcardAtBeginningAndNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtBeginningNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtBeginningUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenFreeWildcardInMiddleAndMissingEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenFreeWildcardInMiddleNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenFreeWildcardInMiddleNotUsedAndMissingBeginningName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndDoubleFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenDoubleFreeWildcardInMiddleAndMissingEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenDoubleFreeWildcardInMiddleNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenDoubleFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenDoubleFreeWildcardInMiddleAndMissingBeginningName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenDoubleFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenFreeLocalWildcardInMiddleAndMissingEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenFreeLocalWildcardInMiddleNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenFreeLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenFreeLocalWildcardInMiddleAndMissingBeginningName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenFreeLocalWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenLocalFreeWildcardInMiddleAndMissingEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenLocalFreewildcardInMiddleNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenLocalFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenLocalFreeWildcardInMiddleAndMissingBeginningName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenLocalFreeWildcardInMiddle() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenMultipleFreeWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailboxsub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenMultipleFreeWildcardsNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailbox.sub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenMultipleFreeWildcardsUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("subtosh.boshmailboxtosh.boshsubboshtosh");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMultipleFreeWildcardsAndMissingMiddleName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.a.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMultipleFreeWildcardsAndMissingEndName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.a.submailbox.u");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMultipleFreeWildcardsAndMissingBeginningdName() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("utosh.boshmailboxtosh.boshsubasubboshtoshmailboxu");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenMixedLocalFreeWildcardsNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox*sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailboxsub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenMixedLocalFreeWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox*sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailboxsub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenMixedFreeLocalWildcardsNotUsed() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailboxsub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailboxsub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailbox.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchFolderWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailboxwhateversub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderEndingWithDelimiterWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("submailboxsub.Whatever.");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailboxsub.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFoldeWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.mailboxsub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchDeeplyNestedFoldeWhenMixedFreeLocalWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("sub.whatever.mailbox123sub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchFolderWhenTwoLocalPathDelimitedWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%.%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenTwoLocalPathDelimitedWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%.%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.sub.sub");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenTwoLocalPathDelimitedWildcards() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%.%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("mailbox.sub");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardAndPathDelimiterAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*.test", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("blah.test");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchSubFolderWhenWhenFreeWildcardAndPathDelimiterAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*.test", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("blah.test3");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenFreeWildcardAndPathDelimiterAtBeginning() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*.test", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("blah.test.go");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldIgnoreRegexInjection() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "folder^$!)(%3", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("folder^$!)(123");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingEndOfQuoteAndNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Efo.", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("\\Efol");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingEndOfQuoteAndMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Efo.", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("\\Efo.");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingBeginOfQuoteAndNoMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Qfo?", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("\\Qfol");
+
+        assertThat(actual).isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingBeginOfQuoteAndMatching() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Qfo?", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("\\Qfo?");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotEscapeFreeWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "folder\\*", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("folder\\123");
+
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldNotEscapeLocalWildcard() throws Exception {
+        PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "folder\\%", PATH_DELIMITER);
+
+        boolean actual = testee.isExpressionMatch("folder\\123");
+
+        assertThat(actual).isTrue();
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedWildcardTest.java
----------------------------------------------------------------------
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedWildcardTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedWildcardTest.java
new file mode 100644
index 0000000..762b025
--- /dev/null
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/PrefixedWildcardTest.java
@@ -0,0 +1,71 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ ****************************************************************/
+
+package org.apache.james.mailbox.model.search;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.Test;
+
+public class PrefixedWildcardTest {
+    public static final String NAME = "toto";
+
+    @Test
+    public void constructorShouldThrowOnNullName() {
+        assertThatThrownBy(() -> new PrefixedWildcard(null))
+            .isInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    public void isWildShouldReturnTrue() {
+        assertThat(new PrefixedWildcard(NAME).isWild())
+            .isTrue();
+    }
+
+    @Test
+    public void getCombinedNameShouldReturnName() {
+        assertThat(new PrefixedWildcard(NAME).getCombinedName())
+            .isEqualTo(NAME + MailboxNameExpression.FREEWILDCARD);
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenName() {
+        assertThat(new PrefixedWildcard(NAME).isExpressionMatch(NAME))
+            .isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnTrueWhenNameAndPostfix() {
+        assertThat(new PrefixedWildcard(NAME).isExpressionMatch(NAME + "any"))
+            .isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldReturnFalseWhenOtherValue() {
+        assertThat(new PrefixedWildcard(NAME).isExpressionMatch("other"))
+            .isFalse();
+    }
+
+    @Test
+    public void isExpressionMatchShouldThrowOnNullValue() {
+        assertThatThrownBy(() -> new PrefixedWildcard(NAME).isExpressionMatch(null))
+            .isInstanceOf(NullPointerException.class);
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/WildcardTest.java
----------------------------------------------------------------------
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/WildcardTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/WildcardTest.java
new file mode 100644
index 0000000..a607164
--- /dev/null
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/WildcardTest.java
@@ -0,0 +1,59 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ ****************************************************************/
+
+package org.apache.james.mailbox.model.search;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.Test;
+
+public class WildcardTest {
+
+    @Test
+    public void isWildShouldBeTrue() {
+        assertThat(new Wildcard().isWild())
+            .isTrue();
+    }
+
+    @Test
+    public void getCombinedNameShouldReturnWildcard() {
+        assertThat(new Wildcard().getCombinedName())
+            .isEqualTo(String.valueOf(MailboxNameExpression.FREEWILDCARD));
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchAnyValue() {
+        assertThat(new Wildcard().isExpressionMatch("any"))
+            .isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldMatchEmptyValue() {
+        assertThat(new Wildcard().isExpressionMatch(""))
+            .isTrue();
+    }
+
+    @Test
+    public void isExpressionMatchShouldThrowOnNullValue() {
+        assertThatThrownBy(() -> new Wildcard().isExpressionMatch(null))
+            .isInstanceOf(NullPointerException.class);
+    }
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManager.java
----------------------------------------------------------------------
diff --git a/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManager.java b/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManager.java
index 9e7f521..566a284 100644
--- a/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManager.java
+++ b/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManager.java
@@ -41,11 +41,11 @@ import org.apache.james.mailbox.model.FetchGroupImpl;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.MessageResult;
 import org.apache.james.mailbox.model.MessageResult.FetchGroup;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.util.OptionalUtils;
 
 import com.github.fge.lambdas.Throwing;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManagerTestSystem.java
----------------------------------------------------------------------
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManagerTestSystem.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManagerTestSystem.java
index c78a9ef..5a35ae9 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManagerTestSystem.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageIdManagerTestSystem.java
@@ -32,8 +32,8 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.MessageIdManagerTestSystem;
 import org.apache.james.mailbox.store.mail.model.Mailbox;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageManagerTestSystem.java
----------------------------------------------------------------------
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageManagerTestSystem.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageManagerTestSystem.java
index 9763281..273df14 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageManagerTestSystem.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/InMemoryMessageManagerTestSystem.java
@@ -32,8 +32,8 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.MessageManagerTestSystem;
 import org.apache.james.mailbox.store.mail.model.Mailbox;
 import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
index 91a5acd..5ee075f 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
@@ -59,11 +59,11 @@ import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxMetaData.Selectability;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.MessageId.Factory;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.MultimailboxesSearchQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.quota.QuotaManager;
 import org.apache.james.mailbox.quota.QuotaRootResolver;
 import org.apache.james.mailbox.store.event.DefaultDelegatingMailboxListener;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractCombinationManagerTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractCombinationManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractCombinationManagerTest.java
index 1f4c025..530a0fd 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractCombinationManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractCombinationManagerTest.java
@@ -42,12 +42,12 @@ import org.apache.james.mailbox.fixture.MailboxFixture;
 import org.apache.james.mailbox.mock.MockMailboxSession;
 import org.apache.james.mailbox.model.ComposedMessageId;
 import org.apache.james.mailbox.model.FetchGroupImpl;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.MessageResult;
 import org.apache.james.mailbox.model.MultimailboxesSearchQuery;
 import org.apache.james.mailbox.model.SearchQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.mail.model.Mailbox;
 import org.junit.Test;
 

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerTest.java
----------------------------------------------------------------------
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerTest.java
index 0fad4e9..ed736ac 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerTest.java
@@ -37,10 +37,10 @@ import org.apache.james.mailbox.mock.MockMailboxSession;
 import org.apache.james.mailbox.model.MailboxACL;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.MessageId.Factory;
 import org.apache.james.mailbox.model.TestId;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.mail.MailboxMapper;
 import org.apache.james.mailbox.store.mail.model.Mailbox;
 import org.apache.james.mailbox.store.mail.model.impl.MessageParser;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
----------------------------------------------------------------------
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
index 5a42df4..cfe604c 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
@@ -40,7 +40,7 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.exception.SubscriptionException;
 import org.apache.james.mailbox.model.MailboxConstants;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.metrics.api.MetricFactory;
 import org.apache.james.util.MDCBuilder;
 import org.slf4j.Logger;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
----------------------------------------------------------------------
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
index b9ccf4e..7d4bd31 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
@@ -45,7 +45,7 @@ import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxMetaData.Children;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.metrics.api.MetricFactory;
 import org.apache.james.util.MDCBuilder;
 import org.slf4j.Logger;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/protocols/imap/src/test/java/org/apache/james/imap/processor/base/MailboxEventAnalyserTest.java
----------------------------------------------------------------------
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/processor/base/MailboxEventAnalyserTest.java b/protocols/imap/src/test/java/org/apache/james/imap/processor/base/MailboxEventAnalyserTest.java
index 7aecb0d..0aff062 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/processor/base/MailboxEventAnalyserTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/processor/base/MailboxEventAnalyserTest.java
@@ -64,7 +64,6 @@ import org.apache.james.mailbox.model.MailboxCounters;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageAttachment;
 import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.MessageRange;
@@ -76,6 +75,7 @@ import org.apache.james.mailbox.model.MultimailboxesSearchQuery;
 import org.apache.james.mailbox.model.SearchQuery;
 import org.apache.james.mailbox.model.TestId;
 import org.apache.james.mailbox.model.UpdatedFlags;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.mail.model.DefaultMessageId;
 import org.junit.Test;
 

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/container/guice/mailbox/src/main/java/org/apache/james/modules/MailboxProbeImpl.java
----------------------------------------------------------------------
diff --git a/server/container/guice/mailbox/src/main/java/org/apache/james/modules/MailboxProbeImpl.java b/server/container/guice/mailbox/src/main/java/org/apache/james/modules/MailboxProbeImpl.java
index 7ad811a..32cebbd 100644
--- a/server/container/guice/mailbox/src/main/java/org/apache/james/modules/MailboxProbeImpl.java
+++ b/server/container/guice/mailbox/src/main/java/org/apache/james/modules/MailboxProbeImpl.java
@@ -39,7 +39,7 @@ import org.apache.james.mailbox.model.ComposedMessageId;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.mail.MailboxMapper;
 import org.apache.james.mailbox.store.mail.MailboxMapperFactory;
 import org.apache.james.mailbox.store.mail.model.Mailbox;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/MailboxManagerManagement.java
----------------------------------------------------------------------
diff --git a/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/MailboxManagerManagement.java b/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/MailboxManagerManagement.java
index 5f60816..151ab62 100644
--- a/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/MailboxManagerManagement.java
+++ b/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/MailboxManagerManagement.java
@@ -39,7 +39,7 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.util.MDCBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/mailet/mailets/src/main/java/org/apache/james/transport/matchers/AbstractStorageQuota.java
----------------------------------------------------------------------
diff --git a/server/mailet/mailets/src/main/java/org/apache/james/transport/matchers/AbstractStorageQuota.java b/server/mailet/mailets/src/main/java/org/apache/james/transport/matchers/AbstractStorageQuota.java
index 9034b9b..816e83d 100755
--- a/server/mailet/mailets/src/main/java/org/apache/james/transport/matchers/AbstractStorageQuota.java
+++ b/server/mailet/mailets/src/main/java/org/apache/james/transport/matchers/AbstractStorageQuota.java
@@ -36,9 +36,9 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.FetchGroupImpl;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.MessageResult;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.user.api.UsersRepository;
 import org.apache.james.user.api.UsersRepositoryException;
 import org.apache.mailet.Experimental;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/protocols/jmap/src/main/java/org/apache/james/jmap/methods/GetMailboxesMethod.java
----------------------------------------------------------------------
diff --git a/server/protocols/jmap/src/main/java/org/apache/james/jmap/methods/GetMailboxesMethod.java b/server/protocols/jmap/src/main/java/org/apache/james/jmap/methods/GetMailboxesMethod.java
index 8c66d15..1354c20 100644
--- a/server/protocols/jmap/src/main/java/org/apache/james/jmap/methods/GetMailboxesMethod.java
+++ b/server/protocols/jmap/src/main/java/org/apache/james/jmap/methods/GetMailboxesMethod.java
@@ -40,7 +40,7 @@ import org.apache.james.mailbox.MailboxSession;
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.metrics.api.MetricFactory;
 import org.apache.james.metrics.api.TimeMetric;
 import org.apache.james.util.MDCBuilder;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/protocols/jmap/src/main/java/org/apache/james/jmap/utils/SystemMailboxesProviderImpl.java
----------------------------------------------------------------------
diff --git a/server/protocols/jmap/src/main/java/org/apache/james/jmap/utils/SystemMailboxesProviderImpl.java b/server/protocols/jmap/src/main/java/org/apache/james/jmap/utils/SystemMailboxesProviderImpl.java
index 21c32de..c51d6ad 100644
--- a/server/protocols/jmap/src/main/java/org/apache/james/jmap/utils/SystemMailboxesProviderImpl.java
+++ b/server/protocols/jmap/src/main/java/org/apache/james/jmap/utils/SystemMailboxesProviderImpl.java
@@ -31,7 +31,7 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.exception.MailboxNotFoundException;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 
 import com.github.fge.lambdas.Throwing;
 import com.github.fge.lambdas.functions.ThrowingFunction;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/protocols/jmap/src/test/java/org/apache/james/jmap/DefaultMailboxesProvisioningFilterThreadTest.java
----------------------------------------------------------------------
diff --git a/server/protocols/jmap/src/test/java/org/apache/james/jmap/DefaultMailboxesProvisioningFilterThreadTest.java b/server/protocols/jmap/src/test/java/org/apache/james/jmap/DefaultMailboxesProvisioningFilterThreadTest.java
index 764bd35..ac14cc2 100644
--- a/server/protocols/jmap/src/test/java/org/apache/james/jmap/DefaultMailboxesProvisioningFilterThreadTest.java
+++ b/server/protocols/jmap/src/test/java/org/apache/james/jmap/DefaultMailboxesProvisioningFilterThreadTest.java
@@ -36,11 +36,11 @@ import org.apache.james.mailbox.model.MailboxAnnotationKey;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.MultimailboxesSearchQuery;
 import org.apache.james.mailbox.model.TestId;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.metrics.api.NoopMetricFactory;
 import org.junit.Test;
 

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserMailboxesService.java
----------------------------------------------------------------------
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserMailboxesService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserMailboxesService.java
index 25e9891..be9713d 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserMailboxesService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserMailboxesService.java
@@ -31,7 +31,7 @@ import org.apache.james.mailbox.exception.MailboxExistsException;
 import org.apache.james.mailbox.exception.MailboxNotFoundException;
 import org.apache.james.mailbox.model.MailboxMetaData;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.user.api.UsersRepository;
 import org.apache.james.user.api.UsersRepositoryException;
 import org.apache.james.webadmin.dto.MailboxResponse;

http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserMailboxesRoutesTest.java
----------------------------------------------------------------------
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserMailboxesRoutesTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserMailboxesRoutesTest.java
index 8b9e3fd..01b6212 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserMailboxesRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserMailboxesRoutesTest.java
@@ -48,8 +48,8 @@ import org.apache.james.mailbox.inmemory.InMemoryMailboxManager;
 import org.apache.james.mailbox.inmemory.InMemoryMailboxSessionMapperFactory;
 import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.MailboxQuery;
 import org.apache.james.mailbox.model.MessageId;
+import org.apache.james.mailbox.model.search.MailboxQuery;
 import org.apache.james.mailbox.store.FakeAuthorizator;
 import org.apache.james.mailbox.store.JVMMailboxPathLocker;
 import org.apache.james.mailbox.store.SimpleMailboxMetaData;


---------------------------------------------------------------------
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