EDIT

								description.addElement(protolog);

								taxonNameBase.addDescription(description);

								if (citation != null){

									protolog.addSource(null, null, citation, nameFactRefDetail, null, null);

								}

							}//end NAME_FACT_PROTOLOGUE

			if (StringUtils.isNotBlank(ref)) {

				if (ve instanceof TaxonDescription) {

					TaxonDescription td = (TaxonDescription) ve;

					} else {

						sources.add(descriptionSource);

						this.associateImageWithCdmBase(ref,descriptionSource);

					}

				} else {

					location.setAnnotationType(annotationType);

					(publication).addAnnotation(location);

				}

			}

		}

		logger.info("end makeTaxonDescriptions ...");

	private Map<String,String> locations = new HashMap<String,String>();

	private Map<String,List<CdmBase>> mediaObject_ListCdmBase = new HashMap<String,List<CdmBase>>();

	private Map<String,String> mediaObject_Role = new HashMap<String,String>();

	private Map<String,State> states = new HashMap<String,State>();

	private Map<String,TaxonDescription> taxonDescriptions = new HashMap<String,TaxonDescription>();

	private Map<String,MeasurementUnit> units = new HashMap<String,MeasurementUnit>();

	private Map<String,TaxonNode> taxonNodes = new HashMap<String,TaxonNode>();

	private Map<String,NamedArea> namedAreas = new HashMap<String,NamedArea>();

	private Map<String,Modifier> modifiers = new HashMap<String,Modifier>();

	private Set<MarkerType> markerTypes = new HashSet<MarkerType>();

	private Set<Feature> descriptiveConcepts = new HashSet<Feature>();

	private Set<AnnotationType> annotationTypes = new HashSet<AnnotationType>();

//	private Set<Feature> featureSet = new HashSet<Feature>();

	private Language datasetLanguage = null;

	private WorkingSet workingSet = null;

		// <TechnicalMetadata created="2006-04-20T10:00:00">

		importTechnicalMetadata(root, sddNamespace, sddConfig);

		List<Element> elDatasets = root.getChildren("Dataset",sddNamespace);

		//for each Dataset

		logger.info("start Dataset ...");

			if (StringUtils.isNotBlank(ref)) {

				if (ve instanceof TaxonDescription) {

					TaxonDescription td = (TaxonDescription) ve;

					} else {

						sources.add(descriptionSource);

						this.associateImageWithCdmBase(ref,descriptionSource);

					}

				} else {

					location.setAnnotationType(annotationType);

					(publication).addAnnotation(location);

				}

			}

		}

		logger.info("end makeTaxonDescriptions ...");

		}

		saveFeatures();

			getReferenceService().save(publication); 

		}

			getReferenceService().save(source); 

		}

	 * 

	 */

	private void saveVocabularies() {

			getVocabularyService().save(vocabulary);

		}

		Element elSpecimens = elDataset.getChild("Specimens",sddNamespace);

		if (elSpecimens != null){

			List<Element> listSpecimens = elSpecimens.getChildren("Specimen", sddNamespace);

			for (Element elSpecimen : listSpecimens) {

				String id = elSpecimen.getAttributeValue("id");

				Specimen specimen = null;

				String id = elTaxonName.getAttributeValue("id");

				String uri = elTaxonName.getAttributeValue("uri");

				if (!id.equals("")) {

					tnb = NonViralName.NewInstance(null);

					IdentifiableSource source = null;

	 */

	private Taxon handleCDNoScope(Namespace sddNamespace, SDDImportState cdmState, Element elCodedDescription	) {

		Taxon taxon = null;

		String id = new String("" + taxonNamesCount);

		IdentifiableSource source = IdentifiableSource.NewInstance(id, "TaxonName");

		importRepresentation(elCodedDescription, sddNamespace, nonViralName, id, cdmState);

		Taxon taxon = null;

		Element elTaxonName = elScope.getChild("TaxonName", sddNamespace);

		String ref = elTaxonName.getAttributeValue("ref");

		if(cdmState.getConfig().isDoMatchTaxa()){

			taxon = getTaxonService().findBestMatchingTaxon(nonViralName.getTitleCache());

				try {

					String idP = elPublication.getAttributeValue("id");

					importRepresentation(elPublication, sddNamespace, publication, idP, cdmState);

					publications.put(idP,publication);

						if (lcb != null) {

							for (int k = 0; k < lcb.size(); k++) {

								if (lcb.get(k) instanceof DefinedTermBase) {

									// if (lcb.get(0) instanceof DefinedTermBase) {

									// DefinedTermBase dtb = (DefinedTermBase) lcb.get(0);

									//									if (dtb!=null) {

									//										}

									//									}

								} else if (lcb.get(k) instanceof Reference) {

									//} else if (lcb.get(0) instanceof Reference) {

									//Reference rb = (Reference) lcb.get(0);

									// rb.setTitleCache(label);

						Classification classification =  Classification.NewInstance(label);

						importRepresentation(elTaxonHierarchy, sddNamespace, classification, "", cdmState);

						Element elNodes = elTaxonHierarchy.getChild("Nodes", sddNamespace); // There can be only one <Nodes> block for TaxonHierarchies

						List<Element> listNodes = elNodes.getChildren("Node", sddNamespace);

						for (Element elNode : listNodes){

							String idN = elNode.getAttributeValue("id");

							if (!idN.equals("")) {

								Element elTaxonName = elNode.getChild("TaxonName", sddNamespace);

								String refTN = elTaxonName.getAttributeValue("ref");

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

	private SDDDataSet cdmSource;

	private final Map<Person, String> agents = new HashMap<Person, String>();

	private final Map<Feature, String> characters = new HashMap<Feature, String>();

	private final Map<FeatureNode, String> featureNodes = new HashMap<FeatureNode, String>();

	private final Map<Feature, String> descriptiveConcepts = new HashMap<Feature, String>();

	private final Map<TaxonDescription, String> codedDescriptions = new HashMap<TaxonDescription, String>();

	private final Map<Media, String> medias = new HashMap<Media, String>();

	private final Map<State, String> states = new HashMap<State, String>();

	private final Map<VersionableEntity, String> featuretrees = new HashMap<VersionableEntity, String>();

	private final Map<Modifier, String> modifiers = new HashMap<Modifier, String>();

	private final Map<TaxonNode, String> taxonNodes = new HashMap<TaxonNode, String>();

	private final Map<NamedArea, String> namedAreas = new HashMap<NamedArea, String>();

	private final Map<Specimen, String> specimens = new HashMap<Specimen, String>();

	private final Map<VersionableEntity, String> features = new HashMap<VersionableEntity, String>();

	private int agentsCount = 0;

	private int articlesCount = 0;

		List<Reference> references = cdmSource.getReferences();

		Iterator<Reference> iterator = references.iterator();

		while (iterator.hasNext()) {

			Reference reference = iterator.next();

			if (reference.getType().equals(ReferenceType.Database)) {

		List<Reference> references = cdmSource.getReferences();

		Iterator<Reference> iterator = references.iterator();

		boolean database = false;

		while ((iterator.hasNext()) && (!database)) {

			if (reference.getType().equals(ReferenceType.Database)) {

				d = reference;

			}

		buildLabel(representation, reference.getTitleCache());

		Set<Annotation> annotations = ((Reference) reference).getAnnotations();

		String detailText = null;

		if (iterator.hasNext()) {

			Annotation annotation = (Annotation) iterator.next();

			}

		}

			Reference descriptionSource = rb.next();

			if (descriptionSource.getType().equals(ReferenceType.Article)) {

				articlesCount = buildReference(descriptionSource, articles,

						REF, citation, "p", articlesCount);

					Annotation annotation = a.next();

					if (annotationType != null) {

						String type = annotationType.getLabel();

						if (type.equals("location")) {

						}

					}

				}

			for (int i = 0; i < cdmSource.getReferences().size(); i++) {

				ElementImpl elPublication = new ElementImpl(document,

						"Publication");

				Set<Annotation> annotations = publication.getAnnotations();

				for (Iterator<Annotation> a = annotations.iterator(); a

						.hasNext();) {

		TaxonDescription description = TaxonDescription.NewInstance();

		description.setTitleCache(getDescriptionTitle(state), true);

		if (modsReference != null){

		}

		Element elTaxonBody = root.getChild("taxonxBody", nsTaxonx);

				Taxon taxon = Taxon.NewInstance(taxonNameBase, sec);

				List<DescriptionElementBase> geoList = makeGeo(elTaxonConcept, geoNamespace, rdfNamespace);

				TaxonDescription description = TaxonDescription.NewInstance(taxon);

				for (DescriptionElementBase geo: geoList){

					description.addElement(geo);

					DescriptionElementSource source = DescriptionElementSource.NewInstance(null, null, taxon.getSec(), null);

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import java.net.URISyntaxException;

import java.net.URL;

 * @version 1.0

 */

public class SDDImportTest extends CdmTransactionalIntegrationTest {

	@SpringBeanByType

	@Before

	public void setUp() throws URISyntaxException {

		URL url = this.getClass().getResource("/eu/etaxonomy/cdm/io/sdd/SDDImportTest-input.xml");

		Assert.assertNotNull(url);

	}

	@Test