'CommitAfterUnitTesting'

Author: Teju

.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="lib" path="C:/Users/Teju/workspace/Sample/DiamondKinetics/junit-4.10.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.project

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

README.md

@@ -1,2 +1,27 @@
 # DiamondKinetics
 Solution for the coding challenge round at DiamondKinetics
+
+
+
+1. The source file which contains the API is "SensorDataAnalysis.java".  "SensorData.java" class holds the sensor data value which are retrieved from the csv file (the csv file is kept
+   within the src folder for now, you can have many more csv files but kindly specify the path of the csv file as input to the APIs. The data attribute of the API takes in a string value
+   which would be the path of the csv file on which the criteria has to be checked. This file can be changed at any point in time.  
+   The values from any csv file given are added into an ArrayList<SensorData> which is later retrieved from indexBegin to indexEnd to check for the criteria as per each APIs requirement and
+   an index value in returned as output. 
+   
+2. In case of the fourth operation since two index values have to returned I have considered the output to be a string wherein the values are separated by a space. 
+
+3. Additionally, I have also written parametrized test cases for each one of the API to test them. You can add many more test data within the parameterized array to check 
+   for the functional correctness of all four operations. Incase I have missed out on something or some of the scenario are incorrect or some edge conditions fail kindly help me with it.
+   I owuld love to work with you to fix things.
+   
+4. In case, the indexEnd - indexBegin < winLength I have returned -1 value, similarly if am not able to find any samples within the winLength window I have returned -1. This is just to handle
+   the edge conditions.
+   
+5. If am totally wrong with my approach, I would like to get some comments/feedback to improvize on the solution that I have obtained.
+
+6. I have not uplaoded the latestSwing.csv file due to confidentiality reasons, kindly place the csv file in the src folder before executing the test cases otherwise it would throw 
+   file not found exception
+
+
+

bin/BackSearchContinuityWithinRangeTest.class

@@ -0,0 +1,47 @@
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+	@RunWith(Parameterized.class)
+	public class BackSearchContinuityWithinRangeTest {		
+		
+	    @Parameters
+	    public static Collection<Object[]> data() {
+	        return Arrays.asList(new Object[][] {   	              
+	                 { "../DiamondKinetics/src/latestSwing.csv", 90, 0, 0.2, 0.702148, 12, 90}, 
+	               
+	           });
+	    }
+	  
+	    private String data;
+	    private int indexBegin,indexEnd,winLength;
+	    private Double thresholdLo,thresholdHi;
+	    private int expected;
+	    
+	    public BackSearchContinuityWithinRangeTest(String data, int indexBegin, int indexEnd, Double thresholdLo,
+				Double thresholdHi, int winLength, int out) {
+	    	
+	        this.data= data;
+	        this.indexBegin = indexBegin;
+	        this.indexEnd = indexEnd;
+	        this.thresholdLo = thresholdLo;
+	        this.thresholdHi = thresholdHi;
+	        this.winLength = winLength;
+	        this.expected = out;
+	    }
+	    
+	    @Test
+	    public void testBackSearchContinuityWithinRange() {
+	    	 assertEquals(expected, SensorDataAnalysis.backSearchContinuityWithinRange(data,indexBegin,indexEnd,thresholdLo,thresholdHi,winLength));
+	    }
+	}
+
+

bin/SearchContinuityAboveValueTest$Type.class

@@ -0,0 +1,58 @@
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+	@RunWith(Parameterized.class)
+	public class SearchContinuityAboveValueTest {
+		
+		enum Type {searchContinuityAboveValue,backSearchContinuityWithinRange,searchContinuityAboveValueTwoSignals,searchMultiContinuityWithinRange};
+		
+	    @Parameters
+	    public static Collection<Object[]> data() {
+	        return Arrays.asList(new Object[][] {     
+	                 {Type.searchContinuityAboveValue,"../DiamondKinetics/src/latestSwing.csv", 139, 145, 0.4564, 3, 139}, 
+	                 {Type.searchContinuityAboveValue,"../DiamondKinetics/src/latestSwing.csv", 0, 10, -17.9999, 12, -1}, 
+	                 {Type.searchContinuityAboveValue,"../DiamondKinetics/src/latestSwing.csv", 0, 25, 4.0, 15, -1}, 
+	                 {Type.searchContinuityAboveValue,"../DiamondKinetics/src/latestSwing.csv", 1200, 1250, 3.0, 40, 1200}, 
+	                
+	               
+	           });
+	    }
+	    private Type type;
+	    private String data;
+	    private int indexBegin,indexEnd,winLength;
+	    private Double threshold;
+	    private int expected;
+	   
+
+	    public SearchContinuityAboveValueTest(Type type,String data, int indexBegin, int indexEnd, Double threshold,
+				int winLength, int out) {
+	    	this.type= type;
+	        this.data= data;
+	        this.indexBegin = indexBegin;
+	        this.indexEnd = indexEnd;
+	        this.threshold = threshold;
+	        this.winLength = winLength;
+	        this.expected = out;
+	    }
+	    
+	  
+	    
+	    @Test
+	    public void testSearchContinuityAboveValue() {
+	    	Assume.assumeTrue(type == Type.searchContinuityAboveValue);
+	        assertEquals(expected, SensorDataAnalysis.searchContinuityAboveValue(data,indexBegin,indexEnd,threshold,winLength));
+	    }
+	    
+
+	}
+
+

bin/SearchContinuityAboveValueTest.class

@@ -0,0 +1,53 @@
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+	@RunWith(Parameterized.class)
+	public class SearchContinuityAboveValueTwoSignalsTest {
+		
+		enum Type {searchContinuityAboveValueTwoSignals};
+		
+	    @Parameters
+	    public static Collection<Object[]> data() {
+	        return Arrays.asList(new Object[][] {     
+	                 {Type.searchContinuityAboveValueTwoSignals, "../DiamondKinetics/src/latestSwing.csv", "../DiamondKinetics/src/latestSwing.csv", 2, 90, 0.2, 0.3, 12, 2 }, 
+	                
+	           });
+	    }
+	    private Type type;
+	    private String data1,data2;
+	    private int indexBegin,indexEnd,winLength;
+	    private Double thresholdLo,thresholdHi;
+	    private int expected;
+	    private String expectedOutput;
+	    
+	    public SearchContinuityAboveValueTwoSignalsTest(Type type,String data1, String data2, int indexBegin, int indexEnd, Double thresholdLo,
+					Double thresholdHi, int winLength, int out) {
+		    	this.type= type;
+		        this.data1= data1;
+		        this.data2 = data2;
+		        this.indexBegin = indexBegin;
+		        this.indexEnd = indexEnd;
+		        this.thresholdLo = thresholdLo;
+		        this.thresholdHi = thresholdHi;
+		        this.winLength = winLength;
+		        this.expected = out;
+		    }
+
+	    @Test
+	    public void testSearchContinuityAboveValueTwoSignals() {
+	    	Assume.assumeTrue(type == Type.searchContinuityAboveValueTwoSignals);
+	        assertEquals(expected, SensorDataAnalysis.searchContinuityAboveValueTwoSignals(data1,data2,indexBegin,indexEnd,thresholdLo,thresholdHi,winLength));
+	    }
+	    
+	}
+
+

bin/SearchContinuityAboveValueTwoSignalsTest$Type.class

@@ -0,0 +1,51 @@
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+	@RunWith(Parameterized.class)
+	public class SearchMultiContinuityWithinRangeTest {
+		
+		enum Type {searchContinuityAboveValue,backSearchContinuityWithinRange,searchContinuityAboveValueTwoSignals,searchMultiContinuityWithinRange};
+		
+	    @Parameters
+	    public static Collection<Object[]> data() {
+	        return Arrays.asList(new Object[][] {     
+	                 {Type.searchMultiContinuityWithinRange,"../DiamondKinetics/src/latestSwing.csv", 0, 90, 0.2, 0.702148, 12, "0 11" }
+	           });
+	    }
+	    private Type type;
+	    private String data;
+	    private int indexBegin,indexEnd,winLength;
+	    private Double thresholdLo,thresholdHi;	 
+	    private String expectedOutput;
+
+	   public SearchMultiContinuityWithinRangeTest(Type type,String data, int indexBegin, int indexEnd, Double thresholdLo, Double thresholdHi, int
+	    		  winLength, String out) {
+		    	this.type= type;
+		        this.data= data;		     
+		        this.indexBegin = indexBegin;
+		        this.indexEnd = indexEnd;
+		        this.thresholdLo = thresholdLo;
+		        this.thresholdHi = thresholdHi;
+		        this.winLength = winLength;
+		        this.expectedOutput = out;
+		    }
+	    
+	  
+	    @Test
+	    public void testSearchMultiContinuityWithinRange() {
+	    	Assume.assumeTrue(type == Type.searchMultiContinuityWithinRange);
+	        assertEquals(expectedOutput, SensorDataAnalysis.searchMultiContinuityWithinRange(data,indexBegin,indexEnd,thresholdLo,thresholdHi,winLength));
+	    }
+	    
+	}
+
+

bin/SearchContinuityAboveValueTwoSignalsTest.class

@@ -0,0 +1,48 @@
+import java.math.BigInteger;
+
+public class SensorData {
+	BigInteger timestamp;
+	public BigInteger getTimestamp() {
+		return timestamp;
+	}
+	public void setTimestamp(BigInteger timestamp) {
+		this.timestamp = timestamp;
+	}
+	public Double getAx() {
+		return ax;
+	}
+	public void setAx(Double ax) {
+		this.ax = ax;
+	}
+	public Double getAy() {
+		return ay;
+	}
+	public void setAy(Double ay) {
+		this.ay = ay;
+	}
+	public Double getAz() {
+		return az;
+	}
+	public void setAz(Double az) {
+		this.az = az;
+	}
+	public Double getBx() {
+		return bx;
+	}
+	public void setBx(Double bx) {
+		this.bx = bx;
+	}
+	public Double getBy() {
+		return by;
+	}
+	public void setBy(Double by) {
+		this.by = by;
+	}
+	public Double getBz() {
+		return bz;
+	}
+	public void setBz(Double bz) {
+		this.bz = bz;
+	}
+	Double ax, ay, az, bx, by, bz;
+}