Printing only numbers with non-repeating digits

	/**
	Print From 45 to 4578 Without Repeating Digits
	Write a method that prints all the numbers from 45 to 4578 to the console,
	with the constraint that you cannot print any number with repeating digits.
	This means the following numbers would be skipped:
	11, 22, ...., 122, 110,....
	**/
	package puzzlers
	object NumberPrinter {
	def nonRepeatingDigitNumbers(start:Int, end:Int): IndexedSeq[Int] = {
	(start to end).filterNot(x => x.toString.toCharArray().groupBy(identity).exists(_._2.size > 1))
	}
	def main(args: Array[String]): Unit = {
	for (number <- nonRepeatingDigitNumbers(45, 4578)) {
	println(number)
	}
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Finding string pairs

	package pelssers.io
	import scala.collection.mutable.Map
	import scala.math.abs
	/** TASK DESCRIPTION
	Create a method that takes a string parameter and looks for pairs of strings in the code,
	breaking the string up using spaces as the delimiter.
	There are two types of pairs, combinations and adjacent, and you'll need to find a count of each.
	Adjacent pairs appear alongside each other, while combination pairs cover every permutation
	that can be found of pairing the strings.
	So if you have a string
	dzone java dzone dzone javascript java
	the results would be
	dzone has 1 adjacent pair
	dzone has 3 combination pairs (0,2) (0,3) (2,3)
	java has 1 combination pair (1,5)
	USAGE of solution:
	val theText = "dzone java dzone dzone javascript java"
	//> theText : String = dzone java dzone dzone javascript java
	StringPairFinder.printStringPairs(theText) //> java has 1 combination pair(s): (1,5)
	//| dzone has 1 adjacent pair(s)
	//| dzone has 3 combination pair(s): (0,2) (0,3) (2,3)
	**/
	object StringPairFinder {
	def toCombinations(text: String): Map[String, List[(Int,Int)]] = {
	val wordMap: Map[String, List[Int]] = new scala.collection.mutable.HashMap[String, List[Int]]
	for ((word,index) <- text.split(" ").zipWithIndex) {
	wordMap.update(word, wordMap.getOrElseUpdate(word, List()) :+ index)
	}
	val result = wordMap.map {
	case (key, positions) => (key, positions.combinations(2).toList.map(ele => (ele(0), ele(1))))
	}
	result.filter(!_._2.isEmpty)
	}
	def printStringPairs(text: String): Unit = {
	for ((key, pairs) <- toCombinations(text)) {
	val adjacent = (pairs.map {case (index1, index2) => if (abs(index1 - index2) == 1) 1 else 0}).sum
	if (adjacent > 0) println(s"$key has $adjacent adjacent pair(s)")
	println(s"$key has ${pairs.size} combination pair(s): " + pairs.mkString(" "))
	}
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Spring batch demo

In this article I will show you how easy it is to create a batch job by configuring out-of-the-box components. Today we will read a [CSV file] and convert it to an [XML file] and while we are at it we filter out all persons who don't live in New York. I also stick with using annotations to configure my complete application context. Unfortunately this code currently runs into a nullpointer which I expect to be [this issue].

	<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.pelssers</groupId>
	<artifactId>batchdemo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
	<spring.version>3.2.4.RELEASE</spring.version>
	</properties>
	<dependencies>
	<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib-nodep</artifactId>
	<version>2.2</version>
	<scope>compile</scope>
	</dependency>
	<!-- spring dependencies -->
	<dependency>
	<groupId>org.springframework.batch</groupId>
	<artifactId>spring-batch-core</artifactId>
	<version>2.2.1.RELEASE</version>
	<exclusions>
	<exclusion>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	</exclusion>
	<exclusion>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	</exclusion>
	</exclusions>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-oxm</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<!-- functional programming -->
	<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>14.0.1</version>
	</dependency>
	<!-- use in-memory database for batch -->
	<dependency>
	<groupId>hsqldb</groupId>
	<artifactId>hsqldb</artifactId>
	<version>1.8.0.10</version>
	</dependency>
	</dependencies>
	</project>

view raw gistfile1.xml hosted with ❤ by GitHub

	package com.pelssers.domain;
	import javax.xml.bind.annotation.XmlRootElement;
	import javax.xml.bind.annotation.XmlTransient;
	@XmlRootElement
	public class Person {
	private String firstName;
	private String lastName;
	private String email;
	private String state;
	public String getFirstName() {
	return firstName;
	}
	public void setFirstName(String firstName) {
	this.firstName = firstName;
	}
	public String getLastName() {
	return lastName;
	}
	public void setLastName(String lastName) {
	this.lastName = lastName;
	}
	public String getEmail() {
	return email;
	}
	public void setEmail(String email) {
	this.email = email;
	}
	public String getState() {
	return state;
	}
	@XmlTransient
	public void setState(String state) {
	this.state = state;
	}
	@Override
	public String toString() {
	return "Person {firstName: " + firstName + ", lastName: " + lastName
	+ ",state: " + state + ", email:" + email + "}";
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.processor;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import org.springframework.batch.item.ItemProcessor;
	import com.google.common.base.Predicate;
	public class FilterProcessor<S> implements ItemProcessor<S,S> {
	public static Logger logger = Logger.getLogger(FilterProcessor.class.getName());
	private Predicate<S> predicate;
	public FilterProcessor(Predicate<S> predicate) {
	this.predicate = predicate;
	}
	public S process(S item) throws Exception {
	boolean isValid = predicate.apply(item);
	if (!isValid) {
	logger.log(Level.INFO, "Skipping " + item.toString());
	}
	return isValid ? item : null;
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.configuration;
	import javax.sql.DataSource;
	import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
	import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
	@Configuration
	@EnableBatchProcessing
	public class TestConfiguration {
	@Bean
	public DataSource dataSource() {
	EmbeddedDatabaseBuilder databaseBuilder = new EmbeddedDatabaseBuilder();
	return
	databaseBuilder
	.addScript("classpath:org/springframework/batch/core/schema-drop-hsqldb.sql")
	.addScript("classpath:org/springframework/batch/core/schema-hsqldb.sql")
	.setType(EmbeddedDatabaseType.HSQL)
	.build();
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.configuration.jobs;
	import org.springframework.batch.core.Job;
	import org.springframework.batch.core.Step;
	import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
	import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
	import org.springframework.batch.core.configuration.annotation.StepScope;
	import org.springframework.batch.item.ItemProcessor;
	import org.springframework.batch.item.ItemStreamWriter;
	import org.springframework.batch.item.file.FlatFileItemReader;
	import org.springframework.batch.item.file.LineMapper;
	import org.springframework.batch.item.file.ResourceAwareItemWriterItemStream;
	import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
	import org.springframework.batch.item.file.mapping.DefaultLineMapper;
	import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
	import org.springframework.batch.item.xml.StaxEventItemWriter;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.beans.factory.annotation.Value;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.Import;
	import org.springframework.core.io.ClassPathResource;
	import org.springframework.core.io.FileSystemResource;
	import org.springframework.oxm.Marshaller;
	import org.springframework.oxm.jaxb.Jaxb2Marshaller;
	import com.google.common.base.Predicate;
	import com.pelssers.configuration.TestConfiguration;
	import com.pelssers.domain.Person;
	import com.pelssers.processor.FilterProcessor;
	@Configuration
	@Import(TestConfiguration.class)
	public class CsvToXMLJobConfiguration {
	/**
	* Attention:
	* You have to name these beans jobBuilders and stepbuilders respectively.
	* See http://docs.spring.io/spring-batch/reference/html/configureJob.html
	*/
	private static final String XML_FILEPATH_PLACEHOLDER = null;
	private static final String CLASSPATH_RESOURCE_PLACEHOLDER = null;
	public static final String JOBPARAM_XML_FILEPATH = "xmlFilePath";
	public static final String JOBPARAM_CLASSPATH_RESOURCE = "classPathResource";
	@Autowired
	private JobBuilderFactory jobBuilders;
	@Autowired
	private StepBuilderFactory stepBuilders;
	@Autowired
	private TestConfiguration testConfiguration;
	@Bean
	public Job csvToXmlJob() {
	return jobBuilders.get("csvToXmlJob")
	.start(step())
	.build();
	}
	@Bean
	public Step step() {
	//CLASSPATH_RESOURCE_PLACEHOLDER and XML_FILEPATH_PLACEHOLDER will be overriden
	//by injected jobparameter using late binding (stepscope)
	return stepBuilders.get("step")
	.<Person, Person>chunk(50)
	.reader(reader(CLASSPATH_RESOURCE_PLACEHOLDER))
	.processor(processor())
	.writer(writer(XML_FILEPATH_PLACEHOLDER))
	.build();
	}
	@Bean
	@StepScope
	public FlatFileItemReader<Person> reader(@Value("#{jobParameters[classPathResource]}") String classPathResource) {
	FlatFileItemReader<Person> itemReader = new FlatFileItemReader<Person>();
	itemReader.setLinesToSkip(1);
	itemReader.setLineMapper(lineMapper());
	itemReader.setResource(new ClassPathResource(classPathResource));
	return itemReader;
	}
	@Bean
	public LineMapper<Person> lineMapper() {
	DefaultLineMapper<Person> lineMapper = new DefaultLineMapper<Person>();
	DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
	//we are only interested in below 4 fields from this CSV file
	lineTokenizer.setNames(new String[]{"firstName","lastName", "state","email"});
	lineTokenizer.setIncludedFields(new int[]{0,1,6, 10});
	BeanWrapperFieldSetMapper<Person> fieldSetMapper = new BeanWrapperFieldSetMapper<Person>();
	fieldSetMapper.setTargetType(Person.class);
	lineMapper.setLineTokenizer(lineTokenizer);
	lineMapper.setFieldSetMapper(fieldSetMapper);
	return lineMapper;
	}
	@Bean
	@StepScope
	public ItemProcessor<Person, Person> processor() {
	return new FilterProcessor<Person>(new IsNewYorkerPredicate());
	}
	@Bean
	@StepScope
	public ResourceAwareItemWriterItemStream<Person> writer(@Value("#{jobParameters[xmlFilePath]}") String xmlFilePath) {
	StaxEventItemWriter<Person> writer = new StaxEventItemWriter<Person>();
	writer.setResource(new FileSystemResource(xmlFilePath));
	writer.setRootTagName("result");
	writer.setMarshaller(marshaller());
	writer.setEncoding("UTF-8");
	writer.setOverwriteOutput(true);
	return writer;
	}
	@Bean
	public Marshaller marshaller() {
	Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
	marshaller.setClassesToBeBound(Person.class);
	return marshaller;
	}
	public class IsNewYorkerPredicate implements Predicate<Person> {
	public boolean apply(Person person) {
	return "NY".equals(person.getState());
	}
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.main;
	import org.springframework.batch.core.Job;
	import org.springframework.batch.core.JobParametersBuilder;
	import org.springframework.batch.core.JobParametersInvalidException;
	import org.springframework.batch.core.launch.JobLauncher;
	import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
	import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
	import org.springframework.batch.core.repository.JobRestartException;
	import org.springframework.context.ApplicationContext;
	import org.springframework.context.annotation.AnnotationConfigApplicationContext;
	import com.pelssers.configuration.jobs.CsvToXMLJobConfiguration;
	public class CsvToXmlJobLauncher {
	/**
	* @param args
	* @throws JobParametersInvalidException
	* @throws JobInstanceAlreadyCompleteException
	* @throws JobRestartException
	* @throws JobExecutionAlreadyRunningException
	*/
	public static void main(String[] args) throws JobExecutionAlreadyRunningException,
	JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException {
	ApplicationContext context = new AnnotationConfigApplicationContext(CsvToXMLJobConfiguration.class);
	JobLauncher jobLauncher = context.getBean(JobLauncher.class);
	Job job = context.getBean(Job.class);
	jobLauncher.run(
	job,
	new JobParametersBuilder()
	.addString(CsvToXMLJobConfiguration.JOBPARAM_XML_FILEPATH, "c:/tmp/persons.xml")
	.addString(CsvToXMLJobConfiguration.JOBPARAM_CLASSPATH_RESOURCE, "500.csv")
	.toJobParameters());
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

Unit testing with Mockito

In this article I created a realistic scenario of services depending on each other. This article shows you how you can easily test business logic in isolation.

	/************************************************/
	DOMAIN OBJECTS
	*************************************************/
	/*********** Coordinates.java *******************/
	package com.pelssers.domain;
	public class Coordinates {
	private Double latitude;
	private Double longitude;
	public Coordinates(Double latitude, Double longitude) {
	this.latitude = latitude;
	this.longitude = longitude;
	}
	public Double getLatitude() {
	return latitude;
	}
	public Double getLongitude() {
	return longitude;
	}
	}
	/*********** Weather.java *******************/
	package com.pelssers.domain;
	import java.util.Set;
	public class Weather {
	private Double temperature;
	private Set<WeatherType> weatherTypes;
	public Weather(Double temperature, Set<WeatherType> weatherTypes) {
	this.temperature = temperature;
	this.weatherTypes = weatherTypes;
	}
	public Double getTemperature() {
	return temperature;
	}
	public Set<WeatherType> getWeatherTypes() {
	return weatherTypes;
	}
	@Override
	public String toString() {
	return "{temperature: " + getTemperature().toString() +
	", weatherTypes: [" + weatherTypes.toString() + "]";
	}
	}
	/*********** WeatherType.java *******************/
	package com.pelssers.domain;
	public enum WeatherType {
	RAINY, DRY, SUNNY, CLOUDY
	}
	/************************************************/
	SERVICE INTERFACES
	*************************************************/
	/*********** IHumidityService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	public interface IHumidityService {
	Double predictHumidity(Date date, Coordinates coordinates);
	}
	/*********** ISatteliteService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	public interface ISatteliteService {
	boolean isCloudy(Date date, Coordinates coordinates);
	}
	/*********** ITemperatureService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	public interface ITemperatureService {
	Double predictTemperature(Date date, Coordinates coordinates);
	}
	/*********** IWeatherForecastService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	import com.pelssers.domain.Weather;
	public interface IWeatherForecastService {
	Weather getForecast(Date date, Coordinates coordinates);
	}
	/************************************************/
	SERVICE IMPLEMENTATION(S)
	*************************************************/
	/*********** WeatherForecastService.java *************/
	package com.pelssers.services.impl;
	import java.util.Date;
	import java.util.HashSet;
	import java.util.Set;
	import javax.inject.Inject;
	import org.springframework.stereotype.Component;
	import com.pelssers.domain.Coordinates;
	import com.pelssers.domain.Weather;
	import com.pelssers.domain.WeatherType;
	import com.pelssers.services.ISatteliteService;
	import com.pelssers.services.ITemperatureService;
	import com.pelssers.services.IWeatherForecastService;
	import com.pelssers.services.IHumidityService;
	@Component()
	public class WeatherForecastService implements IWeatherForecastService {
	@Inject
	private ITemperatureService temperatureService;
	@Inject
	private IHumidityService humidityService;
	@Inject
	private ISatteliteService satteliteService;
	@Override
	public Weather getForecast(Date date, Coordinates coordinates) {
	final Double predictedTemperature = temperatureService.predictTemperature(date, coordinates);
	final Double predictedHumidity = humidityService.predictHumidity(date, coordinates);
	final boolean isCloudy = satteliteService.isCloudy(date, coordinates);
	//here starts our actual business logic
	Set<WeatherType> weatherTypes = new HashSet<WeatherType>();
	weatherTypes.add(isCloudy? WeatherType.CLOUDY : WeatherType.SUNNY);
	weatherTypes.add(predictedHumidity > 50 ? WeatherType.RAINY : WeatherType.DRY);
	return new Weather(predictedTemperature, weatherTypes);
	}
	}
	/************************************************/
	UNIT TEST
	*************************************************/
	package com.pelssers.services.impl;
	import java.util.Date;
	import org.junit.Assert;
	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.InjectMocks;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;
	import static org.mockito.Matchers.*;
	import static org.mockito.Mockito.*;
	import com.google.common.collect.ImmutableSet;
	import com.pelssers.domain.Coordinates;
	import com.pelssers.domain.Weather;
	import com.pelssers.domain.WeatherType;
	import com.pelssers.services.IHumidityService;
	import com.pelssers.services.ISatteliteService;
	import com.pelssers.services.ITemperatureService;
	import com.pelssers.services.IWeatherForecastService;
	public class WeatherForecastServiceTest {
	/**
	* As our weather forecast service depends on lots of other services
	* we want to mock the services we depend on and test our business logic
	* in isolation. As you can see we no longer need setters and getters in
	* WeatherForecastService, not for dependency injection and neither for unit testing
	*/
	@InjectMocks
	private IWeatherForecastService weatherForecastService = new WeatherForecastService();
	@Mock
	private IHumidityService humidityService;
	@Mock
	private ITemperatureService temperatureService;
	@Mock
	private ISatteliteService satteliteService;
	private Coordinates coordinates;
	private Date forecastDate;
	private Double expectedTemperature;
	@Before
	public void setUp() {
	//instruct mockito to process all annotations
	MockitoAnnotations.initMocks(this);
	forecastDate = new Date(2013, 10 , 1);
	coordinates = new Coordinates(14.5, 123.4);
	expectedTemperature = 16D;
	when(temperatureService.predictTemperature(any(Date.class), any(Coordinates.class)))
	.thenReturn(expectedTemperature);
	}
	@Test
	public void testRainyAndCloudyWeather() {
	Weather expectedWeather = new Weather(expectedTemperature,
	ImmutableSet.of(WeatherType.RAINY, WeatherType.CLOUDY));
	when(humidityService.predictHumidity(any(Date.class), any(Coordinates.class)))
	.thenReturn(60D);
	when(satteliteService.isCloudy(any(Date.class), any(Coordinates.class)))
	.thenReturn(true);
	testWeather(expectedWeather);
	}
	@Test
	public void testDryAndSunnyWeather() {
	Weather expectedWeather = new Weather(expectedTemperature,
	ImmutableSet.of(WeatherType.DRY, WeatherType.SUNNY));
	when(humidityService.predictHumidity(any(Date.class), any(Coordinates.class)))
	.thenReturn(40D);
	when(satteliteService.isCloudy(any(Date.class), any(Coordinates.class)))
	.thenReturn(false);
	testWeather(expectedWeather);
	}
	private void testWeather(Weather expectedWeather) {
	Weather actualWeather = weatherForecastService.getForecast(forecastDate, coordinates);
	//verify our services are called once
	verify(humidityService, times(1)).predictHumidity(forecastDate, coordinates);
	verify(temperatureService, times(1)).predictTemperature(forecastDate, coordinates);
	verify(satteliteService, times(1)).isCloudy(forecastDate, coordinates);
	Assert.assertEquals(expectedWeather.getTemperature(), actualWeather.getTemperature());
	Assert.assertEquals(expectedWeather.getWeatherTypes(), actualWeather.getWeatherTypes());
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.pelssers</groupId>
	<artifactId>mockitodemo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Mockito Demo</name>
	<packaging>jar</packaging>
	<properties>
	<spring.version>3.1.2.RELEASE</spring.version>
	</properties>
	<dependencies>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>javax.inject</groupId>
	<artifactId>javax.inject</artifactId>
	<version>1</version>
	</dependency>
	<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>14.0.1</version>
	</dependency>
	<!-- Test Dependencies -->
	<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.8.2</version>
	<scope>test</scope>
	</dependency>
	<dependency>
	<groupId>org.mockito</groupId>
	<artifactId>mockito-core</artifactId>
	<version>1.9.5</version>
	<scope>test</scope>
	</dependency>
	</dependencies>
	</project>

view raw gistfile1.xml hosted with ❤ by GitHub