Changeset 689

Timestamp:

08/21/10 14:10:33 (18 months ago)

Author:

octorian

Message:

Conversion of connection layer to be byte-based, and complete rewrite of the IMAP paren-string parser (#224, #222)

Location:

trunk

Files:

• LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapClient.java (modified) (4 diffs)
• LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapParser.java (modified) (24 diffs)
• LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapProtocol.java (modified) (75 diffs)
• LogicMail/src/org/logicprobe/LogicMail/mail/pop/PopProtocol.java (modified) (3 diffs)
• LogicMail/src/org/logicprobe/LogicMail/mail/smtp/SmtpProtocol.java (modified) (2 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/ApplicationContent.java (modified) (2 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/AudioContent.java (modified) (2 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/ImageContent.java (modified) (3 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/MessageContent.java (modified) (2 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/MimeMessageContent.java (modified) (3 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/MimeMessageContentFactory.java (modified) (3 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/TextContent.java (modified) (3 diffs)
• LogicMail/src/org/logicprobe/LogicMail/message/VideoContent.java (modified) (2 diffs)
• LogicMail/src/org/logicprobe/LogicMail/ui/CompositionScreen.java (modified) (2 diffs)
• LogicMail/src/org/logicprobe/LogicMail/util/Connection.java (modified) (14 diffs)
• LogicMail/src/org/logicprobe/LogicMail/util/ConnectionResponseTester.java (added)
• LogicMail/src/org/logicprobe/LogicMail/util/MailMessageParser.java (modified) (3 diffs)
• LogicMail/src/org/logicprobe/LogicMail/util/StringArrays.java (added)
• LogicMail/src/org/logicprobe/LogicMail/util/StringParser.java (modified) (4 diffs)
• LogicMailTests/src/org/logicprobe/LogicMail/mail/imap/ImapParserTest.java (modified) (7 diffs)
• LogicMailTests/src/org/logicprobe/LogicMail/mail/imap/ImapProtocolTest.java (modified) (19 diffs)
• LogicMailTests/src/org/logicprobe/LogicMail/util/StringArraysTest.java (added)
• LogicMailTests/src/org/logicprobe/LogicMail/util/StringParserTest.java (modified) (5 diffs)
• LogicMailTests/src/org/logicprobe/LogicMail/util/UtilTests.java (modified) (1 diff)

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapClient.java

@@ -917 +917 @@
 
 
-        String data = getMessageBody(imapMessageToken.getImapMessageUid(), partAddress, progressHandler);
+        byte[] data = getMessageBody(imapMessageToken.getImapMessageUid(), partAddress, progressHandler);
         MimeMessageContent content;
         try {
-            content = MimeMessageContentFactory.createContent(mimeMessagePart, data);
+            content = MimeMessageContentFactory.createContentEncoded(mimeMessagePart, data);
         } catch (UnsupportedContentException e) {
             content = null;
@@ -937 +937 @@
         MimeMessagePart part;
         if(MimeMessagePartFactory.isMimeMessagePartSupported(structure.type, structure.subtype)) {
-            String data;
+            byte[] data;
             if(structure.type.equalsIgnoreCase("multipart"))
                 data = null;
@@ -961 +961 @@
                     structure.address);
             try {
-                contentMap.put(part, MimeMessageContentFactory.createContent(part, data));
+                contentMap.put(part, MimeMessageContentFactory.createContentEncoded(part, data));
             } catch (UnsupportedContentException e) {
                 System.err.println("UnsupportedContentException: " + e.getMessage());
@@ -1042 +1042 @@
     }
 
-    private String getMessageBody(int uid, String address, MailProgressHandler progressHandler) throws IOException, MailException {
+    private byte[] getMessageBody(int uid, String address, MailProgressHandler progressHandler) throws IOException, MailException {
         if(activeMailbox == null) {
             throw new MailException("Mailbox not selected");

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapParser.java

@@ -1 +1 @@
 /*-
- * Copyright (c) 2006, Derek Konigsberg
+ * Copyright (c) 2010, Derek Konigsberg
  * All rights reserved.
  *
@@ -32 +32 @@
 
 import net.rim.device.api.system.EventLogger;
+import net.rim.device.api.util.Arrays;
+import net.rim.device.api.util.ByteVector;
 
 import org.logicprobe.LogicMail.AppInfo;
 import org.logicprobe.LogicMail.message.MessageEnvelope;
+import org.logicprobe.LogicMail.util.StringArrays;
 import org.logicprobe.LogicMail.util.StringParser;
 
@@ -48 +51 @@
  */
 class ImapParser {
-    private static String strNIL = "NIL";
-    private static String MODIFIED_BASE64_ALPHABET =
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
-
+    private static String NIL = "NIL";
+    private static String BODYSTRUCTURE = "BODYSTRUCTURE";
+    private static String MODIFIED_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
+    private static Character LPAREN = new Character('(');
+    private static Character RPAREN = new Character(')');
+    private static String US_ASCII = "US-ASCII";
     static String FLAG_SEEN = "\\Seen";
     static String FLAG_ANSWERED = "\\Answered";
@@ -61 +66 @@
     static String FLAG_JUNK0 = "Junk";
     static String FLAG_JUNK1 = "$Junk";
-
+    
     private ImapParser() {
     }
@@ -110 +115 @@
                 buf.append(' ');
             }
+
             buf.append(FLAG_ANSWERED);
         }
@@ -117 +123 @@
                 buf.append(' ');
             }
+
             buf.append(FLAG_FLAGGED);
         }
@@ -124 +131 @@
                 buf.append(' ');
             }
+
             buf.append(FLAG_DELETED);
         }
@@ -131 +139 @@
                 buf.append(' ');
             }
+
             buf.append(FLAG_DRAFT);
         }
@@ -138 +147 @@
                 buf.append(' ');
             }
+
             buf.append(FLAG_RECENT);
         }
@@ -145 +155 @@
                 buf.append(' ');
             }
+
             buf.append(FLAG_FORWARDED);
         }
@@ -163 +174 @@
         MessageEnvelope env = new MessageEnvelope();
 
-        if (parsedEnv.elementAt(0) instanceof String) {
+        if (parsedEnv.elementAt(0) instanceof byte[]) {
             try {
-                env.date = StringParser.parseDateString((String) parsedEnv.elementAt(
-                            0));
+                env.date = StringParser.parseDateString(
+                        new String((byte[]) parsedEnv.elementAt(0)));
             } catch (Exception e) {
                 env.date = Calendar.getInstance().getTime();
             }
         }
-
-        if (parsedEnv.elementAt(1) instanceof String) {
-            String subject = (String) parsedEnv.elementAt(1);
-
-            if (subject.equals(strNIL)) {
-                env.subject = "";
-            } else {
-                env.subject = StringParser.parseEncodedHeader(subject);
-            }
+        else {
+            env.date = Calendar.getInstance().getTime();
+        }
+
+        if (parsedEnv.elementAt(1) instanceof byte[]) {
+            env.subject = StringParser.parseEncodedHeader(
+                    new String((byte[])parsedEnv.elementAt(1)));
+        }
+        else {
+            env.subject = "";
         }
 
@@ -206 +218 @@
         }
 
-        if (parsedEnv.elementAt(8) instanceof String) {
-            env.inReplyTo = (String) parsedEnv.elementAt(8);
-
-            if (env.inReplyTo.equals(strNIL)) {
-                env.inReplyTo = "";
-            }
-        }
-
-        if (parsedEnv.elementAt(9) instanceof String) {
-            env.messageId = (String) parsedEnv.elementAt(9);
-
-            if (env.messageId.equals(strNIL)) {
-                env.messageId = "";
-            }
+        if (parsedEnv.elementAt(8) instanceof byte[]) {
+            env.inReplyTo = new String((byte[])parsedEnv.elementAt(8));
+        }
+        else {
+            env.inReplyTo = "";
+        }
+
+        if (parsedEnv.elementAt(9) instanceof byte[]) {
+            env.messageId = new String((byte[])parsedEnv.elementAt(9));
+        }
+        else {
+            env.messageId = "";
         }
 
@@ -235 +245 @@
                 Vector entry = (Vector) addrVec.elementAt(i);
 
-                String realName = strNIL;
-
-                if (entry.elementAt(0) instanceof String) {
-                    realName = StringParser.parseEncodedHeader((String) entry.elementAt(
-                                0));
-                }
-
-                String mbName = strNIL;
-
-                if (entry.elementAt(2) instanceof String) {
-                    mbName = (String) entry.elementAt(2);
-                }
-
-                String hostName = strNIL;
-
-                if (entry.elementAt(3) instanceof String) {
-                    hostName = (String) entry.elementAt(3);
-                }
-
-                String addrStr = (mbName.equals(strNIL) ? "" : mbName) +
-                    (hostName.equals(strNIL) ? "" : ('@' + hostName));
+                String realName = NIL;
+
+                if (entry.elementAt(0) instanceof byte[]) {
+                    realName = StringParser.parseEncodedHeader(
+                            new String((byte[]) entry.elementAt(0)));
+                }
+
+                String mbName = NIL;
+
+                if (entry.elementAt(2) instanceof byte[]) {
+                    mbName = new String((byte[]) entry.elementAt(2));
+                }
+
+                String hostName = NIL;
+
+                if (entry.elementAt(3) instanceof byte[]) {
+                    hostName = new String((byte[]) entry.elementAt(3));
+                }
+
+                String addrStr = (mbName.equals(NIL) ? "" : mbName) +
+                    (hostName.equals(NIL) ? "" : ('@' + hostName));
 
                 // Now assemble these into a single address entry
                 // (possibly eventually storing them separately)
-                if ((realName.length() > 0) && !realName.equals(strNIL)) {
+                if ((realName.length() > 0) && !realName.equals(NIL)) {
                     addrList[index] = realName + " <" + addrStr + ">";
                 } else {
@@ -288 +298 @@
      * @return Root of the message structure tree
      */
-    static MessageSection parseMessageStructure(String rawText) {
+    static MessageSection parseMessageStructure(byte[] rawText) {
         Vector parsedText = null;
 
         try {
-            parsedText = StringParser.nestedParenStringLexer(rawText.substring(
-                        rawText.indexOf('(')));
+            int offset = Arrays.getIndex(rawText, (byte)'(');
+            parsedText = ImapParser.parenListParser(rawText, offset, rawText.length - offset);
         } catch (Exception exp) {
             EventLogger.logEvent(AppInfo.GUID,
@@ -311 +321 @@
                 String label = (String) parsedText.elementAt(i);
 
-                if (label.equalsIgnoreCase("BODYSTRUCTURE") &&
+                if (label.equalsIgnoreCase(BODYSTRUCTURE) &&
                         (i < (size - 1)) &&
                         parsedText.elementAt(i + 1) instanceof Vector) {
@@ -335 +345 @@
     /**
      * Parse the IMAP message structure tree from a prepared object tree
-     * generated by {@link StringParser#nestedParenStringLexer(String)}.
+     * generated by {@link ImapParser#parenListParser(String)}.
      *
      * @param parsedStruct Tree containing the {@link Vector} that follows a BODYSTRUCTURE string
@@ -341 +351 @@
      */
     static MessageSection parseMessageStructureParameter(Vector parsedStruct) {
-        MessageSection msgStructure = parseMessageStructureHelper(null, 1, parsedStruct);
+        MessageSection msgStructure = parseMessageStructureHelper(
+                null, 1, parsedStruct);
         fixMessageStructure(msgStructure);
+
         return msgStructure;
     }
-    
+
     /**
      * This method implements a kludge to fix body part addresses
@@ -380 +392 @@
 
         // Determine the number of body parts and parse
-        if (parsedStruct.elementAt(0) instanceof String) {
+        if (parsedStruct.elementAt(0) instanceof byte[]) {
             // The first element is a string, so we hit a simple message part
             MessageSection section = parseMessageStructureSection(parsedStruct);
@@ -396 +408 @@
                     subSectionsVector.addElement(parseMessageStructureHelper(
                             address, i + 1, (Vector) parsedStruct.elementAt(i)));
-                } else if (parsedStruct.elementAt(i) instanceof String) {
+                } else if (parsedStruct.elementAt(i) instanceof byte[]) {
                     MessageSection section = new MessageSection();
                     section.type = "multipart";
-                    section.subtype = ((String) parsedStruct.elementAt(i)).toLowerCase();
+                    section.subtype = (new String((byte[]) parsedStruct.elementAt(i))).toLowerCase();
                     section.subsections = new MessageSection[subSectionsVector.size()];
                     subSectionsVector.copyInto(section.subsections);
@@ -412 +424 @@
     }
 
-    private static MessageSection parseMessageStructureSection(Vector sectionList) {
+    private static MessageSection parseMessageStructureSection(
+        Vector sectionList) {
         MessageSection sec = new MessageSection();
         Vector tmpVec;
         int sectionListSize = sectionList.size();
 
-        if (sectionList.elementAt(0) instanceof String) {
-            sec.type = ((String) sectionList.elementAt(0)).toLowerCase();
-        }
-
-        if (sectionList.elementAt(1) instanceof String) {
-            sec.subtype = ((String) sectionList.elementAt(1)).toLowerCase();
+        if (sectionList.elementAt(0) instanceof byte[]) {
+            sec.type = (new String((byte[])sectionList.elementAt(0))).toLowerCase();
+        }
+
+        if (sectionList.elementAt(1) instanceof byte[]) {
+            sec.subtype = (new String((byte[])sectionList.elementAt(1))).toLowerCase();
         }
 
@@ -431 +444 @@
 
             int size = tmpVec.size();
-            for(int i=0; i < size - 1; i+=2) {
-                if(tmpVec.elementAt(i) instanceof String &&
-                   tmpVec.elementAt(i+1) instanceof String) {
-                        String key = (String)tmpVec.elementAt(i);
-                        String value = (String)tmpVec.elementAt(i+1);
-                        if(key.equalsIgnoreCase("charset")) {
-                                sec.charset = value;
-                        }
-                        else if(key.equalsIgnoreCase("name")) {
-                                sec.name = value;
-                        }
-                }
-            }
-        }
-
-        if (sectionList.elementAt(3) instanceof String) {
-                sec.contentId = (String) sectionList.elementAt(3);
-        }
-        
-        if (sectionList.elementAt(5) instanceof String) {
-            sec.encoding = ((String) sectionList.elementAt(5)).toLowerCase();
+
+            for (int i = 0; i < (size - 1); i += 2) {
+                if (tmpVec.elementAt(i) instanceof byte[] &&
+                        tmpVec.elementAt(i + 1) instanceof byte[]) {
+                    String key = new String((byte[]) tmpVec.elementAt(i));
+                    String value = new String((byte[]) tmpVec.elementAt(i + 1));
+
+                    if (key.equalsIgnoreCase("charset")) {
+                        sec.charset = value;
+                    } else if (key.equalsIgnoreCase("name")) {
+                        sec.name = value;
+                    }
+                }
+            }
+        }
+
+        if (sectionList.elementAt(3) instanceof byte[]) {
+            sec.contentId = new String((byte[]) sectionList.elementAt(3));
+        }
+
+        if (sectionList.elementAt(5) instanceof byte[]) {
+            sec.encoding = new String(((byte[]) sectionList.elementAt(5))).toLowerCase();
         }
 
@@ -462 +476 @@
         }
 
-        if (sectionListSize > 8 && sectionList.elementAt(8) instanceof Vector) {
-                tmpVec = (Vector) sectionList.elementAt(8);
-                if(tmpVec.elementAt(0) instanceof String) {
-                        sec.disposition = ((String)tmpVec.elementAt(0)).toLowerCase();
-                }
-        }
-        
+        if ((sectionListSize > 8) &&
+                sectionList.elementAt(8) instanceof Vector) {
+            tmpVec = (Vector) sectionList.elementAt(8);
+
+            if (tmpVec.elementAt(0) instanceof byte[]) {
+                sec.disposition = new String((byte[]) tmpVec.elementAt(0)).toLowerCase();
+            }
+        }
+
         return sec;
     }
@@ -574 +590 @@
     }
 
+    static Vector parenListLexer(byte[] rawText, int offset, int length) {
+        if(offset + length > rawText.length) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        Vector result = new Vector();
+        ByteVector buf = new ByteVector();
+
+        int size = offset + length;
+        int i = offset;
+
+        while (i < size) {
+            byte ch = rawText[i];
+
+            if (ch == (byte)'(') {
+                result.addElement(LPAREN);
+                i++;
+            } else if (ch == (byte)')') {
+                result.addElement(RPAREN);
+                i++;
+            } else if (ch == (byte)'"') {
+                // Quoted string
+                i++;
+                buf.setSize(0);
+
+                while (i < (size - 1)) {
+                    ch = rawText[i];
+
+                    if (ch == (byte)'\\') {
+                        byte ch1 = rawText[i + 1];
+
+                        if (ch1 == (byte)'\\' || ch1 == (byte)'"') {
+                            buf.addElement(ch1);
+                        }
+
+                        i += 2;
+                    } else if (ch == '"') {
+                        result.addElement(buf.toArray());
+                        i++;
+
+                        break;
+                    } else {
+                        buf.addElement(ch);
+                        i++;
+                    }
+                }
+            } else if (ch == '{') {
+                // Literal string
+                int p = StringArrays.indexOf(rawText, (byte)'}', i);
+                int len = StringArrays.parseInt(rawText, i + 1, p - i - 1);
+                i = p + 3;
+                result.addElement(Arrays.copy(rawText, i, len));
+                i += len;
+
+                // Check for invalid length, etc
+            } else if (ch == ' ') {
+                // Skip the space
+                i++;
+            } else {
+                // Keyword
+                int p1 = StringArrays.indexOf(rawText, (byte)' ', i);
+                int p2 = StringArrays.indexOf(rawText, (byte)')', i);
+                int p;
+
+                if (p1 == -1) {
+                    p = p2;
+                } else if (p2 == -1) {
+                    p = p1;
+                } else {
+                    p = Math.min(p1, p2);
+                }
+
+                // check if p == -1, and bomb out
+                if(p == -1) {
+                    p = size;
+                }
+                try {
+                    result.addElement(new String(rawText, i, p - i, US_ASCII));
+                } catch (UnsupportedEncodingException e) {
+                    result.addElement(new String(rawText, i, p - i));
+                }
+
+                i = p;
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Recursively parse an IMAP parenthesized string.
+     * <p>
+     * Parses through a string of the form "(A (B C (D) E F))" and
+     * returns a tree of representing its contents.  Each element will either
+     * be a <code>Vector</code>, <code>String</code>, or a <code>byte[]</code>.
+     * Vectors are elements that contain other elements, strings are unquoted
+     * elements (e.g. keywords, flags, numbers), and byte arrays are quoted
+     * text or literals.
+     * </p>
+     *
+     * @param rawText The raw text to be parsed
+     * @return A tree containing the parsed data
+     */
+    static Vector parenListParser(byte[] rawText) {
+        return parenListParser(rawText, 0, rawText.length);
+    }
+    
+    /**
+     * Recursively parse an IMAP parenthesized string.
+     * <p>
+     * Parses through a string of the form "(A (B C (D) E F))" and
+     * returns a tree of representing its contents.  Each element will either
+     * be a <code>Vector</code>, <code>String</code>, or a <code>byte[]</code>.
+     * Vectors are elements that contain other elements, strings are unquoted
+     * elements (e.g. keywords, flags, numbers), and byte arrays are quoted
+     * text or literals.
+     * </p>
+     *
+     * @param rawText The raw text to be parsed
+     * @param The offset to start parsing from
+     * @param length The length of the data to parse
+     * @return A tree containing the parsed data
+     */
+    static Vector parenListParser(byte[] rawText, int offset, int length) {
+        Vector tokenized = parenListLexer(rawText, offset, length);
+        MutableInteger mutableInteger = new MutableInteger();
+        Vector result = parenListParserImpl(tokenized, mutableInteger);
+        return result;
+    }
+
+    static Vector parenListParserImpl(Vector tokenized, MutableInteger index) {
+        Vector result = new Vector();
+        Object element = tokenized.elementAt(++index.value);
+
+        while (element != RPAREN) {
+            if (element == LPAREN) {
+                result.addElement(parenListParserImpl(tokenized, index));
+            } else {
+                result.addElement(element);
+            }
+
+            element = tokenized.elementAt(++index.value);
+        }
+
+        return result;
+    }
+
     /**
      * Simple container for a parsed message structure tree
@@ -589 +752 @@
         public MessageSection[] subsections;
     }
+
+    private static class MutableInteger {
+        public int value = 0;
+    }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapProtocol.java

@@ -33 +33 @@
 import net.rim.device.api.system.EventLogger;
 import net.rim.device.api.util.Arrays;
-import net.rim.device.api.util.ToIntHashtable;
+import net.rim.device.api.util.IntIntHashtable;
 
 import org.logicprobe.LogicMail.AppInfo;
@@ -40 +40 @@
 import org.logicprobe.LogicMail.message.MessageEnvelope;
 import org.logicprobe.LogicMail.util.Connection;
+import org.logicprobe.LogicMail.util.ConnectionResponseTester;
+import org.logicprobe.LogicMail.util.StringArrays;
 import org.logicprobe.LogicMail.util.StringParser;
 
@@ -52 +54 @@
  */
 public class ImapProtocol {
+
     private Connection connection;
     private String idleCommandTag;
-    
+
     /**
      * Counts the commands executed so far in this session. Every command of an
@@ -66 +69 @@
     }
 
-
     /**
      * Execute the "STARTTLS" command.
@@ -75 +77 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeStartTLS()").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
+                ("ImapProtocol.executeStartTLS()").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
         execute(STARTTLS, null, null);
     }
@@ -88 +91 @@
      */
     public boolean executeLogin(String username, String password)
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeLogin(\"" + username + "\", \"" +
-                            password + "\")").getBytes(), EventLogger.DEBUG_INFO);
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeLogin(\"" + username + "\", \"" +
+                password + "\")").getBytes(), EventLogger.DEBUG_INFO);
         }
 
@@ -98 +101 @@
         try {
             execute(LOGIN,
-                    CHAR_QUOTE + StringParser.addEscapedChars(username) + "\" \"" +
-                    StringParser.addEscapedChars(password) + CHAR_QUOTE, null);
+                CHAR_QUOTE + StringParser.addEscapedChars(username) + "\" \"" +
+                StringParser.addEscapedChars(password) + CHAR_QUOTE, null);
         } catch (MailException exp) {
             // Invalid users are caught by execute()
@@ -115 +118 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeLogout()").getBytes(),
-                    EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeLogout()").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
@@ -128 +131 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeClose()").getBytes(),
-                    EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeClose()").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
@@ -143 +146 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeCapability()").getBytes(),
-                    EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeCapability()").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
@@ -170 +173 @@
      */
     public NamespaceResponse executeNamespace()
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeNamespace()").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
-
-        String[] replyText = execute(NAMESPACE, null, null);
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeNamespace()").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] replyText = executeResponse(NAMESPACE, null, null);
 
         if ((replyText == null) || (replyText.length < 1)) {
@@ -183 +186 @@
         }
 
-        // Assume a single-line reply
-        Vector tokens = StringParser.nestedParenStringLexer("(" +
-                replyText[0].substring(replyText[0].indexOf('(')) + ")");
+        // Assume a single-line reply, and modify that reply so its enclosed
+        // within a set of outer parenthesis so that the parser is happy.
+        int offset = Arrays.getIndex(replyText[0], (byte)'(');
+        byte[] data = new byte[(replyText[0].length - offset) + 2];
+        data[0] = (byte)'(';
+        int j = 1;
+        for(int i=offset; i<replyText[0].length; i++) {
+            data[j++] = replyText[0][i];
+        }
+        data[j] = (byte)')';
+        
+        Vector tokens = ImapParser.parenListParser(data);
 
         // Sanity check on results
@@ -210 +222 @@
 
                     if (temp.size() >= 2) {
-                        if (temp.elementAt(0) instanceof String) {
-                            response.personal[i].prefix =
-                                StringParser.removeEscapedChars((String) temp.elementAt(0));
+                        if (temp.elementAt(0) instanceof byte[]) {
+                            response.personal[i].prefix = new String((byte[]) temp.elementAt(0));
                         }
 
-                        if (temp.elementAt(1) instanceof String) {
-                            response.personal[i].delimiter =
-                                StringParser.removeEscapedChars((String) temp.elementAt(1));
+                        if (temp.elementAt(1) instanceof byte[]) {
+                            response.personal[i].delimiter = new String((byte[]) temp.elementAt(1));
                         }
                     }
@@ -236 +246 @@
 
                     if (temp.size() >= 2) {
-                        if (temp.elementAt(0) instanceof String) {
-                            response.other[i].prefix =
-                                StringParser.removeEscapedChars((String) temp.elementAt(0));
+                        if (temp.elementAt(0) instanceof byte[]) {
+                            response.other[i].prefix = new String((byte[]) temp.elementAt(0));
                         }
 
-                        if (temp.elementAt(1) instanceof String) {
-                            response.other[i].delimiter =
-                                StringParser.removeEscapedChars((String) temp.elementAt(1));
+                        if (temp.elementAt(1) instanceof byte[]) {
+                            response.other[i].delimiter = new String((byte[]) temp.elementAt(1));
                         }
                     }
@@ -262 +270 @@
 
                     if (temp.size() >= 2) {
-                        if (temp.elementAt(0) instanceof String) {
-                            response.shared[i].prefix =
-                                StringParser.removeEscapedChars((String) temp.elementAt(0));
+                        if (temp.elementAt(0) instanceof byte[]) {
+                            response.shared[i].prefix = new String((byte[]) temp.elementAt(0));
                         }
 
-                        if (temp.elementAt(1) instanceof String) {
-                            response.shared[i].delimiter =
-                                StringParser.removeEscapedChars((String) temp.elementAt(1));
+                        if (temp.elementAt(1) instanceof byte[]) {
+                            response.shared[i].delimiter = new String((byte[]) temp.elementAt(1));
                         }
                     }
@@ -285 +291 @@
      */
     public SelectResponse executeSelect(String mboxpath)
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeSelect(\"" + mboxpath + "\")").getBytes(),
-                    EventLogger.DEBUG_INFO);
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeSelect(\"" + mboxpath + "\")").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
         String[] replyText = execute(SELECT,
-                CHAR_QUOTE + StringParser.addEscapedChars(mboxpath) + CHAR_QUOTE, null);
+                CHAR_QUOTE + StringParser.addEscapedChars(mboxpath) +
+                CHAR_QUOTE, null);
         SelectResponse response = new SelectResponse();
 
@@ -308 +315 @@
                 if ((q != -1) && (p != -1) && (q > p)) {
                     try {
-                        response.exists = Integer.parseInt(
-                                rowText.substring(p + 1, q));
+                        response.exists = Integer.parseInt(rowText.substring(p +
+                                    1, q));
                     } catch (NumberFormatException e) {
                         response.exists = 0;
@@ -320 +327 @@
                 if ((q != -1) && (p != -1) && (q > p)) {
                     try {
-                        response.recent = Integer.parseInt(
-                                rowText.substring(p + 1, q));
+                        response.recent = Integer.parseInt(rowText.substring(p +
+                                    1, q));
                     } catch (NumberFormatException e) {
                         response.recent = 0;
@@ -332 +339 @@
                 if ((q != -1) && (p != -1) && (q > p)) {
                     try {
-                        response.unseen = Integer.parseInt(
-                                rowText.substring(p + 1, q));
+                        response.unseen = Integer.parseInt(rowText.substring(p +
+                                    1, q));
                     } catch (NumberFormatException e) {
                         response.unseen = 0;
@@ -344 +351 @@
                 if ((q != -1) && (p != -1) && (q > p)) {
                     try {
-                        response.uidValidity = Integer.parseInt(
-                                rowText.substring(p + 1, q));
+                        response.uidValidity = Integer.parseInt(rowText.substring(p +
+                                    1, q));
                     } catch (NumberFormatException e) {
                         response.uidValidity = 0;
@@ -356 +363 @@
                 if ((q != -1) && (p != -1) && (q > p)) {
                     try {
-                        response.uidNext = Integer.parseInt(
-                                rowText.substring(p + 1, q));
+                        response.uidNext = Integer.parseInt(rowText.substring(p +
+                                    1, q));
                     } catch (NumberFormatException e) {
                         response.uidNext = -1;
@@ -371 +378 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeExpunge()").getBytes(),
-                    EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeExpunge()").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
@@ -378 +385 @@
     }
 
-    public StatusResponse[] executeStatus(String[] mboxpaths, MailProgressHandler progressHandler)
-    throws IOException, MailException {
+    public StatusResponse[] executeStatus(String[] mboxpaths,
+        MailProgressHandler progressHandler) throws IOException, MailException {
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             StringBuffer buf = new StringBuffer();
@@ -394 +401 @@
             buf.append("})");
             EventLogger.logEvent(AppInfo.GUID, buf.toString().getBytes(),
-                    EventLogger.DEBUG_INFO);
+                EventLogger.DEBUG_INFO);
         }
 
@@ -403 +410 @@
 
         for (i = 0; i < mboxpaths.length; i++) {
-            arguments[i] = CHAR_QUOTE + StringParser.addEscapedChars(mboxpaths[i]) +
-            "\" (MESSAGES UNSEEN)";
+            arguments[i] = CHAR_QUOTE +
+                StringParser.addEscapedChars(mboxpaths[i]) +
+                "\" (MESSAGES UNSEEN)";
         }
 
@@ -427 +435 @@
             }
 
-            String[] fields = StringParser.parseTokenString(
-                    result[i].substring(p + 1, q), CHAR_SP);
+            String[] fields = StringParser.parseTokenString(result[i].substring(p +
+                        1, q), CHAR_SP);
 
             if (fields.length != 4) {
@@ -459 +467 @@
      * @return Array of FetchFlagsResponse objects
      */
-    public FetchFlagsResponse[] executeFetchFlags(
-            int firstIndex,
-            int lastIndex,
-            MailProgressHandler progressHandler) throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchFlags(" + firstIndex + ", " +
-                            lastIndex + ")").getBytes(), EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(FETCH,
+    public FetchFlagsResponse[] executeFetchFlags(int firstIndex,
+        int lastIndex, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchFlags(" + firstIndex + ", " +
+                lastIndex + ")").getBytes(), EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(FETCH,
                 Integer.toString(firstIndex) + CHAR_COLON +
                 Integer.toString(lastIndex) + " (FLAGS UID)", progressHandler);
@@ -482 +489 @@
      * @return Array of FetchFlagsResponse objects
      */
-    public FetchFlagsResponse[] executeFetchFlagsUid(
-            int uidNext,
-            MailProgressHandler progressHandler) throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchFlagsUid(" + uidNext + ")").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(UID_FETCH,
-                Integer.toString(uidNext) + CHAR_COLON_ASTERISK + " (FLAGS UID)", progressHandler);
+    public FetchFlagsResponse[] executeFetchFlagsUid(int uidNext,
+        MailProgressHandler progressHandler) throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchFlagsUid(" + uidNext + ")").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(UID_FETCH,
+                Integer.toString(uidNext) + CHAR_COLON_ASTERISK +
+                " (FLAGS UID)", progressHandler);
 
         return prepareFetchFlagsResponse(rawList, progressHandler);
     }
 
-    private FetchFlagsResponse[] prepareFetchFlagsResponse(
-            String[] rawList, MailProgressHandler progressHandler) throws IOException, MailException {
-
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); }
-        // Preprocess the returned text to clean up mid-field line breaks
-        // This should all become unnecessary once execute()
-        // becomes more intelligent in how it handles replies
-        Vector rawList2 = prepareCleanFetchResponse(rawList);
+    private FetchFlagsResponse[] prepareFetchFlagsResponse(byte[][] rawList,
+        MailProgressHandler progressHandler) throws IOException, MailException {
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING,
+                0, -1);
+        }
 
         Vector flagResponses = new Vector();
-        int size = rawList2.size();
-
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, size); }
-        for (int i = 0; i < size; i++) {
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(
+                    MailProgressHandler.TYPE_PROCESSING, 0, rawList.length);
+        }
+        
+        for (int i = 0; i < rawList.length; i++) {
+            byte[] rawText = rawList[i];
+            if(rawText == null || rawText.length == 0 || rawText[0] != CHAR_ASTERISK) {
+                continue;
+            }
+            
             try {
-                String rawText = (String) rawList2.elementAt(i);
-
                 Vector parsedText = null;
 
                 try {
-                    parsedText = StringParser.nestedParenStringLexer(rawText.substring(
-                            rawText.indexOf('(')));
+                    int offset = Arrays.getIndex(rawText, (byte)'(');
+                    parsedText = ImapParser.parenListParser(rawText, offset, rawText.length - offset);
                 } catch (Exception exp) {
                     parsedText = null;
+
                     continue;
                 }
@@ -533 +545 @@
                 for (int j = 0; j < parsedSize; j++) {
                     if (parsedText.elementAt(j) instanceof String) {
-                        if (((String)parsedText.elementAt(j)).equals(FLAGS)
-                                && (parsedSize > (j + 1))
-                                && parsedText.elementAt(j + 1) instanceof Vector) {
-                            flagRespItem.flags = ImapParser.parseMessageFlags((Vector) parsedText.elementAt(j + 1));
-                        }
-                        else if (((String)parsedText.elementAt(j)).equals(UID)
-                                && (parsedSize > (j + 1))
-                                && parsedText.elementAt(j + 1) instanceof String) {
+                        if (((String) parsedText.elementAt(j)).equals(FLAGS) &&
+                                (parsedSize > (j + 1)) &&
+                                parsedText.elementAt(j + 1) instanceof Vector) {
+                            flagRespItem.flags = ImapParser.parseMessageFlags((Vector) parsedText.elementAt(j +
+                                        1));
+                        } else if (((String) parsedText.elementAt(j)).equals(
+                                    UID) && (parsedSize > (j + 1)) &&
+                                parsedText.elementAt(j + 1) instanceof String) {
                             try {
-                                flagRespItem.uid = Integer.parseInt((String) parsedText.elementAt(j + 1));
+                                flagRespItem.uid = Integer.parseInt((String) parsedText.elementAt(j +
+                                            1));
                             } catch (NumberFormatException e) {
                                 flagRespItem.uid = -1;
@@ -555 +568 @@
 
                 // Find the message index in the reply
-                int midx = Integer.parseInt(rawText.substring(rawText.indexOf(
-                ' '), rawText.indexOf(FETCH) - 1).trim());
+                int spaceIndex = Arrays.getIndex(rawText, (byte)' ');
+                int fetchIndex = StringArrays.indexOf(rawText, FETCH.getBytes(), spaceIndex);
+                int midx = StringArrays.parseInt(rawText, spaceIndex + 1, fetchIndex - spaceIndex - 2);
 
                 flagRespItem.index = midx;
@@ -562 +576 @@
             } catch (Exception exp) {
                 EventLogger.logEvent(AppInfo.GUID,
-                        ("Parse error: " + exp).getBytes(),
-                        EventLogger.ERROR);
-            }
-            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, i, size); }
+                    ("Parse error: " + exp).getBytes(), EventLogger.ERROR);
+            }
+
+            if (progressHandler != null) {
+                progressHandler.mailProgress(
+                        MailProgressHandler.TYPE_PROCESSING, i, rawList.length);
+            }
         }
 
         FetchFlagsResponse[] result = new FetchFlagsResponse[flagResponses.size()];
         flagResponses.copyInto(result);
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, size, size); }
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(
+                    MailProgressHandler.TYPE_PROCESSING,
+                    rawList.length, rawList.length);
+        }
 
         return result;
@@ -582 +604 @@
      * @param progressHandler the progress handler
      */
-    public void executeFetchEnvelope(
-            int firstIndex,
-            int lastIndex,
-            FetchEnvelopeCallback callback,
-            MailProgressHandler progressHandler) throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchEnvelope(" + firstIndex + ", " +
-                            lastIndex + ")").getBytes(), EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(FETCH,
+    public void executeFetchEnvelope(int firstIndex, int lastIndex,
+        FetchEnvelopeCallback callback, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchEnvelope(" + firstIndex + ", " +
+                lastIndex + ")").getBytes(), EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(FETCH,
                 Integer.toString(firstIndex) + CHAR_COLON +
-                Integer.toString(lastIndex) + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler);
+                Integer.toString(lastIndex) +
+                " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler);
 
         prepareFetchEnvelopeResponse(rawList, callback, progressHandler);
@@ -606 +627 @@
      * @param progressHandler the progress handler
      */
-    public void executeFetchEnvelopeUid(int uidNext, FetchEnvelopeCallback callback, MailProgressHandler progressHandler)
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchEnvelopeUid(" + uidNext + ")").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(UID_FETCH,
-                Integer.toString(uidNext) + CHAR_COLON_ASTERISK + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler);
+    public void executeFetchEnvelopeUid(int uidNext,
+        FetchEnvelopeCallback callback, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchEnvelopeUid(" + uidNext + ")").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(UID_FETCH,
+                Integer.toString(uidNext) + CHAR_COLON_ASTERISK +
+                " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler);
 
         prepareFetchEnvelopeResponse(rawList, callback, progressHandler);
@@ -626 +649 @@
      * @param progressHandler the progress handler
      */
-    public void executeFetchEnvelopeUid(int[] uids, FetchEnvelopeCallback callback, MailProgressHandler progressHandler)
-    throws IOException, MailException {
-        if(uids.length == 0) { callback.responseAvailable(null); return; }
+    public void executeFetchEnvelopeUid(int[] uids,
+        FetchEnvelopeCallback callback, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if (uids.length == 0) {
+            callback.responseAvailable(null);
+
+            return;
+        }
+
         StringBuffer buf = new StringBuffer();
-        for(int i=0; i<uids.length - 1; i++) {
+
+        for (int i = 0; i < (uids.length - 1); i++) {
             buf.append(uids[i]);
             buf.append(',');
         }
+
         buf.append(uids[uids.length - 1]);
+
         String uidList = buf.toString();
 
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchEnvelopeUid(" + uidList + ")").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(UID_FETCH,
+                ("ImapProtocol.executeFetchEnvelopeUid(" + uidList + ")").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(UID_FETCH,
                 uidList + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler);
 
@@ -649 +681 @@
     }
 
-    private void prepareFetchEnvelopeResponse(
-            String[] rawList, FetchEnvelopeCallback callback, MailProgressHandler progressHandler) throws IOException, MailException {
-
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); }
-        // Preprocess the returned text to clean up mid-field line breaks
-        // This should all become unnecessary once execute()
-        // becomes more intelligent in how it handles replies
-        Vector rawList2 = prepareCleanFetchResponse(rawList);
-
-        int size = rawList2.size();
-
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, size); }
-        for (int i = 0; i < size; i++) {
+    private void prepareFetchEnvelopeResponse(byte[][] rawList,
+        FetchEnvelopeCallback callback, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING,
+                0, -1);
+        }
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(
+                    MailProgressHandler.TYPE_PROCESSING, 0, rawList.length);
+        }
+
+        for (int i = 0; i < rawList.length; i++) {
+            byte[] rawText = rawList[i];
+            if(rawText == null || rawText.length == 0 || rawText[0] != CHAR_ASTERISK) {
+                continue;
+            }
+            
             FetchEnvelopeResponse envRespItem = null;
             try {
-                String rawText = (String) rawList2.elementAt(i);
-
                 MessageEnvelope env = null;
                 ImapParser.MessageSection structure = null;
@@ -671 +707 @@
 
                 try {
-                    parsedText = StringParser.nestedParenStringLexer(rawText.substring(
-                            rawText.indexOf('(')));
+                    int offset = Arrays.getIndex(rawText, (byte)'(');
+                    parsedText = ImapParser.parenListParser(rawText, offset, rawText.length - offset);
                 } catch (Exception exp) {
                     continue;
@@ -685 +721 @@
 
                 for (int j = 0; j < parsedSize; j++) {
-                    if (parsedText.elementAt(j) instanceof String) {
-                        if (((String)parsedText.elementAt(j)).equals(FLAGS)
-                                && (parsedSize > (j + 1))
-                                && parsedText.elementAt(j + 1) instanceof Vector) {
-                            envRespItem.flags = ImapParser.parseMessageFlags((Vector) parsedText.elementAt(j + 1));
+                    if (FLAGS.equals(parsedText.elementAt(j))
+                            && (parsedSize > (j + 1))
+                            && parsedText.elementAt(j + 1) instanceof Vector) {
+                        envRespItem.flags = ImapParser.parseMessageFlags((Vector) parsedText.elementAt(j + 1));
+                    }
+                    else if (UID.equals(parsedText.elementAt(j))
+                            && (parsedSize > (j + 1))
+                            && parsedText.elementAt(j + 1) instanceof String) {
+                        try {
+                            envRespItem.uid = Integer.parseInt((String) parsedText.elementAt(j + 1));
+                        } catch (NumberFormatException e) {
+                            envRespItem.uid = -1;
                         }
-                        else if (((String)parsedText.elementAt(j)).equals(UID)
-                                && (parsedSize > (j + 1))
-                                && parsedText.elementAt(j + 1) instanceof String) {
-                            try {
-                                envRespItem.uid = Integer.parseInt((String) parsedText.elementAt(j + 1));
-                            } catch (NumberFormatException e) {
-                                envRespItem.uid = -1;
-                            }
-                        }
-                        else if (((String)parsedText.elementAt(j)).equals(ENVELOPE)
-                                && (parsedSize > (j + 1))
-                                && parsedText.elementAt(j + 1) instanceof Vector) {
-                            env = ImapParser.parseMessageEnvelope((Vector) parsedText.elementAt(j + 1));
-                        }
-                        else if (((String)parsedText.elementAt(j)).equals(BODYSTRUCTURE)
-                                && (parsedSize > (j + 1))
-                                && parsedText.elementAt(j + 1) instanceof Vector) {
-                            structure = ImapParser.parseMessageStructureParameter(
-                                    (Vector)parsedText.elementAt(j + 1));
-                        }
+                    }
+                    else if (ENVELOPE.equals(parsedText.elementAt(j))
+                            && (parsedSize > (j + 1))
+                            && parsedText.elementAt(j + 1) instanceof Vector) {
+                        env = ImapParser.parseMessageEnvelope((Vector) parsedText.elementAt(j + 1));
+                    }
+                    else if (BODYSTRUCTURE.equals(parsedText.elementAt(j))
+                            && (parsedSize > (j + 1))
+                            && parsedText.elementAt(j + 1) instanceof Vector) {
+                        structure = ImapParser.parseMessageStructureParameter((Vector) parsedText.elementAt(j + 1));
                     }
                 }
@@ -725 +758 @@
 
                 // Find the message index in the reply
-                int midx = Integer.parseInt(rawText.substring(rawText.indexOf(
-                ' '), rawText.indexOf(FETCH) - 1).trim());
+                int spaceIndex = Arrays.getIndex(rawText, (byte)' ');
+                int fetchIndex = StringArrays.indexOf(rawText, FETCH.getBytes(), spaceIndex);
+                int midx = StringArrays.parseInt(rawText, spaceIndex + 1, fetchIndex - spaceIndex - 2);
 
                 envRespItem.index = midx;
@@ -733 +767 @@
             } catch (Exception exp) {
                 EventLogger.logEvent(AppInfo.GUID,
-                        ("Parse error: " + exp).getBytes(),
-                        EventLogger.ERROR);
+                    ("Parse error: " + exp).getBytes(), EventLogger.ERROR);
                 envRespItem = null;
             }
-            if(envRespItem != null) {
+
+            if (envRespItem != null) {
                 callback.responseAvailable(envRespItem);
             }
-            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, i, size); }
+
+            if (progressHandler != null) {
+                progressHandler.mailProgress(
+                        MailProgressHandler.TYPE_PROCESSING, i, rawList.length);
+            }
         }
 
         callback.responseAvailable(null);
-    }
-
-    private static Vector prepareCleanFetchResponse(String[] rawList) {
-        Vector cleanList = new Vector();
-        String line;
-        StringBuffer lineBuf = new StringBuffer();
-        for (int i = 0; i < rawList.length; i++) {
-            line = rawList[i];
-
-            if ((line.length() > 0) && lineBuf.toString().startsWith(CHAR_ASTERISK_SP) &&
-                    line.startsWith(CHAR_ASTERISK_SP)) {
-                cleanList.addElement(lineBuf.toString());
-                lineBuf = new StringBuffer();
-            }
-
-            lineBuf.append(line);
-
-            if ((i == (rawList.length - 1)) &&
-                    lineBuf.toString().startsWith(CHAR_ASTERISK_SP)) {
-                cleanList.addElement(lineBuf.toString());
-            }
-        }
-        return cleanList;
     }
 
@@ -775 +790 @@
      */
     public ImapParser.MessageSection executeFetchBodystructure(int uid)
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchBodyStructure(" + uid + ")").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(UID_FETCH, uid + " (BODYSTRUCTURE)", null);
-
-        // Pre-process the returned text to clean up mid-field line breaks
-        // This should all become unnecessary once execute()
-        // becomes more intelligent in how it handles replies
-        String line;
-        StringBuffer lineBuf = new StringBuffer();
-        Vector rawList2 = new Vector();
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchBodyStructure(" + uid + ")").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(UID_FETCH, uid + " (BODYSTRUCTURE)", null);
+
+        ImapParser.MessageSection msgStructure = null;
 
         for (int i = 0; i < rawList.length; i++) {
-            line = rawList[i];
-
-            if ((line.length() > 0) && lineBuf.toString().startsWith(CHAR_ASTERISK_SP) &&
-                    line.startsWith(CHAR_ASTERISK_SP)) {
-                rawList2.addElement(lineBuf.toString());
-                lineBuf = new StringBuffer();
-            }
-
-            lineBuf.append(line);
-
-            if ((i == (rawList.length - 1)) &&
-                    lineBuf.toString().startsWith(CHAR_ASTERISK_SP)) {
-                rawList2.addElement(lineBuf.toString());
-            }
-        }
-
-        ImapParser.MessageSection msgStructure = null;
-        int size = rawList2.size();
-
-        for (int i = 0; i < size; i++) {
+            byte[] rawText = rawList[i];
+            if(rawText == null || rawText.length == 0 || rawText[0] != CHAR_ASTERISK) {
+                continue;
+            }
+            
             try {
-                msgStructure = ImapParser.parseMessageStructure((String) rawList2.elementAt(i));
+                msgStructure = ImapParser.parseMessageStructure(rawText);
             } catch (Exception exp) {
                 EventLogger.logEvent(AppInfo.GUID,
-                        ("Parse error: " + exp).getBytes(),
-                        EventLogger.ERROR);
+                    ("Parse error: " + exp).getBytes(), EventLogger.ERROR);
             }
         }
@@ -831 +825 @@
      * @return Body text as a string
      */
-    public String executeFetchBody(int uid, String address, MailProgressHandler progressHandler)
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeFetchBody(" + uid + ", \"" + address +
-                    "\")").getBytes(), EventLogger.DEBUG_INFO);
-        }
-
-        String[] rawList = execute(
-                UID_FETCH,
-                uid + " (BODY[" + address + "])",
-                progressHandler);
-
-        if (rawList.length <= 1) {
-            return "";
-        }
-
-        // Attempt to parse the message length out of the first line of the response
-        int p = rawList[0].indexOf('{');
-        int q = rawList[0].indexOf('}');
-        int messageLength = -1;
-
-        if ((p != -1) && (q != -1) && ((q - p) > 1)) {
-            try {
-                messageLength = Integer.parseInt(rawList[0].substring(p + 1, q));
-            } catch (NumberFormatException e) {
-                messageLength = -1;
-            }
-        }
-
-        StringBuffer msgBuf = new StringBuffer();
-
-        if (messageLength != -1) {
-            for (int i = 1; i < rawList.length; i++) {
-                int rawListLength = rawList[i].length();
-                if ((rawListLength + 2) <= messageLength) {
-                    msgBuf.append(rawList[i]);
-                    messageLength -= rawListLength;
-                    msgBuf.append(CRLF);
-                    messageLength -= 2;
-                } else if (!(messageLength == 1 && rawListLength == 1 && rawList[i].charAt(0) == ')')) {
-                    msgBuf.append(rawList[i].substring(0, messageLength));
-                }
-            }
-        } else {
-            // Workaround for mail servers that sometimes append untagged
-            // replies to the end of this response
-            int lastLineIndex = rawList.length - 1;
-
-            while ((lastLineIndex > 0) && rawList[lastLineIndex].startsWith(CHAR_ASTERISK_SP)) {
-                lastLineIndex--;
-            }
-
-            for (int i = 1; i < lastLineIndex; i++) {
-                msgBuf.append(rawList[i]);
-                msgBuf.append(CRLF);
-            }
-
-            String lastLine = rawList[lastLineIndex];
-            msgBuf.append(lastLine.substring(0, lastLine.lastIndexOf(')')));
-        }
-
-        return msgBuf.toString();
+    public byte[] executeFetchBody(int uid, String address,
+        MailProgressHandler progressHandler) throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchBody(" + uid + ", \"" + address +
+                "\")").getBytes(), EventLogger.DEBUG_INFO);
+        }
+
+        byte[][] rawList = executeResponse(UID_FETCH,
+                uid + " (BODY[" + address + "])", progressHandler);
+
+        if (rawList.length < 1) {
+            return new byte[0];
+        }
+
+        int offset = Arrays.getIndex(rawList[0], (byte)'(');
+        Vector parsedList = ImapParser.parenListParser(rawList[0], offset, rawList[0].length - offset);
+        int size = parsedList.size();
+        
+        byte[] rawMessage = null;
+        for(int i=0; i<(size - 1); i++) {
+            Object element = parsedList.elementAt(i);
+            if(element instanceof String
+                    && ((String)element).startsWith(BODY)
+                    && parsedList.elementAt(i + 1) instanceof byte[]) {
+                rawMessage = (byte[])parsedList.elementAt(i + 1);
+            }
+        }
+
+        if(rawMessage == null) {
+            rawMessage = new byte[0];
+        }
+
+
+        return rawMessage;
     }
 
@@ -903 +869 @@
      * @return Updated standard message flags, or null if there was a parse error.
      */
-    public MessageFlags executeStore(int uid, boolean addOrRemove, String[] flags)
-    throws IOException, MailException {
+    public MessageFlags executeStore(int uid, boolean addOrRemove,
+        String[] flags) throws IOException, MailException {
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             StringBuffer buf = new StringBuffer();
@@ -919 +885 @@
 
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeStore(" + uid + ", " +
-                            (addOrRemove ? "add" : "remove") + ", {" + buf.toString() +
-                    "})").getBytes(), EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeStore(" + uid + ", " +
+                (addOrRemove ? "add" : "remove") + ", {" + buf.toString() +
+                "})").getBytes(), EventLogger.DEBUG_INFO);
         }
 
@@ -947 +913 @@
 
         MessageFlags result;
+
         try {
             int p = rawList[0].indexOf('(');
             int q = rawList[0].lastIndexOf(')');
             Vector tokenVec = null;
+
             if ((p != -1) && (q != -1) && (p < q)) {
-                Vector parsedText =
-                    StringParser.nestedParenStringLexer(rawList[0].substring(p, q + 1));
+                Vector parsedText = ImapParser.parenListParser(
+                        rawList[0].substring(p, q + 1).getBytes());
                 int size = parsedText.size();
-                for(int i=0; i<size; i++) {
+
+                for (int i = 0; i < size; i++) {
                     Object element = parsedText.elementAt(i);
-                    if(element instanceof String
-                            && element.equals(FLAGS)
-                            && i < size - 1
-                            && parsedText.elementAt(i + 1) instanceof Vector) {
-                        tokenVec = (Vector)parsedText.elementAt(i + 1);
+
+                    if (element instanceof String && element.equals(FLAGS) &&
+                            (i < (size - 1)) &&
+                            parsedText.elementAt(i + 1) instanceof Vector) {
+                        tokenVec = (Vector) parsedText.elementAt(i + 1);
+
                         break;
                     }
@@ -967 +937 @@
             }
 
-            if(tokenVec != null) {
+            if (tokenVec != null) {
                 result = ImapParser.parseMessageFlags(tokenVec);
-            }
-            else {
+            } else {
                 result = null;
             }
         } catch (Exception e) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("Unable to parse STORE response: " + e.toString()).getBytes(),
-                    EventLogger.ERROR);
+                ("Unable to parse STORE response: " + e.toString()).getBytes(),
+                EventLogger.ERROR);
 
             result = null;
         }
+
         return result;
     }
@@ -990 +960 @@
      */
     public void executeAppend(String mboxName, String rawMessage,
-            MessageFlags flags) throws IOException, MailException {
+        MessageFlags flags) throws IOException, MailException {
         String flagsString = ImapParser.createMessageFlagsString(flags);
 
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeAppend(rawMessage, \"" + flagsString +
-                    "\")").getBytes(), EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeAppend(rawMessage, \"" + flagsString +
+                "\")").getBytes(), EventLogger.DEBUG_INFO);
         }
 
         executeContinue(APPEND,
-                CHAR_QUOTE + StringParser.addEscapedChars(mboxName) + "\" (" +
-                flagsString + ") {" + rawMessage.length() + "}", rawMessage,
-                "Unable to append message to " + mboxName);
+            CHAR_QUOTE + StringParser.addEscapedChars(mboxName) + "\" (" +
+            flagsString + ") {" + rawMessage.length() + "}", rawMessage,
+            "Unable to append message to " + mboxName);
     }
 
@@ -1008 +978 @@
      * Execute the "COPY" command to copy a message from the current mailbox
      * to a different mailbox.
-     * 
-     * @param uid The IMAP unique ID of the message to copy. 
+     *
+     * @param uid The IMAP unique ID of the message to copy.
      * @param mboxPath The path of the destination mailbox
      */
-    public void executeCopy(int uid, String mboxPath) throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeCopy(\"" + uid + "\", \"" + mboxPath +
-                    "\")").getBytes(), EventLogger.DEBUG_INFO);
+    public void executeCopy(int uid, String mboxPath)
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeCopy(\"" + uid + "\", \"" + mboxPath +
+                "\")").getBytes(), EventLogger.DEBUG_INFO);
         }
 
         execute(UID_COPY,
-                uid + " \"" + StringParser.addEscapedChars(mboxPath) + CHAR_QUOTE,
-                null);
+            uid + " \"" + StringParser.addEscapedChars(mboxPath) + CHAR_QUOTE,
+            null);
     }
 
     /**
      * Execute the "LIST" command, and return a fully parsed response.
-     * 
+     *
      * @param refName Reference name
      * @param mboxName Mailbox name or wildcards (i.e. "%")
@@ -1032 +1003 @@
      * @return Vector of ListResponse objects
      */
-    public Vector executeList(String refName, String mboxName, MailProgressHandler progressHandler)
-    throws IOException, MailException {
+    public Vector executeList(String refName, String mboxName,
+        MailProgressHandler progressHandler) throws IOException, MailException {
         //
         // The default behavior should be to use executeListSubscribed.
@@ -1045 +1016 @@
     /**
      * Execute the "LSUB" command, and return a fully parsed response.
-     * 
+     *
      * @param refName Reference name
      * @param mboxName Mailbox name or wildcards (i.e. "%")
@@ -1051 +1022 @@
      * @return Vector of ListResponse objects
      */
-    public Vector executeLsub(String refName, String mboxName, MailProgressHandler progressHandler)
-    throws IOException, MailException {
+    public Vector executeLsub(String refName, String mboxName,
+        MailProgressHandler progressHandler) throws IOException, MailException {
         return executeListImpl(LSUB, refName, mboxName, progressHandler);
     }
 
-    private Vector executeListImpl(String ListVerb, String refName, String mboxName, MailProgressHandler progressHandler)
-    throws IOException, MailException {
-        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeList(\"" + refName + "\", \"" + mboxName +
-                    "\")").getBytes(), EventLogger.DEBUG_INFO);
+    private Vector executeListImpl(String ListVerb, String refName,
+        String mboxName, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeList(\"" + refName + "\", \"" + mboxName +
+                "\")").getBytes(), EventLogger.DEBUG_INFO);
         }
 
@@ -1067 +1039 @@
         results = execute(ListVerb,
                 CHAR_QUOTE + StringParser.addEscapedChars(refName) + "\" \"" +
-                StringParser.addEscapedChars(mboxName) + CHAR_QUOTE, progressHandler);
+                StringParser.addEscapedChars(mboxName) + CHAR_QUOTE,
+                progressHandler);
 
         Vector retVec = new Vector(results.length);
@@ -1081 +1054 @@
         int line = 0;
 
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); }
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING,
+                0, -1);
+        }
 
         StringBuffer buf = new StringBuffer();
+
         while (line < results.length) {
             p = results[line].indexOf('{');
@@ -1091 +1068 @@
                     (p < q) && (q == (results[line].length() - 1))) {
                 int len = Integer.parseInt(results[line].substring(p + 1, q));
-                
+
                 buf.append(results[line].substring(0, p));
                 buf.append('"');
@@ -1107 +1084 @@
         int resultsSize = resultsVec.size();
 
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, resultsSize); }
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING,
+                0, resultsSize);
+        }
+
         for (int i = 0; i < resultsSize; i++) {
             // Separate out the flag and argument strings
@@ -1125 +1106 @@
 
             // List response is invalid if both parts are not available
-            if(flagStr == null || argStr == null) { continue; }
-            
+            if ((flagStr == null) || (argStr == null)) {
+                continue;
+            }
+
             response = new ListResponse();
             response.delim = "";
@@ -1136 +1119 @@
             response.noInferiors = (flagStr.indexOf(FLAG_NOINFERIORS) != -1);
             response.marked = (flagStr.indexOf(FLAG_MARKED) != -1);
+
             try {
                 p = 0;
@@ -1198 +1182 @@
                 // Prevent parse errors from being fatal
             }
-            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, i, resultsSize); }
-        }
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, resultsSize, resultsSize); }
+
+            if (progressHandler != null) {
+                progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING,
+                    i, resultsSize);
+            }
+        }
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING,
+                resultsSize, resultsSize);
+        }
 
         return retVec;
@@ -1213 +1205 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeNoop()").getBytes(),
-                    EventLogger.DEBUG_INFO);
-        }
+                ("ImapProtocol.executeNoop()").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
         String[] replyText = execute(NOOP, null, null);
 
         if ((replyText == null) || (replyText.length < 1)) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("Unable to read NOOP response").getBytes(),
-                    EventLogger.WARNING);
+                ("Unable to read NOOP response").getBytes(), EventLogger.WARNING);
+
             return false;
         }
 
-        for(int i=0; i<replyText.length; i++) {
-            if(replyText[i].startsWith(CHAR_ASTERISK) && replyText[i].toLowerCase().endsWith("recent")) {
+        for (int i = 0; i < replyText.length; i++) {
+            if (replyText[i].startsWith(ASTERISK) &&
+                    replyText[i].toLowerCase().endsWith("recent")) {
                 return true;
             }
@@ -1240 +1234 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeIdle()").getBytes(),
-                    EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeIdle()").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
@@ -1253 +1247 @@
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
-                    ("ImapProtocol.executeIdleDone()").getBytes(),
-                    EventLogger.DEBUG_INFO);
+                ("ImapProtocol.executeIdleDone()").getBytes(),
+                EventLogger.DEBUG_INFO);
         }
 
@@ -1270 +1264 @@
         String result = receive();
 
-        if ((result != null) && result.startsWith(CHAR_ASTERISK) &&
+        if ((result != null) && result.startsWith(ASTERISK) &&
                 result.toLowerCase().endsWith("recent")) {
             return true;
@@ -1286 +1280 @@
      * @return List of returned strings
      */
-    protected String[] executeBatch(String command, String[] arguments, MailProgressHandler progressHandler)
-    throws IOException, MailException {
+    protected String[] executeBatch(String command, String[] arguments,
+        MailProgressHandler progressHandler) throws IOException, MailException {
         String[] result = new String[arguments.length];
         int count = 0;
 
-        ToIntHashtable commandMap = new ToIntHashtable();
+        IntIntHashtable commandMap = new IntIntHashtable();
         StringBuffer commandBuf = new StringBuffer();
 
         for (int i = 0; i < arguments.length; i++) {
             String tag = TAG_PREFIX + (commandCount++);
-            commandMap.put(tag, i);
+            commandMap.put(StringArrays.hashCode(tag.getBytes()), i);
             commandBuf.append(tag);
             commandBuf.append(' ');
             commandBuf.append(command);
-            commandBuf.append(((arguments[i] == null) ? "" : (CHAR_SP +
-                    arguments[i])));
+            commandBuf.append(((arguments[i] == null) ? ""
+                                                      : (CHAR_SP +
+                arguments[i])));
             commandBuf.append(CRLF);
         }
@@ -1307 +1302 @@
         int preCount = connection.getBytesReceived();
         connection.sendRaw(commandBuf.toString());
+
         int postCount = connection.getBytesReceived();
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
-
-        String temp;
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK,
+                (postCount - preCount), -1);
+        }
+
+        byte[] temp;
         String tempResult = "";
         int p;
@@ -1318 +1318 @@
             temp = connection.receive();
             postCount = connection.getBytesReceived();
-            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
-
-            String temp2 = temp.substring(temp.indexOf(CHAR_SP) + 1);
-
-            if (temp2.startsWith(BAD_PREFIX) || temp2.startsWith(NO_PREFIX)) {
-                throw new MailException(temp);
-            }
-
-            p = temp.indexOf(CHAR_SP);
-
-            if ((p != -1) && commandMap.containsKey(temp.substring(0, p))) {
-                result[commandMap.get(temp.substring(0, p))] = tempResult;
+
+            if (progressHandler != null) {
+                progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK,
+                    (postCount - preCount), -1);
+            }
+
+            p = Arrays.getIndex(temp, (byte) ' ');
+
+            if ((StringArrays.indexOf(temp, BAD_PREFIX, p + 1) != -1) ||
+                    (StringArrays.indexOf(temp, NO_PREFIX, p + 1) != -1)) {
+                throw new MailException(new String(temp));
+            }
+
+            int keyHashCode = StringArrays.hashCode(temp, 0, p);
+
+            if ((p != -1) && commandMap.containsKey(keyHashCode)) {
+                result[commandMap.get(keyHashCode)] = tempResult;
                 tempResult = "";
                 count++;
             } else {
-                tempResult = temp;
+                tempResult = new String(temp);
             }
         }
@@ -1348 +1353 @@
      * @return List of returned strings
      */
-    protected String[] execute(String command, String arguments, MailProgressHandler progressHandler)
-    throws IOException, MailException {
-        String[] result = new String[0];
+    protected byte[][] executeResponse(String command, String arguments,
+        MailProgressHandler progressHandler) throws IOException, MailException {
+        byte[][] result = new byte[0][];
 
         String tag = TAG_PREFIX + commandCount++ + CHAR_SP;
         connection.sendCommand(tag + command +
-                ((arguments == null) ? "" : (CHAR_SP + arguments)));
+            ((arguments == null) ? "" : (CHAR_SP + arguments)));
+
+        byte[] tagBytes = tag.getBytes();
 
         int preCount = connection.getBytesReceived();
-        String temp = connection.receive();
+        byte[] temp = connection.receive(executeResponseTester);
         int postCount = connection.getBytesReceived();
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
-
-        while (!temp.startsWith(tag)) {
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK,
+                (postCount - preCount), -1);
+        }
+
+        while (!StringArrays.startsWith(temp, tagBytes)) {
             Arrays.add(result, temp);
+            preCount = postCount;
+            temp = connection.receive(executeResponseTester);
+            postCount = connection.getBytesReceived();
+
+            if (progressHandler != null) {
+                progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK,
+                    (postCount - preCount), -1);
+            }
+        }
+
+        if (StringArrays.startsWith(temp, BAD_PREFIX, tagBytes.length) ||
+                StringArrays.startsWith(temp, NO_PREFIX,
+                    tagBytes.length)) {
+            throw new MailException(new String(temp));
+        }
+
+        return result;
+    }
+
+    /**
+     * Executes an IMAP command, and returns the reply as an
+     * array of strings.
+     * @param command IMAP command
+     * @param arguments Arguments for the command
+     * @param progressHandler the progress handler
+     * @return List of returned strings
+     */
+    protected String[] execute(String command, String arguments,
+        MailProgressHandler progressHandler) throws IOException, MailException {
+        String[] result = new String[0];
+
+        String tag = TAG_PREFIX + commandCount++ + CHAR_SP;
+        connection.sendCommand(tag + command +
+            ((arguments == null) ? "" : (CHAR_SP + arguments)));
+
+        byte[] tagBytes = tag.getBytes();
+
+        int preCount = connection.getBytesReceived();
+        byte[] temp = connection.receive();
+        int postCount = connection.getBytesReceived();
+
+        if (progressHandler != null) {
+            progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK,
+                (postCount - preCount), -1);
+        }
+
+        while (!StringArrays.startsWith(temp, tagBytes)) {
+            Arrays.add(result, new String(temp));
             preCount = postCount;
             temp = connection.receive();
             postCount = connection.getBytesReceived();
-            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
-        }
-
-        temp = temp.substring(tag.length());
-
-        if (temp.startsWith(BAD_PREFIX) || temp.startsWith(NO_PREFIX)) {
-            throw new MailException(temp);
+
+            if (progressHandler != null) {
+                progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK,
+                    (postCount - preCount), -1);
+            }
+        }
+
+        if (StringArrays.startsWith(temp, BAD_PREFIX, tagBytes.length) ||
+                StringArrays.startsWith(temp, NO_PREFIX,
+                    tagBytes.length)) {
+            throw new MailException(new String(temp));
         }
 
@@ -1389 +1452 @@
      */
     protected String[] executeContinue(String command, String arguments,
-            String text, String errorMsg) throws IOException, MailException {
+        String text, String errorMsg) throws IOException, MailException {
         String[] result = new String[0];
 
         String tag = TAG_PREFIX + commandCount++ + CHAR_SP;
         connection.sendCommand(tag + command +
-                ((arguments == null) ? "" : (CHAR_SP + arguments)));
-
-        String temp = connection.receive();
-
-        if (!temp.startsWith(CHAR_PLUS)) {
+            ((arguments == null) ? "" : (CHAR_SP + arguments)));
+
+        byte[] tagBytes = tag.getBytes();
+
+        byte[] temp = connection.receive();
+
+        if (Arrays.getIndex(temp, CHAR_PLUS) == -1) {
             throw new MailException(errorMsg);
         }
@@ -1407 +1472 @@
         temp = connection.receive();
 
-        while (!temp.startsWith(tag)) {
-            Arrays.add(result, temp);
+        while (!StringArrays.startsWith(temp, tagBytes)) {
+            Arrays.add(result, new String(temp));
             temp = connection.receive();
         }
 
-        temp = temp.substring(tag.length());
-
-        if (temp.startsWith(BAD_PREFIX) || temp.startsWith(NO_PREFIX)) {
-            throw new MailException(temp);
+        if (StringArrays.startsWith(temp, BAD_PREFIX, tagBytes.length) ||
+                StringArrays.startsWith(temp, NO_PREFIX,
+                    tagBytes.length)) {
+            throw new MailException(new String(temp));
         }
 
@@ -1430 +1495 @@
 
         if (connection.available() > 0) {
-            result = connection.receive();
+            result = new String(connection.receive());
         } else {
             result = null;
@@ -1445 +1510 @@
      */
     protected String executeNoReply(String command, String arguments)
-    throws IOException, MailException {
+        throws IOException, MailException {
         String tag = TAG_PREFIX + commandCount++ + CHAR_SP;
         connection.sendCommand(tag + command +
-                ((arguments == null) ? "" : (CHAR_SP + arguments)));
+            ((arguments == null) ? "" : (CHAR_SP + arguments)));
 
         return tag;
@@ -1461 +1526 @@
      * @return List of returned strings
      */
-    protected String[] executeUntagged(String command, String arguments, String endTag)
-    throws IOException, MailException {
+    protected String[] executeUntagged(String command, String arguments,
+        String endTag) throws IOException, MailException {
         String[] result = new String[0];
 
         connection.sendCommand(command +
-                ((arguments == null) ? "" : (CHAR_SP + arguments)));
-
-        String temp = connection.receive();
-
-        while (!temp.startsWith(endTag)) {
-            Arrays.add(result, temp);
+            ((arguments == null) ? "" : (CHAR_SP + arguments)));
+
+        byte[] tagBytes = endTag.getBytes();
+        byte[] temp = connection.receive();
+
+        while (!StringArrays.startsWith(temp, tagBytes)) {
+            Arrays.add(result, new String(temp));
             temp = connection.receive();
         }
 
-        temp = temp.substring(endTag.length());
-
-        if (temp.startsWith(BAD_PREFIX) || temp.startsWith(NO_PREFIX)) {
-            throw new MailException(temp);
+        if (StringArrays.startsWith(temp, BAD_PREFIX, tagBytes.length) ||
+                StringArrays.startsWith(temp, NO_PREFIX,
+                    tagBytes.length)) {
+            throw new MailException(new String(temp));
         }
 
         return result;
+    }
+
+    /**
+     * Callback for fetching envelopes.
+     */
+    public static interface FetchEnvelopeCallback {
+        void responseAvailable(FetchEnvelopeResponse response);
     }
 
@@ -1506 +1579 @@
         /** Message has recently arrived */
         public boolean recent;
-        
+
         /** Message has been forwarded */
         public boolean forwarded;
@@ -1580 +1653 @@
 
     /**
-     * Callback for fetching envelopes.
-     */
-    public static interface FetchEnvelopeCallback {
-        void responseAvailable(FetchEnvelopeResponse response);
-    }
-
-    /**
      * Container for a LIST response
      */
@@ -1597 +1663 @@
         public String name;
     }
-
+    
+    private static ConnectionResponseTester executeResponseTester = new ConnectionResponseTester() {
+        private static final byte CR = (byte) 0x0D;
+        private static final byte LF = (byte) 0x0A;
+        private int trimCount;
+        private int lastLength = 0;
+        private int literalLength = 0;
+
+        public int checkForCompleteResponse(byte[] buf, int len) {
+            trimCount = 0;
+
+            if (literalLength > 0) {
+                if ((lastLength + literalLength) < len) {
+                    lastLength += literalLength;
+                    literalLength = 0;
+                } else {
+                    literalLength -= (len - lastLength);
+                    lastLength = len;
+
+                    return -1;
+                }
+            }
+
+            int p = StringArrays.indexOf(buf, LF, lastLength);
+
+            while ((p != -1) && (p < len)) {
+                if ((p > 0) && (buf[p - 1] == CR)) {
+                    if ((p > 3) && (buf[p - 2] == '}')) {
+                        int i = p - 3;
+
+                        while (i >= 0) {
+                            if ((buf[i] >= '0') && (buf[i] <= '9')) {
+                                i--;
+                            } else if (buf[i] == '{') {
+                                try {
+                                    literalLength = StringArrays.parseInt(buf, i + 1, p - i - 3);
+                                    break;
+                                } catch (NumberFormatException e) { }
+                            }
+                        }
+                    }
+
+                    trimCount = 2;
+                } else {
+                    trimCount = 1;
+                }
+
+                p++;
+
+                if (literalLength > 0) {
+                    if ((len - p) >= literalLength) {
+                        p += literalLength;
+                        literalLength = 0;
+                    } else {
+                        literalLength -= (len - p);
+                        lastLength = len;
+
+                        return -1;
+                    }
+                } else {
+                    lastLength = 0;
+                    literalLength = 0;
+
+                    return p;
+                }
+
+                p = StringArrays.indexOf(buf, LF, p);
+            }
+
+            lastLength = len;
+
+            return -1;
+        }
+
+        public int trimCount() {
+            return trimCount;
+        }
+
+        public String logString(byte[] result) {
+            return new String(result);
+        }
+    };
+    
     // String constants
     private static String UID_COPY = "UID COPY";
@@ -1610 +1758 @@
     private static String FETCH = "FETCH";
     private static String BODYSTRUCTURE = "BODYSTRUCTURE";
+    private static String BODY = "BODY";
     private static String ENVELOPE = "ENVELOPE";
     private static String UID = "UID";
@@ -1629 +1778 @@
     private static String FLAG_NOSELECT = "\\Noselect";
     private static String TAG_PREFIX = "A";
-    private static String NO_PREFIX = "NO ";
-    private static String BAD_PREFIX = "BAD ";
+    private static final byte[] NO_PREFIX = "NO ".getBytes();
+    private static final byte[] BAD_PREFIX = "BAD ".getBytes();
     private static String CHAR_SP = " ";
-    private static String CHAR_ASTERISK = "*";
-    private static String CHAR_PLUS = "+";
+    private static final byte CHAR_PLUS = (byte) '+';
     private static String CHAR_COLON = ":";
-    private static String CHAR_ASTERISK_SP = "* ";
+    private static final byte CHAR_ASTERISK = (byte)'*';
+    private static String ASTERISK = "*";
     private static String CHAR_QUOTE = "\"";
     private static String CHAR_COLON_ASTERISK = ":*";

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/pop/PopProtocol.java

@@ -265 +265 @@
         if(execute(command, errorFatal) == null) { return null; }
         
-        String buffer = connection.receive();
+        String buffer = new String(connection.receive());
         int postCount = connection.getBytesReceived();
         if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
@@ -273 +273 @@
             Arrays.add(lines, buffer);
             preCount = postCount;
-            buffer = connection.receive();
+            buffer = new String(connection.receive());
             postCount = connection.getBytesReceived();
             if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
@@ -308 +308 @@
         }
         
-        String result = connection.receive();
+        String result = new String(connection.receive());
         
         if((result.length() > 1) && (result.charAt(0) == '-')) {

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/smtp/SmtpProtocol.java

@@ -397 +397 @@
         }
         
-        String result = connection.receive();
+        String result = new String(connection.receive());
         
         return result;
@@ -414 +414 @@
         execute(command);
             
-        String buffer = connection.receive();
+        String buffer = new String(connection.receive());
         String[] lines = new String[0];
         while(buffer != null) {
-            buffer = connection.receive();
+            buffer = new String(connection.receive());
             Arrays.add(lines, buffer);
             if(buffer.length() >=4 && buffer.charAt(3) == ' ') {

trunk/LogicMail/src/org/logicprobe/LogicMail/message/ApplicationContent.java

@@ -33 +33 @@
 import java.io.IOException;
 
-import net.rim.device.api.io.Base64InputStream;
-
 public class ApplicationContent extends MimeMessageContent {
         private byte[] rawData;
         
-        public ApplicationContent(ApplicationPart applicationPart, String encoding, String data) throws UnsupportedContentException {
+        public ApplicationContent(ApplicationPart applicationPart, String encoding, byte[] data) throws UnsupportedContentException {
                 super(applicationPart);
         // Decode the binary data
-        if (encoding.equalsIgnoreCase("base64")) {
+        if (encoding.equalsIgnoreCase(ENCODING_BASE64)) {
                 try {
-                        this.rawData = Base64InputStream.decode(data);
+                        this.rawData = decodeBase64(data);
                 } catch (IOException e) {
                         throw new UnsupportedContentException("Unable to decode");
@@ -54 +52 @@
     public ApplicationContent(ApplicationPart applicationPart, byte[] rawData) throws UnsupportedContentException {
         super(applicationPart);
-        applicationPart.setEncoding("base64");
+        applicationPart.setEncoding(ENCODING_BASE64);
         this.rawData = rawData;
     }

trunk/LogicMail/src/org/logicprobe/LogicMail/message/AudioContent.java

@@ -33 +33 @@
 import java.io.IOException;
 
-import net.rim.device.api.io.Base64InputStream;
-
 public class AudioContent extends MimeMessageContent {
         private byte[] rawData;
         
-        public AudioContent(AudioPart audioPart, String encoding, String data) throws UnsupportedContentException {
+        public AudioContent(AudioPart audioPart, String encoding, byte[] data) throws UnsupportedContentException {
                 super(audioPart);
         // Decode the binary data
-        if (encoding.equalsIgnoreCase("base64")) {
+        if (encoding.equalsIgnoreCase(ENCODING_BASE64)) {
                 try {
-                        this.rawData = Base64InputStream.decode(data);
+                        this.rawData = decodeBase64(data);
                 } catch (IOException e) {
                         throw new UnsupportedContentException("Unable to decode");
@@ -54 +52 @@
         public AudioContent(AudioPart audioPart, byte[] rawData) {
             super(audioPart);
-            audioPart.setEncoding("base64");
+            audioPart.setEncoding(ENCODING_BASE64);
             this.rawData = rawData;
         }

trunk/LogicMail/src/org/logicprobe/LogicMail/message/ImageContent.java

@@ -33 +33 @@
 import java.io.IOException;
 
-import net.rim.device.api.io.Base64InputStream;
 import net.rim.device.api.system.EncodedImage;
 
@@ -52 +51 @@
         }
 
-        public ImageContent(ImagePart imagePart, String encoding, String data) throws UnsupportedContentException {
+        public ImageContent(ImagePart imagePart, String encoding, byte[] data) throws UnsupportedContentException {
                 super(imagePart);
         // Decode the binary data, and create an image
-        if (encoding.equalsIgnoreCase("base64")) {
+        if (encoding.equalsIgnoreCase(ENCODING_BASE64) && data != null && data.length > 0) {
                 try {
                         String mimeSubtype = imagePart.getMimeSubtype();
-                        byte[] imgBytes = Base64InputStream.decode(data);
+                        
+                        byte[] imgBytes = decodeBase64(data);
+                        
                         this.image = EncodedImage.createEncodedImage(
                                         imgBytes,
@@ -74 +75 @@
         public ImageContent(ImagePart imagePart, byte[] rawData) {
         super(imagePart);
-        imagePart.setEncoding("base64");
+        imagePart.setEncoding(ENCODING_BASE64);
         this.rawData = rawData;
         }

trunk/LogicMail/src/org/logicprobe/LogicMail/message/MessageContent.java

@@ -33 +33 @@
 import java.io.IOException;
 
-import net.rim.device.api.io.Base64InputStream;
-
 public class MessageContent extends MimeMessageContent {
         private byte[] rawData;
         
-        public MessageContent(MessagePart messagePart, String encoding, String data) throws UnsupportedContentException {
+        public MessageContent(MessagePart messagePart, String encoding, byte[] data) throws UnsupportedContentException {
                 super(messagePart);
         // Decode the binary data
-        if (encoding.equalsIgnoreCase("base64")) {
+        if (encoding.equalsIgnoreCase(ENCODING_BASE64)) {
                 try {
-                        this.rawData = Base64InputStream.decode(data);
+                        this.rawData = decodeBase64(data);
                 } catch (IOException e) {
                         throw new UnsupportedContentException("Unable to decode");
                 }
         } else {
-                rawData = data.getBytes();
+                rawData = data;
         }
         }
@@ -54 +52 @@
     public MessageContent(MessagePart messagePart, byte[] rawData) {
         super(messagePart);
-        messagePart.setEncoding("base64");
+        messagePart.setEncoding(ENCODING_BASE64);
         this.rawData = rawData;
     }   

trunk/LogicMail/src/org/logicprobe/LogicMail/message/MimeMessageContent.java

@@ -31 +31 @@
 package org.logicprobe.LogicMail.message;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
+
+import net.rim.device.api.io.Base64InputStream;
 
 import org.logicprobe.LogicMail.util.Serializable;
@@ -47 +51 @@
     private long uniqueId;
     private ContentPart messagePart;
+    protected static String ENCODING_BASE64 = "base64";
 
     /**
@@ -92 +97 @@
     protected abstract void putRawData(byte[] rawData);
 
+    /**
+     * Decode the provided data as Base64.
+     * 
+     * @param data byte array representing a Base64-encoded string
+     * @return decoded form of the input data
+     * @throws IOException thrown if a decoding error occurred.
+     */
+    protected static byte[] decodeBase64(byte[] data) throws IOException {
+        if(data == null || data.length == 0) {
+            return new byte[0];
+        }
+        
+        byte[] decodedData;
+        if(data.length < 32768) {
+            decodedData = Base64InputStream.decode(data, 0, data.length);
+        }
+        else {
+            Base64InputStream inputStream = new Base64InputStream(new ByteArrayInputStream(data, 0, data.length));
+            ByteArrayOutputStream outputStream = new ByteArrayOutputStream(65536);
+            
+            byte[] buf = new byte[1024];
+            int count;
+            while ((count = inputStream.read(buf)) >= 0)
+            {
+                outputStream.write(buf, 0, count);
+            }
+            inputStream.close();
+            
+            decodedData = outputStream.toByteArray();
+        }
+        return decodedData;
+    }
+    
     /* (non-Javadoc)
      * @see org.logicprobe.LogicMail.util.Serializable#getUniqueId()

trunk/LogicMail/src/org/logicprobe/LogicMail/message/MimeMessageContentFactory.java

@@ -35 +35 @@
  */
 public class MimeMessageContentFactory {
-        // TODO: Refactor encoding/param up into the MessagePart classes
-        
     /**
          * Creates a new MessageContent object.
@@ -47 +45 @@
          * @throws UnsupportedContentException Thrown if the content type was not supported or the data could not be decoded.
          */
-        public static MimeMessageContent createContent(MimeMessagePart mimeMessagePart, String encodedData) throws UnsupportedContentException {
+        public static MimeMessageContent createContentEncoded(MimeMessagePart mimeMessagePart, byte[] encodedData) throws UnsupportedContentException {
         MimeMessageContent content;
         if(mimeMessagePart instanceof TextPart) {
@@ -89 +87 @@
      * @throws UnsupportedContentException Thrown if the content type was not supported or the data could not be decoded.
      */
-        public static MimeMessageContent createContent(MimeMessagePart mimeMessagePart, byte[] rawData) throws UnsupportedContentException {
+        public static MimeMessageContent createContentRaw(MimeMessagePart mimeMessagePart, byte[] rawData) throws UnsupportedContentException {
             MimeMessageContent content;
         if(mimeMessagePart instanceof TextPart) {

trunk/LogicMail/src/org/logicprobe/LogicMail/message/TextContent.java

@@ -34 +34 @@
 import java.io.UnsupportedEncodingException;
 
-import net.rim.device.api.io.Base64InputStream;
-
 import org.logicprobe.LogicMail.util.StringFactory;
 import org.logicprobe.LogicMail.util.StringParser;
@@ -54 +52 @@
             String encoding,
             String charset,
-            String data) throws UnsupportedContentException {
+            byte[] data) throws UnsupportedContentException {
         super(textPart);
         String mimeSubtype = textPart.getMimeSubtype();
         
+        // Check for a supported text sub-type
+        if (!mimeSubtype.equalsIgnoreCase("plain") &&
+                !mimeSubtype.equalsIgnoreCase("html")) {
+            throw new UnsupportedContentException("Unsupported subtype");
+        }
+        
         // Check for any encodings that need to be handled
         if (encoding.equalsIgnoreCase("quoted-printable")) {
-            data = StringParser.decodeQuotedPrintable(data);
+            this.text = StringParser.decodeQuotedPrintable(data);
         }
-        else if (encoding.equalsIgnoreCase("base64")) {
+        else if (encoding.equalsIgnoreCase(ENCODING_BASE64)) {
                 byte[] textBytes;
 
             try {
-                textBytes = Base64InputStream.decode(data);
+                textBytes = decodeBase64(data);
             } catch (IOException exp) {
                 throw new UnsupportedContentException("Unable to decode");
@@ -77 +81 @@
                 }
 
-                data = StringFactory.create(textBytes, charset);
+                this.text = StringFactory.create(textBytes, charset);
             } catch (UnsupportedEncodingException exp) {
                 // If encoding type is bad, attempt with the default encoding
                 // so the user will at least see something.
-                data = new String(textBytes);
+                this.text = new String(textBytes);
             }
         }
-        else if ((charset != null) &&
-                !charset.equalsIgnoreCase("ISO-8859-1") &&
-                !charset.equalsIgnoreCase("US-ASCII")) {
+        else if (charset != null) {
             // If the text is not encoded (i.e. 7bit or 8bit) and uses a
             // non-Latin charset, then bring the text back to a byte array
             // and attempt to decode it based on the charset parameter.
-            byte[] textBytes = data.getBytes();
 
             try {
-                data = StringFactory.create(textBytes, charset);
+                this.text = StringFactory.create(data, charset);
             } catch (UnsupportedEncodingException exp) {
-                // If encoding type is bad, leave the message text as
-                // it was originally.  This may result in the user seeing
-                // garbage, but at least they'll know there was a
-                // decoding problem.
+                // If encoding type is bad, use the default platform charset.
+                // This may result in the user seeing garbage, but at least
+                // they'll know there was a decoding problem.
+                this.text = new String(data);
             }
-        }
-
-        // Check for a supported text sub-type and decode if necessary
-        if (mimeSubtype.equalsIgnoreCase("plain") ||
-                mimeSubtype.equalsIgnoreCase("html")) {
-            this.text = data;
-        }
-        else {
-                throw new UnsupportedContentException("Unsupported subtype");
         }
     }

trunk/LogicMail/src/org/logicprobe/LogicMail/message/VideoContent.java

@@ -33 +33 @@
 import java.io.IOException;
 
-import net.rim.device.api.io.Base64InputStream;
-
 public class VideoContent extends MimeMessageContent {
         private byte[] rawData;
         
-        public VideoContent(VideoPart videoPart, String encoding, String data) throws UnsupportedContentException {
+        public VideoContent(VideoPart videoPart, String encoding, byte[] data) throws UnsupportedContentException {
                 super(videoPart);
         // Decode the binary data
-        if (encoding.equalsIgnoreCase("base64")) {
+        if (encoding.equalsIgnoreCase(ENCODING_BASE64)) {
                 try {
-                        this.rawData = Base64InputStream.decode(data);
+                        this.rawData = decodeBase64(data);
                 } catch (IOException e) {
                         throw new UnsupportedContentException("Unable to decode");
@@ -54 +52 @@
     public VideoContent(VideoPart videoPart, byte[] rawData) {
         super(videoPart);
-        videoPart.setEncoding("base64");
+        videoPart.setEncoding(ENCODING_BASE64);
         this.rawData = rawData;
     }

trunk/LogicMail/src/org/logicprobe/LogicMail/ui/CompositionScreen.java

@@ -659 +659 @@
             MimeMessageContent bodyContent;
             try {
-                        bodyContent = MimeMessageContentFactory.createContent(
-                                        bodyPart, contentText);
+                        bodyContent = MimeMessageContentFactory.createContentEncoded(
+                                        bodyPart, contentText.getBytes());
                 } catch (UnsupportedContentException e) {
                         bodyContent = null;
@@ -763 +763 @@
                     try {
                         MimeMessageContent attachmentContent =
-                            MimeMessageContentFactory.createContent(attachmentPart, data);
+                            MimeMessageContentFactory.createContentRaw(attachmentPart, data);
                         MultiPart multiPart = (MultiPart)pendingMessage.getStructure();
                         multiPart.addPart(attachmentPart);

trunk/LogicMail/src/org/logicprobe/LogicMail/util/Connection.java

@@ -97 +97 @@
     private int bytesSent = 0;
     private int bytesReceived = 0;
+    private final Object socketLock = new Object();
     
     /**
@@ -103 +104 @@
      */
     private final ByteArrayOutputStream byteStream = new NoCopyByteArrayOutputStream(1024);
-
+    
+    /**
+     * Temporary read buffer used as an intermediary between the socket and
+     * the byteStream.
+     */
+    private final byte[] readBuffer = new byte[1024];
+    
     /**
      * Initializes a new connection object.
@@ -163 +170 @@
      * Opens a connection.
      */
-    public synchronized void open() throws IOException {
+    public void open() throws IOException {
         if ((input != null) || (output != null) || (socket != null)) {
             close();
@@ -170 +177 @@
         utilFactory.addOpenConnection(this);
 
-        socket = openStreamConnection();
-        if(socket == null) {
-            throw new IOException(resources.getString(LogicMailResource.ERROR_UNABLE_TO_OPEN_CONNECTION));
-        }
-        
-        input = socket.openDataInputStream();
-        output = socket.openDataOutputStream();
-        localAddress = ((SocketConnection) socket).getLocalAddress();
-        bytesSent = 0;
-        bytesReceived = 0;
-
+        synchronized(socketLock) {
+            socket = openStreamConnection();
+            if(socket == null) {
+                throw new IOException(resources.getString(LogicMailResource.ERROR_UNABLE_TO_OPEN_CONNECTION));
+            }
+            
+            input = socket.openDataInputStream();
+            output = socket.openDataOutputStream();
+            localAddress = ((SocketConnection) socket).getLocalAddress();
+            bytesSent = 0;
+            bytesReceived = 0;
+        }
+        
         if (EventLogger.getMinimumLevel() >= EventLogger.INFORMATION) {
             String msg = "Connection established:\r\n" + "Socket: " +
@@ -224 +233 @@
      * Closes a connection.
      */
-    public synchronized void close() throws IOException {
-        try {
-            if (input != null) {
-                input.close();
+    public void close() throws IOException {
+        synchronized(socketLock) {
+            try {
+                if (input != null) {
+                    input.close();
+                    input = null;
+                }
+            } catch (Exception exp) {
                 input = null;
             }
-        } catch (Exception exp) {
-            input = null;
-        }
-
-        try {
-            if (output != null) {
-                output.close();
+    
+            try {
+                if (output != null) {
+                    output.close();
+                    output = null;
+                }
+            } catch (Exception exp) {
                 output = null;
             }
-        } catch (Exception exp) {
-            output = null;
-        }
-
-        try {
-            if (socket != null) {
-                socket.close();
+    
+            try {
+                if (socket != null) {
+                    socket.close();
+                    socket = null;
+                }
+            } catch (Exception exp) {
                 socket = null;
             }
-        } catch (Exception exp) {
-            socket = null;
-        }
-
+            setConnectionUrl(null);
+        }
+        
         utilFactory.removeOpenConnection(this);
-
-        setConnectionUrl(null);
         
         EventLogger.logEvent(AppInfo.GUID, "Connection closed".getBytes(),
@@ -321 +331 @@
      * is a prepared protocol command.
      */
-    public synchronized void sendCommand(String s) throws IOException {
+    public void sendCommand(String s) throws IOException {
         if (globalConfig.getConnDebug()) {
             EventLogger.logEvent(AppInfo.GUID, ("[SEND CMD] " + s).getBytes(),
@@ -327 +337 @@
         }
 
-        if (s == null) {
-            output.write(CRLF, 0, 2);
-            bytesSent += 2;
-        } else {
-            byte[] buf = (s + strCRLF).getBytes();
-            output.write(buf);
-            bytesSent += buf.length;
-        }
-
-        output.flush();
+        synchronized(socketLock) {
+            if (s == null) {
+                output.write(CRLF, 0, 2);
+                bytesSent += 2;
+            } else {
+                byte[] buf = (s + strCRLF).getBytes();
+                output.write(buf);
+                bytesSent += buf.length;
+            }
+    
+            output.flush();
+        }
     }
 
@@ -347 +359 @@
      * @see #send
      */
-    public synchronized void sendRaw(String s) throws IOException {
+    public void sendRaw(String s) throws IOException {
         byte[] buf = s.getBytes();
 
@@ -355 +367 @@
         }
 
-        output.write(buf, 0, buf.length);
-        bytesSent += buf.length;
-
-        output.flush();
+        synchronized(socketLock) {
+            output.write(buf, 0, buf.length);
+            bytesSent += buf.length;
+    
+            output.flush();
+        }
     }
 
@@ -374 +388 @@
         }
     }
-    
+
     /**
      * Receives a string from the server. This method is used internally for
@@ -382 +396 @@
      * returned as part of the result.
      *
-     * @see #send
-     */
-    public synchronized String receive() throws IOException {
-        // Check existing data for a usable line
-        String line = checkForLine();
-        if(line != null) {
-            return line;
-        }
-
-        // Read from the socket
-        int firstByte = input.read();
-        if(firstByte != -1) {
-            byteStream.write((byte)firstByte);
-            bytesReceived++;
-            int bytesAvailable = input.available();
-            while(bytesAvailable > 0) {
-                byte[] buf = new byte[bytesAvailable];
-                int len = input.read(buf);
-                byteStream.write(buf, 0, len);
-                bytesReceived += len;
+     * @return the complete line, minus the CRLF, as a byte array
+     */
+    public byte[] receive() throws IOException {
+        return receive(lineResponseTester);
+    }
+    
+    
+    /**
+     * Receives a string from the server. This method is used internally for
+     * incoming communication from the server.
+     *
+     * @param responseTester class to determine when a complete response has
+     *   been read from the network, and whether to trim it prior to returning
+     * @return the complete response, as a byte array
+     */
+    public byte[] receive(ConnectionResponseTester responseTester) throws IOException {
+        byte[] result = receiveImpl(responseTester);
+        
+        if(result != null && globalConfig.getConnDebug()) {
+                EventLogger.logEvent(AppInfo.GUID,
+                        ("[RECV] " + responseTester.logString(result)).getBytes(),
+                        EventLogger.DEBUG_INFO);
+        }
+        
+        return result;
+    }
+    
+    private byte[] receiveImpl(ConnectionResponseTester responseTester) throws IOException {
+        synchronized(socketLock) {
+            // Check existing data for a usable line
+            byte[] line = checkForLine(responseTester);
+            if(line != null) {
+                return line;
+            }
+    
+            // Read from the socket
+            int firstByte = input.read();
+            if(firstByte != -1) {
+                byteStream.write((byte)firstByte);
+                bytesReceived++;
+                int bytesAvailable = input.available();
+                while(bytesAvailable > 0) {
+                    int len = input.read(readBuffer);
+                    byteStream.write(readBuffer, 0, len);
+                    bytesReceived += len;
+                    
+                    // Check read data for a usable line
+                    line = checkForLine(responseTester);
+                    if(line != null) {
+                        return line;
+                    }
+                    
+                    bytesAvailable = input.available();
+    
+                    // If no bytes are reported as being available, but we have
+                    // not yet received a full line, then we need to attempt
+                    // another single-byte blocking read.
+                    if(bytesAvailable == 0) {
+                        firstByte = input.read();
+                        byteStream.write((byte)firstByte);
+                        bytesReceived++;
+                        bytesAvailable = input.available();
+                    }
+                }
+            }
+            else {
+                // If we got here, that means that the InputStream is either closed
+                // or we are in some otherwise unrecoverable state.  This means we
+                // will try to close the connection, ignore any errors from the
+                // close operation, and throw an IOException.
                 
-                // Check read data for a usable line
-                line = checkForLine();
-                if(line != null) {
-                    return line;
-                }
-                
-                bytesAvailable = input.available();
-
-                // If no bytes are reported as being available, but we have
-                // not yet received a full line, then we need to attempt
-                // another single-byte blocking read.
-                if(bytesAvailable == 0) {
-                    firstByte = input.read();
-                    byteStream.write((byte)firstByte);
-                    bytesReceived++;
-                    bytesAvailable = input.available();
-                }
-            }
-        }
-        else {
-            // If we got here, that means that the InputStream is either closed
-            // or we are in some otherwise unrecoverable state.  This means we
-            // will try to close the connection, ignore any errors from the
-            // close operation, and throw an IOException.
-            
-            EventLogger.logEvent(AppInfo.GUID,
-                    "Unable to read from socket, closing connection".getBytes(),
-                    EventLogger.INFORMATION);
-
-            try {
-                close();
-            } catch (IOException e) { }
-
-            throw new IOException("Connection closed");
-        }
-        
+                EventLogger.logEvent(AppInfo.GUID,
+                        "Unable to read from socket, closing connection".getBytes(),
+                        EventLogger.INFORMATION);
+    
+                try {
+                    close();
+                } catch (IOException e) { }
+    
+                throw new IOException("Connection closed");
+            }
+        }
         // This should never normally happen
         return null;
@@ -450 +489 @@
      * @return the trimmed string which ended in a CRLF in the source data
      */
-    private String checkForLine() throws IOException {
-        String result;
+    private byte[] checkForLine(ConnectionResponseTester responseTester) throws IOException {
+        byte[] result;
         
         byte[] buf = byteStream.toByteArray();
         int size = byteStream.size();
         
-        int p = Arrays.getIndex(buf, LF);
-        if(p != -1 && p < size) {
-            int q = p + 1;
-            if(p > 0 && buf[p - 1] == CR) {
-                p--;
-            }
-            result = new String(buf, 0, p);
+        int p = responseTester.checkForCompleteResponse(buf, size);
+        
+        if(p != -1) {
+            int trimCount = responseTester.trimCount();
             
-            if (globalConfig.getConnDebug()) {
-                EventLogger.logEvent(AppInfo.GUID,
-                        ("[RECV] " + result).getBytes(),
-                        EventLogger.DEBUG_INFO);
-            }
+            result = Arrays.copy(buf, 0, p - trimCount);
             
-            if(q < size) {
-                buf = Arrays.copy(buf, q, size - q);
+            if(p < size) {
+                buf = Arrays.copy(buf, p, size - p);
                 byteStream.reset();
                 byteStream.write(buf);
@@ -488 +520 @@
     }
 
+    private static ConnectionResponseTester lineResponseTester = new ConnectionResponseTester() {
+        private int trimCount;
+        
+        public int checkForCompleteResponse(byte[] buf, int len) {
+            trimCount = 0;
+            int p = Arrays.getIndex(buf, LF);
+            if(p != -1 && p < len) {
+                if(p > 0 && buf[p - 1] == CR) {
+                    trimCount = 2;
+                }
+                else {
+                    trimCount = 1;
+                }
+                return ++p;
+            }
+            else {
+                return -1;
+            }
+        }
+
+        public int trimCount() {
+            return trimCount;
+        }
+        
+        public String logString(byte[] result) {
+            return new String(result);
+        };
+    };
+    
     /**
      * Switches the underlying connection to SSL mode, as commonly done after
@@ -495 +556 @@
      */
     public void startTLS() throws IOException {
-        // Shortcut the method if we're already in SSL mode
-        if(socket instanceof TLS10Connection) { return; }
-        
-        if(socket == null || connectionUrl == null) {
-            throw new IOException("Connection has not been opened");
-        }
-
-        try {
-            TLS10Connection tlsSocket = new TLS10Connection(
-                    new StreamConnectionWrapper(
-                            socket,
-                            (DataInputStream)input,
-                            (DataOutputStream)output),
-                            connectionUrl,
-                            true);
-
-            socket = tlsSocket;
-            input = socket.openDataInputStream();
-            output = socket.openDataOutputStream();
-        } catch (IOException e) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("Unable to switch to TLS mode: " + e.getMessage()).getBytes(), EventLogger.ERROR);
-            throw new IOException("Unable to switch to TLS mode");
-        } catch (TLSException e) {
-            EventLogger.logEvent(AppInfo.GUID,
-                    ("Unable to switch to TLS mode: " + e.getMessage()).getBytes(), EventLogger.ERROR);
-            throw new IOException("Unable to switch to TLS mode");
+        synchronized(socketLock) {
+            // Shortcut the method if we're already in SSL mode
+            if(socket instanceof TLS10Connection) { return; }
+            
+            if(socket == null || connectionUrl == null) {
+                throw new IOException("Connection has not been opened");
+            }
+    
+            try {
+                TLS10Connection tlsSocket = new TLS10Connection(
+                        new StreamConnectionWrapper(
+                                socket,
+                                (DataInputStream)input,
+                                (DataOutputStream)output),
+                                connectionUrl,
+                                true);
+    
+                socket = tlsSocket;
+                input = socket.openDataInputStream();
+                output = socket.openDataOutputStream();
+            } catch (IOException e) {
+                EventLogger.logEvent(AppInfo.GUID,
+                        ("Unable to switch to TLS mode: " + e.getMessage()).getBytes(), EventLogger.ERROR);
+                throw new IOException("Unable to switch to TLS mode");
+            } catch (TLSException e) {
+                EventLogger.logEvent(AppInfo.GUID,
+                        ("Unable to switch to TLS mode: " + e.getMessage()).getBytes(), EventLogger.ERROR);
+                throw new IOException("Unable to switch to TLS mode");
+            }
         }
     }

trunk/LogicMail/src/org/logicprobe/LogicMail/util/MailMessageParser.java

@@ -34 +34 @@
 import net.rim.device.api.mime.MIMEInputStream;
 import net.rim.device.api.mime.MIMEParsingException;
+import net.rim.device.api.util.Arrays;
 
 import org.logicprobe.LogicMail.AppInfo;
@@ -275 +276 @@
                 int size = buffer.length - offset;
 
-                String data = new String(buffer, offset, size);
+                byte[] data = Arrays.copy(buffer, offset, size);
                 MimeMessagePart part = MimeMessagePartFactory.createMimeMessagePart(
                                 type, subtype, name, encoding, charset, disposition, contentId, size);
                 try {
-                                        contentMap.put(part, MimeMessageContentFactory.createContent(part, data));
+                                        contentMap.put(part, MimeMessageContentFactory.createContentEncoded(part, data));
                                 } catch (UnsupportedContentException e) {
                                         System.err.println("UnsupportedContentException: " + e.getMessage());
@@ -287 +288 @@
                 buffer = StringParser.readWholeStream(mimeInputStream);
 
-                String data = new String(buffer);
                 MimeMessagePart part = MimeMessagePartFactory.createMimeMessagePart(
-                                type, subtype, name, encoding, charset, disposition, contentId, data.length());
+                                type, subtype, name, encoding, charset, disposition, contentId, buffer.length);
                 try {
-                                        contentMap.put(part, MimeMessageContentFactory.createContent(part, data));
+                                        contentMap.put(part, MimeMessageContentFactory.createContentEncoded(part, buffer));
                                 } catch (UnsupportedContentException e) {
                                         System.err.println("UnsupportedContentException: " + e.getMessage());

trunk/LogicMail/src/org/logicprobe/LogicMail/util/StringParser.java

@@ -49 +49 @@
 import java.util.Hashtable;
 import java.util.TimeZone;
-import java.util.Vector;
 
 import org.logicprobe.LogicMail.AppInfo;
@@ -469 +468 @@
 
     /**
-     * Recursively parse a nested paren string.
-     * Parses through a string of the form "(A (B C (D) E F))" and
-     * returns a tree of Vector and String objects representing its
-     * contents.  This is useful for parsing the response to the
-     * IMAP "ENVELOPE" fetch command.
-     *
-     * @param rawText The raw text to be parsed
-     * @return A tree of Vector and String objects
-     */
-    public static Vector nestedParenStringLexer(String rawText) {
-        Vector parsedText = new Vector();
-
-        // Sanity checking
-        if (!((rawText.charAt(0) == '(') &&
-                (rawText.charAt(rawText.length() - 1) == ')'))) {
-            return null;
-        }
-
-        int p = 1;
-        int q = p;
-        int len;
-        String tmpText;
-        boolean inQuote = false;
-
-        while (q < rawText.length()) {
-            if (isQuoteChar(rawText, q, p)) {
-                if (!inQuote) {
-                    inQuote = true;
-                    p = q;
-                } else {
-                    parsedText.addElement(rawText.substring(p + 1, q));
-                    p = q + 1;
-                    inQuote = false;
-                }
-            } else if ((rawText.charAt(q) == '{') && !inQuote) {
-                p = rawText.indexOf('}', q);
-                len = Integer.parseInt(rawText.substring(q + 1, p));
-                p++;
-
-                while ((rawText.charAt(p) == '\r') ||
-                        (rawText.charAt(p) == '\n'))
-                    p++;
-
-                // Quick kludge for length miscalculation due to the way
-                // line breaks are currently handled
-                tmpText = rawText.substring(p, p + len);
-
-                if (tmpText.endsWith(" NIL")) {
-                    len -= 4;
-                } else if (tmpText.endsWith(" NI")) {
-                    len -= 3;
-                } else if (tmpText.endsWith(" N")) {
-                    len -= 2;
-                } else if (tmpText.endsWith(" ")) {
-                    len -= 1;
-                }
-
-                parsedText.addElement(rawText.substring(p, p + len));
-                q = p + len;
-            } else if (((rawText.charAt(q) == ' ') && !inQuote) ||
-                    (q == (rawText.length() - 1))) {
-                if ((q - p) > 0) {
-                    parsedText.addElement(rawText.substring(p, q).trim());
-                    p = q;
-                } else {
-                    p++;
-                }
-            } else if ((rawText.charAt(q) == '(') && !inQuote) {
-                p = q;
-
-                // paren matching
-                int level = 0;
-                boolean subInQuote = false;
-
-                for (int i = q + 1; i < rawText.length(); i++) {
-                    if ((rawText.charAt(i) == '{') && !subInQuote) {
-                        int matchIndex = rawText.indexOf('}', i);
-
-                        if ((matchIndex > (i + 1)) &&
-                                (rawText.charAt(matchIndex + 1) != ' ')) {
-                            int matchLen = Integer.parseInt(rawText.substring(i +
-                                        1, matchIndex));
-                            matchIndex++;
-
-                            while ((rawText.charAt(matchIndex) == '\r') ||
-                                    (rawText.charAt(matchIndex) == '\n')) {
-                                matchIndex++;
-                            }
-
-                            i = matchIndex + matchLen;
-                        }
-                    }
-
-                    if (isQuoteChar(rawText, i, q + 1) && !subInQuote) {
-                        subInQuote = true;
-                    } else if (isQuoteChar(rawText, i, q + 1) && subInQuote) {
-                        subInQuote = false;
-                    }
-
-                    if ((rawText.charAt(i) == '(') && !subInQuote) {
-                        level++;
-                    } else if ((rawText.charAt(i) == ')') && !subInQuote) {
-                        if (level == 0) {
-                            q = i;
-
-                            break;
-                        } else {
-                            level--;
-                        }
-                    }
-                }
-
-                if ((q == 1) || (q < p)) {
-                    return null;
-                } else {
-                    parsedText.addElement(nestedParenStringLexer(
-                            rawText.substring(p, q + 1)));
-                }
-
-                p = q + 1;
-            }
-
-            q++;
-        }
-
-        return parsedText;
-    }
-
-    /**
-     * Helper method to determine if a character is a quote.
-     */
-    private static boolean isQuoteChar(String rawText, int index, int startIndex) {
-        if (index == startIndex) {
-            return rawText.charAt(index) == '\"';
-        } else if (rawText.charAt(index) == '\"') {
-            if (rawText.charAt(index - 1) == '\\') {
-                if (((index - 2) < startIndex) ||
-                        (rawText.charAt(index - 2) == '\\')) {
-                    return true;
-                } else {
-                    return false;
-                }
-            } else {
-                return true;
-            }
-        } else {
-            return false;
-        }
-    }
-
-    /**
      * This method iterates through the raw lines that make up
      * standard E-Mail headers, and parses them out into hash
@@ -799 +647 @@
                 // Quoted-Printable
                 result = new String(
-                        decodeQuotedPrintable(encodedText).getBytes(),
+                        decodeQuotedPrintable(encodedText.getBytes()).getBytes(),
                         charset);
             } catch (UnsupportedEncodingException ex) {
@@ -1271 +1119 @@
      * Decode a quoted-printable string
      */
-    public static String decodeQuotedPrintable(String text) {
+    public static String decodeQuotedPrintable(byte[] text) {
         StringBuffer buffer = new StringBuffer();
         int index = 0;
-        int length = text.length();
+        int length = text.length;
 
         while (index < length) {
-            if (text.charAt(index) == '=') {
+            if (text[index] == (byte)'=') {
                 if ((index + 2) >= length) {
                     break;
                 } else {
-                    char ch1 = text.charAt(index + 1);
-                    char ch2 = text.charAt(index + 2);
-
-                    if ((ch1 == '\r') && (ch2 == '\n')) {
+                    byte ch1 = text[index + 1];
+                    byte ch2 = text[index + 2];
+
+                    if ((ch1 == (byte)'\r') && (ch2 == (byte)'\n')) {
                         index += 3;
-                    } else if (ch1 == '\n') {
+                    } else if (ch1 == (byte)'\n') {
                         index += 2;
                     } else {
                         try {
-                            int charVal = Integer.parseInt(text.substring(index +
-                                        1, index + 3), 16);
+                            int charVal = StringArrays.parseHexInt(text, index + 1, 2);
                             buffer.append((char) charVal);
-                        } catch (NumberFormatException exp) {
-                        }
+                        } catch (NumberFormatException exp) { }
 
                         index += 3;
                     }
                 }
-            } else if (text.charAt(index) == '_') {
+            } else if (text[index] == (byte)'_') {
                 buffer.append(' ');
                 index++;
             } else {
-                buffer.append(text.charAt(index));
+                buffer.append((char)text[index]);
                 index++;
             }

trunk/LogicMailTests/src/org/logicprobe/LogicMail/mail/imap/ImapParserTest.java

@@ -1 +1 @@
 /*-
- * Copyright (c) 2008, Derek Konigsberg
+ * Copyright (c) 2010, Derek Konigsberg
  * All rights reserved.
  *
@@ -8 +8 @@
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution. 
+ *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the project nor the names of its
  *    contributors may be used to endorse or promote products derived
@@ -29 +29 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 package org.logicprobe.LogicMail.mail.imap;
 
@@ -37 +36 @@
 import j2meunit.framework.TestSuite;
 
+import java.util.Vector;
+
+
 /**
  * Unit test for ImapParser
  */
 public class ImapParserTest extends TestCase {
-    
     public ImapParserTest() {
     }
@@ -48 +49 @@
         super(testName, testMethod);
     }
-    
+
     public void setUp() {
     }
-    
+
     public void tearDown() {
     }
-    
+
     public void testParseFolderName() {
         String result = ImapParser.parseFolderName("Hello");
@@ -68 +69 @@
         assertEquals("Umlaut Test 2", "Gelöschte Objekte", result);
     }
+
+    public void testParenStringLexer1() {
+        String rawText = "(FLAGS (\\Answered \\Seen) " +
+            "ENVELOPE (\"Mon, 12 Mar 2007 19:38:31 -0700\" \"Re: Calm down! :-)\" " +
+            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
+            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
+            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
+            "((\"John Doe\" NIL \"jdoe\" \"generic.test\")) " + "NIL NIL " +
+            "\"<200703121933.25327.jdoe@generic.test>\" " +
+            "\"<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>\"))";
+
+        byte[] data = rawText.getBytes();
+        Vector result = ImapParser.parenListLexer(data, 0, data.length);
+        assertNotNull(result);
+
+        Character LPAREN = new Character('(');
+        Character RPAREN = new Character(')');
+
+        Object[] expected = new Object[] {
+                LPAREN, "FLAGS", LPAREN, "\\Answered", "\\Seen", RPAREN,
+                "ENVELOPE", LPAREN, "Mon, 12 Mar 2007 19:38:31 -0700".getBytes(),
+                "Re: Calm down! :-)".getBytes(), LPAREN, LPAREN, "jim smith".getBytes(), "NIL",
+                "jsmith".getBytes(), "scratch.test".getBytes(), RPAREN, RPAREN, LPAREN, LPAREN,
+                "jim smith".getBytes(), "NIL", "jsmith".getBytes(), "scratch.test".getBytes(), RPAREN, RPAREN,
+                LPAREN, LPAREN, "jim smith".getBytes(), "NIL", "jsmith".getBytes(), "scratch.test".getBytes(),
+                RPAREN, RPAREN, LPAREN, LPAREN, "John Doe".getBytes(), "NIL", "jdoe".getBytes(),
+                "generic.test".getBytes(), RPAREN, RPAREN, "NIL", "NIL",
+                "<200703121933.25327.jdoe@generic.test>".getBytes(),
+                "<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>".getBytes(),
+                RPAREN, RPAREN
+            };
+
+        assertEquals(expected.length, result.size());
+
+        for (int i = 0; i < expected.length; i++) {
+            if(expected[i] instanceof byte[] && result.elementAt(i) instanceof byte[]) {
+                assertEquals(new String((byte[])expected[i]), new String((byte[])result.elementAt(i)));
+            }
+            else {
+                assertEquals(expected[i], result.elementAt(i));
+            }
+        }
+    }
+
+    public void testParenStringLexer2() {
+        String rawText = "(FLAGS () ENVELOPE (\"Sun, 18 Mar 2007 09:04:29 -0700\" {23}\r\n" +
+            "[list] \"this is a test\" " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
+            "((NIL NIL \"jsmith\" \"XXXXXXXX\")) " +
+            "NIL NIL NIL \"<45FD630D.1040808@XXXXX>\"))";
+
+        byte[] data = rawText.getBytes();
+        Vector result = ImapParser.parenListLexer(data, 0, data.length);
+        assertNotNull(result);
+
+        Character LPAREN = new Character('(');
+        Character RPAREN = new Character(')');
+
+        Object[] expected = new Object[] {
+                LPAREN, "FLAGS", LPAREN, RPAREN, "ENVELOPE", LPAREN,
+                "Sun, 18 Mar 2007 09:04:29 -0700".getBytes(), "[list] \"this is a test\"".getBytes(),
+                LPAREN, LPAREN, "Jim Smith".getBytes(), "NIL", "jsmith".getBytes(), "XXXX".getBytes(), RPAREN,
+                RPAREN, LPAREN, LPAREN, "Jim Smith".getBytes(), "NIL", "jsmith".getBytes(), "XXXX".getBytes(),
+                RPAREN, RPAREN, LPAREN, LPAREN, "Jim Smith".getBytes(), "NIL", "jsmith".getBytes(),
+                "XXXX".getBytes(), RPAREN, RPAREN, LPAREN, LPAREN, "NIL", "NIL", "jsmith".getBytes(),
+                "XXXXXXXX".getBytes(), RPAREN, RPAREN, "NIL", "NIL", "NIL",
+                "<45FD630D.1040808@XXXXX>".getBytes(), RPAREN, RPAREN
+            };
+
+        assertEquals(expected.length, result.size());
+
+        for (int i = 0; i < expected.length; i++) {
+            if(expected[i] instanceof byte[] && result.elementAt(i) instanceof byte[]) {
+                assertEquals(new String((byte[])expected[i]), new String((byte[])result.elementAt(i)));
+            }
+            else {
+                assertEquals(expected[i], result.elementAt(i));
+            }
+        }
+    }
+
+    //    /**
+    //     * Prints the token list for debugging purposes
+    //     *
+    //     * @param tokenList the token list
+    //     */
+    //    private void printTokenList(Vector tokenList) {
+    //        int size = tokenList.size();
+    //        System.err.println("-->");
+    //        for(int i=0; i<size; i++) {
+    //            Object element = tokenList.elementAt(i);
+    //            if(element instanceof Character) {
+    //                System.err.print("'" + element + "' ");
+    //            }
+    //            else if(element instanceof String) {
+    //                System.err.print("[" + element + "] ");
+    //            }
+    //            else if(element == null) {
+    //                System.err.print("<NIL> ");
+    //            }
+    //            else {
+    //                System.err.println("ERROR!!!!");
+    //            }
+    //        }
+    //        System.err.println();
+    //    }
+    public void testParenStringParserEnvelope1() {
+        String rawText = "(FLAGS (\\Answered \\Seen) " +
+            "ENVELOPE (\"Mon, 12 Mar 2007 19:38:31 -0700\" \"Re: Calm down! :-)\" " +
+            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
+            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
+            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
+            "((\"John Doe\" NIL \"jdoe\" \"generic.test\")) " + "NIL NIL " +
+            "\"<200703121933.25327.jdoe@generic.test>\" " +
+            "\"<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>\"))";
+
+        Vector result = ImapParser.parenListParser(rawText.getBytes());
+        Vector temp;
+
+        //printTree(result, 0);
+        assertEquals("FLAGS", (String) result.elementAt(0));
+
+        Vector flags = (Vector) result.elementAt(1);
+        assertEquals("\\Answered", (String) flags.elementAt(0));
+        assertEquals("\\Seen", (String) flags.elementAt(1));
+
+        assertEquals("ENVELOPE", (String) result.elementAt(2));
+
+        Vector envelope = (Vector) result.elementAt(3);
+        assertNotNull(envelope);
+        assertEquals("Mon, 12 Mar 2007 19:38:31 -0700",
+            (byte[]) envelope.elementAt(0));
+        assertEquals("Re: Calm down! :-)", (byte[]) envelope.elementAt(1));
+
+        temp = (Vector) envelope.elementAt(2);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("jim smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("scratch.test", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(3);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("jim smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("scratch.test", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(4);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("jim smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("scratch.test", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(5);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("John Doe", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jdoe", (byte[]) temp.elementAt(2));
+        assertEquals("generic.test", (byte[]) temp.elementAt(3));
+
+        assertEquals("NIL", (String) envelope.elementAt(6));
+        assertEquals("NIL", (String) envelope.elementAt(7));
+        assertEquals("<200703121933.25327.jdoe@generic.test>",
+            (byte[]) envelope.elementAt(8));
+        assertEquals("<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>",
+            (byte[]) envelope.elementAt(9));
+    }
+
+    public void testParenStringParserEnvelope2() {
+        String rawText = "(FLAGS () ENVELOPE (\"Sun, 18 Mar 2007 09:04:29 -0700\" {23}\r\n" +
+            "[list] \"this is a test\" " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
+            "((NIL NIL \"jsmith\" \"XXXXXXXX\")) " +
+            "NIL NIL NIL \"<45FD630D.1040808@XXXXX>\"))";
+
+        Vector result = ImapParser.parenListParser(rawText.getBytes());
+        Vector temp;
+
+        //printTree(result, 0);
+        assertEquals("FLAGS", (String) result.elementAt(0));
+
+        Vector flags = (Vector) result.elementAt(1);
+        assertEquals(0, flags.size());
+
+        assertEquals("ENVELOPE", (String) result.elementAt(2));
+
+        Vector envelope = (Vector) result.elementAt(3);
+        assertNotNull(envelope);
+        assertEquals("Sun, 18 Mar 2007 09:04:29 -0700",
+            (byte[]) envelope.elementAt(0));
+        assertEquals("[list] \"this is a test\"", (byte[]) envelope.elementAt(1));
+
+        temp = (Vector) envelope.elementAt(2);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("Jim Smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("XXXX", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(3);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("Jim Smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("XXXX", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(4);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("Jim Smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("XXXX", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(5);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("NIL", (String) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("XXXXXXXX", (byte[]) temp.elementAt(3));
+
+        assertEquals("NIL", (String) envelope.elementAt(6));
+        assertEquals("NIL", (String) envelope.elementAt(7));
+        assertEquals("NIL", (String) envelope.elementAt(8));
+        assertEquals("<45FD630D.1040808@XXXXX>", (byte[]) envelope.elementAt(9));
+    }
+
+    public void testParenStringParserEnvelope3() {
+        String rawText = "(FLAGS (\\Seen) " +
+            "ENVELOPE (\"Fri, 15 Jun 2007 12:37:27 -0400\" {42}\r\n" +
+            "[Theelist] 19\" monitor free to a good home " +
+            "((\"Jim Smith\" NIL \"jsmith\" \"smith.test\")) " +
+            "((NIL NIL \"thelist-bounces\" \"thelist.test\")) " +
+            "((\"This is the list\" NIL \"thelist\" \"thelist.test\")) " +
+            "((\"This is the list\" NIL \"thelist\" \"thelist.test\")) " +
+            "NIL NIL NIL " +
+            "\"<1ECCDABD-5242-4180-9584-E5873C3FEA17@smith.test>\"))";
+
+        Vector result = ImapParser.parenListParser(rawText.getBytes());
+        Vector temp;
+
+        //printTree(result, 0);
+        assertEquals("FLAGS", (String) result.elementAt(0));
+
+        Vector flags = (Vector) result.elementAt(1);
+        assertEquals("\\Seen", (String) flags.elementAt(0));
+
+        assertEquals("ENVELOPE", (String) result.elementAt(2));
+
+        Vector envelope = (Vector) result.elementAt(3);
+        assertNotNull(envelope);
+        assertEquals("Fri, 15 Jun 2007 12:37:27 -0400",
+            (byte[]) envelope.elementAt(0));
+        assertEquals("[Theelist] 19\" monitor free to a good home",
+            (byte[]) envelope.elementAt(1));
+
+        temp = (Vector) envelope.elementAt(2);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("Jim Smith", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("jsmith", (byte[]) temp.elementAt(2));
+        assertEquals("smith.test", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(3);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("NIL", (String) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("thelist-bounces", (byte[]) temp.elementAt(2));
+        assertEquals("thelist.test", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(4);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("This is the list", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("thelist", (byte[]) temp.elementAt(2));
+        assertEquals("thelist.test", (byte[]) temp.elementAt(3));
+
+        temp = (Vector) envelope.elementAt(5);
+        temp = (Vector) temp.elementAt(0);
+        assertEquals("This is the list", (byte[]) temp.elementAt(0));
+        assertEquals("NIL", (String) temp.elementAt(1));
+        assertEquals("thelist", (byte[]) temp.elementAt(2));
+        assertEquals("thelist.test", (byte[]) temp.elementAt(3));
+
+        assertEquals("NIL", (String) envelope.elementAt(6));
+        assertEquals("NIL", (String) envelope.elementAt(7));
+        assertEquals("NIL", (String) envelope.elementAt(8));
+        assertEquals("<1ECCDABD-5242-4180-9584-E5873C3FEA17@smith.test>",
+            (byte[]) envelope.elementAt(9));
+    }
+
+    public void testParenStringParserBodyStructure() {
+        String rawText = "(BODYSTRUCTURE " +
+            "((\"TEXT\" \"PLAIN\" (\"CHARSET\" \"us-ascii\") NIL NIL \"7BIT\" 165 8 NIL NIL NIL) " +
+            "(\"TEXT\" \"HTML\" (\"CHARSET\" \"us-ascii\") NIL NIL \"7BIT\" 627 10 NIL NIL NIL) " +
+            "\"ALTERNATIVE\" (\"BOUNDARY\" \"Boundary-00=_y9RuEFduwo6YU42\") (\"INLINE\" NIL) NIL))";
+
+        Vector result = ImapParser.parenListParser(rawText.getBytes());
+        Vector temp1;
+        Vector temp2;
+        Vector temp3;
+
+        //printTree(result, 0);
+        assertEquals("BODYSTRUCTURE", (String) result.elementAt(0));
+        temp1 = (Vector) result.elementAt(1);
+
+        temp2 = (Vector) temp1.elementAt(0);
+        assertEquals("TEXT", (byte[]) temp2.elementAt(0));
+        assertEquals("PLAIN", (byte[]) temp2.elementAt(1));
+        temp3 = (Vector) temp2.elementAt(2);
+        assertEquals("CHARSET", (byte[]) temp3.elementAt(0));
+        assertEquals("us-ascii", (byte[]) temp3.elementAt(1));
+        assertEquals("NIL", (String) temp2.elementAt(3));
+        assertEquals("NIL", (String) temp2.elementAt(4));
+        assertEquals("7BIT", (byte[]) temp2.elementAt(5));
+        assertEquals("165", (String) temp2.elementAt(6));
+        assertEquals("8", (String) temp2.elementAt(7));
+        assertEquals("NIL", (String) temp2.elementAt(8));
+        assertEquals("NIL", (String) temp2.elementAt(9));
+        assertEquals("NIL", (String) temp2.elementAt(10));
+
+        temp2 = (Vector) temp1.elementAt(1);
+        assertEquals("TEXT", (byte[]) temp2.elementAt(0));
+        assertEquals("HTML", (byte[]) temp2.elementAt(1));
+        temp3 = (Vector) temp2.elementAt(2);
+        assertEquals("CHARSET", (byte[]) temp3.elementAt(0));
+        assertEquals("us-ascii", (byte[]) temp3.elementAt(1));
+        assertEquals("NIL", (String) temp2.elementAt(3));
+        assertEquals("NIL", (String) temp2.elementAt(4));
+        assertEquals("7BIT", (byte[]) temp2.elementAt(5));
+        assertEquals("627", (String) temp2.elementAt(6));
+        assertEquals("10", (String) temp2.elementAt(7));
+        assertEquals("NIL", (String) temp2.elementAt(8));
+        assertEquals("NIL", (String) temp2.elementAt(9));
+        assertEquals("NIL", (String) temp2.elementAt(10));
+
+        assertEquals("ALTERNATIVE", (byte[]) temp1.elementAt(2));
+
+        temp2 = (Vector) temp1.elementAt(3);
+        assertEquals("BOUNDARY", (byte[]) temp2.elementAt(0));
+        assertEquals("Boundary-00=_y9RuEFduwo6YU42", (byte[]) temp2.elementAt(1));
+
+        temp2 = (Vector) temp1.elementAt(4);
+        assertEquals("INLINE", (byte[]) temp2.elementAt(0));
+        assertEquals("NIL", (String) temp2.elementAt(1));
+
+        assertEquals("NIL", (String) temp1.elementAt(5));
+    }
+
+    //    /**
+    //     * This method prints the parse tree for debugging purposes.
+    //     * @param node Node to start at.
+    //     * @param level Level to print from.
+    //     */
+    //    private void printTree(Object node, int level) {
+    //        if(node instanceof Vector) {
+    //            Vector vec = (Vector)node;
+    //            int size = vec.size();
+    //            for(int i=0; i<size; i++)
+    //                printTree(vec.elementAt(i), level + 1);
+    //        }
+    //        else {
+    //            StringBuffer buf = new StringBuffer();
+    //            buf.append(level+">");
+    //            for(int i=0; i<level; i++)
+    //                buf.append("    ");
+    //            if(node != null) {
+    //                buf.append(node.toString());
+    //            }
+    //            else {
+    //                buf.append("null");
+    //            }
+    //            System.err.println(buf.toString());
+    //        }
+    //    }
+    
+    protected void assertEquals(String expected, byte[] actual) {
+        assertEquals(expected, new String(actual));
+    }
     
     public Test suite() {
@@ -73 +458 @@
 
         suite.addTest(new ImapParserTest("parseFolderName", new TestMethod()
-        { public void run(TestCase tc) {((ImapParserTest)tc).testParseFolderName(); } }));
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParseFolderName(); }}));
+
+        suite.addTest(new ImapParserTest("parenStringLexer1", new TestMethod()
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParenStringLexer1(); }}));
+
+        suite.addTest(new ImapParserTest("parenStringLexer2", new TestMethod()
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParenStringLexer2(); }}));
+
+        suite.addTest(new ImapParserTest("parenStringParserEnvelope1", new TestMethod()
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParenStringParserEnvelope1(); }}));
+
+        suite.addTest(new ImapParserTest("parenStringParserEnvelope2", new TestMethod()
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParenStringParserEnvelope2(); }}));
+
+        suite.addTest(new ImapParserTest("parenStringParserEnvelope3", new TestMethod()
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParenStringParserEnvelope3(); }}));
+
+        suite.addTest(new ImapParserTest("parenStringParserBodyStructure", new TestMethod()
+        { public void run(TestCase tc) { ((ImapParserTest) tc).testParenStringParserBodyStructure(); }}));
 
         return suite;
-    }    
+    }
 }

trunk/LogicMailTests/src/org/logicprobe/LogicMail/mail/imap/ImapProtocolTest.java

@@ -37 +37 @@
 import j2meunit.framework.TestSuite;
 
+import org.logicprobe.LogicMail.mail.MailException;
 import org.logicprobe.LogicMail.mail.MailProgressHandler;
 import org.logicprobe.LogicMail.message.MessageEnvelope;
 import org.logicprobe.LogicMail.util.StringParser;
 
+import java.io.IOException;
 import java.util.Calendar;
 import java.util.Hashtable;
 import java.util.TimeZone;
 import java.util.Vector;
+
 
 /**
@@ -348 +351 @@
         }
     }
-    
+
     public void testExecuteList7() {
         try {
             // Test specified-length encoding for path name, with spaces
             instance.addExecuteExpectation("LIST", "\"\" \"%\"",
-                    new String[] {
+                new String[] {
                     "* LIST (\\Noselect) \":\" {5}", "Marya",
                     "* LIST (\\Noselect) \":\" {11}", "Old Inboxes",
-                    "* LIST (\\Noinferiors) \":\" {17}", "Pre-filtered Junk" });
-            
+                    "* LIST (\\Noinferiors) \":\" {17}", "Pre-filtered Junk"
+                });
+
             Vector result = instance.executeList("", "%", null);
             assertNotNull(result);
@@ -364 +368 @@
             assertTrue(result.elementAt(1) instanceof ImapProtocol.ListResponse);
             assertTrue(result.elementAt(2) instanceof ImapProtocol.ListResponse);
-            
+
             ImapProtocol.ListResponse result1 = (ImapProtocol.ListResponse) result.elementAt(0);
             ImapProtocol.ListResponse result2 = (ImapProtocol.ListResponse) result.elementAt(1);
             ImapProtocol.ListResponse result3 = (ImapProtocol.ListResponse) result.elementAt(2);
-            
+
             assertTrue(!result1.canSelect);
             assertTrue(!result1.noInferiors);
             assertEquals(":", result1.delim);
             assertEquals("Marya", result1.name);
-            
+
             assertTrue(!result2.canSelect);
             assertTrue(!result2.noInferiors);
             assertEquals(":", result2.delim);
             assertEquals("Old Inboxes", result2.name);
-            
+
             assertTrue(result3.canSelect);
             assertTrue(result3.noInferiors);
             assertEquals(":", result3.delim);
             assertEquals("Pre-filtered Junk", result3.name);
-            
         } catch (AssertionFailedError e) {
             throw e;
@@ -391 +394 @@
         }
     }
-    
-    private static class ShimCallback implements ImapProtocol.FetchEnvelopeCallback {
-        private Vector responses = new Vector();
-        
-        public void responseAvailable(ImapProtocol.FetchEnvelopeResponse response) {
-            if(response != null) {
-                responses.addElement(response);
-            }
-        }
-        
-        public ImapProtocol.FetchEnvelopeResponse[] getResponses() {
-            ImapProtocol.FetchEnvelopeResponse[] result = new ImapProtocol.FetchEnvelopeResponse[responses.size()];
-            responses.copyInto(result);
-            return result;
-        }
-    }
 
     public void testExecuteFetchEnvelope1() {
         try {
-            instance.addExecuteExpectation("FETCH", "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
+            instance.addExecuteExpectation("FETCH",
+                "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
                 new String[] {
                     "* 1 FETCH (FLAGS (\\Answered \\Seen) UID 10 " +
@@ -425 +413 @@
             ShimCallback shim = new ShimCallback();
             instance.executeFetchEnvelope(1, 1, shim, null);
+
             ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses();
-            
+
             assertNotNull(result);
             assertEquals(1, result.length);
@@ -482 +471 @@
             assertEquals("<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>",
                 env.messageId);
-            
+
             ImapParser.MessageSection structure = result[0].structure;
             assertNotNull(structure);
@@ -497 +486 @@
     public void testExecuteFetchEnvelope2() {
         try {
-            instance.addExecuteExpectation("FETCH", "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
+            instance.addExecuteExpectation("FETCH",
+                "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
                 new String[] {
                     "* 1 FETCH (" +
@@ -512 +502 @@
             ShimCallback shim = new ShimCallback();
             instance.executeFetchEnvelope(1, 1, shim, null);
+
             ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses();
-            
+
             assertNotNull(result);
             assertEquals(1, result.length);
@@ -583 +574 @@
     public void testExecuteFetchEnvelope3() {
         try {
-            instance.addExecuteExpectation("FETCH", "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
+            instance.addExecuteExpectation("FETCH",
+                "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
                 new String[] {
                     "* 1 FETCH (" + "FLAGS (\\Seen) UID 10 " +
@@ -599 +591 @@
             ShimCallback shim = new ShimCallback();
             instance.executeFetchEnvelope(1, 1, shim, null);
+
             ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses();
 
@@ -627 +620 @@
                 StringParser.createDateString(env.date));
 
-            assertEquals("[LogicMail for BlackBerry] #93: Endless \\\"refresh folders\\\" loop when using qmail server",
+            assertEquals("[LogicMail for BlackBerry] #93: Endless \"refresh folders\" loop when using qmail server",
                 env.subject);
 
@@ -673 +666 @@
     public void testExecuteFetchEnvelope4() {
         try {
-            instance.addExecuteExpectation("FETCH", "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
+            instance.addExecuteExpectation("FETCH",
+                "1:1 (FLAGS UID ENVELOPE BODYSTRUCTURE)",
                 new String[] {
                     "* 1 FETCH (FLAGS (\\Seen) UID 10 " +
@@ -689 +683 @@
             ShimCallback shim = new ShimCallback();
             instance.executeFetchEnvelope(1, 1, shim, null);
+
             ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses();
 
@@ -716 +711 @@
                 StringParser.createDateString(env.date));
 
-            assertEquals("Re: [LogicMail for BlackBerry] #94: Message \\\"\\\"This message does not contain any sections that could be displayed\\\"",
+            assertEquals("Re: [LogicMail for BlackBerry] #94: Message \"\"This message does not contain any sections that could be displayed\"",
                 env.subject);
 
@@ -760 +755 @@
         }
     }
-    
+
     public void testExecuteFetchFlags1() {
         try {
             instance.addExecuteExpectation("FETCH", "1:1 (FLAGS UID)",
-                    new String[] {
-                        "* 1 FETCH (FLAGS () UID 42)"
-                    });
-
-                ImapProtocol.FetchFlagsResponse[] result = instance.executeFetchFlags(1, 1, null);
-                
-                assertNotNull(result);
-                assertEquals(1, result.length);
-                assertEquals(1, result[0].index);
-                assertEquals(42, result[0].uid);
-                
-                ImapProtocol.MessageFlags flags = result[0].flags;
-                assertNotNull(flags);
-                assertTrue("answered", !flags.answered);
-                assertTrue("deleted", !flags.deleted);
-                assertTrue("draft", !flags.draft);
-                assertTrue("flagged", !flags.flagged);
-                assertTrue("junk", !flags.junk);
-                assertTrue("recent", !flags.recent);
-                assertTrue("seen", !flags.seen);
-            
-        } catch (Throwable t) {
-            fail("Exception thrown during test: " + t.toString());
-            t.printStackTrace();
-        }
-    }
-    
+                new String[] { "* 1 FETCH (FLAGS () UID 42)" });
+
+            ImapProtocol.FetchFlagsResponse[] result = instance.executeFetchFlags(1,
+                    1, null);
+
+            assertNotNull(result);
+            assertEquals(1, result.length);
+            assertEquals(1, result[0].index);
+            assertEquals(42, result[0].uid);
+
+            ImapProtocol.MessageFlags flags = result[0].flags;
+            assertNotNull(flags);
+            assertTrue("answered", !flags.answered);
+            assertTrue("deleted", !flags.deleted);
+            assertTrue("draft", !flags.draft);
+            assertTrue("flagged", !flags.flagged);
+            assertTrue("junk", !flags.junk);
+            assertTrue("recent", !flags.recent);
+            assertTrue("seen", !flags.seen);
+        } catch (Throwable t) {
+            fail("Exception thrown during test: " + t.toString());
+            t.printStackTrace();
+        }
+    }
+
     public void testExecuteFetchFlags2() {
         try {
             instance.addExecuteExpectation("FETCH", "1:1 (FLAGS UID)",
-                    new String[] {
-                        "* 1 FETCH (FLAGS (\\Seen) UID 42)"
-                    });
-
-                ImapProtocol.FetchFlagsResponse[] result = instance.executeFetchFlags(1, 1, null);
-                
-                assertNotNull(result);
-                assertEquals(1, result.length);
-                assertEquals(1, result[0].index);
-                assertEquals(42, result[0].uid);
-                
-                ImapProtocol.MessageFlags flags = result[0].flags;
-                assertNotNull(flags);
-                assertTrue("answered", !flags.answered);
-                assertTrue("deleted", !flags.deleted);
-                assertTrue("draft", !flags.draft);
-                assertTrue("flagged", !flags.flagged);
-                assertTrue("junk", !flags.junk);
-                assertTrue("recent", !flags.recent);
-                assertTrue("seen", flags.seen);
-            
-        } catch (Throwable t) {
-            fail("Exception thrown during test: " + t.toString());
-            t.printStackTrace();
-        }
-    }
-    
+                new String[] { "* 1 FETCH (FLAGS (\\Seen) UID 42)" });
+
+            ImapProtocol.FetchFlagsResponse[] result = instance.executeFetchFlags(1,
+                    1, null);
+
+            assertNotNull(result);
+            assertEquals(1, result.length);
+            assertEquals(1, result[0].index);
+            assertEquals(42, result[0].uid);
+
+            ImapProtocol.MessageFlags flags = result[0].flags;
+            assertNotNull(flags);
+            assertTrue("answered", !flags.answered);
+            assertTrue("deleted", !flags.deleted);
+            assertTrue("draft", !flags.draft);
+            assertTrue("flagged", !flags.flagged);
+            assertTrue("junk", !flags.junk);
+            assertTrue("recent", !flags.recent);
+            assertTrue("seen", flags.seen);
+        } catch (Throwable t) {
+            fail("Exception thrown during test: " + t.toString());
+            t.printStackTrace();
+        }
+    }
+
     public void testExecuteStore1() {
         try {
@@ -864 +855 @@
         }
     }
-    
+
     public void testExecuteStore3() {
         try {
             instance.addExecuteExpectation("UID STORE",
                 "36410 +FLAGS (\\Deleted)",
-                new String[] { "* 5 FETCH (UID 36410 FLAGS (\\Deleted \\Seen $NotJunk NotJunk))" });
-
-            ImapProtocol.MessageFlags result = instance.executeStore(36410, true,
-                    new String[] { "\\Deleted" });
+                new String[] {
+                    "* 5 FETCH (UID 36410 FLAGS (\\Deleted \\Seen $NotJunk NotJunk))"
+                });
+
+            ImapProtocol.MessageFlags result = instance.executeStore(36410,
+                    true, new String[] { "\\Deleted" });
             assertNotNull(result);
 
@@ -890 +883 @@
         TestSuite suite = new TestSuite("ImapProtocol");
 
-        suite.addTest(new ImapProtocolTest("executeCapability", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteCapability(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeNamespace1", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteNamespace1(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeNamespace2", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteNamespace2(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList1", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList1(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList2", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList2(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList3", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList3(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList4", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList4(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList5", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList5(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList6", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList6(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeList7", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteList7(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeFetchEnvelope1", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteFetchEnvelope1(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeFetchEnvelope2", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteFetchEnvelope2(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeFetchEnvelope3", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteFetchEnvelope3(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeFetchEnvelope4", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteFetchEnvelope4(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeFetchFlags1", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteFetchFlags1(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeFetchFlags2", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteFetchFlags2(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeStore1", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteStore1(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeStore2", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteStore2(); }}));
-        
-        suite.addTest(new ImapProtocolTest("executeStore3", new TestMethod()
-        { public void run(TestCase tc) { ((ImapProtocolTest) tc).testExecuteStore3(); }}));
-        
+        suite.addTest(new ImapProtocolTest("executeCapability",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteCapability();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeNamespace1",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteNamespace1();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeNamespace2",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteNamespace2();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList1",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList1();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList2",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList2();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList3",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList3();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList4",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList4();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList5",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList5();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList6",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList6();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeList7",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteList7();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeFetchEnvelope1",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteFetchEnvelope1();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeFetchEnvelope2",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteFetchEnvelope2();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeFetchEnvelope3",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteFetchEnvelope3();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeFetchEnvelope4",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteFetchEnvelope4();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeFetchFlags1",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteFetchFlags1();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeFetchFlags2",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteFetchFlags2();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeStore1",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteStore1();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeStore2",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteStore2();
+                }
+            }));
+
+        suite.addTest(new ImapProtocolTest("executeStore3",
+                new TestMethod() {
+                public void run(TestCase tc) {
+                    ((ImapProtocolTest) tc).testExecuteStore3();
+                }
+            }));
+
         return suite;
+    }
+
+    private static class ShimCallback implements ImapProtocol.FetchEnvelopeCallback {
+        private Vector responses = new Vector();
+
+        public void responseAvailable(
+            ImapProtocol.FetchEnvelopeResponse response) {
+            if (response != null) {
+                responses.addElement(response);
+            }
+        }
+
+        public ImapProtocol.FetchEnvelopeResponse[] getResponses() {
+            ImapProtocol.FetchEnvelopeResponse[] result = new ImapProtocol.FetchEnvelopeResponse[responses.size()];
+            responses.copyInto(result);
+
+            return result;
+        }
     }
 
@@ -979 +1066 @@
         }
 
-        protected String[] execute(String command, String arguments, MailProgressHandler progressHandler) {
+        protected String[] execute(String command, String arguments,
+            MailProgressHandler progressHandler) {
             assertTrue("No expectations", !executeExpectations.isEmpty());
 
@@ -990 +1078 @@
         }
 
+        protected byte[][] executeResponse(String command, String arguments,
+                MailProgressHandler progressHandler) throws IOException, MailException {
+            assertTrue("No expectations", !executeExpectations.isEmpty());
+
+            ExecuteExpectation expect = (ExecuteExpectation) executeExpectations.lastElement();
+            assertEquals("Bad command", expect.command, command);
+            assertEquals("Bad arguments", expect.arguments, arguments);
+            executeExpectations.removeElement(expect);
+
+            byte[][] result = new byte[expect.result.length][];
+            for(int i=0; i<expect.result.length; i++) {
+                result[i] = expect.result[i].getBytes();
+            }
+            return result;
+        }
+        
         private class ExecuteExpectation {
             public String command;

trunk/LogicMailTests/src/org/logicprobe/LogicMail/util/StringParserTest.java

@@ -40 +40 @@
 import java.util.Hashtable;
 import java.util.TimeZone;
-import java.util.Vector;
 
 /**
@@ -190 +189 @@
         assertEquals("GMT", expected, actual);
     }
-
-    /**
-     * Test of nestedParenStringLexer method, of class org.logicprobe.LogicMail.util.StringParser.
-     */
-    public void testNestedParenStringLexerEnvelope1() {
-        System.out.println("nestedParenStringLexer (Envelope1)");
-
-        String rawText = "(FLAGS (\\Answered \\Seen) " +
-            "ENVELOPE (\"Mon, 12 Mar 2007 19:38:31 -0700\" \"Re: Calm down! :-)\" " +
-            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
-            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
-            "((\"jim smith\" NIL \"jsmith\" \"scratch.test\")) " +
-            "((\"John Doe\" NIL \"jdoe\" \"generic.test\")) " + "NIL NIL " +
-            "\"<200703121933.25327.jdoe@generic.test>\" " +
-            "\"<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>\"))";
-
-        Vector result = StringParser.nestedParenStringLexer(rawText);
-        Vector temp;
-
-        //printTree(result, 0);
-        assertEquals("FLAGS", (String) result.elementAt(0));
-
-        Vector flags = (Vector) result.elementAt(1);
-        assertEquals("\\Answered", (String) flags.elementAt(0));
-        assertEquals("\\Seen", (String) flags.elementAt(1));
-
-        assertEquals("ENVELOPE", (String) result.elementAt(2));
-
-        Vector envelope = (Vector) result.elementAt(3);
-        assertNotNull(envelope);
-        assertEquals("Mon, 12 Mar 2007 19:38:31 -0700",
-            (String) envelope.elementAt(0));
-        assertEquals("Re: Calm down! :-)", (String) envelope.elementAt(1));
-
-        temp = (Vector) envelope.elementAt(2);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("jim smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("scratch.test", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(3);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("jim smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("scratch.test", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(4);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("jim smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("scratch.test", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(5);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("John Doe", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jdoe", (String) temp.elementAt(2));
-        assertEquals("generic.test", (String) temp.elementAt(3));
-
-        assertEquals("NIL", (String) envelope.elementAt(6));
-        assertEquals("NIL", (String) envelope.elementAt(7));
-        assertEquals("<200703121933.25327.jdoe@generic.test>",
-            (String) envelope.elementAt(8));
-        assertEquals("<7b02460f0703121938sff23a05xd3c2a37dc6b9eb7d@mail.scratch.test>",
-            (String) envelope.elementAt(9));
-    }
-
-    /**
-     * Test of nestedParenStringLexer method, of class org.logicprobe.LogicMail.util.StringParser.
-     */
-    public void testNestedParenStringLexerEnvelope2() {
-        System.out.println("nestedParenStringLexer (Envelope2)");
-
-        String rawText = "(FLAGS () ENVELOPE (\"Sun, 18 Mar 2007 09:04:29 -0700\" {23}\r\n" +
-            "[list] \"this is a test\" " +
-            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
-            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
-            "((\"Jim Smith\" NIL \"jsmith\" \"XXXX\")) " +
-            "((NIL NIL \"jsmith\" \"XXXXXXXX\")) " +
-            "NIL NIL NIL \"<45FD630D.1040808@XXXXX>\"))";
-
-        Vector result = StringParser.nestedParenStringLexer(rawText);
-        Vector temp;
-
-        //printTree(result, 0);
-        assertEquals("FLAGS", (String) result.elementAt(0));
-
-        Vector flags = (Vector) result.elementAt(1);
-        assertEquals(0, flags.size());
-
-        assertEquals("ENVELOPE", (String) result.elementAt(2));
-
-        Vector envelope = (Vector) result.elementAt(3);
-        assertNotNull(envelope);
-        assertEquals("Sun, 18 Mar 2007 09:04:29 -0700",
-            (String) envelope.elementAt(0));
-        assertEquals("[list] \"this is a test\"", (String) envelope.elementAt(1));
-
-        temp = (Vector) envelope.elementAt(2);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("Jim Smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("XXXX", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(3);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("Jim Smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("XXXX", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(4);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("Jim Smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("XXXX", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(5);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("NIL", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("XXXXXXXX", (String) temp.elementAt(3));
-
-        assertEquals("NIL", (String) envelope.elementAt(6));
-        assertEquals("NIL", (String) envelope.elementAt(7));
-        assertEquals("NIL", (String) envelope.elementAt(8));
-        assertEquals("<45FD630D.1040808@XXXXX>", (String) envelope.elementAt(9));
-    }
-
-    /**
-     * Test of nestedParenStringLexer method, of class org.logicprobe.LogicMail.util.StringParser.
-     */
-    public void testNestedParenStringLexerEnvelope3() {
-        System.out.println("nestedParenStringLexer (Envelope3)");
-
-        String rawText = "(FLAGS (\\Seen) " +
-            "ENVELOPE (\"Fri, 15 Jun 2007 12:37:27 -0400\" {42}\r\n" +
-            "[Theelist] 19\" monitor free to a good home " +
-            "((\"Jim Smith\" NIL \"jsmith\" \"smith.test\")) " +
-            "((NIL NIL \"thelist-bounces\" \"thelist.test\")) " +
-            "((\"This is the list\" NIL \"thelist\" \"thelist.test\")) " +
-            "((\"This is the list\" NIL \"thelist\" \"thelist.test\")) " +
-            "NIL NIL NIL " +
-            "\"<1ECCDABD-5242-4180-9584-E5873C3FEA17@smith.test>\"))";
-
-        Vector result = StringParser.nestedParenStringLexer(rawText);
-        Vector temp;
-
-        //printTree(result, 0);
-        assertEquals("FLAGS", (String) result.elementAt(0));
-
-        Vector flags = (Vector) result.elementAt(1);
-        assertEquals("\\Seen", (String) flags.elementAt(0));
-
-        assertEquals("ENVELOPE", (String) result.elementAt(2));
-
-        Vector envelope = (Vector) result.elementAt(3);
-        assertNotNull(envelope);
-        assertEquals("Fri, 15 Jun 2007 12:37:27 -0400",
-            (String) envelope.elementAt(0));
-        assertEquals("[Theelist] 19\" monitor free to a good home",
-            (String) envelope.elementAt(1));
-
-        temp = (Vector) envelope.elementAt(2);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("Jim Smith", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("jsmith", (String) temp.elementAt(2));
-        assertEquals("smith.test", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(3);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("NIL", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("thelist-bounces", (String) temp.elementAt(2));
-        assertEquals("thelist.test", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(4);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("This is the list", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("thelist", (String) temp.elementAt(2));
-        assertEquals("thelist.test", (String) temp.elementAt(3));
-
-        temp = (Vector) envelope.elementAt(5);
-        temp = (Vector) temp.elementAt(0);
-        assertEquals("This is the list", (String) temp.elementAt(0));
-        assertEquals("NIL", (String) temp.elementAt(1));
-        assertEquals("thelist", (String) temp.elementAt(2));
-        assertEquals("thelist.test", (String) temp.elementAt(3));
-
-        assertEquals("NIL", (String) envelope.elementAt(6));
-        assertEquals("NIL", (String) envelope.elementAt(7));
-        assertEquals("NIL", (String) envelope.elementAt(8));
-        assertEquals("<1ECCDABD-5242-4180-9584-E5873C3FEA17@smith.test>",
-            (String) envelope.elementAt(9));
-    }
-
-    /**
-     * Test of nestedParenStringLexer method, of class org.logicprobe.LogicMail.util.StringParser.
-     */
-    public void testNestedParenStringLexerBodyStructure() {
-        System.out.println("nestedParenStringLexer (BodyStructure)");
-
-        String rawText = "(BODYSTRUCTURE " +
-            "((\"TEXT\" \"PLAIN\" (\"CHARSET\" \"us-ascii\") NIL NIL \"7BIT\" 165 8 NIL NIL NIL) " +
-            "(\"TEXT\" \"HTML\" (\"CHARSET\" \"us-ascii\") NIL NIL \"7BIT\" 627 10 NIL NIL NIL) " +
-            "\"ALTERNATIVE\" (\"BOUNDARY\" \"Boundary-00=_y9RuEFduwo6YU42\") (\"INLINE\" NIL) NIL))";
-
-        Vector result = StringParser.nestedParenStringLexer(rawText);
-        Vector temp1;
-        Vector temp2;
-        Vector temp3;
-
-        //printTree(result, 0);
-        assertEquals("BODYSTRUCTURE", (String) result.elementAt(0));
-        temp1 = (Vector) result.elementAt(1);
-
-        temp2 = (Vector) temp1.elementAt(0);
-        assertEquals("TEXT", (String) temp2.elementAt(0));
-        assertEquals("PLAIN", (String) temp2.elementAt(1));
-        temp3 = (Vector) temp2.elementAt(2);
-        assertEquals("CHARSET", (String) temp3.elementAt(0));
-        assertEquals("us-ascii", (String) temp3.elementAt(1));
-        assertEquals("NIL", (String) temp2.elementAt(3));
-        assertEquals("NIL", (String) temp2.elementAt(4));
-        assertEquals("7BIT", (String) temp2.elementAt(5));
-        assertEquals("165", (String) temp2.elementAt(6));
-        assertEquals("8", (String) temp2.elementAt(7));
-        assertEquals("NIL", (String) temp2.elementAt(8));
-        assertEquals("NIL", (String) temp2.elementAt(9));
-        assertEquals("NIL", (String) temp2.elementAt(10));
-
-        temp2 = (Vector) temp1.elementAt(1);
-        assertEquals("TEXT", (String) temp2.elementAt(0));
-        assertEquals("HTML", (String) temp2.elementAt(1));
-        temp3 = (Vector) temp2.elementAt(2);
-        assertEquals("CHARSET", (String) temp3.elementAt(0));
-        assertEquals("us-ascii", (String) temp3.elementAt(1));
-        assertEquals("NIL", (String) temp2.elementAt(3));
-        assertEquals("NIL", (String) temp2.elementAt(4));
-        assertEquals("7BIT", (String) temp2.elementAt(5));
-        assertEquals("627", (String) temp2.elementAt(6));
-        assertEquals("10", (String) temp2.elementAt(7));
-        assertEquals("NIL", (String) temp2.elementAt(8));
-        assertEquals("NIL", (String) temp2.elementAt(9));
-        assertEquals("NIL", (String) temp2.elementAt(10));
-
-        assertEquals("ALTERNATIVE", (String) temp1.elementAt(2));
-
-        temp2 = (Vector) temp1.elementAt(3);
-        assertEquals("BOUNDARY", (String) temp2.elementAt(0));
-        assertEquals("Boundary-00=_y9RuEFduwo6YU42", (String) temp2.elementAt(1));
-
-        temp2 = (Vector) temp1.elementAt(4);
-        assertEquals("INLINE", (String) temp2.elementAt(0));
-        assertEquals("NIL", (String) temp2.elementAt(1));
-
-        assertEquals("NIL", (String) temp1.elementAt(5));
-    }
-
-    //    /**
-    //     * This method prints the parse tree for debugging purposes.
-    //     * @param node Node to start at.
-    //     * @param level Level to print from.
-    //     */
-    //    private void printTree(Object node, int level) {
-    //        if(node instanceof Vector) {
-    //            Vector vec = (Vector)node;
-    //            int size = vec.size();
-    //            for(int i=0; i<size; i++)
-    //                printTree(vec.elementAt(i), level + 1);
-    //        }
-    //        else {
-    //            StringBuffer buf = new StringBuffer();
-    //            buf.append(level+">");
-    //            for(int i=0; i<level; i++)
-    //                buf.append("    ");
-    //            if(node != null) {
-    //                buf.append(node.toString());
-    //            }
-    //            else {
-    //                buf.append("null");
-    //            }
-    //            System.err.println(buf.toString());
-    //        }
-    //    }
 
     /**
@@ -839 +545 @@
         String text = "=A1Hol=E1 Se=F1or!";
         String expectedResult = "¡Holá Señor!";
-        String result = StringParser.decodeQuotedPrintable(text);
+        String result = StringParser.decodeQuotedPrintable(text.getBytes());
         assertEquals(expectedResult, result);
     }
@@ -853 +559 @@
             "ow=20are=20you=20today?";
         String expectedResult = "¡Holá Señor!  How are you today?";
-        String result = StringParser.decodeQuotedPrintable(text);
+        String result = StringParser.decodeQuotedPrintable(text.getBytes());
         assertEquals(expectedResult, result);
     }
@@ -969 +675 @@
         { public void run(TestCase tc) { ((StringParserTest) tc).testCreateDateString(); }}));
         
-        testSuite.addTest(new StringParserTest("nestedParenStringLexerEnvelope1", new TestMethod()
-        { public void run(TestCase tc) { ((StringParserTest) tc).testNestedParenStringLexerEnvelope1(); }}));
-        
-        testSuite.addTest(new StringParserTest("nestedParenStringLexerEnvelope2", new TestMethod()
-        { public void run(TestCase tc) { ((StringParserTest) tc).testNestedParenStringLexerEnvelope2(); }}));
-        
-        testSuite.addTest(new StringParserTest("nestedParenStringLexerEnvelope3", new TestMethod()
-        { public void run(TestCase tc) { ((StringParserTest) tc).testNestedParenStringLexerEnvelope3(); }}));
-        
-        testSuite.addTest(new StringParserTest("nestedParenStringLexerBodyStructure", new TestMethod()
-        { public void run(TestCase tc) { ((StringParserTest) tc).testNestedParenStringLexerBodyStructure(); }}));
-        
         testSuite.addTest(new StringParserTest("parseMailHeaders", new TestMethod()
         { public void run(TestCase tc) { ((StringParserTest) tc).testParseMailHeaders(); }}));

trunk/LogicMailTests/src/org/logicprobe/LogicMail/util/UtilTests.java

@@ -48 +48 @@
         TestSuite testSuite = new TestSuite("LogicMail.util");
         testSuite.addTest(new StringParserTest().suite());
+        testSuite.addTest(new StringArraysTest().suite());
         testSuite.addTest(new SerializableHashtableTest().suite());
         testSuite.addTest(new EventListenerListTest().suite());