/*
 * Copyright (C) 2003 The University of Manchester 
 *
 * Modifications to the initial code base are copyright of their
 * respective authors, or their employers as appropriate.  Authorship
 * of the modifications may be determined from the ChangeLog placed at
 * the end of this file.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 * 
 * This program 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA.
 *
 ****************************************************************
 * Source code information
 * -----------------------
 * Filename           $RCSfile: TypeDescriptorTest.java,v $
 * Revision           $Revision: 1.2 $
 * Release status     $State: Exp $
 * Last modified on   $Date: 2007/11/30 12:13:38 $
 *               by   $Author: sowen70 $
 * Created on 17-May-2006
 *****************************************************************/
package net.sf.taverna.wsdl.parser;

import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;

public class TypeDescriptorTest extends TestCase {

	// array of strings
	public void testRetrieveSignitureForArrayDescriptor() {
		ArrayTypeDescriptor desc = new ArrayTypeDescriptor();
		desc.setName("AnArray");
		desc.setType("arrayofstring");

		BaseTypeDescriptor base = new BaseTypeDescriptor();
		base.setName("");
		base.setType("string");

		desc.setElementType(base);

		String[] names = new String[1];
		Class<?>[] types = new Class[1];

		List<TypeDescriptor> params = new ArrayList<TypeDescriptor>();
		params.add(desc);
		TypeDescriptor.retrieveSignature(params, names, types);

		assertEquals("AnArray", names[0]);
		assertEquals(String[].class, types[0]);
	}

	// array of strings, but type for array is defined as string
	// (which is logically warped, but some wsdl's describe their string arrays
	// this way).
	public void testRetrieveSignitureForArrayDescriptor3() {
		ArrayTypeDescriptor desc = new ArrayTypeDescriptor();
		desc.setName("AnArray");
		desc.setType("string");

		BaseTypeDescriptor base = new BaseTypeDescriptor();
		base.setName("");
		base.setType("string");

		desc.setElementType(base);

		String[] names = new String[1];
		Class<?>[] types = new Class[1];

		List<TypeDescriptor> params = new ArrayList<TypeDescriptor>();
		params.add(desc);
		TypeDescriptor.retrieveSignature(params, names, types);

		assertEquals("AnArray", names[0]);
		assertEquals(String[].class, types[0]);
	}

	// array of complex types
	public void testRetrieveSignitureForArrayDescriptor2() {
		ArrayTypeDescriptor desc = new ArrayTypeDescriptor();
		desc.setName("AnArray");
		desc.setType("complextype");

		ComplexTypeDescriptor complex = new ComplexTypeDescriptor();
		complex.setName("complex");
		complex.setType("complextype");

		desc.setElementType(complex);

		String[] names = new String[1];
		Class<?>[] types = new Class[1];

		List<TypeDescriptor> params = new ArrayList<TypeDescriptor>();
		params.add(desc);
		TypeDescriptor.retrieveSignature(params, names, types);

		assertEquals("AnArray", names[0]);
		assertEquals(org.w3c.dom.Element.class, types[0]);
	}

	public void testForCyclicTrue() {
		ComplexTypeDescriptor a = new ComplexTypeDescriptor();
		a.setName("a");
		a.setType("outertype");

		ComplexTypeDescriptor b = new ComplexTypeDescriptor();
		b.setName("b");
		b.setType("middletype");

		ComplexTypeDescriptor c = new ComplexTypeDescriptor();
		c.setName("c");
		c.setType("innertype");

		a.getElements().add(b);
		b.getElements().add(c);
		c.getElements().add(a);

		assertTrue("should be identified as cyclic", TypeDescriptor.isCyclic(a));
	}

	public void testForCyclicTrueWithArray() {
		ComplexTypeDescriptor a = new ComplexTypeDescriptor();
		a.setName("a");
		a.setType("outertype");

		ArrayTypeDescriptor b = new ArrayTypeDescriptor();
		b.setName("b");
		b.setType("arraytype");

		ComplexTypeDescriptor c = new ComplexTypeDescriptor();
		c.setName("c");
		c.setType("innertype");

		a.getElements().add(b);
		b.setElementType(c);
		c.getElements().add(a);

		assertTrue("should be identified as cyclic", TypeDescriptor.isCyclic(a));
	}

	public void testForCyclicFalse() {
		ComplexTypeDescriptor a = new ComplexTypeDescriptor();
		a.setName("a");
		a.setType("person");

		ComplexTypeDescriptor b = new ComplexTypeDescriptor();
		b.setName("b");
		b.setType("name");

		ComplexTypeDescriptor c = new ComplexTypeDescriptor();
		c.setName("c");
		c.setType("age");

		a.getElements().add(b);
		a.getElements().add(c);

		assertFalse("should be not identified as cyclic", TypeDescriptor
				.isCyclic(a));
	}

	public void testQNameAsString() {
		ComplexTypeDescriptor a = new ComplexTypeDescriptor();
		a.setQnameFromString("{URI}localPart");
		assertEquals("URI", a.getQname().getNamespaceURI());
		assertEquals("localPart", a.getQname().getLocalPart());

		a = new ComplexTypeDescriptor();
		a.setQnameFromString("{}localPart");
		assertEquals("", a.getQname().getNamespaceURI());
		assertEquals("localPart", a.getQname().getLocalPart());
	}
	
	public void testBaseTypeKnownSigniture() {
		TypeDescriptor decimal=new BaseTypeDescriptor();
		decimal.setName("adecimal");
		decimal.setType("decimal");
		
		List<TypeDescriptor> params=new ArrayList<TypeDescriptor>();
		String [] names=new String[1];
		Class<?> [] types=new Class[1];
		params.add(decimal);
		TypeDescriptor.retrieveSignature(params, names, types);
		
		assertEquals("should only be 1 type",1,types.length);
		assertEquals("should only be 1 name",1,names.length);
		
		assertEquals("name should be adecimal","adecimal",names[0]);
		assertEquals("type should be double",Double.TYPE,types[0]);
	}
	
	public void testBaseTypeUnrecognisedSigniture() {
		TypeDescriptor date=new BaseTypeDescriptor();
		date.setName("adate");
		date.setType("date");
		
		List<TypeDescriptor> params=new ArrayList<TypeDescriptor>();
		String [] names=new String[1];
		Class<?> [] types=new Class[1];
		params.add(date);
		TypeDescriptor.retrieveSignature(params, names, types);
		
		assertEquals("should only be 1 type",1,types.length);
		assertEquals("should only be 1 name",1,names.length);
		
		assertEquals("name should be adecimal","adate",names[0]);
		assertEquals("type should be string",String.class,types[0]);
	}
	
	public void testComplex() {
		TypeDescriptor complex=new ComplexTypeDescriptor();
		complex.setName("acomplex");
		complex.setType("complextype");
		
		List<TypeDescriptor> params=new ArrayList<TypeDescriptor>();
		String [] names=new String[1];
		Class<?> [] types=new Class[1];
		params.add(complex);
		TypeDescriptor.retrieveSignature(params, names, types);
		
		assertEquals("should only be 1 type",1,types.length);
		assertEquals("should only be 1 name",1,names.length);
		
		assertEquals("name should be adecimal","acomplex",names[0]);
		assertEquals("type should be string",org.w3c.dom.Element.class,types[0]);
	}

}