This is an automated email from the ASF dual-hosted git repository.
rcordier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit be58a5943e4576eea43bcb84661db1d1c22e836d
Author: Jan-Eric Hellenberg <janeric.hellenb...@gmail.com>
AuthorDate: Fri Jan 3 14:56:22 2025 +0100
James-4099 Properly indent MailboxPath tests
---
.../james/mailbox/model/MailboxPathTest.java | 734 ++++++++++-----------
1 file changed, 367 insertions(+), 367 deletions(-)
diff --git
a/mailbox/api/src/test/java/org/apache/james/mailbox/model/MailboxPathTest.java
b/mailbox/api/src/test/java/org/apache/james/mailbox/model/MailboxPathTest.java
index cadac1abe2..2542651543 100644
---
a/mailbox/api/src/test/java/org/apache/james/mailbox/model/MailboxPathTest.java
+++
b/mailbox/api/src/test/java/org/apache/james/mailbox/model/MailboxPathTest.java
@@ -61,435 +61,435 @@ class MailboxPathTest {
}
abstract static class TestBase extends MailboxFolderDelimiterAwareTest {
- private static final Username USER = Username.of("user");
- private static final Username BUGGY_USER = Username.of("buggy:bob");
-
- @Test
- void shouldMatchBeanContract() {
- EqualsVerifier.forClass(MailboxPath.class)
- .withNonnullFields("namespace")
- .verify();
- }
+ private static final Username USER = Username.of("user");
+ private static final Username BUGGY_USER = Username.of("buggy:bob");
- static Stream<Arguments> parseShouldYieldCorrectResults() {
- return Stream.of(
- Arguments.of(MailboxPath.forUser(USER, "test")),
- Arguments.of(MailboxPath.forUser(USER, "a:b")),
- Arguments.of(MailboxPath.forUser(USER, "a;b")),
- Arguments.of(MailboxPath.forUser(USER, "a;;b")),
- Arguments.of(MailboxPath.forUser(USER, "a:b:c:")),
- Arguments.of(MailboxPath.forUser(USER, "a:b:c:")),
- Arguments.of(MailboxPath.forUser(USER, ":")),
- Arguments.of(MailboxPath.forUser(USER, ";")),
- Arguments.of(MailboxPath.forUser(USER, "")),
- Arguments.of(MailboxPath.inbox(USER)),
- Arguments.of(MailboxPath.inbox(Username.of("a;b"))),
- Arguments.of(MailboxPath.inbox(Username.of(";"))),
- Arguments.of(MailboxPath.inbox(Username.of(":"))),
- Arguments.of(MailboxPath.inbox(Username.of("a;;a"))),
- Arguments.of(MailboxPath.inbox(Username.of("a:::;:::;:;;;a"))),
- Arguments.of(MailboxPath.inbox(Username.of("a::a"))),
- Arguments.of(MailboxPath.inbox(Username.of("a/a"))),
- Arguments.of(MailboxPath.inbox(Username.of("a//a"))),
- Arguments.of(MailboxPath.inbox(Username.of("a/:a"))),
- Arguments.of(MailboxPath.inbox(Username.of("a/;a"))),
-
Arguments.of(MailboxPath.inbox(Username.of("a/:::;;/:://:;//:/a"))),
- Arguments.of(MailboxPath.inbox(BUGGY_USER)),
- Arguments.of(new MailboxPath("#whatever", USER, "whatever")),
- Arguments.of(new MailboxPath(null, USER, "whatever")));
- }
+ @Test
+ void shouldMatchBeanContract() {
+ EqualsVerifier.forClass(MailboxPath.class)
+ .withNonnullFields("namespace")
+ .verify();
+ }
- @ParameterizedTest
- @MethodSource
- void parseShouldYieldCorrectResults(MailboxPath mailboxPath) {
- assertThat(MailboxPath.parseEscaped(mailboxPath.asEscapedString()))
- .contains(mailboxPath);
- }
+ static Stream<Arguments> parseShouldYieldCorrectResults() {
+ return Stream.of(
+ Arguments.of(MailboxPath.forUser(USER, "test")),
+ Arguments.of(MailboxPath.forUser(USER, "a:b")),
+ Arguments.of(MailboxPath.forUser(USER, "a;b")),
+ Arguments.of(MailboxPath.forUser(USER, "a;;b")),
+ Arguments.of(MailboxPath.forUser(USER, "a:b:c:")),
+ Arguments.of(MailboxPath.forUser(USER, "a:b:c:")),
+ Arguments.of(MailboxPath.forUser(USER, ":")),
+ Arguments.of(MailboxPath.forUser(USER, ";")),
+ Arguments.of(MailboxPath.forUser(USER, "")),
+ Arguments.of(MailboxPath.inbox(USER)),
+ Arguments.of(MailboxPath.inbox(Username.of("a;b"))),
+ Arguments.of(MailboxPath.inbox(Username.of(";"))),
+ Arguments.of(MailboxPath.inbox(Username.of(":"))),
+ Arguments.of(MailboxPath.inbox(Username.of("a;;a"))),
+
Arguments.of(MailboxPath.inbox(Username.of("a:::;:::;:;;;a"))),
+ Arguments.of(MailboxPath.inbox(Username.of("a::a"))),
+ Arguments.of(MailboxPath.inbox(Username.of("a/a"))),
+ Arguments.of(MailboxPath.inbox(Username.of("a//a"))),
+ Arguments.of(MailboxPath.inbox(Username.of("a/:a"))),
+ Arguments.of(MailboxPath.inbox(Username.of("a/;a"))),
+
Arguments.of(MailboxPath.inbox(Username.of("a/:::;;/:://:;//:/a"))),
+ Arguments.of(MailboxPath.inbox(BUGGY_USER)),
+ Arguments.of(new MailboxPath("#whatever", USER,
"whatever")),
+ Arguments.of(new MailboxPath(null, USER, "whatever")));
+ }
- @Test
- void asStringShouldFormatUser() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder")).asString())
-
.isEqualTo(adjustToActiveFolderDelimiter("#private:user:inbox.folder.subfolder"));
- }
+ @ParameterizedTest
+ @MethodSource
+ void parseShouldYieldCorrectResults(MailboxPath mailboxPath) {
+ assertThat(MailboxPath.parseEscaped(mailboxPath.asEscapedString()))
+ .contains(mailboxPath);
+ }
- @Test
- void getNameShouldReturnSubfolder() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder")).getName(folderDelimiter()))
- .isEqualTo("subfolder");
- }
+ @Test
+ void asStringShouldFormatUser() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder")).asString())
+
.isEqualTo(adjustToActiveFolderDelimiter("#private:user:inbox.folder.subfolder"));
+ }
- @Test
- void getNameShouldNoopWhenNoDelimiter() {
- assertThat(MailboxPath.forUser(USER,
"name").getName(folderDelimiter()))
- .isEqualTo("name");
- }
+ @Test
+ void getNameShouldReturnSubfolder() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder")).getName(folderDelimiter()))
+ .isEqualTo("subfolder");
+ }
- @Test
- void getNameShouldNoopWhenEmpty() {
- assertThat(MailboxPath.forUser(USER, "").getName(folderDelimiter()))
- .isEqualTo("");
- }
+ @Test
+ void getNameShouldNoopWhenNoDelimiter() {
+ assertThat(MailboxPath.forUser(USER,
"name").getName(folderDelimiter()))
+ .isEqualTo("name");
+ }
- @Test
- void getNameShouldNoopWhenBlank() {
- assertThat(MailboxPath.forUser(USER, " ").getName(folderDelimiter()))
- .isEqualTo(" ");
- }
+ @Test
+ void getNameShouldNoopWhenEmpty() {
+ assertThat(MailboxPath.forUser(USER,
"").getName(folderDelimiter()))
+ .isEqualTo("");
+ }
- @Test
- void getHierarchyLevelsShouldBeOrdered() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder"))
- .getHierarchyLevels(folderDelimiter()))
- .containsExactly(
- MailboxPath.forUser(USER, "inbox"),
- MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder")),
- MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder")));
- }
+ @Test
+ void getNameShouldNoopWhenBlank() {
+ assertThat(MailboxPath.forUser(USER, "
").getName(folderDelimiter()))
+ .isEqualTo(" ");
+ }
- @Test
- void childShouldConcatenateChildNameWithParentFolder() {
- assertThat(MailboxPath.forUser(USER, "folder")
- .child("toto", folderDelimiter()))
- .isEqualTo(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("folder.toto")));
- }
+ @Test
+ void getHierarchyLevelsShouldBeOrdered() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder"))
+ .getHierarchyLevels(folderDelimiter()))
+ .containsExactly(
+ MailboxPath.forUser(USER, "inbox"),
+ MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder")),
+ MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder")));
+ }
- @Test
- void childShouldThrowWhenNull() {
- MailboxPath path = MailboxPath.forUser(USER, "folder");
- assertThatThrownBy(() -> path.child(null, folderDelimiter()))
- .isInstanceOf(IllegalArgumentException.class);
- }
+ @Test
+ void childShouldConcatenateChildNameWithParentFolder() {
+ assertThat(MailboxPath.forUser(USER, "folder")
+ .child("toto", folderDelimiter()))
+ .isEqualTo(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("folder.toto")));
+ }
- @Test
- void childShouldThrowWhenEmpty() {
- MailboxPath path = MailboxPath.forUser(USER, "folder");
- assertThatThrownBy(() -> path.child("", folderDelimiter()))
- .isInstanceOf(IllegalArgumentException.class);
- }
+ @Test
+ void childShouldThrowWhenNull() {
+ MailboxPath path = MailboxPath.forUser(USER, "folder");
+ assertThatThrownBy(() -> path.child(null, folderDelimiter()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
- @Test
- void shouldThrowWhenLineBreak() {
- assertThatThrownBy(() -> MailboxPath.forUser(USER, "a\r\n [ALERT]
that's bad").assertAcceptable(folderDelimiter()))
- .isInstanceOf(MailboxNameException.class);
- }
+ @Test
+ void childShouldThrowWhenEmpty() {
+ MailboxPath path = MailboxPath.forUser(USER, "folder");
+ assertThatThrownBy(() -> path.child("", folderDelimiter()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
- @Test
- void childShouldThrowWhenBlank() {
- MailboxPath path = MailboxPath.forUser(USER, "folder");
- assertThatThrownBy(() -> path.child(" ", folderDelimiter()))
- .isInstanceOf(IllegalArgumentException.class);
- }
+ @Test
+ void shouldThrowWhenLineBreak() {
+ assertThatThrownBy(() -> MailboxPath.forUser(USER, "a\r\n [ALERT]
that's bad").assertAcceptable(folderDelimiter()))
+ .isInstanceOf(MailboxNameException.class);
+ }
- @Test
- void childShouldThrowWhenContainsDelimiter() {
- MailboxPath path = MailboxPath.forUser(USER, "folder");
- assertThatThrownBy(() ->
path.child(adjustToActiveFolderDelimiter("a.b"), folderDelimiter()))
- .isInstanceOf(IllegalArgumentException.class);
- }
+ @Test
+ void childShouldThrowWhenBlank() {
+ MailboxPath path = MailboxPath.forUser(USER, "folder");
+ assertThatThrownBy(() -> path.child(" ", folderDelimiter()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
- @Test
- void getHierarchyLevelsShouldReturnPathWhenOneLevel() {
- assertThat(MailboxPath.forUser(USER, "inbox")
- .getHierarchyLevels(folderDelimiter()))
- .containsExactly(
- MailboxPath.forUser(USER, "inbox"));
- }
+ @Test
+ void childShouldThrowWhenContainsDelimiter() {
+ MailboxPath path = MailboxPath.forUser(USER, "folder");
+ assertThatThrownBy(() ->
path.child(adjustToActiveFolderDelimiter("a.b"), folderDelimiter()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
- @Test
- void getHierarchyLevelsShouldReturnPathWhenEmptyName() {
- assertThat(MailboxPath.forUser(USER, "")
- .getHierarchyLevels(folderDelimiter()))
- .containsExactly(
- MailboxPath.forUser(USER, ""));
- }
+ @Test
+ void getHierarchyLevelsShouldReturnPathWhenOneLevel() {
+ assertThat(MailboxPath.forUser(USER, "inbox")
+ .getHierarchyLevels(folderDelimiter()))
+ .containsExactly(
+ MailboxPath.forUser(USER, "inbox"));
+ }
- @Test
- void getHierarchyLevelsShouldReturnPathWhenBlankName() {
- assertThat(MailboxPath.forUser(USER, " ")
- .getHierarchyLevels(folderDelimiter()))
- .containsExactly(
- MailboxPath.forUser(USER, " "));
- }
+ @Test
+ void getHierarchyLevelsShouldReturnPathWhenEmptyName() {
+ assertThat(MailboxPath.forUser(USER, "")
+ .getHierarchyLevels(folderDelimiter()))
+ .containsExactly(
+ MailboxPath.forUser(USER, ""));
+ }
- @Test
- void getHierarchyLevelsShouldReturnPathWhenNullName() {
- assertThat(MailboxPath.forUser(USER, null)
- .getHierarchyLevels(folderDelimiter()))
- .containsExactly(
- MailboxPath.forUser(USER, null));
- }
+ @Test
+ void getHierarchyLevelsShouldReturnPathWhenBlankName() {
+ assertThat(MailboxPath.forUser(USER, " ")
+ .getHierarchyLevels(folderDelimiter()))
+ .containsExactly(
+ MailboxPath.forUser(USER, " "));
+ }
- @Test
- void sanitizeShouldNotThrowOnNullMailboxName() {
- assertThat(MailboxPath.forUser(USER, null)
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER, null));
- }
+ @Test
+ void getHierarchyLevelsShouldReturnPathWhenNullName() {
+ assertThat(MailboxPath.forUser(USER, null)
+ .getHierarchyLevels(folderDelimiter()))
+ .containsExactly(
+ MailboxPath.forUser(USER, null));
+ }
- @Test
- void sanitizeShouldReturnEmptyWhenEmpty() {
- assertThat(MailboxPath.forUser(USER, "")
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER, ""));
- }
+ @Test
+ void sanitizeShouldNotThrowOnNullMailboxName() {
+ assertThat(MailboxPath.forUser(USER, null)
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER, null));
+ }
- @Test
- void sanitizeShouldRemoveMaximumOneTrailingDelimiterWhenAlone() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("."))
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER, ""));
- }
+ @Test
+ void sanitizeShouldReturnEmptyWhenEmpty() {
+ assertThat(MailboxPath.forUser(USER, "")
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER, ""));
+ }
- @Test
- void sanitizeShouldPreserveHeadingDelimiter() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter(".a"))
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter(".a")));
- }
+ @Test
+ void sanitizeShouldRemoveMaximumOneTrailingDelimiterWhenAlone() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("."))
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER, ""));
+ }
- @Test
- void sanitizeShouldRemoveTrailingDelimiter() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a."))
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER, "a"));
- }
+ @Test
+ void sanitizeShouldPreserveHeadingDelimiter() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter(".a"))
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter(".a")));
+ }
- @Test
- void sanitizeShouldRemoveMaximumOneTrailingDelimiter() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.."))
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.")));
- }
+ @Test
+ void sanitizeShouldRemoveTrailingDelimiter() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a."))
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER, "a"));
+ }
- @Test
- void sanitizeShouldPreserveRedundantDelimiters() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..a"))
- .sanitize(folderDelimiter()))
- .isEqualTo(
- MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..a")));
- }
+ @Test
+ void sanitizeShouldRemoveMaximumOneTrailingDelimiter() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.."))
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.")));
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeFalseIfSingleLevelPath() {
- assertThat(MailboxPath.forUser(USER, "a")
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isFalse();
- }
+ @Test
+ void sanitizeShouldPreserveRedundantDelimiters() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..a"))
+ .sanitize(folderDelimiter()))
+ .isEqualTo(
+ MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..a")));
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeFalseIfNestedLevelWithNonEmptyNames() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.b.c"))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isFalse();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeFalseIfSingleLevelPath() {
+ assertThat(MailboxPath.forUser(USER, "a")
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isFalse();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfEmptyPath() {
- assertThat(MailboxPath.forUser(USER, "")
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void
hasEmptyNameInHierarchyShouldBeFalseIfNestedLevelWithNonEmptyNames() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.b.c"))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isFalse();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfBlankPath() {
- assertThat(MailboxPath.forUser(USER, " ")
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfEmptyPath() {
+ assertThat(MailboxPath.forUser(USER, "")
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithTwoEmptyNames() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("."))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfBlankPath() {
+ assertThat(MailboxPath.forUser(USER, " ")
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void
hasEmptyNameInHierarchyShouldBeTrueIfPathWithAnEmptyNameBetweenTwoNames() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..b"))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithTwoEmptyNames() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("."))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void
hasEmptyNameInHierarchyShouldBeTrueIfPathWithABlankNameBetweenTwoNames() {
- assertThat(MailboxPath.forUser(USER, adjustToActiveFolderDelimiter("a.
.b"))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void
hasEmptyNameInHierarchyShouldBeTrueIfPathWithAnEmptyNameBetweenTwoNames() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..b"))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithHeadingEmptyNames() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("..a"))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void
hasEmptyNameInHierarchyShouldBeTrueIfPathWithABlankNameBetweenTwoNames() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a. .b"))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithHeadingBlankName() {
- assertThat(MailboxPath.forUser(USER, adjustToActiveFolderDelimiter("
.a"))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithHeadingEmptyNames() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("..a"))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithATrailingEmptyName() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a."))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithHeadingBlankName() {
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter(" .a"))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithATrailingBlankName() {
- assertThat(MailboxPath.forUser(USER, adjustToActiveFolderDelimiter("a.
"))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithATrailingEmptyName()
{
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a."))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithTrailingEmptyNames() {
- assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.."))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithATrailingBlankName()
{
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a. "))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void hasEmptyNameInHierarchyShouldBeTrueIfPathWithTrailingBlankNames() {
- assertThat(MailboxPath.forUser(USER, adjustToActiveFolderDelimiter("a.
. "))
- .hasEmptyNameInHierarchy(folderDelimiter()))
- .isTrue();
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithTrailingEmptyNames()
{
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a.."))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void assertAcceptableShouldThrowOnDoubleSeparator() {
- assertThatThrownBy(() -> MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..b"))
- .assertAcceptable(folderDelimiter()))
- .isInstanceOf(HasEmptyMailboxNameInHierarchyException.class);
- }
+ @Test
+ void hasEmptyNameInHierarchyShouldBeTrueIfPathWithTrailingBlankNames()
{
+ assertThat(MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a. . "))
+ .hasEmptyNameInHierarchy(folderDelimiter()))
+ .isTrue();
+ }
- @Test
- void assertAcceptableShouldThrowWhenStartsWithSharp() {
- assertThatThrownBy(() -> MailboxPath.forUser(USER, "#ab")
- .assertAcceptable(folderDelimiter()))
- .isInstanceOf(MailboxNameException.class);
- }
+ @Test
+ void assertAcceptableShouldThrowOnDoubleSeparator() {
+ assertThatThrownBy(() -> MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("a..b"))
+ .assertAcceptable(folderDelimiter()))
+
.isInstanceOf(HasEmptyMailboxNameInHierarchyException.class);
+ }
- @Test
- void assertAcceptableShouldNotThrowWhenSharpInTheMiddle() {
- assertThatCode(() -> MailboxPath.forUser(USER, "mailbox #17")
- .assertAcceptable(folderDelimiter()))
- .doesNotThrowAnyException();
- }
+ @Test
+ void assertAcceptableShouldThrowWhenStartsWithSharp() {
+ assertThatThrownBy(() -> MailboxPath.forUser(USER, "#ab")
+ .assertAcceptable(folderDelimiter()))
+ .isInstanceOf(MailboxNameException.class);
+ }
- @Test
- void assertAcceptableShouldThrowOnPercent() {
- assertThatThrownBy(() -> MailboxPath.forUser(USER, "a%b")
- .assertAcceptable(folderDelimiter()))
- .isInstanceOf(MailboxNameException.class);
- }
+ @Test
+ void assertAcceptableShouldNotThrowWhenSharpInTheMiddle() {
+ assertThatCode(() -> MailboxPath.forUser(USER, "mailbox #17")
+ .assertAcceptable(folderDelimiter()))
+ .doesNotThrowAnyException();
+ }
- @Test
- void assertAcceptableShouldThrowOnWildcard() {
- assertThatThrownBy(() -> MailboxPath.forUser(USER, "a*b")
- .assertAcceptable(folderDelimiter()))
- .isInstanceOf(MailboxNameException.class);
- }
+ @Test
+ void assertAcceptableShouldThrowOnPercent() {
+ assertThatThrownBy(() -> MailboxPath.forUser(USER, "a%b")
+ .assertAcceptable(folderDelimiter()))
+ .isInstanceOf(MailboxNameException.class);
+ }
- @Nested
- class WithMailboxNameValidationRelaxed {
- @BeforeEach
- void setUp() {
- MailboxPath.RELAX_MAILBOX_NAME_VALIDATION = true;
- MailboxPath.INVALID_CHARS = MailboxPath.evaluateInvalidChars();
- MailboxPath.INVALID_CHARS_MATCHER =
CharMatcher.anyOf(MailboxPath.INVALID_CHARS);
+ @Test
+ void assertAcceptableShouldThrowOnWildcard() {
+ assertThatThrownBy(() -> MailboxPath.forUser(USER, "a*b")
+ .assertAcceptable(folderDelimiter()))
+ .isInstanceOf(MailboxNameException.class);
}
- @AfterEach
- void tearDown() {
- MailboxPath.RELAX_MAILBOX_NAME_VALIDATION = false;
- MailboxPath.INVALID_CHARS = MailboxPath.evaluateInvalidChars();
- MailboxPath.INVALID_CHARS_MATCHER =
CharMatcher.anyOf(MailboxPath.INVALID_CHARS);
+ @Nested
+ class WithMailboxNameValidationRelaxed {
+ @BeforeEach
+ void setUp() {
+ MailboxPath.RELAX_MAILBOX_NAME_VALIDATION = true;
+ MailboxPath.INVALID_CHARS = MailboxPath.evaluateInvalidChars();
+ MailboxPath.INVALID_CHARS_MATCHER =
CharMatcher.anyOf(MailboxPath.INVALID_CHARS);
+ }
+
+ @AfterEach
+ void tearDown() {
+ MailboxPath.RELAX_MAILBOX_NAME_VALIDATION = false;
+ MailboxPath.INVALID_CHARS = MailboxPath.evaluateInvalidChars();
+ MailboxPath.INVALID_CHARS_MATCHER =
CharMatcher.anyOf(MailboxPath.INVALID_CHARS);
+ }
+
+ @Test
+ void assertAcceptableShouldNotThrowOnPercentWhenRelaxMode() {
+ assertThatCode(() -> MailboxPath.forUser(USER, "a%b")
+ .assertAcceptable(folderDelimiter()))
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ void assertAcceptableShouldNotThrowOnWildcardWhenRelaxMode() {
+ assertThatCode(() -> MailboxPath.forUser(USER, "a*b")
+ .assertAcceptable(folderDelimiter()))
+ .doesNotThrowAnyException();
+ }
}
@Test
- void assertAcceptableShouldNotThrowOnPercentWhenRelaxMode() {
- assertThatCode(() -> MailboxPath.forUser(USER, "a%b")
+ void assertAcceptableShouldThrowOnTooLongMailboxName() {
+ assertThatThrownBy(() -> MailboxPath.forUser(USER,
Strings.repeat("a", 201))
.assertAcceptable(folderDelimiter()))
- .doesNotThrowAnyException();
+ .isInstanceOf(TooLongMailboxNameException.class);
}
@Test
- void assertAcceptableShouldNotThrowOnWildcardWhenRelaxMode() {
- assertThatCode(() -> MailboxPath.forUser(USER, "a*b")
+ void assertAcceptableShouldNotThrowOnNotTooLongMailboxName() {
+ assertThatCode(() -> MailboxPath.forUser(USER, Strings.repeat("a",
200))
.assertAcceptable(folderDelimiter()))
.doesNotThrowAnyException();
}
- }
- @Test
- void assertAcceptableShouldThrowOnTooLongMailboxName() {
- assertThatThrownBy(() -> MailboxPath.forUser(USER, Strings.repeat("a",
201))
- .assertAcceptable(folderDelimiter()))
- .isInstanceOf(TooLongMailboxNameException.class);
- }
-
- @Test
- void assertAcceptableShouldNotThrowOnNotTooLongMailboxName() {
- assertThatCode(() -> MailboxPath.forUser(USER, Strings.repeat("a",
200))
- .assertAcceptable(folderDelimiter()))
- .doesNotThrowAnyException();
- }
-
- @Test
- void isInboxShouldReturnTrueWhenINBOX() {
- MailboxPath mailboxPath = new
MailboxPath(MailboxConstants.USER_NAMESPACE, USER, DefaultMailboxes.INBOX);
- assertThat(mailboxPath.isInbox()).isTrue();
- }
+ @Test
+ void isInboxShouldReturnTrueWhenINBOX() {
+ MailboxPath mailboxPath = new
MailboxPath(MailboxConstants.USER_NAMESPACE, USER, DefaultMailboxes.INBOX);
+ assertThat(mailboxPath.isInbox()).isTrue();
+ }
- @Test
- void isInboxShouldReturnTrueWhenINBOXWithOtherCase() {
- MailboxPath mailboxPath = new
MailboxPath(MailboxConstants.USER_NAMESPACE, USER, "InBoX");
- assertThat(mailboxPath.isInbox()).isTrue();
- }
+ @Test
+ void isInboxShouldReturnTrueWhenINBOXWithOtherCase() {
+ MailboxPath mailboxPath = new
MailboxPath(MailboxConstants.USER_NAMESPACE, USER, "InBoX");
+ assertThat(mailboxPath.isInbox()).isTrue();
+ }
- @Test
- void isInboxShouldReturnFalseWhenOtherThanInbox() {
- MailboxPath mailboxPath = new
MailboxPath(MailboxConstants.USER_NAMESPACE, USER, DefaultMailboxes.ARCHIVE);
- assertThat(mailboxPath.isInbox()).isFalse();
- }
+ @Test
+ void isInboxShouldReturnFalseWhenOtherThanInbox() {
+ MailboxPath mailboxPath = new
MailboxPath(MailboxConstants.USER_NAMESPACE, USER, DefaultMailboxes.ARCHIVE);
+ assertThat(mailboxPath.isInbox()).isFalse();
+ }
- @Test
- void hasParentShouldReturnTrueWhenMailboxHasParent() {
- MailboxPath mailboxPath = MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder"));
- assertThat(mailboxPath.hasParent(folderDelimiter())).isTrue();
- }
+ @Test
+ void hasParentShouldReturnTrueWhenMailboxHasParent() {
+ MailboxPath mailboxPath = MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder"));
+ assertThat(mailboxPath.hasParent(folderDelimiter())).isTrue();
+ }
- @Test
- void hasParentShouldReturnFalseWhenNoParent() {
- MailboxPath mailboxPath = MailboxPath.forUser(USER, "inbox");
- assertThat(mailboxPath.hasParent(folderDelimiter())).isFalse();
- }
+ @Test
+ void hasParentShouldReturnFalseWhenNoParent() {
+ MailboxPath mailboxPath = MailboxPath.forUser(USER, "inbox");
+ assertThat(mailboxPath.hasParent(folderDelimiter())).isFalse();
+ }
- @Test
- void getParentShouldReturnParents() {
- MailboxPath mailboxPath = MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder"));
- assertThat(mailboxPath.getParents(folderDelimiter()))
- .containsExactly(
- MailboxPath.forUser(USER, "inbox"),
- MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder")));
- }
+ @Test
+ void getParentShouldReturnParents() {
+ MailboxPath mailboxPath = MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder.subfolder"));
+ assertThat(mailboxPath.getParents(folderDelimiter()))
+ .containsExactly(
+ MailboxPath.forUser(USER, "inbox"),
+ MailboxPath.forUser(USER,
adjustToActiveFolderDelimiter("inbox.folder")));
+ }
- @Test
- void getParentShouldReturnEmptyWhenTopLevelMailbox() {
- MailboxPath mailboxPath = MailboxPath.forUser(USER, "inbox");
- assertThat(mailboxPath.getParents(folderDelimiter()))
- .isEmpty();
- }
+ @Test
+ void getParentShouldReturnEmptyWhenTopLevelMailbox() {
+ MailboxPath mailboxPath = MailboxPath.forUser(USER, "inbox");
+ assertThat(mailboxPath.getParents(folderDelimiter()))
+ .isEmpty();
+ }
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscr...@james.apache.org
For additional commands, e-mail: notifications-h...@james.apache.org
