public void validateSearchTermsWhenShouldMarkAsReadNoExistingFlagsGuts(String userFlag, ImapMailReceiver receiver) throws NoSuchFieldException, IllegalAccessException, InvocationTargetException { receiver.setShouldMarkMessagesAsRead(true); receiver.setBeanFactory(mock(BeanFactory.class)); Field folderField = AbstractMailReceiver.class.getDeclaredField("folder"); folderField.setAccessible(true); Folder folder = mock(Folder.class); when(folder.getPermanentFlags()).thenReturn(new Flags(Flags.Flag.USER)); folderField.set(receiver, folder); Method compileSearchTerms = ReflectionUtils.findMethod(receiver.getClass(), "compileSearchTerms", Flags.class); compileSearchTerms.setAccessible(true); Flags flags = new Flags(); SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags); assertTrue(searchTerms instanceof NotTerm); NotTerm notTerm = (NotTerm) searchTerms; Flags siFlags = new Flags(); siFlags.add(userFlag); assertEquals(siFlags, ((FlagTerm) notTerm.getTerm()).getFlags()); }
protected Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
protected Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
@Test public void validateSearchTermsWhenShouldMarkAsReadWithExistingFlags() throws Exception { ImapMailReceiver receiver = new ImapMailReceiver(); receiver.setShouldMarkMessagesAsRead(true); receiver.setBeanFactory(mock(BeanFactory.class)); receiver.afterPropertiesSet(); Field folderField = AbstractMailReceiver.class.getDeclaredField("folder"); folderField.setAccessible(true); Folder folder = mock(Folder.class); when(folder.getPermanentFlags()).thenReturn(new Flags(Flags.Flag.USER)); folderField.set(receiver, folder); Method compileSearchTerms = ReflectionUtils.findMethod(receiver.getClass(), "compileSearchTerms", Flags.class); compileSearchTerms.setAccessible(true); Flags flags = new Flags(); flags.add(Flag.ANSWERED); SearchTerm searchTerms = (SearchTerm) compileSearchTerms.invoke(receiver, flags); assertTrue(searchTerms instanceof AndTerm); AndTerm andTerm = (AndTerm) searchTerms; SearchTerm[] terms = andTerm.getTerms(); assertEquals(2, terms.length); NotTerm notTerm = (NotTerm) terms[0]; assertTrue(((FlagTerm) notTerm.getTerm()).getFlags().contains(Flag.ANSWERED)); notTerm = (NotTerm) terms[1]; Flags siFlags = new Flags(); siFlags.add(AbstractMailReceiver.DEFAULT_SI_USER_FLAG); assertTrue(((FlagTerm) notTerm.getTerm()).getFlags().contains(siFlags)); }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * append IMAP search term information from a NotTerm item. * * @param term The source NotTerm * @param charset target charset for the search information (can be null). */ protected void appendNot(NotTerm term, String charset) throws MessagingException { // we're goint to generate this with parenthetical search keys, even if it is just a simple term. appendAtom("NOT"); startList(); // generated the NOT expression appendSearchTerm(term.getTerm(), charset); // and the closing parens endList(); }
private static Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
protected Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
protected Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
protected Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
private static Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
protected Argument not(NotTerm term, String charset) throws SearchException, IOException { Argument result = new Argument(); // Add the NOT search-key result.writeAtom("NOT"); /* If this term is an AND expression, we need to enclose it * within paranthesis. * * AND expressions are either AndTerms or FlagTerms */ SearchTerm nterm = term.getTerm(); if (nterm instanceof AndTerm || nterm instanceof FlagTerm) result.writeArgument(generateSequence(nterm, charset)); else result.append(generateSequence(nterm, charset)); return result; }
public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm || term instanceof OrTerm) { SearchTerm[] terms; if (term instanceof AndTerm) terms = ((AndTerm)term).getTerms(); else terms = ((OrTerm)term).getTerms(); for (int i = 0; i < terms.length; i++) if (!isAscii(terms[i])) // outta here ! return false; } else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm || term instanceof OrTerm) { SearchTerm[] terms; if (term instanceof AndTerm) terms = ((AndTerm)term).getTerms(); else terms = ((OrTerm)term).getTerms(); for (int i = 0; i < terms.length; i++) if (!isAscii(terms[i])) // outta here ! return false; } else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
/** * Check if the "text" terms in the given SearchTerm contain * non US-ASCII characters. * * @param term the search term * @return true if only ASCII */ public static boolean isAscii(SearchTerm term) { if (term instanceof AndTerm) return isAscii(((AndTerm)term).getTerms()); else if (term instanceof OrTerm) return isAscii(((OrTerm)term).getTerms()); else if (term instanceof NotTerm) return isAscii(((NotTerm)term).getTerm()); else if (term instanceof StringTerm) return isAscii(((StringTerm)term).getPattern()); else if (term instanceof AddressTerm) return isAscii(((AddressTerm)term).getAddress().toString()); // Any other term returns true. return true; }
return checkSearchEncoding(((NotTerm)term).getTerm());