D-Net

{"type_source": "SVN", "goal": "package -U source:jar", 

"url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-openaireplus-mapping-utils/trunk/", "deploy_repository": "dnet45-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it", "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots", "name": "dnet-openaireplus-mapping-utils"}

package eu.dnetlib.openaire.exporter.model;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class ProjectTest {

	Project pMZOS;

	Project pFP7;

	@Before

	public void setUp() throws Exception {

		pMZOS = new Project()

				.setFunder("MZOS")

				.setJurisdiction("HR")

				.setFundingpathid("irb_hr______::MZOS")

				.setAcronym("")

				.setTitle("Project Title")

				.setCode("115-1152437-2500")

				.setStartdate("2007-01-01")

				.setEnddate("2009-01-01");

		pFP7 = new Project()

				.setFunder("EC")

				.setJurisdiction("EU")

				.setFundingpathid("ec__________::EC::FP7::SP1::NMP")

				.setAcronym("REFFIBRE")

				.setTitle("Project Title")

				.setCode("604187")

				.setStartdate("2013-11-01")

				.setEnddate("20015-01-01");

	}

	@Test

	public void testIdNamespaceMZOS(){

		String ns = pMZOS.getIdnamespace();

		assertEquals("info:eu-repo/grantAgreement/MZOS//115-1152437-2500/HR", ns);

	}

	@Test

	public void testIdNamespaceFP7(){

		String ns = pFP7.getIdnamespace();

		assertEquals("info:eu-repo/grantAgreement/EC/FP7/604187/EU", ns);

	}

}

package eu.dnetlib.openaire.exporter.model;

import java.io.IOException;

import java.io.StringReader;

import com.google.common.collect.Lists;

import org.apache.commons.io.IOUtils;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import static org.junit.Assert.assertEquals;

/**

 * Created by claudio on 22/09/16.

 */

public class ProjectDetailTest {

	private Resource projectsCsv = new ClassPathResource("/eu/dnetlib/openaire/exporter/model/projectDetails.csv");

	private Resource projectsJson = new ClassPathResource("/eu/dnetlib/openaire/exporter/model/projectDetails.json");

	//@Test

	public void testSerialisationCSV() throws IOException {

		final String csv = IOUtils.toString(projectsCsv.getInputStream());

		doTest(csv, "csv");

	}

	//@Test

	public void testSerialisationCSV2() throws IOException {

		final ProjectDetail p = new ProjectDetail()

				.setAcronym("acro")

				.setCode("01")

				.setOptional1("op1")

				.setOptional2("op2")

				.setProjectId("project_01")

				.setJsonextrainfo("extraInfo")

				.setFundingPath(Lists.newArrayList("fundingpath1", "fundingpath2"));

		doTest(p.asCSV(), "csv");

	}

	//@Test

	public void testSerialisationJSON() throws IOException {

		final String json = IOUtils.toString(projectsJson.getInputStream());

		doTest(json, "json");

	}

	private void doTest(final String data, final String format) throws IOException {

		final StringReader reader = new StringReader(data);

		for(String line : IOUtils.readLines(reader)) {

			System.out.println("line:          " + line);

			ProjectDetail p;

			String s = "";

			switch (format) {

			case "csv":

				p = ProjectDetail.fromCSV(line);

				s = p.asCSV();

				break;

			case "json":

				p = ProjectDetail.fromJson(line);

				s = p.asJson();

				break;

			default: throw new IllegalArgumentException("invalid format: " + format);

			}

			System.out.println("serialisation: " + s);

			assertEquals(s, line);

		}

	}

}

package eu.dnetlib.data.mapreduce.util;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import java.util.List;

import org.junit.Test;

import eu.dnetlib.data.proto.KindProtos.Kind;

import eu.dnetlib.miscutils.functional.xml.IndentXmlString;

public class OafDecoderTest {

	@Test

	public void testAsXml() {

		final OafDecoder decoder = OafTest.embed(OafTest.getResult("50|id_1"), Kind.entity);

		assertNotNull(decoder);

		assertNotNull(decoder.asXml());

		System.out.println(IndentXmlString.apply(decoder.asXml()));

	}

}

package eu.dnetlib.data.mapreduce.util;

import org.junit.Test;

public class OafRowKeyDecoderTest {

	@Test

	public void test() {

		String id1 = "50|acnbad______::0a454baf9c61e63d42fb83ab549f8062";

		OafRowKeyDecoder d = OafRowKeyDecoder.decode(id1);

		System.out.println(d.getId());

	}

}

package eu.dnetlib.data.mapreduce.util;

import eu.dnetlib.data.proto.DedupProtos.Dedup.RelName;

import eu.dnetlib.data.proto.OafProtos.OafRel;

import eu.dnetlib.data.proto.RelTypeProtos.RelType;

import eu.dnetlib.data.proto.RelTypeProtos.SubRelType;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

public class OafRelDecoderTest {

	private OafRel oafRel;

	@Before

	public void setUp() {

		oafRel = OafTest.getDedupRel("ID_1", "ID_2", RelType.resultResult, "isMergedIn");

	}

	@Test

	public void testSetClass() {

		OafRelDecoder d1 = OafRelDecoder.decode(oafRel);

		assertNotNull(d1);

		assertEquals("isMergedIn", d1.getRelClass());

		OafRelDecoder d2 = OafRelDecoder.decode(d1.setClassId("isMergedIn").build());

		assertEquals("isMergedIn", d2.getRelClass());

		assertEquals("isMergedIn", d2.getRelMetadata().getSemantics().getClassid());

		assertEquals("isMergedIn", d2.getRelMetadata().getSemantics().getClassname());

	}

	@Test

	public void testGetCF() {

		assertEquals("resultResult_dedup_isMergedIn", OafRelDecoder.getCFQ(RelType.resultResult, SubRelType.dedup, RelName.isMergedIn));

		assertEquals("resultResult_dedup_isMergedIn", OafRelDecoder.getCFQ(RelType.resultResult, SubRelType.dedup, "isMergedIn"));

	}

}

package eu.dnetlib.data.bulktag;

import com.google.gson.Gson;

import eu.dnetlib.data.bulktag.selectioncriteria.VerbResolver;

import eu.dnetlib.data.bulktag.selectioncriteria.VerbResolverFactory;

import junit.framework.Assert;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.dom4j.DocumentException;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.util.*;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;

/**

 * Created by miriam on 03/08/2018.

 */

public class CommunityConfigurationFactoryTest {

    private String xml;

    private String xml1;

    private final VerbResolver resolver = new VerbResolver();

    @Before

    public void setUp() throws IOException, DocumentException {

        xml = IOUtils.toString(getClass().getResourceAsStream("community_configuration.xml"));

        xml1 = IOUtils.toString(getClass().getResourceAsStream("community_configuration_selcrit.xml"));

    }

    @Test

    public void parseTest() throws DocumentException {

        final CommunityConfiguration cc = CommunityConfigurationFactory.newInstance(xml);

        assertEquals(5,cc.size());

        cc.getCommunityList().forEach(c -> assertTrue(StringUtils.isNoneBlank(c.getId())));

    }

    @Test

    public void applyVerb() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {

        Constraint sc = new Constraint();

        String verb = "not_contains";

        sc.setVerb("not_contains");

        sc.setField("contributor");

        sc.setValue("DARIAH");

        sc.setSelection(resolver.getSelectionCriteria(sc.getVerb(),sc.getValue()));

        String metadata = "This work has been partially supported by DARIAH-EU infrastructure";

        Assert.assertFalse(sc.verifyCriteria(metadata));

    }

    @Test

    public void loadSelCriteriaTest() throws DocumentException {

        final CommunityConfiguration cc = CommunityConfigurationFactory.newInstance(xml1);

        Map<String,List<String>> param = new HashMap<>();

        param.put("author",new ArrayList<>(Collections.singletonList("Pippo Pippi")));

        param.put("description",new ArrayList<>(Collections.singletonList("This work has been partially supported by DARIAH-EU infrastructure")));

        param.put("contributor",new ArrayList<>(Collections.singletonList("Pallino ha aiutato a scrivere il paper. Pallino lavora per DARIAH")));

        List<String> comm = cc.getCommunityForDatasource("openaire____::1cfdb2e14977f31a98e0118283401f32",param);

        Assert.assertEquals(1,comm.size());

        Assert.assertEquals("dariah",comm.get(0));

    }

    @Test

    public void test4() throws DocumentException, IOException {

        final CommunityConfiguration cc = CommunityConfigurationFactory.fromJson(IOUtils.toString(getClass().getResourceAsStream("community_configuration_selcrit.json")));

        cc.toString();

    }

    @Test

    public void test5() throws IOException, DocumentException {

        //final CommunityConfiguration cc = CommunityConfigurationFactory.newInstance(IOUtils.toString(getClass().getResourceAsStream("test.xml")));

        final CommunityConfiguration cc = CommunityConfigurationFactory.fromJson(IOUtils.toString(getClass().getResourceAsStream("community_configuration.json")));

        System.out.println(cc.toJson());

    }

    @Test

    public void test6() {

        String json = "{\"criteria\":[{\"constraint\":[{\"verb\":\"contains\",\"field\":\"contributor\",\"value\":\"DARIAH\"}]}]}";

//        String step1 = "{\"verb\":\"contains\",\"field\":\"contributor\",\"value\":\"DARIAH\"}";

//

//        Constraint c = new Gson().fromJson(step1, Constraint.class);

//

//        String step2 = "{\"constraint\":[{\"verb\":\"contains\",\"field\":\"contributor\",\"value\":\"DARIAH\"}]}";

//

//        ConstraintEncapsulator ce = new Gson().fromJson(step2,ConstraintEncapsulator.class);

//

//

//        String step3 = "{\"ce\":{\"constraint\":[{\"verb\":\"contains\",\"field\":\"contributor\",\"value\":\"DARIAH\"}]}}";

//

//        Constraints cons = new Gson().fromJson(step3,Constraints.class);

//

//        String step4 = "{\"criteria\":[{\"ce\":{\"constraint\":[{\"verb\":\"contains\",\"field\":\"contributor\",\"value\":\"DARIAH\"}]}}]}";

//

//        ConstraintsList cl = new Gson().fromJson(step4,ConstraintsList.class);

//

//        String step5 = "{\"cl\":{\"criteria\":[{\"ce\":{\"constraint\":[{\"verb\":\"contains\",\"field\":\"contributor\",\"value\":\"DARIAH\"}]}}]}}";

        SelectionConstraints sl = new Gson().fromJson(json,SelectionConstraints.class);

    }

}

package eu.dnetlib.data.transform;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringReader;

import java.util.List;

import java.util.Objects;

import java.util.Properties;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.stream.StreamSupport;

import com.google.protobuf.InvalidProtocolBufferException;

import com.mongodb.client.MongoCollection;

import com.mongodb.client.MongoDatabase;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.transform.xml2.DatasetToProto;

import eu.dnetlib.miscutils.collections.Pair;

import eu.dnetlib.miscutils.datetime.HumanTime;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.time.StopWatch;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;

import org.bson.Document;

import org.dom4j.DocumentException;

import org.dom4j.io.SAXReader;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = { ConfigurationTestConfig.class })

public class ParserToProtoIT {

	private static final Log log = LogFactory.getLog(ParserToProtoIT.class);

	private static final String DATACITE = "datacite";

	private static final String NARCIS = "narcis";

	private static final int BATCH_SIZE = 10000;

	private static final int LOG_FREQ = 5000;

	private static final int LIMIT = 10000;

	public static final String BODY = "body";

	private static String basePathProfiles = "/eu/dnetlib/test/profiles/TransformationRuleDSResources/TransformationRuleDSResourceType/";

	private int batchSize = BATCH_SIZE;

	private int logFreq = LOG_FREQ;

	private int limit = LIMIT;

	@Autowired

	private MongoDatabase db;

	@Autowired()

	private Properties testProperties;

	@Before

	public void setUp() {

		logFreq = Integer.valueOf(testProperties.getProperty("test.logFreq", String.valueOf(LOG_FREQ)));

		batchSize = Integer.valueOf(testProperties.getProperty("test.batchSize", String.valueOf(BATCH_SIZE)));

		limit = Integer.valueOf(testProperties.getProperty("test.limit", String.valueOf(limit)));

	}

	@Test

	@Ignore

	public void testParseDataciteWithVTD() throws IOException {

		doTest(s -> new Pair<>(s, new DatasetToProto().apply(s)), DATACITE);

	}

	@Test

	@Ignore

	public void testParseDataciteWithXSLT() throws IOException {

		final String xslt = IOUtils.toString(loadFromTransformationProfile("odf2hbase.xml"));

		final XsltRowTransformer transformer = XsltRowTransformerFactory.newInstance(xslt);

		doTest(rowToOaf(transformer), DATACITE);

	}

	@Test

	@Ignore

	public void testParseNarcisWithXSLT() throws IOException {

		final String xslt = IOUtils.toString(loadFromTransformationProfile("oaf2hbase.xml"));

		final XsltRowTransformer transformer = XsltRowTransformerFactory.newInstance(xslt);

		doTest(rowToOaf(transformer), NARCIS);

	}

	//// HELPERS

	private void doTest(final Function<String, Pair<String, Oaf>> mapper, final String collectionName) {

		final MongoCollection<Document> collection = db.getCollection(collectionName);

		final long collectionSize = collection.count();

		log.info(String.format("found %s records in collection '%s'", collectionSize, collectionName));

		final AtomicInteger read = new AtomicInteger(0);

		final DescriptiveStatistics stats = new DescriptiveStatistics();

		final StopWatch recordTimer = new StopWatch();

		final StopWatch totalTimer = StopWatch.createStarted();

		StreamSupport.stream(collection.find().batchSize(batchSize).spliterator(), false)

				.limit(limit)

				.peek(d -> {

					if (read.addAndGet(1) % logFreq == 0) {

						log.info(String.format("records read so far %s", read.get()));

						//log.info(String.format("stats so far %s", stats.toString()));

					}

				})

				.map(d -> (String) d.get("body"))

				.filter(Objects::nonNull)

				.collect(Collectors.toList())   // load them in memory first

				.stream()

				.peek(s -> recordTimer.start())

				.map(mapper)

				.forEach(pair -> {

					recordTimer.stop();

					stats.addValue(recordTimer.getTime());

					recordTimer.reset();

					assertNotNull(pair);

					assertTrue(pair.getValue().hasEntity());

					try {

						final org.dom4j.Document doc = new SAXReader().read(new StringReader(pair.getKey()));

						final OafEntity entity = pair.getValue().getEntity();

						//TODO add more asserts

						assertTrue(entity.getId().contains(doc.valueOf("/*[local-name() = 'record']/*[local-name() = 'header']/*[local-name() = 'objIdentifier']/text()")));

					} catch (DocumentException e) {

						throw new IllegalArgumentException("unable to parse record " + pair.getKey(), e);

					}

				});

		totalTimer.stop();

		log.info(String.format("processed %s/%s records in %s", read.get(), collectionSize, HumanTime.exactly(totalTimer.getTime())));

		log.info(stats.toString());

	}

	private Function<String, Pair<String, Oaf>> rowToOaf(final XsltRowTransformer transformer) {

		return xml -> {

			final List<Row> rows = transformer.apply(xml);

			if (rows.isEmpty()) {

				return null;

			}

			return rows.stream()

					.filter(row -> row.getColumn(BODY) != null)

					.map(row -> row.getColumn(BODY))

					.map(c -> c.getValue())

					.map(b -> {

						try {

							return Oaf.parseFrom(b);

						} catch (InvalidProtocolBufferException e) {

							throw new IllegalStateException(e);

						}

					})

					.filter(Objects::nonNull)

					.map(oaf -> new Pair<>(xml, oaf))

					.findFirst()

					.get();

		};

	}

	private InputStream loadFromTransformationProfile(final String profilePath) {

		log.info("Loading xslt from: " + basePathProfiles + profilePath);

		InputStream profile = getClass().getResourceAsStream(basePathProfiles + profilePath);

		SAXReader saxReader = new SAXReader();

		org.dom4j.Document doc = null;

		try {

			doc = saxReader.read(profile);

		} catch (DocumentException e) {

			e.printStackTrace();

			throw new RuntimeException(e);

		}

		String xslt = doc.selectSingleNode("//SCRIPT/CODE/*[local-name()='stylesheet']").asXML();

		//log.info(xslt);

		return IOUtils.toInputStream(xslt);

	}

}

package eu.dnetlib.data.transform.xml;

import java.util.List;

import eu.dnetlib.data.transform.xml.OpenTrialsXsltFunctions.JsonProv;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

/**

 * OpenTrialsXsltFunctions Tester.

 *

 */

public class OpenTrialsXsltFunctionsTest {

	private String jsonProv = "[{\"url\" : \"http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT00378508\", \"sourceID\" : \"77eb42c5-0ec7-4e31-963a-5736b66f2d26\", \"sourceName\" : \"ictrp\"},{\"url\" : \"https://www.clinicaltrials.gov/ct2/show/NCT00378508?lup_e=02%2F04%2F2016&lup_s=01%2F01%2F2001&rank=175075&resultsxml=true\", \"sourceID\" : \"b389497c-0833-432b-a09b-930526b7b4d4\", \"sourceName\" : \"nct\"}]";

	private String jsonProvWithNull = "[{\"url\" : \"\", \"sourceID\" : \"77eb42c5-0ec7-4e31-963a-5736b66f2d26\", \"sourceName\" : \"ictrp\"},{\"url\" : \"https://www.clinicaltrials.gov/ct2/show/NCT00378508?lup_e=02%2F04%2F2016&lup_s=01%2F01%2F2001&rank=175075&resultsxml=true\", \"sourceID\" : \"b389497c-0833-432b-a09b-930526b7b4d4\", \"sourceName\" : \"nct\"}]";

	private String jidentifiers = "{112683,NCT00920439}";

	private String jsonRecord = "[{\"source_id\" : \"nct\", \"source_url\" : \"https://clinicaltrials.gov/ct2/show/NCT02321059\", \"is_primary\" : true},{\"source_id\" : \"ictrp\", \"source_url\" : \"http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT02321059\", \"is_primary\" : false}]";

	private String jsonRecordNull = "[{\"source_id\" : \"nct\", \"source_url\" : \"https://clinicaltrials.gov/ct2/show/NCT02321059\"},{\"source_id\" : \"ictrp\", \"source_url\" : \"http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT02321059\", \"is_primary\" : false}]";

	private String jsonRecordVoid = "[{\"source_id\" : \"\", \"source_url\" : \"\", \"is_primary\" : \"\"}]";

	private String jsonRecondPrimary = "[{\"source_id\" : \"nct\", \"source_url\" : \"https://clinicaltrials.gov/ct2/show/NCT02321059\", \"is_primary\" : false},{\"source_id\" : \"ictrp\", \"source_url\" : \"http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT02321059\", \"is_primary\" : false}]";

	private String jsonPeopleVoid ="[{\"person_name\" : null, \"person_id\" : null, \"person_role\" : null}]";

	private String jsonPeopleOne = "[{\"person_name\" : \"Henk Verheul, M.D., PhD\", \"person_id\" : \"116438e9-f8b1-46e5-a1f8-20f851cab73c\", \"person_role\" : \"principal_investigator\"}]";

	private String jsonPeopleMore = "[{\"person_name\" : \"Henk Verheul, M.D., PhD\", \"person_id\" : \"116438e9-f8b1-46e5-a1f8-20f851cab73c\", \"person_role\" : \"principal_investigator\"},{\"person_name\" : \"Miriam Pippolippo Baglioni, PhD\", \"person_id\" : \"fake\", \"person_role\" : \"principal_investigator\"}]";

	private String jsonOrganizationVoid = "[{\"organization_name\" : null, \"organization_id\" : null, \"organization_role\" : null}]";

	private String jsonOrganizationOne = "[{\"organization_name\" : \"Södertälje sjukhus AB\", \"organization_id\" : \"15f0d004-b82b-408c-8605-38a57352468d\", \"organization_role\" : \"sponsor\"}]";

	private String jsonOrganizationMore = "[{\"organization_name\" : \"Södertälje sjukhus AB\", \"organization_id\" : \"15f0d004-b82b-408c-8605-38a57352468d\", \"organization_role\" : \"sponsor\"},{\"organization_name\" : \"Miriam Baglioni AB\", \"organization_id\" : \"fake\", \"organization_role\" : \"primary_sponsor\"}]";

	private String jsonLocationVoid = "[{\"location_name\" : null}]";

	private String jsonLocationOne = "[{\"location_name\" : \"China\"}]";

	private String jsonLocationMore = "[{\"location_name\" : \"China\"},{\"location_name\" : \"North Korea\"}]";

	@Before

	public void before() throws Exception {

	}

	@After

	public void after() throws Exception {

	}

	/**

	 * Method: getProvs(String jsonProvList)

	 */

	@Test

	public void testGetProvs() throws Exception {

		List<JsonProv> list = OpenTrialsXsltFunctions.getProvs(jsonProv);

		assertEquals(2, list.size());

	}

	/**

	 * Method: getMainIdentifierURL(String jsonProvList)

	 */

	@Test

	public void testGetMainIdentifierURL() throws Exception {

		String url = OpenTrialsXsltFunctions.getMainIdentifierURL(jsonProv);

		assertEquals( "http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT00378508", url );

		url = OpenTrialsXsltFunctions.getMainIdentifierURL(jsonProvWithNull);

		assertEquals("https://www.clinicaltrials.gov/ct2/show/NCT00378508?lup_e=02%2F04%2F2016&lup_s=01%2F01%2F2001&rank=175075&resultsxml=true", url);

	}

	@Test

	public void testGetPrimaryRecordUrl(){

		String url = OpenTrialsXsltFunctions.getPrimaryRecordUrl(jsonRecord);

		assertEquals("https://clinicaltrials.gov/ct2/show/NCT02321059", url);

	}

	@Test

	public void testGetPrimaryRecordID(){

		String id = OpenTrialsXsltFunctions.getPrimaryRecordIdentifier(jsonRecord);

		assertEquals("nct", id);

	}

	@Test

	public void testGetPrimaryRecordUrlNull(){

		String url = OpenTrialsXsltFunctions.getPrimaryRecordUrl(jsonRecordNull);

		assertEquals("https://clinicaltrials.gov/ct2/show/NCT02321059", url);

	}

	@Test

	public void testGetPrimaryRecordUrlVoid(){

		String url = OpenTrialsXsltFunctions.getPrimaryRecordUrl(jsonRecordVoid);

		assertEquals("", url);

	}

	@Test

	public void testGetPrimaryRecordUrlNoPrimary(){

		String url = OpenTrialsXsltFunctions.getPrimaryRecordUrl(jsonRecondPrimary);

		assertEquals("https://clinicaltrials.gov/ct2/show/NCT02321059", url);

	}

	@Test

	public void testGetPrimaryRecordIDNoPrimary(){

		String id = OpenTrialsXsltFunctions.getPrimaryRecordIdentifier(jsonRecondPrimary);

		assertEquals("nct", id);

	}

	@Test

	public void testGetPrincipalInvestigatorsVoid(){

		String url = OpenTrialsXsltFunctions.getPrincipalInvestigators(jsonPeopleVoid);

		assertEquals("",url);

	}

	@Test

	public void testGetPrincipalInvestigatorsOne(){

		String url = OpenTrialsXsltFunctions.getPrincipalInvestigators(jsonPeopleOne);

		assertEquals("Verheul, Henk", url);

	}

	@Test

	public void testGetPrincipalInvestigatorsMore(){

		String url = OpenTrialsXsltFunctions.getPrincipalInvestigators(jsonPeopleMore);

		assertEquals("Verheul, Henk@@Baglioni, Miriam Pippolippo", url);

	}

	@Test

	public void testgGetTrialOrganizationsVoid(){

		String url = OpenTrialsXsltFunctions.getTrialOrganizations(jsonOrganizationVoid);

		assertEquals("",url);

	}

	@Test

	public void testgGetTrialOrganizationsOne(){

		String url = OpenTrialsXsltFunctions.getTrialOrganizations(jsonOrganizationOne);

		assertEquals("Södertälje sjukhus AB@sponsor", url);

	}

	@Test

	public void testgGetTrialOrganizationsMore(){

		String url = OpenTrialsXsltFunctions.getTrialOrganizations(jsonOrganizationMore);

		assertEquals("Södertälje sjukhus AB@sponsor@@Miriam Baglioni AB@sponsor", url);

	}

	@Test

	public void testgGetTrialLocationsVoid(){

		String url = OpenTrialsXsltFunctions.getTrialLocations(jsonLocationVoid);

		assertEquals("",url);

	}

	@Test

	public void testgGetTrialLocationsOne(){

		String url = OpenTrialsXsltFunctions.getTrialLocations(jsonLocationOne);

		assertEquals("China", url);

	}

	@Test

	public void testgGetTrialLocationsMore(){

		String url = OpenTrialsXsltFunctions.getTrialLocations(jsonLocationMore);

		assertEquals("China@@North Korea", url);

	}

	@Test

	public void testGetNotPrimaryRecordUrlPrimary(){

		String url = OpenTrialsXsltFunctions.getNotPrimaryRecordUrl(jsonRecondPrimary);

		assertEquals("http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT02321059", url);

	}

	@Test

	public void testGetNotPrimaryRecordUrlVoid(){

		String url = OpenTrialsXsltFunctions.getNotPrimaryRecordUrl(jsonRecordVoid);

		assertEquals("", url);

	}

	@Test

	public void testGetNotPrimaryRecordUrl(){

		String url = OpenTrialsXsltFunctions.getNotPrimaryRecordUrl(jsonRecord);

		assertEquals("http://apps.who.int/trialsearch/Trial3.aspx?trialid=NCT02321059", url);

	}

}

package eu.dnetlib.data.transform.xml;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

/**

 *

 * Created by miriam on 04/05/2017.

 */

public class FWFXsltFunctionsTest {

	private String namesurname ="Gerhard SOMMER";

	private String noSurname = "Gerhard";

	private String noName = "SOMMER";

	private String twoNames = "Gerhard Pippo SOMMER";

	private String twoSurname = "Gerhard PIPPO SOMMER";

	private String nonamesurname = "";

	private String organization ="Universität Linz - Institut für Computational Perception; Universität für Musik und darstellende Kunst Graz - Institut 1: Komposition, Musiktheorie, Musikgeschichte und Dirigieren; Universität Mozarteum Salzburg - Institut für Musikalische Rezeptions- und Interpretationsgeschichte; Anton Bruckner Privatuniversität - Institut für Theorie und Geschichte der Musik; Eliette und Herbert von Karajan Institut - Eliette und Herbert von Karajan Institut";

	@Before

	public void before() throws Exception {

	}

	@After

	public void after() throws Exception {

	}

	@Test

	public void testGetNamesNameNoNameSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(nonamesurname,true);

		assertEquals("",ret );

	}

	@Test

	public void testGetNamesSurnameNoNameSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(nonamesurname,false);

		assertEquals("",ret );

	}

	@Test

	public void testGetNamesNameTwoSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(twoSurname,true);

		assertEquals("Gerhard",ret );

	}

	@Test

	public void testGetNamesSurnameTwoSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(twoSurname,false);

		assertEquals("PIPPO SOMMER",ret );

	}

	@Test

	public void testGetNamesNameTwoNames() throws Exception {

		String ret = FWFXsltFunctions.getName(twoNames,true);

		assertEquals("Gerhard Pippo",ret );

	}

	@Test

	public void testGetNamesSurnameTwoNames() throws Exception {

		String ret = FWFXsltFunctions.getName(twoNames,false);

		assertEquals("SOMMER",ret );

	}

	/**

	 * Method: getProvs(String jsonProvList)

	 */

	@Test

	public void testGetNamesName() throws Exception {

		String ret = FWFXsltFunctions.getName(namesurname,true);

		assertEquals("Gerhard",ret );

	}

	@Test

	public void testGetNamesSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(namesurname,false);

		assertEquals("SOMMER",ret );

	}

	@Test

	public void testGetNamesNameNoSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(noSurname,true);

		assertEquals("Gerhard",ret );

	}

	@Test

	public void testGetNamesSurnameNoSurname() throws Exception {

		String ret = FWFXsltFunctions.getName(noSurname,false);

		assertEquals("",ret );

	}

	@Test

	public void testGetNamesNameNoName() throws Exception {

		String ret = FWFXsltFunctions.getName(noName,true);

		assertEquals("",ret );

	}

	@Test

	public void testGetNamesSurnameNoName() throws Exception {

		String ret = FWFXsltFunctions.getName(noName,false);

		assertEquals("SOMMER",ret );

	}

	@Test

	public void TestGetMd5()throws Exception{

		String md5 = FWFXsltFunctions.getMd5(organization);

		System.out.println(md5);

		assertNotNull(md5);

	}

}

package eu.dnetlib.data.transform.xml.vtd;

import java.io.IOException;

import java.util.function.Function;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.transform.xml2.DatasetToProto;

import eu.dnetlib.data.transform.xml2.PublicationToProto;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.junit.Test;

import static org.junit.Assert.assertNotNull;

public class VtdParserToProtoTest {

	private static final Log log = LogFactory.getLog(VtdParserToProtoTest.class);

	@Test

	public void testParsePublication() throws IOException {

		doTest("/eu/dnetlib/data/transform/publication.xml", new PublicationToProto());

	}

	@Test

	public void testParseDataset() throws IOException {

		doTest("/eu/dnetlib/data/transform/dataset.xml", new DatasetToProto());

	}

	@Test

	public void testParseDataset2() throws IOException {

		doTest("/eu/dnetlib/data/transform/dataset2.xml", new DatasetToProto());

	}

	private void doTest(final String filePath, Function<String, Oaf> f) throws IOException {

		final String xml = IOUtils.toString(getClass().getResourceAsStream(filePath));

		assertNotNull(xml);

		final Oaf oaf = f.apply(xml);

		assertNotNull(oaf);

		log.info(oaf.toString());

	}

}

package eu.dnetlib.data.transform.xml.vtd;

import java.io.IOException;

import java.io.InputStream;

import java.util.Properties;

import com.mongodb.MongoClient;

import com.mongodb.client.MongoDatabase;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.ClassPathResource;

@Configuration

public class ConfigurationTestConfig {

	@Bean

	public MongoDatabase db() throws IOException {

		final Properties p = new Properties();

		final ClassPathResource cp = new ClassPathResource("test.properties");

		try (final InputStream stream = cp.getInputStream()) {

			p.load(stream);

		}

		final MongoClient mongo = new MongoClient(

				p.getProperty("mongodb.host"),

				Integer.valueOf(p.getProperty("mongodb.port")));

		return mongo.getDatabase(p.getProperty("mongodb.dbname"));

	}

}

package eu.dnetlib.data.transform.xml.vtd;

import com.mongodb.client.MongoCollection;

import com.mongodb.client.MongoDatabase;

import eu.dnetlib.data.transform.xml2.DatasetToProto;

import org.apache.commons.lang3.time.StopWatch;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;

import org.bson.Document;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.IOException;

import java.util.Objects;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.StreamSupport;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = { ConfigurationTestConfig.class })

public class VtdParserToProtoIT {

	private static final Log log = LogFactory.getLog(VtdParserToProtoIT.class);

	public static final String COLLECTION_NAME = "datacite";

	private static final int BATCH_SIZE = 10000;

	public static final int LOG_FREQ = 5000;

	@Autowired

	private MongoDatabase db;

	@Test

	@Ignore

	public void testParseDatacite() throws IOException {

		final MongoCollection<Document> collection = db.getCollection(COLLECTION_NAME);

		final long collectionSize = collection.count();

		log.info(String.format("found %s records in collection '%s'", collectionSize, COLLECTION_NAME));

		final AtomicInteger read = new AtomicInteger(0);

		final DescriptiveStatistics stats = new DescriptiveStatistics();

		final StopWatch timer = new StopWatch();

		final DatasetToProto mapper = new DatasetToProto();

		StreamSupport.stream(collection.find().batchSize(BATCH_SIZE).spliterator(), false)

				.peek(d -> {

					if (read.addAndGet(1) % LOG_FREQ == 0) {

						log.info(String.format("records read so far %s", read.get()));

						log.info(String.format("stats so far %s", stats.toString()));

					}

				})

				.map(d -> (String) d.get("body"))

				.filter(Objects::nonNull)

				.peek(s -> timer.start())

				.map(mapper)

				.forEach(oaf -> {

					assertNotNull(oaf);

					assertTrue(oaf.hasEntity());

					timer.stop();

					stats.addValue(timer.getTime());

					timer.reset();

				});

		log.info(String.format("processed %s/%s records", read.get(), collectionSize));

	}

}

package eu.dnetlib.data.transform.xml.vtd;

import java.io.InputStream;

import java.util.List;

import com.ximpleware.AutoPilot;

import com.ximpleware.VTDGen;

import com.ximpleware.VTDNav;

import eu.dnetlib.data.transform.xml2.Node;

import eu.dnetlib.data.transform.xml2.VtdUtilityParser;

import org.apache.commons.io.IOUtils;

import org.junit.Assert;

import org.junit.Test;

public class VtdUtilityParserTest {

	@Test

	public void testUtils1() {

		String xpath = VtdUtilityParser.xpath("a", "b", "c");

		Assert.assertTrue("/*[local-name()='a']/*[local-name()='b']/*[local-name()='c']".equals(xpath));

	}

    @Test

    public void testPartser() throws Exception {

        final InputStream resource = this.getClass().getResourceAsStream("/eu/dnetlib/data/transform/publication.xml");

        final String record =IOUtils.toString(resource);

        final VTDGen vg = VtdUtilityParser.parseXml(record);

        final VTDNav vn = vg.getNav();

        final AutoPilot ap = new AutoPilot(vn);

        List<Node> nodes = VtdUtilityParser.getNodes(ap, vn, "//*[local-name()='referenceaa']");

        nodes.forEach(n -> Assert.assertTrue(n.getAttributes().keySet().size()>0));

        System.out.println(VtdUtilityParser.countNodes(ap, vn, "count(//*[local-name()='CobjIdentifier'])"));

    }

}

package eu.dnetlib.data.transform;

import com.google.common.base.Predicates;

import com.mongodb.client.FindIterable;

import com.mongodb.client.MongoDatabase;

import com.mongodb.client.MongoIterable;

import eu.dnetlib.data.transform.xml.vtd.ConfigurationTestConfig;

import org.bson.Document;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.IOException;

import java.util.List;

import static java.util.stream.Collectors.toList;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = { ConfigurationTestConfig.class })

public class AuthorMergerTestIT extends AbstractAuthorMergerTest {

    @Autowired

    private MongoDatabase db;

    private String collection = "authors";

    @Test

    public void test_mergeAuthorsGroup() throws IOException {

        final FindIterable<Document> docs = db.getCollection(collection).find();

        MongoIterable<String> i = docs

                .map(d -> ((List<List<Document>>) d.get("authors")).stream()

                    .filter(Predicates.notNull())

                    .map(g -> g.stream()

                            .map(Document::toJson)

                            .collect(toList()))

                    .collect(toList()))

                .map(List::toString);

        doTestMergeAuthorGroup(i);

    }

}

package eu.dnetlib.data.transform.xml2;

import java.io.IOException;

import java.util.function.Function;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.junit.Test;

import static org.junit.Assert.assertNotNull;

public class VtdParserToProtoTest {

	private static final Log log = LogFactory.getLog(VtdParserToProtoTest.class);

	@Test

	public void testParsePublication() throws IOException {

		doTest("/eu/dnetlib/data/transform/publication.xml", new PublicationToProto());

	}

	@Test

	public void testParseDataset() throws IOException {

		doTest("/eu/dnetlib/data/transform/dataset.xml", new DatasetToProto());

	}

	@Test

		public void testParseDataset2() throws IOException {

		doTest("/eu/dnetlib/data/transform/dataset2.xml", new DatasetToProto());

	}

	private void doTest(final String filePath, Function<String, Oaf> f) throws IOException {

		final String xml = IOUtils.toString(getClass().getResourceAsStream(filePath));

		assertNotNull(xml);

		final Oaf oaf = f.apply(xml);

		assertNotNull(oaf);

		log.info(oaf.toString());

	}

}

package eu.dnetlib.data.transform.xml2;

import java.io.InputStream;

import java.util.List;

import com.ximpleware.AutoPilot;

import com.ximpleware.VTDGen;

import com.ximpleware.VTDNav;

import eu.dnetlib.data.transform.xml2.Node;

import eu.dnetlib.data.transform.xml2.VtdUtilityParser;

import org.apache.commons.io.IOUtils;

import org.junit.Assert;

import org.junit.Test;

import static eu.dnetlib.data.transform.xml2.VtdUtilityParser.parseXml;

public class VtdUtilityParserTest {

	@Test

	public void testUtils1() {

		String xpath = VtdUtilityParser.xpath("a", "b", "c");

		Assert.assertTrue("/*[local-name()='a']/*[local-name()='b']/*[local-name()='c']".equals(xpath));

	}

    @Test

    public void testPartser() throws Exception {

        final InputStream resource = this.getClass().getResourceAsStream("/eu/dnetlib/data/transform/publication.xml");

        final String record =IOUtils.toString(resource);

        final VTDGen vg = parseXml(record);

        final VTDNav vn = vg.getNav();

        final AutoPilot ap = new AutoPilot(vn);

        List<Node> nodes = VtdUtilityParser.getNodes(ap, vn, "//*[local-name()='referenceaa']");

        nodes.forEach(n -> Assert.assertTrue(n.getAttributes().keySet().size()>0));

        System.out.println(VtdUtilityParser.countNodes(ap, vn, "count(//*[local-name()='CobjIdentifier'])"));

    }

}

package eu.dnetlib.data.transform;

import org.junit.Test;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.Iterator;

import java.util.zip.GZIPInputStream;

public class AuthorMergerTest extends AbstractAuthorMergerTest {

    @Test

    public void test_mergeAuthorsGroup() throws IOException {

        try(GZIPInputStream gzip = new GZIPInputStream(getClass().getResourceAsStream("author_1000.json.gz"))) {

            final BufferedReader br = new BufferedReader(new InputStreamReader(gzip));

            doTestMergeAuthorGroup(() -> new Iterator<String>() {

                String line = null;

                @Override

                public boolean hasNext() {

                    line = doNext();

                    return line != null;

                }

                @Override

                public String next() {

                    return line;

                }

                private String doNext() {

                    try {

                        return br.readLine();

                    } catch (IOException e) {

                        throw new RuntimeException(e);

                    }

                }

            });

        }

    }

}

package eu.dnetlib.data.transform;

import com.google.common.collect.Lists;

import com.google.common.collect.Sets;

import com.google.gson.Gson;

import com.google.gson.JsonElement;

import com.google.gson.internal.StringMap;

import com.googlecode.protobuf.format.JsonFormat;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;

import org.junit.Assert;

import java.io.IOException;

import java.util.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.Collectors;

import java.util.stream.StreamSupport;

import static eu.dnetlib.data.proto.FieldTypeProtos.Author;

import static eu.dnetlib.data.proto.FieldTypeProtos.KeyValue;

import static java.lang.String.format;

import static java.util.stream.Collectors.*;

public abstract class AbstractAuthorMergerTest {

    protected void doTestMergeAuthorGroup(final Iterable<String> input) throws IOException {

        final DescriptiveStatistics groupSize = new DescriptiveStatistics();

        final AtomicInteger authorCount = new AtomicInteger(0);

        final AtomicInteger authorCountMerged = new AtomicInteger(0);

        final AtomicInteger pidCount = new AtomicInteger(0);

        final AtomicInteger pidCountMerged = new AtomicInteger(0);

        final Map<String, Integer> pidTypes = new HashMap<>();

        final Map<String, Integer> pidTypesMerged = new HashMap<>();

        final AtomicInteger orcidCount = new AtomicInteger(0);

        final AtomicInteger equalGroupSizeCount = new AtomicInteger(0);

        final AtomicInteger lines = new AtomicInteger(0);

        final List<List<Author>> authorGroups = Lists.newArrayList();

        final Set<String> orcidIn = new HashSet<>();

        final Set<String> orcidOut= new HashSet<>();

        for(String line : input) {

            lines.incrementAndGet();

            final List<List<StringMap<Object>>> list = new Gson().fromJson(line, List.class);

            final List<List<Author>> groups = new ArrayList<>();

            groups.addAll(list.stream()

                    .filter(Objects::nonNull)

                    .map(j -> {

                        return j.stream().map(AbstractAuthorMergerTest::fixRank).collect(toList());

                    })

                    .map(AbstractAuthorMergerTest::asAuthors)

                    .filter(Objects::nonNull)

                    .collect(toList()));

            groups.stream().forEach(g -> {

                groupSize.addValue(g.size());

                g.stream().forEach(a -> {

                    pidCount.addAndGet(a.getPidCount());

                    authorCount.incrementAndGet();

                    countPids(pidTypes, a);

                    orcidIn.addAll(getOrcid(a));

                });

            });

            final HashSet<Integer> groupSizes = groups.stream()

                    .map(a -> a.size())

                    .collect(toCollection(HashSet::new));

            if (groupSizes.size() == 1) {

                equalGroupSizeCount.incrementAndGet();

            }

            authorGroups.addAll(groups);

            final List<Author> merged = AuthorMerger.merge(groups);

            if (!groupSizes.isEmpty()) {

                Assert.assertTrue(

                        format("the size of the merged group must be the size of one of the input groups. Merged size: %s, Sizes: %s ",

                                merged.size(), groupSizes),

                        groupSizes.contains(merged.size()));

            }

            authorCountMerged.addAndGet(merged.size());

            merged.forEach(a -> {

                pidCountMerged.addAndGet(a.getPidCount());

                countPids(pidTypesMerged, a);

                orcidOut.addAll(getOrcid(a));

            });

        }

        System.out.println(format("lines %s", lines.intValue()));

        System.out.println(format("author groups %s", authorGroups.size()));

        System.out.println(format("author count %s", authorCount.intValue()));

        System.out.println(format("avg authorGroups per group %s", authorCount.doubleValue() / authorGroups.size()));

        System.out.println(format("pid types %s", pidTypes));

        System.out.println(format("pid count %s", pidCount.intValue()));

        System.out.println(format("pid rate among authors %s", pidCount.doubleValue() / authorCount.intValue()));

        System.out.println(format("equal group size %s", equalGroupSizeCount.incrementAndGet()));

        System.out.println(format("[merged] pid count %s", pidCountMerged.intValue()));

        System.out.println(format("[merged] avg pid per group %s", pidCountMerged.doubleValue() / authorCountMerged.intValue()));

        System.out.println(format("[merged] pid types %s", pidTypesMerged));

        System.out.println(format("ORCIDs in  %s", orcidIn.size()));

        System.out.println(format("ORCIDs out %s", orcidOut.size()));

        Sets.SetView<String> diff = Sets.difference(orcidIn, orcidOut);

        System.out.println(format("Difference between the number of distinct input ORCIDs and output (merged) ORCIDs: %s", diff.size()));

        System.out.println(format("\ngroup size %s", groupSize));

    }

    private List<String> getOrcid(Author a) {

        return a.getPidList().stream()

                .filter(p -> p.getKey().equalsIgnoreCase("orcid"))

                .map(KeyValue::getValue)

                .collect(Collectors.toList());

    }

    private void countPids(Map<String, Integer> pidTypes, Author a) {

        a.getPidList().stream()

                .collect(groupingBy(KeyValue::getKey, summingInt(e -> 1)))

                .forEach((k, v) -> pidTypes.merge(k, v, (v1, v2) -> v1 + v2));

    }

    private static StringMap<Object> fixRank(final StringMap<Object> j) {

        final StringMap<Object> m = new StringMap<>();

        m.putAll(j);

        Object rank = j.get("rank");

        rank = StringUtils.substringBefore(rank.toString(), ".0");

        m.put("rank", Integer.parseInt(rank.toString()));

        return m;

    }

    private static List<Author> asAuthors(Object o) {

        final JsonElement json = new Gson().toJsonTree(o);

        return StreamSupport.stream(json.getAsJsonArray().spliterator(), false)

                .map(j -> j.toString())

                .filter(Objects::nonNull)

                .map(AbstractAuthorMergerTest::asAuthor)

                .filter(Objects::nonNull)

                .collect(toList());

    }

    private static Author asAuthor(String json) {

        final Author.Builder a = Author.newBuilder();

        try {

            JsonFormat.merge(json, a);

        } catch (JsonFormat.ParseException e) {

            throw new IllegalArgumentException(e);

        }

        return a.build();

    }

}

package eu.dnetlib.data.transform;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import java.io.IOException;

import java.io.StringWriter;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.solr.common.SolrInputDocument;

import org.apache.solr.common.SolrInputField;

import org.dom4j.DocumentException;

import org.junit.Before;

import org.junit.Test;

import com.google.protobuf.InvalidProtocolBufferException;

import com.googlecode.protobuf.format.JsonFormat;

import eu.dnetlib.data.mapreduce.util.OafTest;

import eu.dnetlib.data.proto.KindProtos.Kind;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.functionality.index.solr.feed.InputDocumentFactory;

public class SolrProtoMapperTest {