//Tags: JDK1.4
//Uses: TestHttpServer

//Copyright (C) 2006 Free Software Foundation, Inc.
//Written by Wolfgang Baer (WBaer@gmx.de)

//This file is part of Mauve.

//Mauve 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, or (at your option)
//any later version.

//Mauve 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 Mauve; see the file COPYING.  If not, write to
//the Free Software Foundation, 51 Franklin Street, Fifth Floor,
//Boston, MA, 02110-1301 USA.

package gnu.testlet.java.net.HttpURLConnection;

import gnu.testlet.TestHarness;
import gnu.testlet.Testlet;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;
import java.util.Map;

public class responseHeadersTest implements Testlet
{

  public void test(TestHarness harness)
  {
    TestHttpServer server = null;
    try
      {
        server = new TestHttpServer(8080);
        Thread thread = new Thread(server);
        thread.start();
        try
          {
            // SUN JDK needs some time to open sockets
            Thread.sleep(100);
          }
        catch (InterruptedException e1)
          {
          }
        
        test_MultiHeaders(harness, server);
        test_LowerUpperCaseHeaders(harness, server);
      }
    finally
      {
        server.killTestServer();
      }   
  }
  
  public void test_MultiHeaders(TestHarness h, TestHttpServer server)
  {    
    try
      {        
        URL url = new URL("http://localhost:8080/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");

        // construct what should be returned by the test server as headers
        ByteArrayOutputStream headers = new ByteArrayOutputStream();
        headers.write("HTTP/1.0 200 OK\r\n".getBytes());
        headers.write("Server: TestServer\r\n".getBytes());
        headers.write("Key1: value, value2\r\n".getBytes());
        // set the header a second time with different values
        // these values must be prepended to key1
        headers.write("Key1: value3\r\n".getBytes());
        headers.write("IntHeader: 1234\r\n".getBytes());
        headers.write("IntHeaderMalformed: 1234XY\r\n".getBytes());
        headers.write("DateHeader: Thu, 02 Mar 2006 14:34:55 +0000\r\n".getBytes());
        headers.write("DateHeaderMalformed: Thu, 02 Mar 2006V 14:13:07 +0000\r\n\r\n".getBytes());

        server.setResponseHeaders(headers.toByteArray());
        
        h.checkPoint("getHeaderFields()");
        Map fields = conn.getHeaderFields();
        
        // check that map is unmodifiable
        try 
          {
            fields.clear();
            h.check(false);
          }
        catch (UnsupportedOperationException e) 
          {
            h.check(true);
          }
      
        // exactly 7 headers with status and server header        
        h.check(fields.size() == 7);
        
        // check for list and that case matters for key
        Object obj = fields.get("Key1");
        if (! (obj instanceof List))
          h.check(false);
        else
          {
            h.check(true);
            List value = (List) obj;
            h.check(value.size() == 2);
            h.check(value.get(0).equals("value3"));
            h.check(value.get(1).equals("value, value2"));
            
            // check that it is an unmodifiable list
            try 
              {
                value.remove(0);
                h.check(false);
              }
            catch (UnsupportedOperationException e) 
              {
                h.check(true);
              }
          }
        
        // wrong case for key
        obj = fields.get("key1");
        h.check(obj == null);
          
        
        // checks for getHeaderField/Key(int)        
        h.checkPoint("getHeaderField(int)");
        // check that index 0 is the statusline
        String statusline = conn.getHeaderField(0);
        h.check(statusline.equals("HTTP/1.0 200 OK"));
        // indexes out of bound must return null
        String aboutIndex = conn.getHeaderField(44);
        h.check(aboutIndex == null);
        String belowIndex = conn.getHeaderField(-1);
        h.check(belowIndex == null);
        // check that correct key/value name is returned
        String key1_Value = conn.getHeaderField(2);
        h.check(key1_Value.equals("value, value2"));
        
        h.checkPoint("getHeaderFieldKey(int)");       
        // check that index 0 is the statusline
        String statuslineKey = conn.getHeaderFieldKey(0);        
        h.check(statuslineKey == null);
        // indexes out of bound must return null
        String aboutIndexKey = conn.getHeaderFieldKey(44);        
        h.check(aboutIndexKey == null);
        String belowIndexKey = conn.getHeaderFieldKey(-1);
        h.check(belowIndexKey == null);
        // check that correct key/value name is returned
        String key1_Key = conn.getHeaderFieldKey(2);
        h.check(key1_Key.equals("Key1"));
        
        
        // checks getHeaderFieldDate
        h.checkPoint("getHeaderFieldDate()");
        // correct date header field
        long dateHeader = conn.getHeaderFieldDate("DateHeader", 5555);
        h.check(dateHeader == 1141310095000L);
        // missing date header field
        dateHeader = conn.getHeaderFieldDate("DateHeaderXX", 5555);
        h.check(dateHeader == 5555);
        // malformed date header value 
        dateHeader = conn.getHeaderFieldDate("DateHeaderMalformed", 5555);
        h.check(dateHeader == 5555);
        
        // checks getHeaderFieldInt
        h.checkPoint("getHeaderFieldInt()");
        // correct int header field
        int intHeader = conn.getHeaderFieldInt("IntHeader", 5555);
        h.check(intHeader == 1234);
        // missing int header field
        intHeader = conn.getHeaderFieldInt("IntHeaderXX", 5555);
        h.check(intHeader == 5555);
        // malformed int header value 
        intHeader = conn.getHeaderFieldInt("IntHeaderMalformed", 5555);
        h.check(intHeader == 5555);
        
        
        // checks that the convenience methods of the headers
        // not set in this test return the correct default values
        h.checkPoint("convenience methods");
        h.check(conn.getLastModified() == 0);
        h.check(conn.getDate() == 0);
        h.check(conn.getExpiration() == 0);
        h.check(conn.getContentEncoding() == null);
        h.check(conn.getContentType() == null);
        h.check(conn.getContentLength() == -1);
        
        
        // checks getHeaderField(String)
        h.checkPoint("getHeaderField(String)");
        String field = conn.getHeaderField("Server");
        String field1 = conn.getHeaderField("server");
        h.check(field.equals("TestServer"));
        h.check(field == field1);
        
        String none = conn.getHeaderField("NotExistent");
        h.check(none == null);
        
        // check for multiple times same key
        String field_key1 = conn.getHeaderField("Key1");
        h.check(field_key1.equals("value3"));

      }
    catch (IOException e)
    {
      h.debug("Unexpected IOException");
      h.debug(e);
    }
    catch (RuntimeException e)
      {
        h.debug("Unexpected IOException");
        h.debug(e);
      }
    
  }
  
  public void test_LowerUpperCaseHeaders(TestHarness h, TestHttpServer server)
  {    
    try
      {        
        URL url = new URL("http://localhost:8080/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");

        // construct what should be returned by the test server as headers
        ByteArrayOutputStream headers = new ByteArrayOutputStream();
        headers.write("HTTP/1.0 200 OK\r\n".getBytes());
        headers.write("Server: TestServer\r\n".getBytes());  
        headers.write("AnotherKey: value\r\n".getBytes());
        headers.write("Key: value\r\n".getBytes());
        headers.write("Key: value1\r\n".getBytes());
        headers.write("key: value2\r\n".getBytes());
        headers.write("key: value3\r\n\r\n".getBytes());
        
        server.setResponseHeaders(headers.toByteArray());
        
        h.checkPoint("LowerUpperCase header fields tests");
        
        Map fields = conn.getHeaderFields();  
                     
        // exactly 5 headers with status and server header        
        h.check(fields.size() == 5);
        
        // check for list and that case matters for key
        List value = (List) fields.get("Key");
        h.check(value.size() == 2);
        h.check(value.get(0).equals("value1"));
        
        List value2 = (List) fields.get("key");
        h.check(value2.size() == 2);
        h.check(value2.get(0).equals("value3"));
        
        List value3 = (List) fields.get("AnotherKey");
        h.check(value3.get(0).equals("value"));
        
        value3 = (List) fields.get("anotherkey");
        h.check(value3 == null);
                     
        // checks getHeaderField(String)
        String field = conn.getHeaderField("Key");
        String field1 = conn.getHeaderField("key");
        h.check(field.equals("value3"));
        h.check(field == field1);
      }
    catch (IOException e)
    {
      h.debug("Unexpected IOException");
      h.debug(e);
    }
    catch (RuntimeException e)
      {
        h.debug("Unexpected IOException");
        h.debug(e);
      }
  }
}