package org.apache.commons.openpgp;
   
   /*
    * 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 static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertTrue;
  
  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * Test the open pgp signer.
   *
   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
   * @todo test text input as well as binary - apparently it fails cross platform
   */
  public class BouncyCastleOpenPgpStreamingSignerTest
  {
      private String keyId = "A7D16BD4";
  
      private KeyRing keyRing;
  
      private static final String PASSWORD = "cop";
  
      @Before
      public void setUp()
          throws Exception
      {
          keyRing = new BouncyCastleKeyRing( getClass().getResourceAsStream( "/secring.gpg" ),
                                             getClass().getResourceAsStream( "/pubring.gpg" ), PASSWORD.toCharArray() );
      }
  
      @Test
      public void testSignDataDetachedBinary()
          throws OpenPgpException, IOException
      {
          OpenPgpStreamingSigner signer = new BouncyCastleOpenPgpStreamingSigner( keyId, keyRing, false );
  
          InputStream in = getClass().getResourceAsStream( "/test-input" );
          byte[] buf = new byte[8192];
          int len;
          try
          {
              do
              {
                  len = in.read( buf, 0, 8192 );
                  if ( len > 0 )
                  {
                      signer.update( buf, 0, len );
                  }
              }
              while ( len >= 0 );
          }
          finally
          {
              in.close();
          }
  
          byte[] signature = signer.finish();
  
          OpenPgpSignatureVerifier verifier = new BouncyCastleOpenPgpSignatureVerifier();
  
          SignatureStatus status =
              verifier.verifyDetachedSignature( getClass().getResourceAsStream( "/test-input" ),
                                                new ByteArrayInputStream( signature ), keyRing );
          assertNotNull( "check we got a status", status );
          assertTrue( "check it was successful", status.isValid() );
      }
  
      @Test
      public void testVerifySignatureDetachedBinary()
          throws IOException, OpenPgpException
      {
          InputStream signature = getClass().getResourceAsStream( "/test-input.bpg" );
          OpenPgpStreamingSignatureVerifier verifier =
              new BouncyCastleOpenPgpStreamingSignatureVerifier( signature, keyRing );
  
          InputStream in = getClass().getResourceAsStream( "/test-input" );
          byte[] buf = new byte[8192];
          int len;
         try
         {
             do
             {
                 len = in.read( buf, 0, 8192 );
                 if ( len > 0 )
                 {
                     verifier.update( buf, 0, len );
                 }
             }
             while ( len >= 0 );
         }
         finally
         {
             in.close();
         }
 
         SignatureStatus status = verifier.finish();
 
         assertNotNull( "check we got a status", status );
         assertTrue( "check it was successful", status.isValid() );
     }
 
     @Test
     public void testVerifySignatureDetachedBinaryGpg()
         throws IOException, OpenPgpException
     {
         InputStream signature = getClass().getResourceAsStream( "/test-input.sig" );
         OpenPgpStreamingSignatureVerifier verifier =
             new BouncyCastleOpenPgpStreamingSignatureVerifier( signature, keyRing );
 
         InputStream in = getClass().getResourceAsStream( "/test-input" );
         byte[] buf = new byte[8192];
         int len;
         try
         {
             do
             {
                 len = in.read( buf, 0, 8192 );
                 if ( len > 0 )
                 {
                     verifier.update( buf, 0, len );
                 }
             }
             while ( len >= 0 );
         }
         finally
         {
             in.close();
         }
 
         SignatureStatus status = verifier.finish();
 
         assertNotNull( "check we got a status", status );
         assertTrue( "check it was successful", status.isValid() );
     }
 
     @Test
     public void testSignDataDetachedAscii()
         throws OpenPgpException, IOException
     {
         OpenPgpStreamingSigner signer = new BouncyCastleOpenPgpStreamingSigner( keyId, keyRing, true );
 
         InputStream in = getClass().getResourceAsStream( "/test-input" );
         byte[] buf = new byte[8192];
         int len;
         try
         {
             do
             {
                 len = in.read( buf, 0, 8192 );
                 if ( len > 0 )
                 {
                     signer.update( buf, 0, len );
                 }
             }
             while ( len >= 0 );
         }
         finally
         {
             in.close();
         }
 
         byte[] signature = signer.finish();
 
         OpenPgpSignatureVerifier verifier = new BouncyCastleOpenPgpSignatureVerifier();
 
         SignatureStatus status =
             verifier.verifyDetachedSignature( getClass().getResourceAsStream( "/test-input" ),
                                               new ByteArrayInputStream( signature ), keyRing );
         assertNotNull( "check we got a status", status );
         assertTrue( "check it was successful", status.isValid() );
     }
 
     @Test
     public void testVerifySignatureDetachedAscii()
         throws IOException, OpenPgpException
     {
         InputStream signature = getClass().getResourceAsStream( "/test-input.asc" );
         OpenPgpStreamingSignatureVerifier verifier =
             new BouncyCastleOpenPgpStreamingSignatureVerifier( signature, keyRing );
 
         InputStream in = getClass().getResourceAsStream( "/test-input" );
         byte[] buf = new byte[8192];
         int len;
         try
         {
             do
             {
                 len = in.read( buf, 0, 8192 );
                 if ( len > 0 )
                 {
                     verifier.update( buf, 0, len );
                 }
             }
             while ( len >= 0 );
         }
         finally
         {
             in.close();
         }
 
         SignatureStatus status = verifier.finish();
 
         assertNotNull( "check we got a status", status );
         assertTrue( "check it was successful", status.isValid() );
     }
 }