Java/File Input Output/FilterOutputStream

Adds extra dot if dot occurs in message body at beginning of line (according to RFC1939)

   
/****************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one   *
 * or more contributor license agreements.  See the NOTICE file *
 * distributed with this work for additional information        *
 * regarding copyright ownership.  The ASF licenses this file   *
 * to you under the Apache License, Version 2.0 (the            *
 * "License"); you may not use this file except in compliance   *
 * with the License.  You may obtain a copy of the License at   *
 *                                                              *
 *   http://www.apache.org/licenses/LICENSE-2.0                 *
 *                                                              *
 * Unless required by applicable law or agreed to in writing,   *
 * software distributed under the License is distributed on an  *
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
 * KIND, either express or implied.  See the License for the    *
 * specific language governing permissions and limitations      *
 * under the License.                                           *
 ****************************************************************/

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
 * Adds extra dot if dot occurs in message body at beginning of line (according to RFC1939)
 * Compare also org.apache.james.smtpserver.SMTPInputStream
 */
public class ExtraDotOutputStream extends FilterOutputStream {
    /*
    static public void main(String[] args) throws IOException
    {
        String data = ".This is a test\r\nof the thing.\r\nWe should not have much trouble.\r\n.doubled?\r\nor not?\n.doubled\nor not?\r\n\r\n\n\n\r\r\r\n";
        OutputStream os = new ExtraDotOutputStream(System.out);
        os.write(data.getBytes());
    }
    */
    /**
     * Counter for number of last (0A or 0D).
     */
    protected int countLast0A0D;
    /**
     * Constructor that wraps an OutputStream.
     *
     * @param out the OutputStream to be wrapped
     */
    public ExtraDotOutputStream(OutputStream out) {
        super(out);
        countLast0A0D = 2; // we already assume a CRLF at beginning (otherwise TOP would not work correctly !)
    }
    /**
     * Writes a byte to the stream, adding dots where appropriate.
     * Also fixes any naked CR or LF to the RFC 2821 mandated CFLF
     * pairing.
     *
     * @param b the byte to write
     *
     * @throws IOException if an error occurs writing the byte
     */
    public void write(int b) throws IOException {
        switch (b) {
            case ".":
                if (countLast0A0D == 2) {
                    // add extra dot (the first of the pair)
                    out.write(".");
                }
                countLast0A0D = 0;
                break;
            case "\r":
                if (countLast0A0D == 1) out.write("\n"); // two CR in a row, so insert an LF first
                countLast0A0D = 1;
                break;
            case "\n":
                /* RFC 2821 #2.3.7 mandates that line termination is
                 * CRLF, and that CR and LF must not be transmitted
                 * except in that pairing.  If we get a naked LF,
                 * convert to CRLF.
                 */
                if (countLast0A0D != 1) out.write("\r");
                countLast0A0D = 2;
                break;
            default:
                // we"re  no longer at the start of a line
                countLast0A0D = 0;
                break;
        }
        out.write(b);
    }
    
    /**
     * Ensure that the stream is CRLF terminated.
     * 
     * @throws IOException  if an error occurs writing the byte
     */
    public void checkCRLFTerminator() throws IOException {
        if (countLast0A0D != 2) {
            write("\n");
        }
    }
}
//////////////////////////////
/****************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one   *
 * or more contributor license agreements.  See the NOTICE file *
 * distributed with this work for additional information        *
 * regarding copyright ownership.  The ASF licenses this file   *
 * to you under the Apache License, Version 2.0 (the            *
 * "License"); you may not use this file except in compliance   *
 * with the License.  You may obtain a copy of the License at   *
 *                                                              *
 *   http://www.apache.org/licenses/LICENSE-2.0                 *
 *                                                              *
 * Unless required by applicable law or agreed to in writing,   *
 * software distributed under the License is distributed on an  *
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
 * KIND, either express or implied.  See the License for the    *
 * specific language governing permissions and limitations      *
 * under the License.                                           *
 ****************************************************************/

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import junit.framework.TestCase;
/**
 * Tests for the ExtraDotOutputStream
 */
public class ExtraDotOutputStreamTest extends TestCase {
    public void testMain() throws IOException {
        String data = ".This is a test\r\nof the thing.\r\nWe should not have much trouble.\r\n.doubled?\r\nor not?\n.doubled\nor not?\r\n\r\n\n\n\r\r\r\n";
        ByteArrayOutputStream bOut = new ByteArrayOutputStream();
        OutputStream os = new ExtraDotOutputStream(bOut);
        os.write(data.getBytes());
        os.flush();
        String expected = "..This is a test\r\nof the thing.\r\nWe should not have much trouble.\r\n..doubled?\r\nor not?\r\n..doubled\r\nor not?\r\n\r\n\r\n\r\n\r\n\r\n\r\n";
        assertEquals(expected,bOut.toString());
    }
    /*
     * Test method for "org.apache.james.util.ExtraDotOutputStream.checkCRLFTerminator()"
     */
    public void testCheckCRLFTerminator() throws IOException {
        ByteArrayOutputStream bOut = new ByteArrayOutputStream();
        ExtraDotOutputStream os = new ExtraDotOutputStream(bOut);
        // if the stream is empty then we should not add the CRLF.
        os.checkCRLFTerminator();
        os.flush();
        assertEquals("",bOut.toString());
        os.write("Test".getBytes());
        os.flush();
        assertEquals("Test",bOut.toString());
        os.checkCRLFTerminator();
        os.flush();
        assertEquals("Test\r\n",bOut.toString());
        // if the stream ends with \r we should simply add the \n
        os.write("A line with incomplete ending\r".getBytes());
        os.flush();
        assertEquals("Test\r\nA line with incomplete ending\r",bOut.toString());
        os.checkCRLFTerminator();
        os.flush();
        assertEquals("Test\r\nA line with incomplete ending\r\n",bOut.toString());
        // already correctly terminated, should leave the output untouched
        os.checkCRLFTerminator();
        os.flush();
        assertEquals("Test\r\nA line with incomplete ending\r\n",bOut.toString());
    }
}

Capture System.out into a JFrame

  
import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class Main extends JFrame {
  JTextArea aTextArea = new JTextArea();
  PrintStream aPrintStream = new PrintStream(new FilteredStream(new ByteArrayOutputStream()));
  public Main() {
    setSize(300, 300);
    add("Center", new JScrollPane(aTextArea));
    setVisible(true);
    System.setOut(aPrintStream); // catches System.out messages
    System.setErr(aPrintStream); // catches error messages
  }
  class FilteredStream extends FilterOutputStream {
    public FilteredStream(OutputStream aStream) {
      super(aStream);
    }
    public void write(byte b[]) throws IOException {
      String aString = new String(b);
      aTextArea.append(aString);
    }
    public void write(byte b[], int off, int len) throws IOException {
      String aString = new String(b, off, len);
      aTextArea.append(aString);
      FileWriter aWriter = new FileWriter("a.log", true);
      aWriter.write(aString);
      aWriter.close();
    }
  }
}