D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/cnr-misc-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": "cnr-misc-utils"}

package eu.dnetlib.miscutils.maps;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import org.junit.Before;

import org.junit.Test;

import eu.dnetlib.miscutils.maps.ConcurrentSizedMap;

public class ConcurrentSizedMapTest {

	private ConcurrentSizedMap<String, String> map;

	private int size = 2;

	@Before

	public void setUp() throws Exception {

		map = new ConcurrentSizedMap<String, String>();

		map.setQueueSize(size);

	}

	@Test

	public void testMap() throws InterruptedException {

		map.put("a", "value a");

		assertNotNull((map.get("a")));

		map.put("b", "value b");

		assertNotNull((map.get("b")));

		map.put("c", "value c");

		assertNotNull((map.get("c")));

		assertEquals(size, map.size());

		assertNull(map.get("a"));

		map.put("a", "new value a");

		assertEquals("new value a", map.get("a"));

		assertEquals(size, map.size());

	}

}

package eu.dnetlib.miscutils.functional.xml;

import static org.junit.Assert.*;

import java.io.IOException;

import javax.xml.transform.TransformerFactory;

import org.apache.commons.io.IOUtils;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.runners.MockitoJUnit44Runner;

import org.springframework.core.io.ClassPathResource;

@RunWith(MockitoJUnit44Runner.class)

public class ApplyXsltTest {

	TransformerFactory tf = TransformerFactory.newInstance();

	private static final Class<?> transformerClass =  net.sf.saxon.TransformerFactoryImpl.class;

	@Test

	public void testTransformerFactoryType() {

		assertEquals(tf.getClass(), transformerClass);

	}

	@Test

	public void applyXslt() throws IOException {

		String record = IOUtils.toString((new ClassPathResource("/eu/dnetlib/miscutils/functional/xml/sampleRecord.xml")).getInputStream());

		String layout = IOUtils.toString((new ClassPathResource("/eu/dnetlib/miscutils/functional/xml/sampleIndexLayout.xml")).getInputStream());

		String indexXsltOfXslt = IOUtils.toString((new ClassPathResource("/eu/dnetlib/miscutils/functional/xml/layoutToRecordStylesheet.xsl")).getInputStream());

		ApplyXslt applyXslt = new ApplyXslt(IOUtils.toString((new ClassPathResource("/eu/dnetlib/miscutils/functional/xml/recordStylesheet.xsl")).getInputStream()));

		ApplyXslt xslt1 = new ApplyXslt(indexXsltOfXslt);

		String indexXslt = xslt1.evaluate(layout);

		ApplyXslt xslt2 = new ApplyXslt(indexXslt);

		String response = xslt2.evaluate(record);

		System.out.println(response);

	}

}

package eu.dnetlib.miscutils.functional.xml;

import static org.junit.Assert.assertEquals;

import java.io.StringReader;

import java.io.StringWriter;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.stream.StreamResult;

import javax.xml.transform.stream.StreamSource;

import org.dom4j.Document;

import org.dom4j.io.SAXReader;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.runners.MockitoJUnit44Runner;

@RunWith(MockitoJUnit44Runner.class)

public class dnetFunctionsTest {

	private static final String XSLT = 

		"<?xml version='1.0' encoding='UTF-8'?>" + 

		"<xsl:stylesheet version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:dnet='eu.dnetlib.miscutils.functional.xml.DnetXsltFunctions'>" +

        "<xsl:template match='/'>" +

		"   <OUTS>" +

        "      <OUTPUT decade='{dnet:decade(//INPUT/DATE)}' />" +

        "      <OUTPUT year='{dnet:extractYear(//INPUT/DATE)}' />" +

        "   </OUTS>" +

        "</xsl:template>" +

        "</xsl:stylesheet>";

	private Transformer transformer;

	@Before

	public void setUp() {

		try {

			transformer = TransformerFactory.newInstance().newTransformer(new StreamSource(new StringReader(XSLT)));

		} catch (Exception e) {

			System.out.println("**** INITIALIZATION FAILED ****");

		}

	}

	@Test

	public void testDecade_1() throws Exception {

		assertEquals("1980-1989", process("primi anni 80", "decade"));

	}

	@Test

	public void testDecade_2() throws Exception {

		assertEquals("2000-2009", process("04-05-2007", "decade"));

	}

	@Test

	public void testDecade_3() throws Exception {

		assertEquals("1960-1969", process("1964", "decade"));

	}

	@Test

	public void testDecade_4() throws Exception {

		assertEquals("n/a", process("XXXXXXXXXXXX", "decade"));

	}

	@Test

	public void testDecade_5() throws Exception {

		assertEquals("1880-1889", process("    1887-01-01    ", "decade"));

	}

	@Test

	public void testDecade_6() throws Exception {

		assertEquals("1880-1889", process("\n\n    1887-01-01    \n\n", "decade"));

	}

	@Test

	public void testDecade_7() throws Exception {

		assertEquals("1840-1849", process("   1840-03-05   ", "decade"));

	}

	@Test

	public void testYear_1() throws Exception {

		assertEquals("1840", process("1840-03-05", "year"));

	}

	@Test

	public void testYear_2() throws Exception {

		assertEquals("1840", process("1840/03/05", "year"));

	}

	private String process(String s, String attr) throws Exception {

		String xml = "<INPUT><DATE>" + s + "</DATE></INPUT>";

		StringWriter strw = new StringWriter();

		transformer.transform(new StreamSource(new StringReader(xml)), new StreamResult(strw));

		Document document = (new SAXReader()).read(new StringReader((strw.toString())));

		System.out.println(document.asXML());

		String res = document.valueOf("/OUTS/OUTPUT/@" + attr);

		System.out.println(s + " --> " + res);

		return res;

	}

}

package eu.dnetlib.miscutils.functional.xml;

import org.junit.Before;

import org.junit.Test;

public class IndentXmlStringTest {

	@Before

	public void setUp() throws Exception {

	}

	@Test

	public void testEvaluate() {

		String indented = new IndentXmlString().evaluate("<root><a/></root>");

		System.out.println(indented);

	}

}

package eu.dnetlib.miscutils.functional;

import eu.dnetlib.miscutils.functional.UnaryFunction;

public class UnsafeUnaryFunction implements UnaryFunction<String, Integer> {

	@Override

	public String evaluate(Integer arg) {

		return String.valueOf(arg);

	}

}

package eu.dnetlib.miscutils.functional.string;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringWriter;

import org.apache.commons.io.IOUtils;

import org.junit.Test;

public class EscapeUnescapeTest {

	@Test

	public void testEscape() throws IOException {

		String xml = getRecord();

		System.out.println(xml);

		System.out.println("##############");

		String escaped = new EscapeHtml().evaluate(xml);

		System.out.println(escaped);

		String unescaped = new UnescapeHtml().evaluate(escaped);

		System.out.println("##############");

		System.out.println(unescaped);

	}

	private String getRecord() throws IOException {

		InputStream is = getClass().getResourceAsStream("record.xml");

		StringWriter sw = new StringWriter();

		IOUtils.copy(is, sw);

		return sw.toString();

	}

}

package eu.dnetlib.miscutils.functional.string;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import java.io.StringWriter;

import org.apache.commons.io.IOUtils;

import org.junit.Test;

public class SanitizerTest {

	@Test

	public void testIdentity() {

		verifyIdentity("+-@°#()!$%&/()?' ");

		verifyIdentity("asça");

		verifyIdentity("qwéèrtç°§");

		verifyIdentity("AÁaáCĆcćEÉeéIÍiíLĹlĺNŃnńOÓoóRŔrŕSŚsśUÚuúYÝyýZŹzź");

		verifyIdentity("AÂaâCĈcĉEÊeêGĜgĝHĤhĥIÎiîJĴjĵOÔoôSŜsŝUÛuûWŴwŵYŶyŷ");

		verifyIdentity("CÇcçGĢgģKĶkķLĻlļNŅnņRŖrŗSŞsşTŢtţ");

		verifyIdentity("ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩΆΈΉΊΌΎΏΪΫαβγδεζηθικλμνξοπρσςτυφχψωάέήίόύώΐΰ");

		verifyIdentity("АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ");

		verifyIdentity("абвгдеёжзийклмнопрстуфхцчшщъыьэюя");

		verifyIdentity("ـآ آ   ـا ا   بـبـب ب   تـتـت ت   ثـثـث ث   جـجـج ج   حـحـح ح   خـخـخ خ   ـد د   ـذ ذ   ـر ر   ـز ز   سـسـس س"); 

	}

	@Test

	public void testInvalid() throws Exception {

		StringWriter sw = new StringWriter();

		IOUtils.copy(getClass().getResourceAsStream("invalid.txt"), sw); 

		String pre = sw.toString();

		String post = Sanitizer.sanitize(pre); 

		assertFalse(pre.equals(post));	

	}

	private void verifyIdentity(String s) {

		assertEquals(s, Sanitizer.sanitize(s));

	}

}

package eu.dnetlib.miscutils.functional;

import static org.junit.Assert.*; // NOPMD

import org.junit.Test;

public class CompositeUnaryFunctionTest  {

	@Test

	public void testOf() {

		final UnaryFunction<String, Integer> toStringBase = new UnaryFunction<String, Integer>() { // NOPMD

			@Override

			public String evaluate(final Integer arg) {

				return arg.toString();

			}

		};

		final UnaryFunction<Integer, String> fromStringBase = new UnaryFunction<Integer, String>() {

			@Override

			public Integer evaluate(final String arg) {

				return Integer.decode(arg);

			}

		};

		final CompositeUnaryFunction<String, Integer> toString = new CompositeUnaryFunction<String, Integer>(toStringBase);

		final CompositeUnaryFunction<Integer, String> fromString = new CompositeUnaryFunction<Integer, String>(fromStringBase);

		assertEquals("evaluation", toString.evaluate(10), "10");

		assertEquals("evaluation", fromString.evaluate("10"), (Integer) 10);

		final UnaryFunction<String, String> stringIdentity = toString.of(fromString);

		final UnaryFunction<Integer, Integer> integerIdentity = fromString.of(toString);

		final UnaryFunction<Integer, Integer> integerIdentity2 = fromString.of(stringIdentity).of(toString).of(integerIdentity);

		assertEquals("string evaluation", stringIdentity.evaluate("10"), "10");

		assertEquals("integer evaluation", integerIdentity.evaluate(10), (Integer) 10);

		assertEquals("integer identity", integerIdentity2.evaluate(10), (Integer) 10);

	}

	private transient int calls;

	private transient final static int TIMES = 100;

	@Test

	public void testRecursive() {

		calls = 0;

		final UnaryFunction<Integer, Integer> incrementBase = new UnaryFunction<Integer, Integer>() { // NOPMD

			@Override

			public Integer evaluate(final Integer arg) {

				calls++;

				return arg + 1;

			}

		};

		final CompositeUnaryFunction<Integer, Integer> increment = new CompositeUnaryFunction<Integer, Integer>(incrementBase);

		CompositeUnaryFunction<Integer, Integer> comp = increment;

		for (int i = 1; i <= 100; i++) {

			assertEquals("compare", comp.evaluate(0), (Integer) i);

			comp = comp.of(increment);

		}

		assertEquals("number of calls", calls, (TIMES * (TIMES + 1) / 2));

	}

	@Test

	public void testCurry() {

		final UnaryFunction<UnaryFunction<Integer, Integer>, Integer> add = new UnaryFunction<UnaryFunction<Integer, Integer>, Integer>() { // NOPMD

			@Override

			public UnaryFunction<Integer, Integer> evaluate(final Integer arg) {

				return new UnaryFunction<Integer, Integer>() {

					@Override

					public Integer evaluate(final Integer brg) {

						return arg + brg;

					}

				};

			}

		};

		final UnaryFunction<Integer, Integer> increment = add.evaluate(1);

		assertEquals("check add", add.evaluate(1).evaluate(2), (Integer) 3);

		assertEquals("check increment", increment.evaluate(1), (Integer) 2);

	}

}

package eu.dnetlib.miscutils.functional;

import static org.junit.Assert.*;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import org.junit.Before;

import org.junit.Test;

import eu.dnetlib.miscutils.functional.ThreadSafeUnaryFunction;

import eu.dnetlib.miscutils.functional.UnaryFunction;

public class ThreadSafeUnaryFunctionTest {

	/**

	 * Object under test.

	 */

	private ThreadSafeUnaryFunction<String, Integer> tsUnaryFunction;

	private final static int N_THREAD = 10;

	private ExecutorService executor;

	@Before

	public void setUp() {

		executor = Executors.newFixedThreadPool(N_THREAD);

	}

	/**

	 * method creates N_THREAD threads such that each one performs a function.evaluate call

	 * @param function

	 */

	private void createThreads(final ThreadSafeUnaryFunction<String, Integer> function) {

		for (int i = 0; i < N_THREAD; i++) {

			final Integer j = i;

			executor.execute(new Runnable() {

				@Override

				public void run() {

					assertEquals(String.valueOf(j), function.evaluate(j));

				}

			});

		}	

	}	

	@Test

	public void testThreadSafeUnaryFunction_1() {

		tsUnaryFunction = new ThreadSafeUnaryFunction<String, Integer>(new ThreadLocal<UnaryFunction<String, Integer>>() {

		    @Override

			protected synchronized UnaryFunction<String, Integer> initialValue() {

		    	return new UnsafeUnaryFunction();

		    }

		});

		createThreads(tsUnaryFunction);			

	}

}

package eu.dnetlib.miscutils.hstree;

import static org.junit.Assert.*; // NOPMD

import org.junit.Before;

import org.junit.Test;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

import eu.dnetlib.miscutils.hstree.sample.tree.FirstChild;

import eu.dnetlib.miscutils.hstree.sample.tree.MyComputingVisitor;

import eu.dnetlib.miscutils.hstree.sample.tree.MyLoggingVisitor;

import eu.dnetlib.miscutils.hstree.sample.tree.MyTreeNode;

import eu.dnetlib.miscutils.hstree.sample.tree.MyTreeVisitor;

import eu.dnetlib.miscutils.hstree.sample.tree.RootTree;

public class VisitorTest {

	transient RootTree root = null;

	transient MyTreeVisitor loggingVisitor = null;

	transient MyComputingVisitor computingVisitor = null;

	@Before

	public void setUp() throws Exception {

		root = new RootTree(new SampleResource());

		root.addChild(new ChildResource()).appendChild(new SubResource()).appendChild(new SubResource()).addChild(new SubResource());

		loggingVisitor = new MyLoggingVisitor();

		computingVisitor = new MyComputingVisitor();

	}

	@Test

	public void testVisit() {

		final MyTreeNode<SampleResource, ChildResource, FirstChild> root = new RootTree(new SampleResource());

		assertNotNull("exists", root);

		final FirstChild ch1 = root.addChild(new ChildResource());

		ch1.addChild(new SubResource());

		ch1.addChild(new SubResource());

		final FirstChild ch2 = root.addChild(new ChildResource());

		ch2.addChild(new SubResource());

		ch2.addChild(new SubResource());

		ch2.addChild(new SubResource());

		root.breadthFirst(loggingVisitor);

	}

	@Test

	public void testVisit2() {

		final MyTreeNode<SampleResource, ChildResource, FirstChild> root = new RootTree(new SampleResource());

		assertNotNull("exists", root);

		root.addChild(new ChildResource()).appendChild(new SubResource()).appendChild(new SubResource()).addChild(new SubResource());

		root.appendChild(new ChildResource()).appendChild(new ChildResource()).appendChild(new ChildResource()).addChild(new ChildResource()).addChild(

				new SubResource());

		root.breadthFirst(loggingVisitor);

	}

	@Test

	public void testVisit3() {

		final MyTreeNode<SampleResource, ChildResource, FirstChild> root = new RootTree(new SampleResource());

		assertNotNull("exists", root);

		root.addChild(new ChildResource()).appendChild(new SubResource()).appendChild(new SubResource()).addChild(new SubResource());

		root.appendChild(new ChildResource()).appendChild(new ChildResource()).appendChild(new ChildResource()).addChild(new ChildResource()).addChild(

				new SubResource());

		root.depthFirst(loggingVisitor);

	}

	@Test

	public void testMyVisitor() {

		assertNotNull("dummy", root);

		root.accept(loggingVisitor);

		root.getChildren().get(0).accept(loggingVisitor);

	}

	@Test

	public void testComputingVisitor() {

		assertNotNull("dummy", root);

		root.breadthFirst(computingVisitor);

		assertEquals("check count", 113, computingVisitor.getCount());

	}

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import eu.dnetlib.miscutils.hstree.NilTreeNode;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

public class SecondChild extends MyTreeNode<SubResource, Void, NilTreeNode<MyTreeVisitor>> {

	@Override

	public void accept(final MyTreeVisitor visitor) {

		visitor.visit(getResource());

	}

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

public class RootTree extends MyTreeNode<SampleResource, ChildResource, FirstChild> {

	public RootTree(final SampleResource resource) {

		super(resource);

	}

	@Override

	public void accept(final MyTreeVisitor visitor) {

		visitor.visit(getResource());

	}

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

public interface MyTreeVisitor {

	void visit(SampleResource resource);

	void visit(ChildResource resource);

	void visit(SubResource resource);

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

public class FirstChild extends MyTreeNode<ChildResource, SubResource, SecondChild> {

	@Override

	public void accept(final MyTreeVisitor visitor) {

		visitor.visit(getResource());

	}

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

public class MyComputingVisitor implements MyTreeVisitor {

	private static final Log log = LogFactory.getLog(MyComputingVisitor.class); // NOPMD by marko on 11/24/08 5:02 PM

	int count;

	@Override

	public void visit(final SampleResource resource) {

		log.info("increasing sampleresource");

		count += 100;

	}

	@Override

	public void visit(final ChildResource resource) {

		log.info("increasing childresource");

		count += 10;

	}

	@Override

	public void visit(final SubResource resource) {

		log.info("increasing subresource");

		count += 1;

	}

	public int getCount() {

		return count;

	}

	public void setCount(final int count) {

		this.count = count;

	}

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import eu.dnetlib.miscutils.hstree.TreeNode;

public class MyTreeNode<T, N, C extends TreeNode<N, ?, MyTreeVisitor, ?>> extends TreeNode<T, N, MyTreeVisitor, C> {

	public MyTreeNode() {

		// no action

	}

	public MyTreeNode(final T resource) {

		super(resource);

	}

}

package eu.dnetlib.miscutils.hstree.sample.tree;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

public class MyLoggingVisitor implements MyTreeVisitor {

	private static final Log log = LogFactory.getLog(MyLoggingVisitor.class); // NOPMD by marko on 11/24/08 5:02 PM

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * eu.rinfrastructures.genericstest.sample.wrongtree.MyTreeVisitor#visit(eu.rinfrastructures.genericstest.sample

	 * .resources.SampleResource)

	 */

	@Override

	public void visit(final SampleResource resource) {

		log.info("sample");

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * eu.rinfrastructures.genericstest.sample.wrongtree.MyTreeVisitor#visit(eu.rinfrastructures.genericstest.sample

	 * .resources.ChildResource)

	 */

	@Override

	public void visit(final ChildResource resource) {

		log.info("child");

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * eu.rinfrastructures.genericstest.sample.wrongtree.MyTreeVisitor#visit(eu.rinfrastructures.genericstest.sample

	 * .resources.SubResource)

	 */

	@Override

	public void visit(final SubResource resource) {

		log.info("sub");

	}

}

package eu.dnetlib.miscutils.hstree.sample.resources;

public class SubResource extends Resource { // NOPMD

}

package eu.dnetlib.miscutils.hstree.sample.resources;

public class Resource { // NOPMD

}

package eu.dnetlib.miscutils.hstree.sample.resources;

public class SampleResource extends Resource { // NOPMD

}

package eu.dnetlib.miscutils.hstree.sample.resources;

public class ChildResource extends Resource { // NOPMD

}

package eu.dnetlib.miscutils.hstree.sample.wrongtree;

import eu.dnetlib.miscutils.hstree.TreeNode;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.tree.MyLoggingVisitor;

public class WrongRootTree extends TreeNode<SampleResource, ChildResource, MyLoggingVisitor, WrongFirstChild> {

	public WrongRootTree(final SampleResource resource) {

		super(resource);

	}

}

package eu.dnetlib.miscutils.hstree.sample.wrongtree;

import eu.dnetlib.miscutils.hstree.TreeNode;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

import eu.dnetlib.miscutils.hstree.sample.tree.MyLoggingVisitor;

public class WrongFirstChild extends TreeNode<ChildResource, SubResource, MyLoggingVisitor, WrongSecondChild> { // NOPMD

}

package eu.dnetlib.miscutils.hstree.sample.wrongtree;

import eu.dnetlib.miscutils.hstree.NilTreeNode;

import eu.dnetlib.miscutils.hstree.TreeNode;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

import eu.dnetlib.miscutils.hstree.sample.tree.MyLoggingVisitor;

public class WrongSecondChild extends TreeNode<SubResource, Void, MyLoggingVisitor, NilTreeNode<MyLoggingVisitor>> { // NOPMD

}

package eu.dnetlib.miscutils.hstree;

import static org.junit.Assert.assertTrue;

import org.junit.Test;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

import eu.dnetlib.miscutils.hstree.sample.wrongtree.WrongFirstChild;

import eu.dnetlib.miscutils.hstree.sample.wrongtree.WrongRootTree;

import eu.dnetlib.miscutils.hstree.sample.wrongtree.WrongSecondChild;

public class WrongTreeNodeTest {

	/**

	 * Try to break/misalign the signatures of the 'sample.wrongtree' package. The code should not be able to compile.

	 */

	@Test

	public void simpleTest() {

		final WrongRootTree root = new WrongRootTree(new SampleResource());

		final WrongFirstChild ch1 = root.addChild(new ChildResource());

		ch1.addChild(new SubResource());

		ch1.addChild(new SubResource());

		final WrongFirstChild ch2 = root.addChild(new ChildResource());

		ch2.addChild(new SubResource());

		ch2.addChild(new SubResource());

		final WrongSecondChild sc1 = ch2.addChild(new SubResource());

		// of course we can do obscene things like this,

		// but if somebody casts there is no escape.

		boolean gotRuntimeEx = false; // NOPMD

		try {

			sc1.addChild((Void) null);

		} catch (RuntimeException e) {

			if (e.getMessage().equals(TreeNode.CHILDR_UNDER_LEAF))

				gotRuntimeEx = true;

		}

		assertTrue("got exception", gotRuntimeEx); // TODO: exploit junit4 for checking exceptions

	}

}

package eu.dnetlib.miscutils.hstree;

import static org.junit.Assert.assertNotNull;

import org.junit.Test;

import eu.dnetlib.miscutils.hstree.sample.resources.ChildResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SampleResource;

import eu.dnetlib.miscutils.hstree.sample.resources.SubResource;

import eu.dnetlib.miscutils.hstree.sample.tree.FirstChild;

import eu.dnetlib.miscutils.hstree.sample.tree.MyTreeNode;

import eu.dnetlib.miscutils.hstree.sample.tree.RootTree;

public class TreeNodeTest {

	private static final String EXISTS = "exists";

	/**

	 * This test simply shows how to create a statically checked tree. The tree grammar for this test is defined in

	 * package eu.rinfrastructures.genericstest.sample.tree and it contains resource payloads defined in package

	 * eu.rinfrastructures.genericstest.sample.resources

	 */

	@Test

	public void simpleTest() {

		final MyTreeNode<SampleResource, ChildResource, FirstChild> root = new RootTree(new SampleResource());

		final FirstChild ch1 = root.addChild(new ChildResource());

		assertNotNull(EXISTS, ch1);

		ch1.addChild(new SubResource());

		ch1.addChild(new SubResource());

		final FirstChild ch2 = root.addChild(new ChildResource());

		assertNotNull(EXISTS, ch2);

		ch2.addChild(new SubResource());

		ch2.addChild(new SubResource());

		ch2.addChild(new SubResource());

	}

	@Test

	public void typeSafeness() {

		final MyTreeNode<SampleResource, ChildResource, FirstChild> root = new RootTree(new SampleResource());

		final FirstChild ch1 = root.addChild(new ChildResource());

		assertNotNull(EXISTS, ch1);

		ch1.addChild(new SubResource());

		// ILLEGAL:

		//c1.addChild(new SampleResource());

	}

	@Test

	public void cascade() {

		final MyTreeNode<SampleResource, ChildResource, FirstChild> root = new RootTree(new SampleResource());

		assertNotNull(EXISTS, root);

		root.addChild(new ChildResource()).appendChild(new SubResource()).appendChild(new SubResource()).addChild(new SubResource());

	}

}

package eu.dnetlib.miscutils.datetime;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class DateUtilsTest {

	private final DateUtils dateUtils = new DateUtils();

	@Test

	public void testGetDuration() {

		String theDate = "1900-01-01T00:13:57";

		String duration = dateUtils.getDuration(theDate);

		assertEquals("00:13:57", duration);

	}

}

package eu.dnetlib.miscutils.iterators.xml;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.zip.GZIPInputStream;

import java.util.zip.ZipInputStream;

import org.apache.commons.io.IOUtils;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.io.SAXReader;

import org.junit.Before;

import org.junit.Test;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

public class IterableXmlParserTest {

	private Resource xmlZip = new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/opendoar.zip");

	private Resource xmlGz = new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/opendoar.xml.gz");

	private Resource xmlZipErr = new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/opendoarErr.zip");

	private Resource xmlSingle = new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/singleRepo.xml");

	private String element = "repository";

	private IterableXmlParser parser;

	private SAXReader reader;

	@Before

	public void setUp() throws Exception {

		reader = new SAXReader();

	}

	@Test

	public void testGz() throws Exception {

		doTest(new GZIPInputStream(xmlGz.getInputStream()), element);

	}

	@Test

	public void test() throws Exception {

		doTest(read(new ZipInputStream(xmlZip.getInputStream())), element);

	}

	@Test

	public void testErr() throws Exception {

		doTest(read(new ZipInputStream(xmlZipErr.getInputStream())), element);

	}

	@Test

	public void testSingle() throws Exception {

		doTest(xmlSingle.getInputStream(), element);

	}

	@Test

	public void testOaiRecord() throws Exception {

		int count = doTest(new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/oaiRecord.xml").getInputStream(), "record");

		assertTrue(count == 1);

	}

	@Test

	public void testWeird() throws Exception {

		int count = doTest(new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/weirdRecords.xml").getInputStream(), "record");

		assertTrue(count == 3);

	}

	@Test

	public void testWeirdGz() throws Exception {

		int count = doTest(new GZIPInputStream(new ClassPathResource("eu/dnetlib/miscutils/iterators/xml/weirdRecords.xml.gz").getInputStream()), "record");

		assertTrue(count == 3);

	}

	private int doTest(final InputStream stream, final String element) throws DocumentException {

		parser = new IterableXmlParser(element, stream);

		int count = 0;

		for (String xml : parser) {

			System.out.println(xml);

			Document doc = reader.read(new StringReader(xml));

			assertNotNull(doc);

			assertNotNull(doc.selectSingleNode("//" + element));

			count++;

		}

		return count;

	}

	// helper method, reads the compressed text out of the xmlZip file

	private InputStream read(final ZipInputStream zis) throws IOException {

		final StringWriter sw = new StringWriter();

		while (zis.getNextEntry() != null) {

			byte[] buffer = new byte[1];

			while (zis.read(buffer) != -1) {

				IOUtils.write(buffer, sw, "UTF-8");

			}

		}

		zis.close();

		sw.close();

		return new ByteArrayInputStream(sw.toString().getBytes());

	}

}

/**

 * 

 */

package eu.dnetlib.miscutils.dom4j;

import static org.junit.Assert.assertEquals;

import java.io.StringReader;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import org.junit.Test;

/**

 * @author marko

 * 

 */

public class XPathHelperTest {

	/**

	 * Test method for {@link eu.dnetlib.miscutils.dom4j.XPathHelper#selectElements(org.dom4j.Node, java.lang.String)}.

	 * 

	 * @throws DocumentException

	 */

	@Test

	public void testSelectElements() throws DocumentException {

		final String xmlSource = "<root><child/>xxxx<child/>xxxx</root>";

		final Document document = new SAXReader().read(new StringReader(xmlSource));

		for (Element el : XPathHelper.selectElements(document, "//child")) {

			assertEquals("check elements", el.asXML(), "<child/>");

		}

	}

}

package eu.dnetlib.miscutils.collections;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;

import java.util.List;

import org.junit.Test;

import eu.dnetlib.miscutils.functional.UnaryFunction;

public class MappedCollectionTest {

	@Test

	public void testIterator() {

		final List<Integer> list = new ArrayList<Integer>();

		list.add(100);

		final MappedCollection<String, Integer> mapped = new MappedCollection<String, Integer>(list, new UnaryFunction<String, Integer>() { //NOPMD

			@Override

			public String evaluate(final Integer arg) {

				return arg.toString();

			}

		});

		for (String el : mapped)

			assertEquals("check array", el, "100");

	}

}

package eu.dnetlib.miscutils.collections;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;

import java.util.List;

import org.junit.Test;

public class AffixCollectionTest {

	@Test

	public void testIterator() {

		final List<String> list = new ArrayList<String>();

		list.add("100");

		final AffixCollection mapped = new AffixCollection(list, "_test");

		for (String el : mapped)

			assertEquals("check array", "100_test", el);

	}

}

package eu.dnetlib.miscutils.collections;

import static org.junit.Assert.assertTrue;

import java.util.ArrayList;

import java.util.List;

import org.junit.Test;

import eu.dnetlib.miscutils.functional.CompositeUnaryFunction;

import eu.dnetlib.miscutils.functional.UnaryFunction;

public class FilteredCollectionTest {

	@Test

	public void testFilterComposition() {

		final List<Integer> list = new ArrayList<Integer>();

		list.add(1);

		list.add(4);

		list.add(8);

		final Filter<Integer> fi1 = new Filter<Integer>() { // NOPMD

			@Override

			public Boolean evaluate(final Integer arg) {

				return arg < 8;

			}

		};

		final UnaryFunction<Integer, Integer> square = new UnaryFunction<Integer, Integer>() {

			@Override

			public Integer evaluate(final Integer arg) {

				return arg * arg;

			}

		};

		final FilteredCollection<Integer> fic = new FilteredCollection<Integer>(list, fi1);

		for (Integer el : fic)

			assertTrue("check array", el < 8);

		final CompositeUnaryFunction<Boolean, Integer> cf1 = new CompositeUnaryFunction<Boolean, Integer>(fi1);

		final FilteredCollection<Integer> fc2 = new FilteredCollection<Integer>(list, cf1.of(square));

		for (Integer el : fc2)

			assertTrue("check array", el < 8);

	}

}

package eu.dnetlib.miscutils.collections;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.List;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

import org.junit.Test;

import static org.junit.Assert.*; // NOPMD

public class TypeFilteredCollectionTest {

	private void checkContainsTestString(final Iterable<String> iter) {

		int count = 0; // NOPMD

		for (String el : iter) {

			assertEquals("check array", el, "test");

			count++; // NOPMD

		}

		assertEquals("check count", count, 1);

	}

	@Test

	public void testFilter() {

		final List<Object> list = new ArrayList<Object>();

		list.add(1);

		list.add("test");

		final TypeFilteredCollection<Object, String> tfc;

		tfc = new TypeFilteredCollection<Object, String>(list, String.class);

		checkContainsTestString(tfc);

	}

	@Test

	public void testNull() {

		final List<Object> list = new ArrayList<Object>();

		assertNotNull("dummy", list);

		list.add(null);

		list.add("test");

		final TypeFilteredCollection<Object, String> tfc;

		tfc = new TypeFilteredCollection<Object, String>(list, String.class);

		checkContainsTestString(tfc);

	}

	@Test

	public void testJDom() throws DocumentException {

		final String xmlSource = "<root><child/>xxxx<child/>xxxx</root>";

		final Document document = new SAXReader().read(new StringReader(xmlSource));

		@SuppressWarnings("unchecked")

		final List<Node> children = document.selectNodes("//child");

		final TypeFilteredCollection<Node, Element> tfc;

		tfc = new TypeFilteredCollection<Node, Element>(children, Element.class);

		for (Element el : tfc) {

			assertEquals("check array", el.asXML(), "<child/>");

		}

	}

}

/**

 * 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 3 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, see <http://www.gnu.org/licenses/>.

 */

package eu.dnetlib.miscutils.collections;

import static org.junit.Assert.assertArrayEquals;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotSame;

import static org.junit.Assert.assertSame;

import static org.junit.Assert.assertTrue;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.UUID;

import org.junit.Test;

/**

 * Tests for BloomFilter.java

 *

 * @author Magnus Skjegstad <magnus@skjegstad.com>

 */

public class BloomFilterTest {

    static Random r = new Random();

    @Test

    public void testConstructorCNK() throws Exception {

        System.out.println("BloomFilter(c,n,k)");

        for (int i = 0; i < 10000; i++) {

            double c = r.nextInt(20) + 1;

            int n = r.nextInt(10000) + 1;

            int k = r.nextInt(20) + 1;

            BloomFilter<?> bf = new BloomFilter<Object>(c, n, k);

            assertEquals(bf.getK(), k);

            assertEquals(bf.getExpectedBitsPerElement(), c, 0);

            assertEquals(bf.getExpectedNumberOfElements(), n);

            assertEquals(bf.size(), c*n, 0);

        }

    }

    /**

     * Test of createHash method, of class BloomFilter.

     * @throws Exception

     */

    @Test

    public void testCreateHash_String() throws Exception {

        System.out.println("createHash");

        String val = UUID.randomUUID().toString();

        int result1 = BloomFilter.createHash(val);

        int result2 = BloomFilter.createHash(val);

        assertEquals(result2, result1);

        int result3 = BloomFilter.createHash(UUID.randomUUID().toString());

        assertNotSame(result3, result2);

        int result4 = BloomFilter.createHash(val.getBytes("UTF-8"));

        assertEquals(result4, result1);

    }

    /**

     * Test of createHash method, of class BloomFilter.

     * @throws UnsupportedEncodingException

     */

    @Test

    public void testCreateHash_byteArr() throws UnsupportedEncodingException {

        System.out.println("createHash");

        String val = UUID.randomUUID().toString();

        byte[] data = val.getBytes("UTF-8");

        int result1 = BloomFilter.createHash(data);

        int result2 = BloomFilter.createHash(val);

        assertEquals(result1, result2);

    }

    /**

     * Test of createHash method, of class BloomFilter.

     * @throws UnsupportedEncodingException

     */

    @Test

    public void testCreateHashes_byteArr() throws UnsupportedEncodingException {

        System.out.println("createHashes");

        String val = UUID.randomUUID().toString();

        byte[] data = val.getBytes("UTF-8");

        int[] result1 = BloomFilter.createHashes(data, 10);

        int[] result2 = BloomFilter.createHashes(data, 10);

        assertEquals(result1.length, 10);

        assertEquals(result2.length, 10);

        assertArrayEquals(result1, result2);

        int[] result3 = BloomFilter.createHashes(data, 5);

        assertEquals(result3.length, 5);

        for (int i = 0; i < result3.length; i++)

            assertEquals(result3[i], result1[i]);

    }

    /**

     * Test of equals method, of class BloomFilter.

     * @throws UnsupportedEncodingException

     */

    @Test

    public void testEquals() throws UnsupportedEncodingException {

        System.out.println("equals");

        BloomFilter<String> instance1 = new BloomFilter<String>(1000, 100);

        BloomFilter<String> instance2 = new BloomFilter<String>(1000, 100);

        for (int i = 0; i < 100; i++) {

            String val = UUID.randomUUID().toString();

            instance1.add(val);

            instance2.add(val);

        }

        assert(instance1.equals(instance2));

        assert(instance2.equals(instance1));

        instance1.add("Another entry"); // make instance1 and instance2 different before clearing

        instance1.clear();

        instance2.clear();

        assert(instance1.equals(instance2));