First commit.

.classpath

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry combineaccessrules="false" kind="src" path="/br.com.innovox.apps"/>
+	<classpathentry kind="lib" path="lib/Cortix7_fingerprinter.jar"/>
+	<classpathentry kind="lib" path="lib/Cortix7_sharedEntities.jar"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/br.com.innovox.lib.javautils"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/br.com.innovox.lib.soundmatch"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

.gitignore

@@ -0,0 +1 @@
+/target/

.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>BKE_SVSpotDiscoverer</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,8 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

log4j.properties

@@ -0,0 +1,12 @@
+log4j.rootLogger=DEBUG, stdout, logfile
+
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d %p (%t) [%c] - %m%n
+
+log4j.appender.logfile=org.apache.log4j.RollingFileAppender
+log4j.appender.logfile.File=log.out
+log4j.appender.logfile.MaxFileSize=100MB
+log4j.appender.logfile.MaxBackupIndex=4
+log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
+log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

pom.xml

@@ -0,0 +1,52 @@
+<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>br.com.soundview</groupId>
+	<artifactId>BKE_SVSpotDiscoverer</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<name>BKE_SVSpotDiscoverer</name>
+
+	<dependencies>
+
+		<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
+		<dependency>
+			<groupId>commons-io</groupId>
+			<artifactId>commons-io</artifactId>
+			<version>2.5</version>
+		</dependency>
+
+		<!-- https://mvnrepository.com/artifact/junit/junit -->
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.12</version>
+		</dependency>
+
+		<!-- https://mvnrepository.com/artifact/org/jaudiotagger -->
+		<dependency>
+			<groupId>org</groupId>
+			<artifactId>jaudiotagger</artifactId>
+			<version>2.0.3</version>
+		</dependency>
+
+		<!-- https://mvnrepository.com/artifact/log4j/log4j -->
+		<dependency>
+			<groupId>log4j</groupId>
+			<artifactId>log4j</artifactId>
+			<version>1.2.17</version>
+		</dependency>
+
+		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-all -->
+		<dependency>
+			<groupId>org.mockito</groupId>
+			<artifactId>mockito-all</artifactId>
+			<version>1.10.19</version>
+		</dependency>
+
+	</dependencies>
+
+	<properties>
+		<java.version>1.8</java.version>
+	</properties>
+
+</project>

src/main/java/bean/Content.java

@@ -0,0 +1,32 @@
+package bean;
+
+import java.io.File;
+
+public class Content {
+
+	private final int contentId;
+	private final File contentFile;
+	
+	public Content(int contentId, File contentFile) {	
+		this.contentId = contentId;
+		this.contentFile = contentFile;
+	}
+
+	public int getContentId() {
+		return contentId;
+	}
+
+	public File getContentFile() {
+		return contentFile;
+	}
+	
+	@Override
+	public String toString() {
+		
+		return new StringBuilder("Id: ")
+				.append(this.contentId)
+				.append(", file: ")
+				.append(this.contentFile.getName())
+				.toString();
+	}
+}

src/main/java/bean/InnoResult.java

@@ -0,0 +1,28 @@
+package bean;
+
+public class InnoResult {
+
+	private final int contentId;
+	private final double distance;
+	public InnoResult(int contentId, double distance) {
+		super();
+		this.contentId = contentId;
+		this.distance = distance;
+	}
+	public int getContentId() {
+		return contentId;
+	}
+	public double getDistance() {
+		return distance;
+	}
+	
+	@Override
+	public String toString() {
+		
+		return new StringBuilder("content: ")
+				.append(this.contentId)
+				.append(", distance: ")
+				.append(this.distance)
+				.toString();
+	}
+}

src/main/java/bean/Track.java

@@ -0,0 +1,26 @@
+package bean;
+
+import java.io.File;
+import java.time.LocalDateTime;
+
+public class Track {
+
+	private final int id;
+	private final File track;
+	private final LocalDateTime creationTime;
+	
+	public Track(int id, File track, LocalDateTime creationTime) {		
+		this.id = id;
+		this.track = track;
+		this.creationTime = creationTime;
+	}
+	public int getId() {
+		return id;
+	}
+	public File getTrack() {
+		return track;
+	}
+	public LocalDateTime getCreationTime() {
+		return creationTime;
+	}	
+}

src/main/java/extraction/SingleTrackExtractor.java

@@ -0,0 +1,148 @@
+package extraction;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.ProcessBuilder.Redirect;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.log4j.Logger;
+
+public class SingleTrackExtractor {
+
+	private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
+	
+	private static final Logger logger = Logger.getLogger(SingleTrackExtractor.class);
+
+	private final File destinationDirectory;
+
+	private final File temporaryLogFile = new File("/tmp/SingleTrackExtractor.log");
+
+	/**
+	 * Constructor.
+	 * 
+	 * @param destinationDirectory File pointing at the directory where the tracks must be stored.
+	 * 
+	 * @throws IOException thrown if destination directory does not exist and cannot be created.
+	 */
+	public SingleTrackExtractor(File destinationDirectory) throws IOException {
+
+		if (destinationDirectory == null) {
+			throw new NullPointerException("Null destination directory path.");
+		}
+
+		if (!destinationDirectory.isDirectory()) {
+			throw new IllegalArgumentException("Invalid destination directory: "+destinationDirectory.getAbsolutePath());
+		}
+
+		if (!destinationDirectory.exists()) {
+
+			logger.warn("constructor: Inexistent destination directory: '"+destinationDirectory.getAbsolutePath()+"'. Going to create it.");
+
+			if (destinationDirectory.mkdirs()) {
+
+				logger.info("SingleTrackExtractor: Destination directory successfully created: "+destinationDirectory.getAbsolutePath());
+			}
+			else {
+				throw new IOException("Could not create destination directory at '"+destinationDirectory.getAbsolutePath()+"'.");
+			}
+		}		
+
+		this.destinationDirectory = destinationDirectory;
+
+		logger.info("SingleTrackExtractor: Destination directory set to '"+this.destinationDirectory.getAbsolutePath()+"'");
+		logger.info("SingleTrackExtractor: Temporary log file for this class created at '"+this.temporaryLogFile.getAbsolutePath()+"'");
+	}	
+
+	public File extract(File sourceAudioFile, LocalTime startTime, LocalTime duration, String trackName) {
+
+		if (sourceAudioFile == null) {
+			logger.error("extract: Null source audio file.");
+			return null;
+		}
+		
+		if (!sourceAudioFile.exists() || !sourceAudioFile.isFile()) {
+			logger.error("extract: Invalid source audio file.");
+			return null;
+		}
+		
+		if (startTime == null) {
+			logger.error("extract: Null start time.");
+			return null;
+		}
+		
+		if (duration == null) {
+			logger.error("extract: Null duration.");
+			return null;
+		}
+		
+		if (trackName == null) {
+			logger.error("extract: Null track name.");
+			return null;
+		}
+		
+		if (trackName.trim().isEmpty()) {
+			logger.error("extract: Empty track name.");
+			return null;
+		}
+		
+		String destinationTrackPath = new File(this.destinationDirectory, trackName).getAbsolutePath();							
+
+		String command = this.createCommand(sourceAudioFile, startTime, duration, destinationTrackPath);
+
+		ProcessBuilder builder = new ProcessBuilder(Arrays.asList(new String[]{
+				"/bin/bash",
+				"-c",
+				command
+		}));
+
+		builder.redirectOutput(Redirect.appendTo(this.temporaryLogFile));
+		builder.redirectError(this.temporaryLogFile);
+
+		String invocationDescription = new StringBuilder("Source: ")
+				.append(sourceAudioFile.getAbsolutePath())
+				.append(", start: ")
+				.append(startTime)
+				.append(", duration: ")
+				.append(duration)
+				.toString();
+		
+		try {
+			Process process = builder.start();					
+
+			if (process.waitFor(30, TimeUnit.SECONDS)) {
+				logger.info("extract: "+invocationDescription+". Successfully extracted: "+destinationTrackPath);
+			}
+			else {
+				logger.error("extract: "+invocationDescription+". Could not execute: "+command);
+			}
+		}
+		catch (Exception e) {
+			logger.error("extract: Could not extract: "+invocationDescription);
+		}
+		
+		File extractedTrackFile = new File(destinationTrackPath);
+		
+		if (!extractedTrackFile.exists()) {
+			
+			logger.error("generateFilePath: Process completed normally but track was not extracted: "+destinationTrackPath);
+			
+			return null;
+		}
+		
+		return extractedTrackFile;
+	}
+
+	private final String createCommand(File audioFile, LocalTime start, LocalTime duration, String destinationFile) {
+
+		return new StringBuilder("ffmpeg -i ")
+				.append(audioFile.getAbsolutePath())
+				.append(" -t ").append(this.formatter.format(duration))
+				.append(" -ss ").append(this.formatter.format(start))
+				.append(" -acodec ")
+				.append(" copy ").append(destinationFile)
+				.toString();
+	}
+}

src/main/java/extraction/TrackExtractor.java

@@ -0,0 +1,68 @@
+package extraction;
+
+import java.io.File;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+
+import bean.Track;
+import utils.AudioUtils;
+
+public class TrackExtractor {
+	
+	private static final Logger logger = Logger.getLogger(TrackExtractor.class);
+	
+	private final SingleTrackExtractor singleTrackExtractor;
+	
+	private final DateTimeFormatter formatter;
+	
+	private final AudioUtils audioUtils;
+	
+	public TrackExtractor(SingleTrackExtractor singleTrackExtractor) {
+		
+		this.singleTrackExtractor = singleTrackExtractor;
+		this.audioUtils = new AudioUtils();
+		this.formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");;
+	}
+
+	public List<Track> extract(File audioFile, int trackLengthSecs, LocalDateTime initialDateTime) {
+
+		int idGenerator = 0;
+		
+		LocalDateTime localDateTime = initialDateTime;
+		
+		List<Track> extractedTracks = new ArrayList<>();
+		
+		LocalTime initialTime = LocalTime.of(0, 0, 0);
+		LocalTime duration = LocalTime.MIN.plusSeconds(trackLengthSecs);
+		
+		String trackName = this.formatter.format(localDateTime) + ".mp3";
+		
+		File extractedTrack = null;
+		
+		int totalTracks = (int)this.audioUtils.getMp3DurationInSeconds(audioFile) / trackLengthSecs;
+		
+		for (int i = 0 ; i < totalTracks ; i++) {
+		
+			logger.info("extract: Going to extract "+trackName);
+			
+			extractedTrack = this.singleTrackExtractor.extract(audioFile, initialTime, duration, trackName);			
+			
+			extractedTracks.add(new Track(idGenerator, extractedTrack, localDateTime));
+			
+			localDateTime = localDateTime.plusSeconds(trackLengthSecs);
+			
+			initialTime = initialTime.plusSeconds(trackLengthSecs);
+			
+			trackName = this.formatter.format(localDateTime) + ".mp3";		
+		}
+		
+		logger.info("extract: Extracted "+extractedTracks.size()+" tracks from '"+audioFile.getAbsolutePath()+"' with length "+trackLengthSecs+" seconds, starting at "+initialDateTime);
+		
+		return extractedTracks;
+	}
+}

src/main/java/search/inno/InnoSearcher.java

@@ -0,0 +1,141 @@
+package search.inno;
+
+import java.io.File;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+
+import bean.Content;
+import bean.InnoResult;
+import bean.Track;
+import br.com.innovox.apps.managers.ExtractorManager;
+import br.com.innovox.apps.managers.FinderManager;
+import br.com.innovox.apps.managers.LutManager;
+import br.com.innovox.lib.soundmatch.IdtResult;
+import utils.AudioUtils;
+
+public class InnoSearcher {
+
+	private static final Logger logger = Logger.getLogger(InnoSearcher.class);
+
+	private LutManager lut;
+	private ExtractorManager extractor;
+	private FinderManager finder;
+	private AudioUtils audioUtils;
+
+	public InnoSearcher() {
+		
+		this.initLut();
+
+		this.audioUtils = new AudioUtils();
+	}
+	
+	private final void initLut() {
+		
+		logger.info("initLut: Initializing Lut.");
+		
+		this.extractor = new ExtractorManager();
+		this.lut = new LutManager(LutManager.DB_MEDIUM_SIZE);
+		this.finder = new FinderManager(lut);		
+	}
+	
+	public boolean indexAll(List<Content> contents) {
+
+		int indexCount = 0;
+
+		for (Content content : contents) {
+
+			try {
+				byte[] wav = this.audioUtils.toWave(content.getContentFile());
+
+				if (wav == null) {
+					logger.error("index: Could not generate WAV data from "+content.getContentFile().getAbsolutePath());
+					continue;
+				}
+
+				byte[] fingerprint = ExtractorManager.Process(wav);
+
+				this.lut.AddFingerprint(fingerprint, content.getContentId());
+
+				logger.info("index: Indexed "+content.getContentFile().getName()+" (" + ++indexCount + "/" + contents.size() + ")");
+			}
+			catch (Exception e) {
+				logger.error("indexAll: Could not index: "+content, e);
+				return false;
+			}
+		}
+		
+		logger.info("indexAll: Indexed "+indexCount+" contents.");
+		
+		return true;
+	}
+
+	public List<InnoResult> search(Track track) {
+		
+		List<InnoResult> result = new ArrayList<InnoResult>();
+		
+		IdtResult[] searchResult = null;
+		
+		try {
+			searchResult = this.search(track.getTrack(), this.toDate(track.getCreationTime()));
+		} catch (Exception e) {
+			logger.error("search: Could not perform search for track: "+track);
+		}
+		
+		if (searchResult != null) {
+			
+			for (IdtResult idtResult : searchResult) {
+				
+				for (int i = 0 ; i < idtResult.ids.length ; i++) {
+					
+					if (idtResult.ids[i] != 0) {
+						
+						result.add(new InnoResult(idtResult.ids[i], idtResult.distances[i]));
+					}
+				}
+			}
+		}
+		
+		return result;
+	}
+
+	private IdtResult[] search(File query, Date queryCreationTime) throws Exception  {
+		
+		logger.info("search: Searching "+query.getAbsolutePath());
+
+		// Reading wav file
+		byte[] wavstream = this.audioUtils.toWave(query);
+		if (wavstream == null) {
+			logger.error("search: Could not generate WAV data from "+query.getAbsolutePath());
+			return null;
+		}		
+
+		// Processing -- Feature Extration
+		wavstream = extractor.AlingWave(wavstream, queryCreationTime);
+		
+		if (wavstream == null) {
+			logger.error("search: Could not align WAV data from "+query.getAbsolutePath());
+			return null;
+		}
+
+		byte[] fingerprint = extractor.Process(wavstream, ExtractorManager.FLAG_NORMAL_FRAME);
+		
+		return finder.SearchMany(fingerprint, FinderManager.FLAG_NORMAL_FRAME);		
+	}
+	
+	private final Date toDate(LocalDateTime date) {
+		
+		return Date.from(date.atZone(ZoneId.systemDefault()).toInstant());
+	}
+
+	public void clear() {
+		
+		logger.info("clear: Cleaning InnoSearcher index.");
+		
+		this.initLut();
+	}
+}

src/main/java/utils/AudioUtils.java

@@ -0,0 +1,79 @@
+package utils;
+
+import java.io.File;
+
+import org.apache.log4j.Logger;
+import org.jaudiotagger.audio.AudioFile;
+import org.jaudiotagger.audio.AudioFileIO;
+
+import com.musicg.dsp.Resampler;
+import com.musicg.wave.Wave;
+
+import utils.audio.AudioMethods;
+
+public class AudioUtils {
+		
+	private static final Logger logger = Logger.getLogger(AudioUtils.class);
+	
+	private final AudioMethods audioMethods;
+	private final Resampler resampler;
+	
+	public AudioUtils() {
+		this.audioMethods = new AudioMethods();
+		this.resampler = new Resampler();
+	}
+	
+	/**
+	 * Retrieves the duration of an MP3 file in seconds.
+	 * 
+	 * @param mp3File File pointing at the MP3 file.
+	 * 
+	 * @return double containing the duration or -1 in case the duration could not be retrieved.
+	 */
+	public final double getMp3DurationInSeconds(File mp3File) {
+
+		double errorCode = -1;
+		
+		if (mp3File == null) {
+			logger.error("getMp3DurationInSeconds: Null MP3 file.");
+			return errorCode;
+		}
+		
+		if (!mp3File.exists() || !mp3File.isFile()) {
+			logger.error("getMp3DurationInSeconds: Invalid MP3 file: "+mp3File.getAbsolutePath());
+			return errorCode;
+		}
+		
+		try {
+			AudioFile audioFile = AudioFileIO.read(mp3File);
+			
+			double duration = ((double)mp3File.length()) / (audioFile.getAudioHeader().getBitRateAsNumber() / 8);
+			
+			return duration / 1000;
+		} 
+		catch (Exception e) {
+			logger.error("getMp3DurationInSeconds: Could not retrieve duration from "+mp3File.getAbsolutePath(), e);
+			return errorCode;
+		}		
+	}
+	
+	public final byte[] toWave(File file) throws Exception {
+
+		String wavFile = audioMethods.encodeWAVNRenameKeepOriginal(file.getAbsolutePath(), true);
+
+		if (wavFile == null || !new File(wavFile).exists()) {
+			System.out.println("Could not process: "+wavFile);
+			return null;
+		}
+
+		Wave wave = new Wave(wavFile);
+
+		int sourceRate = wave.getWaveHeader().getSampleRate();		
+
+		byte[] wavstream = resampler.reSample(wave.getBytes(), wave.getWaveHeader().getBitsPerSample(), sourceRate, 8000);
+
+		new File(wavFile).delete();
+
+		return wavstream;
+	}
+}

src/test/java/constants/TestConstants.java

@@ -0,0 +1,14 @@
+package constants;
+
+import java.io.File;
+
+public class TestConstants {
+
+	public final static File tempDir = new File("tempTestDir");
+	
+	public final static File testAudioFile = new File("testFiles/1_20171114114500.mp3");
+
+	public final static int testAudioFileDurationSecs = 89;
+	
+	public final static File[] audioToSearch = new File("testFiles/search").listFiles();
+}

src/test/java/extraction/TestSingleTrackExtractor.java

@@ -0,0 +1,72 @@
+package extraction;
+
+import java.io.File;
+import java.time.LocalTime;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.log4j.PropertyConfigurator;
+import org.junit.After;
+import org.junit.AfterClass;
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import constants.TestConstants;
+import utils.AudioUtils;
+
+public class TestSingleTrackExtractor {
+	
+	private final AudioUtils audioUtils = new AudioUtils();
+	
+	private SingleTrackExtractor extractor = null;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		PropertyConfigurator.configure("log4j.properties");
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+		TestConstants.tempDir.mkdirs();
+		extractor = new SingleTrackExtractor(TestConstants.tempDir);
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		FileUtils.deleteDirectory(TestConstants.tempDir);
+	}
+
+	@Test
+	public void should_return_empty_if_data_out_of_range() {
+			
+		File track = extractor.extract(TestConstants.testAudioFile, LocalTime.of(0, 2, 20), LocalTime.of(0, 0, 20), "track.mp3");
+		
+		assertEquals(0, this.audioUtils.getMp3DurationInSeconds(track), 1);
+	}
+	
+	@Test
+	public void should_not_accept_invalid_parameters() {
+	
+		assertNull(extractor.extract(null, LocalTime.now(), LocalTime.now(), "track.mp3"));	
+		
+		assertNull(extractor.extract(TestConstants.testAudioFile, null, null, "track.mp3"));
+		
+		assertNull(extractor.extract(new File("inexistent"), LocalTime.of(0, 0, 20), LocalTime.of(0, 0, 20), "track.mp3"));
+	}
+	
+	@Test
+	public void should_extract_track_if_everything_valid() {
+	
+		LocalTime start = LocalTime.of(0, 0, 20);
+		LocalTime duration = LocalTime.of(0, 0, 10);
+		
+		File track = extractor.extract(TestConstants.testAudioFile, start, duration, "track.mp3");		
+		
+		assertEquals(10, this.audioUtils.getMp3DurationInSeconds(track), 1);
+	}
+} 

src/test/java/extraction/TestTrackExtractor.java

@@ -0,0 +1,92 @@
+package extraction;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.log4j.PropertyConfigurator;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import bean.Track;
+import constants.TestConstants;
+import utils.AudioUtils;
+
+public class TestTrackExtractor {
+	
+	private final AudioUtils audioUtils = new AudioUtils();
+	private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+				
+		PropertyConfigurator.configure("log4j.properties");
+		FileUtils.deleteDirectory(TestConstants.tempDir);
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+		
+		TestConstants.tempDir.mkdirs();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		
+		FileUtils.deleteDirectory(TestConstants.tempDir);
+	}
+
+	@Test
+	public void should_extract_all_tracks() throws Exception {
+	
+		SingleTrackExtractor singleExtractor = new SingleTrackExtractor(TestConstants.tempDir);
+		
+		int trackLength = this.findLargestDivisor(TestConstants.testAudioFileDurationSecs);
+		
+		TrackExtractor extractor = new TrackExtractor(singleExtractor);
+		
+		LocalDateTime initialTime = this.parseCreationTime(TestConstants.testAudioFile);
+		
+		List<Track> tracks = extractor.extract(TestConstants.testAudioFile, trackLength, initialTime);
+		
+		assertEquals(TestConstants.testAudioFileDurationSecs / trackLength, tracks.size());		
+		
+		for (Track track : tracks) {
+			
+			assertEquals(trackLength, audioUtils.getMp3DurationInSeconds(track.getTrack()), 1);
+			
+			assertEquals(initialTime, track.getCreationTime());
+			
+			initialTime = initialTime.plusSeconds(trackLength);
+		}
+	}
+	
+	private final LocalDateTime parseCreationTime(File audioFile) {
+		
+		return LocalDateTime.parse(audioFile.getName().replaceAll(".mp3", "").split("_")[1], formatter);
+	}
+	
+	private final int findLargestDivisor(int length) {
+		
+		if (length % 2 == 0) {
+			return length / 2;
+		}
+		
+		int divisor = length / 2;
+		
+		while (--divisor > 1 && length % divisor != 0);
+		
+		return divisor;
+	}
+}

src/test/java/search/inno/TestInnoSearcher.java

@@ -0,0 +1,200 @@
+package search.inno;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.PropertyConfigurator;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import bean.Content;
+import bean.InnoResult;
+import bean.Track;
+import constants.TestConstants;
+
+public class TestInnoSearcher {
+	
+	private static final Logger logger = Logger.getLogger(TestInnoSearcher.class);
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		PropertyConfigurator.configure("log4j.properties");
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void should_identify_all_if_all_is_indexed() {
+	
+		List<Content> contents = new ArrayList<Content>();
+		for (File file : TestConstants.audioToSearch) {
+			contents.add(new Content(this.getContentId(file), file));
+		}
+		
+		InnoSearcher searcher = new InnoSearcher();
+		
+		searcher.indexAll(contents);
+				
+		int seconds = 10;
+		LocalDateTime initial = LocalDateTime.now();
+		
+		for (Content content : contents) {
+			
+			List<InnoResult> result = searcher.search(new Track(1, content.getContentFile(), initial));	
+			
+			assertTrue(!result.isEmpty());
+			
+			for (InnoResult innoResult : result) {
+
+				logger.info("should_identify_all_if_all_is_indexed: Expected ("+content+"), actual ("+innoResult+")");
+				
+				assertEquals(content.getContentId(), innoResult.getContentId(), 1);
+			}
+			
+			initial = initial.plusSeconds(seconds);
+		}
+	}
+	
+	@Test
+	public void should_only_identify_indexed_content() {
+		
+		List<Content> contents = new ArrayList<Content>();
+		contents.add(new Content(this.getContentId(TestConstants.audioToSearch[0]), TestConstants.audioToSearch[0]));
+		
+		InnoSearcher searcher = new InnoSearcher();
+		
+		searcher.indexAll(contents);
+		
+		List<InnoResult> result = searcher.search(new Track(1, TestConstants.audioToSearch[0], LocalDateTime.now()));
+		
+		assertTrue(!result.isEmpty());
+		
+		for (InnoResult content : result) {
+			
+			assertEquals(contents.get(0).getContentId(), content.getContentId());
+		}
+		
+		result = searcher.search(new Track(3, TestConstants.audioToSearch[2], LocalDateTime.now()));
+		
+		assertTrue(result.isEmpty());
+	}
+	
+	@Test
+	public void should_accept_on_the_fly_indexing() throws Exception {
+		
+		List<Content> contents = new ArrayList<Content>();
+		contents.add(new Content(this.getContentId(TestConstants.audioToSearch[0]), TestConstants.audioToSearch[0]));
+		
+		InnoSearcher searcher = new InnoSearcher();
+		
+		searcher.indexAll(contents);
+		
+		List<InnoResult> result = searcher.search(new Track(1, TestConstants.audioToSearch[0], LocalDateTime.now()));
+		
+		assertTrue(!result.isEmpty());
+		
+		for (InnoResult content : result) {
+			
+			assertEquals(contents.get(0).getContentId(), content.getContentId());
+		}
+		
+		result = searcher.search(new Track(3, TestConstants.audioToSearch[2], LocalDateTime.now()));
+				
+		assertTrue(result.isEmpty());
+		
+		contents.clear();
+		
+		contents.add(new Content(this.getContentId(TestConstants.audioToSearch[2]), TestConstants.audioToSearch[2]));
+		
+		searcher.indexAll(contents);
+		
+		Thread.sleep(2000);
+		
+		result = searcher.search(new Track(3, TestConstants.audioToSearch[2], LocalDateTime.now()));
+		
+		assertTrue(!result.isEmpty());
+		
+		for (InnoResult content : result) {
+			
+			assertEquals(contents.get(0).getContentId(), content.getContentId());
+		}
+	}
+	
+	@Test
+	public void should_return_nothing_if_index_is_empty() {
+		
+		InnoSearcher searcher = new InnoSearcher();
+		
+		for (File file : TestConstants.audioToSearch) {
+			
+			List<InnoResult> result = searcher.search(new Track(1, file, LocalDateTime.now()));
+			
+			assertTrue(result.isEmpty());
+		}		
+	}
+	
+	@Test
+	public void should_be_able_to_clean_up_index() {		
+		
+		List<Content> contents = new ArrayList<Content>();
+		for (File file : TestConstants.audioToSearch) {
+			contents.add(new Content(this.getContentId(file), file));
+		}
+		
+		InnoSearcher searcher = new InnoSearcher();
+		
+		searcher.indexAll(contents);
+				
+		int seconds = 10;
+		LocalDateTime initial = LocalDateTime.now();
+		
+		for (Content content : contents) {
+			
+			List<InnoResult> result = searcher.search(new Track(1, content.getContentFile(), initial));	
+			
+			assertTrue(!result.isEmpty());
+			
+			for (InnoResult innoResult : result) {
+
+				logger.info("should_identify_all_if_all_is_indexed: Expected ("+content+"), actual ("+innoResult+")");
+				
+				assertEquals(content.getContentId(), innoResult.getContentId(), 1);
+			}
+			
+			initial = initial.plusSeconds(seconds);
+		}
+		
+		searcher.clear();
+		
+		for (Content content : contents) {
+			
+			List<InnoResult> result = searcher.search(new Track(1, content.getContentFile(), initial));
+			
+			assertTrue(result.isEmpty());
+		}
+	}
+	
+	private final int getContentId(File content) {
+		
+		return Integer.parseInt(content.getName().replaceAll(".mp3", ""));
+	}
+}

src/test/java/utils/TestAudioUtils.java

@@ -0,0 +1,50 @@
+package utils;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import constants.TestConstants;
+
+public class TestAudioUtils {
+
+	private final AudioUtils audioUtils = new AudioUtils();
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void should_return_correct_length() {
+	
+		double duration = audioUtils.getMp3DurationInSeconds(TestConstants.testAudioFile);
+		
+		assertEquals(89, duration, 1);
+	}
+	
+	@Test
+	public void should_return_negative_value_for_invalid_input() {
+		
+		assertEquals(-1, audioUtils.getMp3DurationInSeconds(null), 0);
+		
+		assertEquals(-1, audioUtils.getMp3DurationInSeconds(new File("inexistent")), 0);
+	}
+}