/******************************************************************************* | |
* Copyright (c) 2010 Mia-Software. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v2.0 | |
* which accompanies this distribution, and is available at | |
* http://www.eclipse.org/legal/epl-v20.html | |
* | |
* Contributors: | |
* Fabien Giquel - initial API and implementation | |
* Gregoire Dupe (Mia-Software) - Bug 453476 - Stop using EMF Facet's deprecated APIs | |
*******************************************************************************/ | |
package org.eclipse.modisco.infra.discovery.core.tests; | |
import java.util.Collection; | |
import java.util.HashMap; | |
import java.util.Map; | |
import junit.framework.Assert; | |
import org.eclipse.core.runtime.NullProgressMonitor; | |
import org.eclipse.emf.common.util.EList; | |
import org.eclipse.emf.common.util.URI; | |
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; | |
import org.eclipse.modisco.facet.util.emf.catalog.Catalog; | |
import org.eclipse.modisco.facet.util.emf.catalog.CatalogSet; | |
import org.eclipse.modisco.facet.util.emf.core.ICatalogSetManager2; | |
import org.eclipse.modisco.facet.util.emf.core.ICatalogSetManagerFactory; | |
import org.eclipse.modisco.infra.discovery.catalog.DirectionKind; | |
import org.eclipse.modisco.infra.discovery.catalog.DiscovererCatalog; | |
import org.eclipse.modisco.infra.discovery.catalog.DiscovererDescription; | |
import org.eclipse.modisco.infra.discovery.catalog.DiscovererParameter; | |
import org.eclipse.modisco.infra.discovery.core.IDiscoverer; | |
import org.eclipse.modisco.infra.discovery.core.IDiscoveryManager; | |
import org.eclipse.modisco.infra.discovery.core.exception.DiscoveryException; | |
import org.junit.Test; | |
public class TestDiscoverersReferential { | |
private static final String BASIC_DISCOVERER_FOR_TESTS = "BasicDiscovererForTests"; //$NON-NLS-1$ | |
private static final String BASIC_DISCOVERER_SUCLASS_FOR_TESTS = "BasicDiscovererForTests2"; //$NON-NLS-1$ | |
@Test | |
public void testDiscovererReferential() { | |
// test discoverers retrieving | |
Assert.assertFalse(IDiscoveryManager.INSTANCE.getDiscoverers() | |
.isEmpty()); | |
// test discoverers catalog registration | |
boolean catalogFound = false; | |
final ICatalogSetManager2 catalogSetManager = ICatalogSetManagerFactory.DEFAULT | |
.createICatalogSetManager(new ResourceSetImpl()); | |
final CatalogSet catalogSet = catalogSetManager.getCatalogSet(); | |
for (Catalog aCatalog : catalogSet.getCatalogs()) { | |
if (aCatalog instanceof DiscovererCatalog) { | |
catalogFound = true; | |
EList<DiscovererDescription> discoDescriptions = ((DiscovererCatalog) aCatalog) | |
.getInstalledDiscoverers(); | |
Assert.assertFalse(discoDescriptions.isEmpty()); | |
} | |
} | |
Assert.assertTrue(catalogFound); | |
// test discoverer search by name | |
IDiscoverer<?> basicDiscoverer = IDiscoveryManager.INSTANCE | |
.createDiscovererImpl(TestDiscoverersReferential.BASIC_DISCOVERER_FOR_TESTS); | |
Assert.assertNotNull(basicDiscoverer); | |
DiscovererDescription discovererDesc = IDiscoveryManager.INSTANCE | |
.getDiscovererDescription(TestDiscoverersReferential.BASIC_DISCOVERER_FOR_TESTS); | |
Assert.assertNotNull(discovererDesc); | |
// test discoverer search for a given source | |
Collection<DiscovererDescription> applicableDiscoverers = IDiscoveryManager.INSTANCE | |
.getApplicableDiscoverers(new Object()); | |
Assert.assertFalse(applicableDiscoverers.isEmpty()); | |
} | |
@Test | |
public void testParametersGenericAPI() { | |
DiscovererDescription basicDiscoverer = IDiscoveryManager.INSTANCE | |
.getDiscovererDescription(TestDiscoverersReferential.BASIC_DISCOVERER_FOR_TESTS); | |
DiscovererParameter DISCO_IN = basicDiscoverer | |
.getParameterDefinition("DISCO_IN"); //$NON-NLS-1$ | |
Assert.assertNotNull(DISCO_IN); | |
Assert.assertTrue(DISCO_IN.getDescription() == null | |
|| DISCO_IN.getDescription().length() == 0); | |
Assert.assertTrue(DISCO_IN.getDirection() == DirectionKind.IN); | |
Assert.assertTrue(DISCO_IN.getType() == Integer.class); | |
Assert.assertTrue(DISCO_IN.isRequiredInput()); | |
// Assert.assertTrue(DISCO_IN.getDeclaringAnnotations().size() == 1); | |
DiscovererParameter DISCO_OUT = basicDiscoverer | |
.getParameterDefinition("DISCO_OUT"); //$NON-NLS-1$ | |
Assert.assertNotNull(DISCO_OUT); | |
Assert.assertTrue(DISCO_OUT.getDescription().equals("DISCO_OUT desc")); //$NON-NLS-1$ | |
Assert.assertTrue(DISCO_OUT.getDirection() == DirectionKind.OUT); | |
Assert.assertTrue(DISCO_OUT.getType() == URI.class); | |
Assert.assertFalse(DISCO_OUT.isRequiredInput()); | |
// Assert.assertTrue(DISCO_OUT.getDeclaringAnnotations().size() == 1); | |
DiscovererParameter DISCO_INOUT_1 = basicDiscoverer | |
.getParameterDefinition("DISCO_INOUT_1"); //$NON-NLS-1$ | |
Assert.assertNotNull(DISCO_INOUT_1); | |
Assert.assertTrue(DISCO_INOUT_1.getDescription().equals( | |
"DISCO_INOUT_1 desc")); //$NON-NLS-1$ | |
Assert.assertTrue(DISCO_INOUT_1.getDirection() == DirectionKind.INOUT); | |
Assert.assertTrue(DISCO_INOUT_1.getType() == Integer.class); | |
Assert.assertTrue(DISCO_INOUT_1.isRequiredInput()); | |
// Assert.assertTrue(DISCO_INOUT_1.getDeclaringAnnotations().size() == | |
// 2); | |
DiscovererParameter DISCO_INOUT_2 = basicDiscoverer | |
.getParameterDefinition("DISCO_INOUT_2"); //$NON-NLS-1$ | |
Assert.assertNotNull(DISCO_INOUT_2); | |
Assert.assertTrue(DISCO_INOUT_2.getDirection() == DirectionKind.INOUT); | |
Assert.assertTrue(DISCO_INOUT_2.getType() == String.class); | |
Assert.assertFalse(DISCO_INOUT_2.isRequiredInput()); | |
// Assert.assertTrue(DISCO_INOUT_2.getDeclaringAnnotations().size() == | |
// 1); | |
} | |
@Test | |
public void testParametersGenericAPIInheritance() { | |
// Test Parameters inheritance | |
DiscovererDescription basicDiscovererSubClass = IDiscoveryManager.INSTANCE | |
.getDiscovererDescription(TestDiscoverersReferential.BASIC_DISCOVERER_SUCLASS_FOR_TESTS); | |
Assert.assertNotNull(basicDiscovererSubClass); | |
Assert.assertTrue(basicDiscovererSubClass.getParameterDefinitions() | |
.size() == 4); | |
} | |
@Test | |
public void testGenericInvocation() { | |
IDiscoverer<?> basicDiscoverer = IDiscoveryManager.INSTANCE | |
.createDiscovererImpl(TestDiscoverersReferential.BASIC_DISCOVERER_FOR_TESTS); | |
Map<String, Object> parametersValues = new HashMap<String, Object>(); | |
parametersValues.put("DISCO_IN", new Integer(2)); //$NON-NLS-1$ | |
parametersValues.put("DISCO_INOUT_1", new Integer(3)); //$NON-NLS-1$ | |
try { | |
IDiscoveryManager.INSTANCE.discoverElement(basicDiscoverer, | |
new Object(), parametersValues, new NullProgressMonitor()); | |
String DISCO_INOUT_2_value = (String) parametersValues | |
.get("DISCO_INOUT_2"); //$NON-NLS-1$ | |
Assert.assertNotNull(DISCO_INOUT_2_value); | |
Assert.assertEquals(DISCO_INOUT_2_value, "2"); //$NON-NLS-1$ | |
} catch (DiscoveryException e) { | |
Assert.fail("Discovery fails : " + e.getMessage()); //$NON-NLS-1$ | |
e.printStackTrace(); | |
} | |
} | |
} |