/******************************************************************************* | |
* Copyright (c) 2009 by SAP AG, Walldorf. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v1.0 | |
* which accompanies this distribution, and is available at | |
* http://www.eclipse.org/legal/epl-v10.html | |
* | |
* Contributors: | |
* SAP AG - initial API and implementation | |
*******************************************************************************/ | |
package org.eclipse.jst.ws.jaxws.utils.tests.internal.annotations; | |
import java.util.Collection; | |
import java.util.HashSet; | |
import java.util.Set; | |
import org.eclipse.jdt.core.IField; | |
import org.eclipse.jdt.core.IMethod; | |
import org.eclipse.jdt.core.IType; | |
import org.eclipse.jst.ws.jaxws.testutils.project.ClassLoadingTest; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.AnnotationFactory; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotation; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IParamValuePair; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IValue; | |
/** | |
* AnnotationFactory class test cases. | |
* | |
* @author Georgi Vachkov | |
*/ | |
@SuppressWarnings("nls") | |
public class AnnotationFactoryTest extends ClassLoadingTest | |
{ | |
private static final String SRC = "src"; | |
private static final String PCK = "org.eclipse.demo"; | |
private IType endpoint; | |
public void testCreateStringValue() | |
{ | |
try | |
{ | |
AnnotationFactory.createStringValue(null); | |
fail("NullPointerException not thrown"); | |
} catch (NullPointerException e) | |
{ | |
} | |
IValue strValue = AnnotationFactory.createStringValue("value"); | |
assertNotNull(strValue); | |
assertTrue(strValue.toString().equals("value")); | |
} | |
public void testCreateParamValuePair() | |
{ | |
IValue strValue = AnnotationFactory.createStringValue("value"); | |
try | |
{ | |
AnnotationFactory.createParamValuePairValue(null, strValue); | |
fail("NullPointerException not thrown"); | |
} catch (NullPointerException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createParamValuePairValue("", null); | |
fail("NullPointerException not thrown"); | |
fail("IllegalArgumentException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
catch (IllegalArgumentException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createParamValuePairValue("param", null); | |
fail("NullPointerException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
IParamValuePair valuePair = AnnotationFactory.createParamValuePairValue("param", strValue); | |
assertNotNull(valuePair); | |
assertTrue(valuePair.getValue() instanceof IValue); | |
assertTrue(valuePair.getParam().equals("param")); | |
} | |
public void testCreateComplexAnnotation() throws Exception | |
{ | |
IValue strValue1 = AnnotationFactory.createStringValue("value"); | |
IParamValuePair valuePair1 = AnnotationFactory.createParamValuePairValue("param", strValue1); | |
IValue strValue2 = AnnotationFactory.createStringValue("value1"); | |
IParamValuePair valuePair2 = AnnotationFactory.createParamValuePairValue("param1", strValue2); | |
Set<IParamValuePair> paramValues = new HashSet<IParamValuePair>(); | |
paramValues.add(valuePair1); | |
paramValues.add(valuePair2); | |
try | |
{ | |
AnnotationFactory.createAnnotation(null, paramValues, endpoint); | |
fail("NullPointerException not thrown"); | |
} catch (NullPointerException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createAnnotation("", null, endpoint); | |
fail("NullPointerException not thrown"); | |
fail("IllegalArgumentException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
catch (IllegalArgumentException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createAnnotation("MyName", null, endpoint); | |
fail("NullPointerException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
// try | |
// { | |
// AnnotationFactory.createAnnotation("MyName", new HashSet<IParamValuePair>()); | |
// fail("IllegalArgumentException not thrown"); | |
// } | |
// catch (IllegalArgumentException e) | |
// { | |
// } | |
prepareProject(); | |
IAnnotation<IType> ca = AnnotationFactory.createAnnotation("name", paramValues, endpoint); | |
assertNotNull(ca); | |
assertEquals(ca.getParamValuePairs().size(), 2); | |
} | |
public void testCreateValuePair() | |
{ | |
try | |
{ | |
AnnotationFactory.createParamValuePairValue("", null); | |
fail("NullPointerException not thrown"); | |
fail("IllegalArgumentException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
catch (IllegalArgumentException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createParamValuePairValue(null, null); | |
fail("NullPointerException not thrown"); | |
} catch (NullPointerException e) | |
{ | |
} | |
} | |
public void testCreateArrayValue() | |
{ | |
try | |
{ | |
AnnotationFactory.createArrayValue(null); | |
fail("NullPointerException not thrown"); | |
} catch (NullPointerException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createArrayValue(new HashSet<IValue>()); | |
fail("IllegalArgumentException not thrown"); | |
} catch (IllegalArgumentException e) | |
{ | |
} | |
IValue strValue1 = AnnotationFactory.createStringValue("value1"); | |
IValue strValue2 = AnnotationFactory.createStringValue("value2"); | |
Set<IValue> values = new HashSet<IValue>(); | |
values.add(strValue1); | |
values.add(strValue2); | |
IValue arrValue = AnnotationFactory.createArrayValue(values); | |
assertNotNull(arrValue); | |
assertTrue(arrValue.toString().equals("[value1, value2]")); | |
} | |
public void testCreateQualifiedNameValue() | |
{ | |
try | |
{ | |
AnnotationFactory.createQualifiedNameValue("QName"); | |
fail("IllegalArgumentException not thrown"); | |
} | |
catch (IllegalArgumentException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.createQualifiedNameValue(null); | |
fail("NullPointerException not thrown"); | |
} catch (NullPointerException e) | |
{ | |
} | |
IValue qName = AnnotationFactory.createQualifiedNameValue("org.eclipse.demo.Test"); | |
assertNotNull(qName); | |
assertTrue(qName.toString().equals("org.eclipse.demo.Test")); | |
} | |
public void testCreateBooleanValue() | |
{ | |
IValue boolValue = AnnotationFactory.createBooleanValue(true); | |
assertNotNull(boolValue); | |
assertEquals(boolValue.toString(), "true"); | |
} | |
public void testGetAnnotationsFromClass() throws Exception // $JL-EXC$ | |
{ | |
prepareProject(); | |
Collection<IAnnotation<IType>> annotations = AnnotationFactory.createAnnotationInspector(endpoint).inspectType(); | |
assertNotNull(annotations); | |
assertTrue(annotations.size() == 2); | |
} | |
// public void testGetAnnotationsFromField() throws Exception // $JL-EXC$ | |
// { | |
// prepareProject(); | |
// | |
// IField field = endpoint.getField("field1"); | |
// assertNotNull(field); | |
// | |
// IAnnotation[] annotations = AnnotationFactory.createAnnotattionInspector(endpoint).inspectMethod(method) getAnnotationsFromField(field); | |
// assertNotNull(annotations); | |
// assertTrue(annotations.length == 1); | |
// } | |
public void testGetAnnotationsFromMethod() throws Exception // $JL-EXC$ | |
{ | |
prepareProject(); | |
IMethod method = endpoint.getMethod("annotatedMethod", new String[] { "QString;" }); | |
Collection<IAnnotation<IMethod>> annotations = AnnotationFactory.createAnnotationInspector(endpoint).inspectMethod(method);; | |
assertNotNull(annotations); | |
assertTrue(annotations.size() == 1); | |
} | |
public void testRemoveAnnotationsIType() throws Exception // $JL-EXC$ | |
{ | |
prepareProject(); | |
try | |
{ | |
AnnotationFactory.removeAnnotationsFromJavaElement(null); | |
fail("NullPointerException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.removeAnnotationsFromJavaElement(endpoint.getPackageFragment()); | |
fail("IllegalArgumentException not thrown"); | |
} | |
catch (IllegalArgumentException e) | |
{ | |
} | |
AnnotationFactory.removeAnnotationsFromJavaElement(endpoint); | |
Collection<IAnnotation<IType>> annotations = AnnotationFactory.createAnnotationInspector(endpoint). inspectType(); | |
assertTrue(annotations.size() == 0); | |
IMethod method = endpoint.getMethod("annotatedMethod", new String[] { "QString;" }); | |
@SuppressWarnings("unused") | |
Collection<IAnnotation<IMethod>> annotationsMethod = AnnotationFactory.createAnnotationInspector(endpoint).inspectMethod(method); | |
assertTrue(annotations.size() == 0); | |
} | |
public void testRemoveAnnotationsITypeSetOfString() throws Exception // $JL-EXC$ | |
{ | |
prepareProject(); | |
Set<String> toRemove = new HashSet<String>(); | |
toRemove.add("WebService"); | |
toRemove.add("WebMethod"); | |
try | |
{ | |
AnnotationFactory.removeAnnotations(null, toRemove); | |
fail("NullPointerException not thrown"); | |
} | |
catch (NullPointerException e) | |
{ | |
} | |
try | |
{ | |
AnnotationFactory.removeAnnotations(endpoint.getPackageFragment(), toRemove); | |
fail("IllegalArgumentException not thrown"); | |
} | |
catch (IllegalArgumentException e) | |
{ | |
} | |
AnnotationFactory.removeAnnotations(endpoint, toRemove); | |
Collection<IAnnotation<IType>> annotations = AnnotationFactory.createAnnotationInspector(endpoint).inspectType(); | |
assertTrue(annotations.size() == 1); | |
IMethod method = endpoint.getMethod("annotatedMethod", new String[] { "QString;" }); | |
Collection<IAnnotation<IMethod>> annotationsMethod = AnnotationFactory.createAnnotationInspector(endpoint).inspectMethod(method); | |
assertTrue(annotationsMethod.size() == 0); | |
} | |
public void testRemoveAnnotationsIField() throws Exception // $JL-EXC$ | |
{ | |
prepareProject(); | |
IField field = endpoint.getField("field1"); | |
assertNotNull(field); | |
AnnotationFactory.removeAnnotationsFromJavaElement(field); | |
Collection<IAnnotation<IType>> annotations = AnnotationFactory.createAnnotationInspector(endpoint).inspectType(); | |
assertTrue(annotations.size() == 2); | |
IMethod method = endpoint.getMethod("annotatedMethod", new String[] { "QString;" }); | |
Collection<IAnnotation<IMethod>> annotationsMethod = AnnotationFactory.createAnnotationInspector(endpoint).inspectMethod(method); | |
assertTrue(annotationsMethod.size() == 1); | |
// annotations = AnnotationFactory.getAnnotationsFromField(field); | |
// assertNotNull(annotations); | |
// assertTrue(annotations.length == 0); | |
} | |
public void testRemoveAnnotationsIMethod() throws Exception // $JL-EXC$ | |
{ | |
prepareProject(); | |
IMethod method = endpoint.getMethod("annotatedMethod", new String[] { "QString;" }); | |
endpoint.getField("field1"); | |
AnnotationFactory.removeAnnotationsFromJavaElement(method); | |
Collection<IAnnotation<IType>> annotations = AnnotationFactory.createAnnotationInspector(endpoint).inspectType(); | |
assertTrue(annotations.size() == 2); | |
Collection<IAnnotation<IMethod>> annotationsMethod = AnnotationFactory.createAnnotationInspector(endpoint).inspectMethod(method); | |
assertTrue(annotationsMethod.size()== 0); | |
// annotations = AnnotationFactory.getAnnotationsFromField(field); | |
// assertNotNull(annotations); | |
// assertTrue(annotations.length == 0); | |
} | |
private void prepareProject() throws Exception // $JL-EXC$ | |
{ | |
createJavaProject(SRC, PCK); | |
endpoint = createClass("Endpoint.src", "Endpoint"); | |
} | |
} |