D-Net

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

package eu.dnetlib.springutils.aop;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class SimpleBean {

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

	private boolean initialized = false;

	public void init() {

		log.info("initialized");

		System.out.println("initialized");

		initialized = true;

	}

	public boolean isInitialized() {

		return initialized;

	}

}

package eu.dnetlib.springutils.aop;

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

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock; // NOPMD

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import net.sf.ehcache.Cache;

import net.sf.ehcache.CacheManager;

import net.sf.ehcache.Element;

import org.aopalliance.intercept.MethodInvocation;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

/**

 * test the methodcache AOP interceptor.

 * 

 * @author marko

 * 

 */

public class MethodCacheInterceptorTest {

	private static final String TEST_VALUE = "mockedTestValue";

	private transient CacheManager singletonManager;

	private transient Cache cache;

	private transient MethodInvocation inv;

	private transient MethodInvocation invArgs;

	private transient MethodCacheInterceptor inter;

	@Before

	public void setUp() throws Throwable {

		singletonManager = CacheManager.create();

		singletonManager.addCache("testCache");

		cache = singletonManager.getCache("testCache");

		inter = new MethodCacheInterceptor();

		inter.setCache(cache);

		final MethodCacheInterceptorTest _this = mock(MethodCacheInterceptorTest.class);

		inv = mock(MethodInvocation.class);

		final Method method = MethodCacheInterceptorTest.class.getDeclaredMethod("test");

		when(inv.getThis()).thenReturn(_this);

		when(inv.getMethod()).thenReturn(method);

		when(inv.proceed()).thenReturn(TEST_VALUE);

		// second method

		invArgs = mock(MethodInvocation.class);

		final Method methodArgs = MethodCacheInterceptorTest.class.getDeclaredMethod("testWithArgs", String.class);

		when(invArgs.getThis()).thenReturn(_this);

		when(invArgs.getMethod()).thenReturn(methodArgs);

		when(invArgs.getArguments()).thenReturn(new Object[] { "test1" });

		when(invArgs.proceed()).thenReturn("mockedTestValueWithArgs");

	}

	@After

	public void tearDown() throws Exception {

		singletonManager.removeAllCaches();

	}

	@Test

	public void testCache() {

		cache.put(new Element("key", "value"));

		assertEquals("check cache", "value", cache.get("key").getObjectValue());

	}

	@Test

	public void testInterceptor() throws Throwable {

		assertEquals("first invocation", TEST_VALUE, inter.invoke(inv));

		assertEquals("cached invocation", TEST_VALUE, inter.invoke(inv));

		// real method has to be called only once

		verify(inv).proceed();

	}

	@Test

	public void testFlush() throws Throwable {

		assertEquals("first invocation", TEST_VALUE, inter.invoke(inv));

		cache.flush();

		assertEquals("cache not flushed", TEST_VALUE, inter.invoke(inv));

		// since cache is flushed, the method is called twice

		// TODO understand why It fail

		// verify(inv, times(2)).proceed();

	}

	@Test

	public void testWithArguments() throws Throwable {

		assertEquals("first invocation", "mockedTestValueWithArgs", inter.invoke(invArgs));

		assertEquals("cached invocation", "mockedTestValueWithArgs", inter.invoke(invArgs));

		verify(invArgs).proceed();

	}

	/**

	 * This method is only needed because of it's signature.

	 * 

	 * @return dummy

	 */

	public String test() { // NOPMD

		return null;

	}

	/**

	 * This method is only needed because of it's signature.

	 * 

	 * @param arg

	 *            dummy

	 * @return dummy

	 */

	public String testWithArgs(final String arg) { // NOPMD

		return null;

	}

	/**

	 * ensure that the spring lifecycle works.

	 * 

	 * @throws NoSuchMethodException

	 *             reflection

	 * @throws InvocationTargetException

	 *             reflection

	 * @throws IllegalAccessException

	 *             reflection

	 */

	@Test

	public void testAfterPropertiesSet() throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {

		inter.getClass().getMethod("afterPropertiesSet").invoke(inter);

		assertNotNull("dummy", inter);

	}

	/**

	 * test write only.

	 */

	@Test

	public void testSetWriteOnly() {

		assertFalse("getter", inter.isWriteOnly());

		inter.setWriteOnly(true);

		assertTrue("getter", inter.isWriteOnly());

	}

}

package eu.dnetlib.springutils.aop;

import static org.junit.Assert.*;

import javax.annotation.Resource;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

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

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration

public class MethodInvokingInitializerTest {

	@Resource

	private SimpleBean simpleBean;

	@Before

	public void setUp() throws Exception {

	}

	@Test

	public void testStart() {

		assertTrue(simpleBean.isInitialized());

	}

}

package eu.dnetlib.springutils.stringtemplate;

import static org.junit.Assert.assertEquals;

import java.io.StringReader;

import org.junit.Before;

import org.junit.Test;

public class ClassPathStringTemplateGroupTest {

	private ClassPathStringTemplateGroup group;

	private final transient String templates = "group simple;\nvardef(type,name) ::= \"<type> <name>;\""

			+ "method(type,name,args) ::= <<<type> <name>(<args; separator=\",\">) {  <statements; separator=\"\n\">}>>";;

	@Before

	public void setUp() throws Exception {

		group = new ClassPathStringTemplateGroup(new StringReader(templates));

	}

	@Test

	public void testName() {

		group.setPackage("eu.dnetlib");

		assertEquals("check Path", "/eu/dnetlib/pippo.st", group.getFileNameFromTemplateName("pippo"));

		assertEquals("check Path", "pippo", group.getTemplateNameFromFileName("/eu/dnetlib/pippo.st"));

	}

	public ClassPathStringTemplateGroup getGroup() {

		return group;

	}

	public void setGroup(final ClassPathStringTemplateGroup group) {

		this.group = group;

	}

}

package eu.dnetlib.springutils.stringtemplate;

import static org.junit.Assert.*;

import javax.annotation.Resource;

import org.antlr.stringtemplate.StringTemplate;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

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

/**

 * Test a string template factory bean.

 * @author marko

 *

 */

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration

public class StringTemplateFactoryTest {

	@Resource

	private StringTemplate template;

	@Test

	public void testStringTemplate() {

		assertEquals("check template", "test\n", template.toString());

	}

}

package eu.dnetlib.springutils.condbean;

public class TestBean {

	int value;

	public int getValue() {

		return value;

	}

	public void setValue(final int value) {

		this.value = value;

	}

}

package eu.dnetlib.springutils.condbean;

import static org.junit.Assert.assertEquals;

import org.junit.BeforeClass;

import org.junit.Test;

import org.junit.runner.RunWith;

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

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

import org.springframework.test.context.ContextConfiguration;

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

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration

public class ConditionalBeanTest {

	private static final int FIVE = 5;

	private static final int THREE = 3;

	@Autowired

	@Qualifier("elementTest")

	transient TestBean elementBean;

	@Autowired

	@Qualifier("elementTest")

	transient TestBean attributeBean;

	@Autowired

	@Qualifier("elementTest2")

	transient TestBean boolBean1;

	@Autowired

	@Qualifier("elementTest2")

	transient TestBean boolBean2;

	@Autowired

	@Qualifier("elementTest3")

	transient TestBean boolBean3;

	@Autowired

	@Qualifier("elementTest3")

	transient TestBean boolBean4;

	/**

	 * required to be "BeforeClass" because otherwise the spring context will not see it.

	 */

	@BeforeClass

	public static void setProperties() {

		System.setProperty("some.existing.property", "pippo");

	}

	@Test

	public void element() {

		assertEquals("element", 1, elementBean.getValue());

	}

	@Test

	public void attribute() {

		assertEquals("attribute", 1, attributeBean.getValue());

	}

	@Test

	public void bool1() {

		assertEquals("boolean 1", THREE, boolBean1.getValue());

	}

	@Test

	public void bool2() {

		assertEquals("boolean 2", THREE, boolBean2.getValue());

	}

	@Test

	public void bool3() {

		assertEquals("boolean 3", FIVE, boolBean3.getValue());

	}

	@Test

	public void bool4() {

		assertEquals("boolean 4", FIVE, boolBean4.getValue());

	}

}

package eu.dnetlib.springutils.condbean;

import static org.junit.Assert.assertTrue;

import org.junit.Ignore;

import org.junit.Test;

public class JParsecConditionExpressionParserTest {

	transient JParsecConditionExpressionParser parser = new JParsecConditionExpressionParser(); 

	@Ignore("implement the parser in parsec")

	@Test

	public void testExpressionValue() {

		assertTrue("test it", parser.expressionValue("1"));

	}

}

package eu.dnetlib.springutils.condbean.parser;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import java.io.IOException;

import java.io.InputStream;

import org.junit.Before;

import org.junit.Test;

import eu.dnetlib.springutils.condbean.parser.ast.AbstractExpression;

import fri.patterns.interpreter.parsergenerator.Lexer;

import fri.patterns.interpreter.parsergenerator.Parser;

import fri.patterns.interpreter.parsergenerator.ParserTables;

import fri.patterns.interpreter.parsergenerator.lexer.LexerBuilder;

import fri.patterns.interpreter.parsergenerator.lexer.LexerException;

import fri.patterns.interpreter.parsergenerator.parsertables.LALRParserTables;

import fri.patterns.interpreter.parsergenerator.syntax.SyntaxException;

import fri.patterns.interpreter.parsergenerator.syntax.builder.SyntaxBuilder;

import fri.patterns.interpreter.parsergenerator.syntax.builder.SyntaxSeparation;

public class CondBeanParserTest {

	private static final String CHECK_EXPRESSION = "check expression";

	private static final String PARSE_FAILED = "parse failed";

	private SyntaxSeparation separation;

	private LexerBuilder builder;

	private Lexer lexer;

	private ParserTables parserTables;

	private Parser parser;

	private AbstractExpression result;

	private ParserTables tables;

	private SyntaxBuilder builder2;

	private InputStream syntaxInput;

	@Before

	public void setUp() throws SyntaxException, LexerException, Exception {

		syntaxInput = CondBeanParser.class.getResourceAsStream("CondBeanParser.syntax");

		builder2 = new SyntaxBuilder(syntaxInput);

		lexer = builder2.getLexer();

		tables = new LALRParserTables(builder2.getParserSyntax());

		parser = new Parser(tables);

		parser.setLexer(lexer);

	}

	@Test

	public void testParser0() throws IOException {

		parser.setInput("1 || 1");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertTrue(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser1() throws IOException {

		parser.setInput("!${some.existing.property} && ${some.value} == 3 || isdef(someBean) || 11");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertTrue(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser2() throws IOException {

		parser.setInput("2 == 3");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertFalse(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser3() throws IOException {

		parser.setInput("2==3");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertFalse(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser4() throws IOException {

		parser.setInput("${some.value} == 3");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertFalse(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser5() throws IOException {

		parser.setInput("!${some.existing.property} && ${some.value} == 3");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertFalse(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser6() throws IOException {

		parser.setInput("${some.value} == 3 && !${some.existing.property}"); // give

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertFalse(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser7() throws IOException {

		parser.setInput("3 < 2 && 2<4");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertFalse(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	@Test

	public void testParser8() throws IOException {

		parser.setInput("3 < 2 || 2<4");

		assertTrue(PARSE_FAILED, parser.parse(new CondBeanParser()));

		result = (AbstractExpression) parser.getResult();

		assertTrue(CHECK_EXPRESSION, (Boolean) result.evaluate());

	}

	public SyntaxSeparation getSeparation() {

		return separation;

	}

	public void setSeparation(final SyntaxSeparation separation) {

		this.separation = separation;

	}

	public LexerBuilder getBuilder() {

		return builder;

	}

	public void setBuilder(final LexerBuilder builder) {

		this.builder = builder;

	}

	public Lexer getLexer() {

		return lexer;

	}

	public void setLexer(final Lexer lexer) {

		this.lexer = lexer;

	}

	public ParserTables getParserTables() {

		return parserTables;

	}

	public void setParserTables(final ParserTables parserTables) {

		this.parserTables = parserTables;

	}

	public Parser getParser() {

		return parser;

	}

	public void setParser(final Parser parser) {

		this.parser = parser;

	}

	public AbstractExpression getResult() {

		return result;

	}

	public void setResult(final AbstractExpression result) {

		this.result = result;

	}

	public ParserTables getTables() {

		return tables;

	}

	public void setTables(final ParserTables tables) {

		this.tables = tables;

	}

	public SyntaxBuilder getBuilder2() {

		return builder2;

	}

	public void setBuilder2(final SyntaxBuilder builder2) {

		this.builder2 = builder2;

	}

	public InputStream getSyntaxInput() {

		return syntaxInput;

	}

	public void setSyntaxInput(final InputStream syntaxInput) {

		this.syntaxInput = syntaxInput;

	}

}

package eu.dnetlib.springutils.condbean.parser;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import java.io.IOException;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import eu.dnetlib.springutils.condbean.parser.ast.AndExpression;

import eu.dnetlib.springutils.condbean.parser.ast.EqualityExpression;

import eu.dnetlib.springutils.condbean.parser.ast.OrExpression;

import eu.dnetlib.springutils.condbean.parser.ast.RelationalExpression;

import eu.dnetlib.springutils.condbean.parser.ast.SysProperty;

public class RunccExpressionParserTest { //NOPMD

	private static final String CHECK_EXPRESSION = "check expression value";

	private static final String EXPRESSION_TYPE = "check expression type";

	private String parseInput;

	private RunccExpressionParser parser;

	@Before

	public void setProperties() {

		System.setProperty("some.existing.property", "pippo");

		parser = new RunccExpressionParser();

		parser.setCondBeanParser(new CondBeanParser());

	}	

	@After

	public void cleanupProperties() {

		System.clearProperty("some.existing.property");

	}

	@Test

    public void test0() throws IOException {

    	parseInput = "${some.existing.property}";

		assertTrue(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof SysProperty);

	}

	@Test

    public void test1() throws IOException {

    	parseInput = "false && false";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof AndExpression);

	}

	@Test

    public void test2() throws IOException {

    	parseInput = "1<2";

		assertTrue(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof RelationalExpression);

	}

	@Test

	public void test3() throws IOException {

		parseInput = "!${some.existing.property} && ${some.value} == 3 || isdef(someBean) || 11";

		assertTrue(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof OrExpression);

	}

	@Test

	public void test4() throws IOException {

		parseInput = "2 == 3";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof EqualityExpression);

	}

	@Test

	public void test5() throws IOException {

		parseInput = "\"3\"==3";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof EqualityExpression);

	}

	@Test

	public void test6() throws IOException {

		parseInput = "${some.value} == 3";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof EqualityExpression);

	}

	@Test

	public void test7() throws IOException {

		parseInput = "!${some.existing.property} && ${some.value} == 3";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof AndExpression);

	}

	@Test

	public void test8() throws IOException {

		parseInput = "${some.value} == 3 && !${some.existing.property}";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof AndExpression);

	}

	@Test

	public void test9() throws IOException {

		parseInput = "3 < 2 && 2<4";

		assertFalse(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof AndExpression);

	}

	@Test

	public void test10() throws IOException	{

		parseInput = "3 < 2 || 2<4";

		assertTrue(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof OrExpression);

	}

	@Test

    public void test11() throws IOException {

    	parseInput = "3==3";

		assertTrue(CHECK_EXPRESSION, parser.expressionValue(parseInput));

		assertTrue(EXPRESSION_TYPE, parser.getTopRule(parseInput) instanceof EqualityExpression);

	}

	public String getParseInput() {

		return parseInput;

	}

	public void setParseInput(final String parseInput) {

		this.parseInput = parseInput;

	}

	public RunccExpressionParser getParser() {

		return parser;

	}

	public void setParser(final RunccExpressionParser parser) {

		this.parser = parser;

	}	

}

package eu.dnetlib.springutils.condbean.parser.ast;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class ExpressionTest {

	private AbstractTerminal term1;

	private AbstractExpression exp1;

	private AbstractBinaryExpression exp2;

	@Test

	public void testExpression() {

		term1 = new IdentifierNode("pippo");

		exp1 = new NotExpression(term1);

		exp2 = new OrExpression(term1, exp1);

		assertEquals("check expression", exp2.getLeft(), term1);

	}

	public AbstractTerminal getTerm1() {

		return term1;

	}

	public void setTerm1(final AbstractTerminal term1) {

		this.term1 = term1;

	}

	public AbstractExpression getExp1() {

		return exp1;

	}

	public void setExp1(final AbstractExpression exp1) {

		this.exp1 = exp1;

	}

	public AbstractBinaryExpression getExp2() {

		return exp2;

	}

	public void setExp2(final AbstractBinaryExpression exp2) {

		this.exp2 = exp2;

	}

}

package eu.dnetlib.springutils.condbean.parser.ast;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.when;

import org.junit.Before;

import org.junit.Test;

public class NotExpressionTest {

	private NotExpression expr;

	private AbstractExpression expression;

	@Before

	public void setUp() throws Exception {

		expression = mock(AbstractExpression.class);

		expr = new NotExpression(expression);

	}

	@Test

	public void testTrue() {

		when(expression.evaluate()).thenReturn(true);

		assertFalse("check expression", (Boolean) expr.evaluate());

	}

	@Test

	public void testFalse() {

		when(expression.evaluate()).thenReturn(false);

		assertTrue("check expression", (Boolean) expr.evaluate());

	}

	public NotExpression getExpr() {

		return expr;

	}

	public void setExpr(final NotExpression expr) {

		this.expr = expr;

	}

	public AbstractExpression getExpression() {

		return expression;

	}

	public void setExpression(final AbstractExpression expression) {

		this.expression = expression;

	}

}

package eu.dnetlib.springutils.condbean.parser.ast;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.when;

import org.junit.Before;

import org.junit.Test;

public class OrExpressionTest {

	private static final String CHECK_EXPRESSION = "check expression";

	private OrExpression expr;

	private AbstractExpression left, right;

	@Before

	public void setUp() throws Exception {

		left = mock(AbstractExpression.class);

		right = mock(AbstractExpression.class);

		expr = new OrExpression(left, right);

	}

	@Test

	public void testTrue() {

		when(left.evaluate()).thenReturn(true);

		when(right.evaluate()).thenReturn(true);

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testFalse() {

		when(left.evaluate()).thenReturn(true);

		when(right.evaluate()).thenReturn(false);

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testOneNull() {

		when(left.evaluate()).thenReturn(null);

		when(right.evaluate()).thenReturn(1);

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testBothNull() {

		when(left.evaluate()).thenReturn(null);

		when(right.evaluate()).thenReturn(null);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	public OrExpression getExpr() {

		return expr;

	}

	public void setExpr(final OrExpression expr) {

		this.expr = expr;

	}

	public AbstractExpression getLeft() {

		return left;

	}

	public void setLeft(final AbstractExpression left) {

		this.left = left;

	}

	public AbstractExpression getRight() {

		return right;

	}

	public void setRight(final AbstractExpression right) {

		this.right = right;

	}

}

package eu.dnetlib.springutils.condbean.parser.ast;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.when;

import org.junit.Before;

import org.junit.Test;

public class AndExpressionTest {

	private static final String CHECK_EXPRESSION = "check expression";

	private AndExpression expr;

	private AbstractExpression left, right;

	@Before

	public void setUp() throws Exception {

		left = mock(AbstractExpression.class);

		right = mock(AbstractExpression.class);

		expr = new AndExpression(left, right);

	}

	@Test

	public void testTrue() {

		when(left.evaluate()).thenReturn(true);

		when(right.evaluate()).thenReturn(true);

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testFalse() {

		when(left.evaluate()).thenReturn(true);

		when(right.evaluate()).thenReturn(false);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testOneNull() {

		when(left.evaluate()).thenReturn(null);

		when(right.evaluate()).thenReturn(1);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testBothNull() {

		when(left.evaluate()).thenReturn(null);

		when(right.evaluate()).thenReturn(null);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	public AndExpression getExpr() {

		return expr;

	}

	public void setExpr(final AndExpression expr) {

		this.expr = expr;

	}

	public AbstractExpression getLeft() {

		return left;

	}

	public void setLeft(final AbstractExpression left) {

		this.left = left;

	}

	public AbstractExpression getRight() {

		return right;

	}

	public void setRight(final AbstractExpression right) {

		this.right = right;

	}

}

package eu.dnetlib.springutils.condbean.parser.ast;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.when;

import org.junit.Before;

import org.junit.Test;

public class RelationalExpressionTest {

	private static final String CHECK_EXPRESSION = "check expression";

	private RelationalExpression expr;

	private AbstractExpression left, right;

	@Before

	public void setUp() throws Exception {

		left = mock(AbstractExpression.class);

		right = mock(AbstractExpression.class);

		expr = new RelationalExpression(left, right, "<=");

	}

	@Test

	public void testString() {

		when(left.evaluate()).thenReturn("pippo");

		when(right.evaluate()).thenReturn("pippo");

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testStringlex1() {

		when(left.evaluate()).thenReturn("pippo1");

		when(right.evaluate()).thenReturn("mippo");

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testStringlex2() {

		when(left.evaluate()).thenReturn("pippo");

		when(right.evaluate()).thenReturn("rippo");

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testInt() {

		when(left.evaluate()).thenReturn(1);

		when(right.evaluate()).thenReturn(1);

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testIntString() {

		when(left.evaluate()).thenReturn("1");

		when(right.evaluate()).thenReturn(1);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	public RelationalExpression getExpr() {

		return expr;

	}

	public void setExpr(final RelationalExpression expr) {

		this.expr = expr;

	}

	public AbstractExpression getLeft() {

		return left;

	}

	public void setLeft(final AbstractExpression left) {

		this.left = left;

	}

	public AbstractExpression getRight() {

		return right;

	}

	public void setRight(final AbstractExpression right) {

		this.right = right;

	}

}

package eu.dnetlib.springutils.condbean.parser.ast;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.when;

import org.junit.Before;

import org.junit.Test;

public class EqualityExpressionTest {

	private static final String CHECK_EXPRESSION = "check expression";

	private EqualityExpression expr;

	private AbstractExpression left, right;

	@Before

	public void setUp() throws Exception {

		left = mock(AbstractExpression.class);

		right = mock(AbstractExpression.class);

		expr = new EqualityExpression(left, right, "==");

	}

	@Test

	public void testEquals() {

		when(left.evaluate()).thenReturn("pippo");

		when(right.evaluate()).thenReturn("pippo");

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testNotEquals() {

		when(left.evaluate()).thenReturn("pippo1");

		when(right.evaluate()).thenReturn("puppo");

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testInteger() {

		when(left.evaluate()).thenReturn("pippo1");

		when(right.evaluate()).thenReturn(1);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testOneNull() {

		when(left.evaluate()).thenReturn(null);

		when(right.evaluate()).thenReturn(1);

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testBothNull() {

		when(left.evaluate()).thenReturn(null);

		when(right.evaluate()).thenReturn(null);

		assertTrue(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testIntString() {

		when(left.evaluate()).thenReturn(1);

		when(right.evaluate()).thenReturn("1");

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testIntChar() {

		when(left.evaluate()).thenReturn(1);

		when(right.evaluate()).thenReturn('1');

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	@Test

	public void testString() {

		when(left.evaluate()).thenReturn("2");

		when(right.evaluate()).thenReturn("3");

		assertFalse(CHECK_EXPRESSION, (Boolean) expr.evaluate());

	}

	public EqualityExpression getExpr() {

		return expr;

	}

	public void setExpr(final EqualityExpression expr) {

		this.expr = expr;

	}

	public AbstractExpression getLeft() {

		return left;

	}

	public void setLeft(final AbstractExpression left) {

		this.left = left;

	}

	public AbstractExpression getRight() {

		return right;

	}

	public void setRight(final AbstractExpression right) {

		this.right = right;

	}

}

package eu.dnetlib.springutils.condbean;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

public class TrivialConditionExpressionParserTest {

	transient TrivialConditionExpressionParser parser = new TrivialConditionExpressionParser();  

	@BeforeClass

	public static void setUpProperties() {

		System.setProperty("trivial.condition.true", "value");

	}

	@Before

	public void setUp() {

		parser.setFinder(new SystemPropertiesFinder());

	}

	@Test

	public void testExpressionValue() {

		assertTrue("check true condition", parser.expressionValue("trivial.condition.true"));

		assertFalse("check false condition", parser.expressionValue("trivial.condition.false"));

	}

	@Test

	public void testGetProperty() {

		assertEquals("check true condition", "value", parser.getProperty("trivial.condition.true"));

		assertEquals("check false condition", null, parser.getProperty("trivial.condition.false"));

	}

}

package eu.dnetlib.springutils.template;

public class TestBean {

	private int value;

	private String address;

	private String prop;

	private TestBean next;

	public int getValue() {

		return value;

	}

	public void setValue(int value) {

		this.value = value;

	}

	public TestBean getNext() {

		return next;

	}

	public void setNext(TestBean next) {

		this.next = next;

	}

	public String getAddress() {

		return address;

	}

	public void setAddress(String address) {

		this.address = address;

	}

	public String getProp() {

		return prop;

	}

	public void setProp(String prop) {

		this.prop = prop;

	}

}

package eu.dnetlib.springutils.template;

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

import javax.annotation.Resource;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

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

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration

public class TemplateTest {

	@Resource(name = "test")

	private transient TestBean testBean;

	@Resource(name = "testDefault1")

	private transient TestBean testDefault1;

	@Resource(name = "testDefault2")

	private transient TestBean testDefault2;

	@Resource(name = "testDefault3")

	private transient TestBean testDefault3;

	@Before

	public void setUp() throws Exception {

	}

	@Test

	public void testTemplate() {

		assertEquals("check property value expansion", "expandedValue", testBean.getAddress());

		assertEquals("check bean reference", "tail-expandedValue", testBean.getNext().getAddress());

	}

	@Test

	public void testMultipleInstances() {

		assertEquals("check expanded value", "expandedValue", testDefault1.getAddress());

		assertEquals("check other value", "otherValue", testDefault2.getAddress());

	}

	@Test

	public void testDefault() {

		assertEquals("check expanded value", "expandedValue", testDefault1.getAddress());

		assertEquals("check default value", "defaultValue", testDefault3.getAddress());

	}

	@Test

	public void testProp() {

		assertEquals("check property", "test", testBean.getProp());

	}

}

package eu.dnetlib.springutils.template;

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

import javax.annotation.Resource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

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

/**

 * Templates should work also if parsed out of order (instantiations before declarations). 

 * 

 * @author marko

 *

 */

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration

public class ReorderTemplateTest {

	@Resource(name = "test")

	private transient TestBean testBean;

	@Test

	public void testOutOfOrder() {

		assertNotNull(testBean);

	}

}

package eu.dnetlib.springutils.collections;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.core.io.Resource;

import org.springframework.test.context.ContextConfiguration;

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

/**

 * Test resource->string transformer.

 * 

 * @author marko

 *

 */

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration

public class ResourceReaderCollectionTest {

	/**

	 * resources filled by spring.

	 */

	@javax.annotation.Resource(name = "resourceList")

	List<Resource> resources;

	/**

	 * test resources

	 */

	@Test

	public void testResources() {

		boolean passed = false;

		for(String el : new ResourceReaderCollection(resources)) {

			passed = true;

			assertEquals("content", "test\n", el);

		}

		assertTrue("passed", passed);

	}

}