////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2004 Kevin Rogers
   //
   // This file is part of MillScript.
   //
   // MillScript is free software; you can redistribute it and/or modify it under
   // the terms of the GNU General Public License as published by the Free
   // Software Foundation; either version 2 of the License, or (at your option)
  // any later version.
  //
  // MillScript is distributed in the hope that it will be useful, but WITHOUT
  // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  // more details.
  //
  // You should have received a copy of the GNU General Public License along with
  // MillScript; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.tools;
  
  import java.io.IOException;
  import java.io.StringReader;
  
  import junit.framework.TestCase;
  
  /**
   * @
   */
  public class PushbackLinenumberReaderTest extends TestCase {
  
      /**
       * Constructor for PushbackLinenumberReaderTest.
       * @param arg0
       */
      public PushbackLinenumberReaderTest(String arg0) {
          super( arg0 );
      }
  
      public void testClose() {
      }
  
      /*
       * Test for int getLineNumber()
       */
      public void testGetLineNumber() {
          final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
              new StringReader( "hello\nthere\rThis\r\nis\n\ra test\n string" ),
              8,
              0
          );
          // Check line feed read
          try {
              assertEquals( 1, PLR.getLineNumber() );
              int ch;
              StringBuffer token = new StringBuffer();
              while( ( ch = PLR.read() ) != '\n' ) {
                  token.append( (char) ch );
              }
              assertEquals( "hello", token.toString() );
              assertEquals( 2, PLR.getLineNumber() );
          } catch ( IOException ex ) {
              System.err.println( ex.getMessage() );
          }
          // Check carriage return read
          // (Should be translated to a line feed)
          try {
              assertEquals( 2, PLR.getLineNumber() );
              int ch;
              StringBuffer token = new StringBuffer();
              while( ( ch = PLR.read() ) != '\n' ) {
                  token.append( (char) ch );
              }
              assertEquals( "there", token.toString() );
              assertEquals( 3, PLR.getLineNumber() );
          } catch ( IOException ex ) {
              System.err.println( ex.getMessage() );
          }
          // Check Windows line thingy read
          // (Should be translated to a single line feed)
          try {
              assertEquals( 3, PLR.getLineNumber() );
              int ch;
              StringBuffer token = new StringBuffer();
              while( ( ch = PLR.read() ) != '\n' ) {
                  token.append( (char) ch );
              }
              assertEquals( "This", token.toString() );
              assertEquals( 4, PLR.getLineNumber() );
          } catch ( IOException ex ) {
              System.err.println( ex.getMessage() );
          }
          // Check a backwards Windows line thingy read
          // (Should be translated into two separate line feeds)
          try {
              assertEquals( 4, PLR.getLineNumber() );
              int ch;
              // Read up to the first backward char
             StringBuffer token = new StringBuffer();
             while( ( ch = PLR.read() ) != '\n' ) {
                 token.append( (char) ch );
             }
             assertEquals( "is", token.toString() );
             assertEquals( 5, PLR.getLineNumber() );
             // reset the token buffer
             token.setLength( 0 );
             // now read the second backward char.
             // the token should remain empty
             while( ( ch = PLR.read() ) != '\n' ) {
                 token.append( (char) ch );
             }
             assertEquals( "", token.toString() );
             assertEquals( 6, PLR.getLineNumber() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
         // A few last checks, no particular purpose
         try {
             assertEquals( 6, PLR.getLineNumber() );
             int ch;
             StringBuffer token = new StringBuffer();
             while( ( ch = PLR.read() ) != '\n' ) {
                 token.append( (char) ch );
             }
             assertEquals( "a test", token.toString() );
             assertEquals( 7, PLR.getLineNumber() );
             token.setLength( 0 );
             while( ( ch = PLR.read() ) != '\n' && ch != -1 ) {
                 token.append( (char) ch );
             }
             assertEquals( " string", token.toString() );
             assertEquals( 7, PLR.getLineNumber() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
     }
 
     public void testMark() {
     }
 
     public void testMarkSupported() {
     }
 
     /*
      * Test for int read()
      */
     public void testRead() {
         final PushbackLinenumberReader PLR = new PushbackLinenumberReader( new StringReader( "hello" ) );
         StringBuffer buffer = new StringBuffer();
         int ch;
         try {
             while( ( ch = PLR.read() ) != -1 ) {
                 buffer.append( (char) ch );
             }
             assertEquals( "hello", buffer.toString() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
     }
 
     /*
      * Test for int read(char[])
      */
     public void testReadcharArray() {
     }
 
     /*
      * Test for int read(char[], int, int)
      */
     public void testReadcharArrayintint() {
         final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
             new StringReader( "hello there. This is a test string" ),
             8,
             0
         );
         // Try to read into a buffer shorter than the readers buffer.
         char[] buffer = new char[5];
         try {
             PLR.read( buffer, 0, 5 );
             assertEquals( "hello", new String( buffer ) );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
         // Now try to read into a buffer a few times longer than the readers
         // buffer.
         char[] newbuffer = new char[25];
         // Copy the previously read characters into the new buffer
         System.arraycopy( buffer, 0, newbuffer, 0, 5 );
         try {
             PLR.read( newbuffer, 5, 20 );
             assertEquals( "hello there. This is a te", new String( newbuffer ) );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
         // Now try to read past the end of file.
         char[] lastbuffer = new char[25];
         try {
             PLR.read( lastbuffer, 0, 25 );
             // We have to remember the trim() here as otherwise we get a String
             // with 0 characters at the end.
             assertEquals( "st string", new String( lastbuffer ).trim() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
     }
 
     /*
      * Test for String readLine()
      */
     public void testReadLine() {
         final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
             new StringReader( "hello\nthere\rThis\r\nis\n\ra test\n string" ),
             8,
             0
         );
         // Check line feed read
         try {
             assertEquals( 1, PLR.getLineNumber() );
             String line = PLR.readLine();
             assertEquals( "hello", line );
             assertEquals( 2, PLR.getLineNumber() );
             line = PLR.readLine();
             assertEquals( "there", line );
             assertEquals( 3, PLR.getLineNumber() );
             line = PLR.readLine();
             assertEquals( "This", line );
             assertEquals( 4, PLR.getLineNumber() );
             while( ( line = PLR.readLine() ) != null ) {
             }
             assertEquals( 7, PLR.getLineNumber() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
     }
 
     public void testReady() {
     }
 
     /*
      * Test for void reset()
      */
     public void testReset() {
     }
 
     /*
      * Test for void setLineNumber()
      */
     public void testSetLineNumber() {
     }
 
     /*
      * Test for long skip()
      */
     public void testSkip() {
         final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
             new StringReader( "hello there. This is a test string" ),
             8,
             0
         );
         // Try to read into a buffer a few times longer than the readers buffer
         char[] newbuffer = new char[25];
         try {
             PLR.skip( 3 );
             PLR.read( newbuffer, 0, 5 );
             assertEquals( "lo th", new String( newbuffer ).trim() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
         try {
             PLR.skip( 10 );
             PLR.read( newbuffer, 2, 9 );
             assertEquals( "lois a test", new String( newbuffer ).trim() );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
         }
     }
 
     /*
      * Test for void unread()
      */
     public void testUnread() {
         try {
             final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
                 new StringReader( "hello there. This is a test string" ),
                 8,
                 0
             );
             char[] newbuffer = new char[5];
             PLR.skip( 3 );
             PLR.unread( 'X' );
             PLR.read( newbuffer, 0, 5 );
             assertEquals( "Xlo t", new String( newbuffer ) );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
             assertFalse( true );
         }
         try {
             final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
                 new StringReader( "hello there. This is a test string" ),
                 8,
                 1
             );
             char[] newbuffer = new char[5];
             PLR.unread( 'X' );
             PLR.read( newbuffer, 0, 5 );
             assertEquals( "Xhell", new String( newbuffer ) );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
             assertFalse( true );
         }
     }
 
     /*
      * Test for void unread(char[])
      */
     public void testUnreadcharArray() {
     }
 
     /*
      * Test for void unread(char[], int, int)
      */
     public void testUnreadcharArrayintint() {
         try {
             final PushbackLinenumberReader PLR = new PushbackLinenumberReader(
                 new StringReader( "hello there. This is a test string" ),
                 12,
                 12
             );
             char[] newbuffer = new char[5];
             PLR.read( newbuffer, 0, 5 );
             PLR.unread( new char[] { 'r','u','b','b','i','s','h' } );
             PLR.read( newbuffer, 0, 5 );
             assertEquals( "rubbi", new String( newbuffer ) );
         } catch ( IOException ex ) {
             System.err.println( ex.getMessage() );
             assertFalse( true );
         }
     }
 
     /*
      * Test for void PushbackLinenumberReader(Reader)
      */
     public void testPushbackLinenumberReaderReader() {
         new PushbackLinenumberReader( new StringReader( "" ) );
     }
 
     /*
      * Test for void PushbackLinenumberReader(Reader, int, int)
      */
     public void testPushbackLinenumberReaderReaderintint() {
         new PushbackLinenumberReader( new StringReader( "" ), 4192, 1024 );
     }
 
 }