diff --git a/src/RomanNumerals.java b/src/RomanNumerals.java
index 20904f0..00851f3 100644
--- a/src/RomanNumerals.java
+++ b/src/RomanNumerals.java
@@ -1,8 +1,109 @@
 
 public class RomanNumerals {
-	public int convertToInteger(String romanNum) {
-		// To be Implemented
-		return 0;
+public int convertToInteger(String romanNum) {
 		
+		romanNum = romanNum.toUpperCase();
+		if(testRepeatIXCM(romanNum)) return -1;
+		if(testRepeatVLD(romanNum)) return -2;
+		if(testAllowedSubstractIXC(romanNum)) return -3;
+		if(testAllowedSubstractOne(romanNum)) return -4;
+		if(testNoSubstractAllowedVLD(romanNum)) return -5;
+		if(!romanNum.matches("^[IVXLCDM]+$") && romanNum != "") return -6;
+		
+		return calculateString(convertToNumberArray(romanNum));
+		
+	}
+	
+	private int getMainNumberValue(char pieceOfString){
+		int result = 0;
+		
+		switch (pieceOfString){
+			case 'I': 	result = 1;
+			break;
+			case 'V':	result = 5;
+			break;
+			case 'X':   result = 10;
+			break;
+			case 'L':   result = 50;
+			break;
+			case 'C':   result = 100;
+			break;
+			case 'D': 	result = 500;
+			break;
+			case 'M':   result = 1000;
+						
+		}	return result;
+	}
+	
+	private boolean testRepeatVLD(String romanNum){
+		boolean test = false;
+		int counter = 1;
+		for(int i = 0; i < romanNum.length(); i++){
+			if(i >= 1 && romanNum.charAt(i) == romanNum.charAt(i-1) && "VLD".indexOf(romanNum.charAt(i)) >= 0) {
+				counter++;
+				if(counter >= 2) test = true;
+			}
+			else counter = 1;
+		}	return test;
+	}
+	
+	private boolean testRepeatIXCM(String romanNum){
+		boolean test = false;
+		int counter = 1;
+		for(int i = 0; i < romanNum.length(); i++){
+			if(i >= 1 && romanNum.charAt(i) == romanNum.charAt(i-1)) {
+				counter++;
+				if(counter >= 4) test = true;
+			}
+			else counter = 1;
+		}	return test;
+	}
+	
+	private boolean testAllowedSubstractOne(String romanNum){
+		boolean test = false;
+
+		for(int i = 2; i < romanNum.length(); i++){
+			if(romanNum.charAt(i-2) == 'I' && romanNum.charAt(i-1) == 'I' && "VX".indexOf(romanNum.charAt(i)) >= 0) test = true;
+			if(romanNum.charAt(i-2) == 'X' && romanNum.charAt(i-1) == 'X' && "LC".indexOf(romanNum.charAt(i)) >= 0) test = true;
+			if(romanNum.charAt(i-2) == 'C' && romanNum.charAt(i-1) == 'C' && "DM".indexOf(romanNum.charAt(i)) >= 0) test = true;
+		}	return test;
+	}
+	
+	private boolean testAllowedSubstractIXC(String romanNum){
+		boolean test = false;
+
+		for(int i = 1; i < romanNum.length(); i++){
+			if(romanNum.charAt(i-1) == 'I' && "LCDM".indexOf(romanNum.charAt(i)) >= 0) test = true;
+			if(romanNum.charAt(i-1) == 'X' && "DM".indexOf(romanNum.charAt(i)) >= 0) test = true;
+		}	return test;
+	}
+	
+	private boolean testNoSubstractAllowedVLD(String romanNum){
+		boolean test = false;
+
+		for(int i = 1; i < romanNum.length(); i++){
+			if(romanNum.charAt(i-1) == 'V' && romanNum.charAt(i) != 'I') test = true;
+			if(romanNum.charAt(i-1) == 'L' && "IVX".indexOf(romanNum.charAt(i)) == -1) test = true;
+			if(romanNum.charAt(i-1) == 'D' && romanNum.charAt(i) == 'M') test = true;
+		}	return test;
+	}
+	
+	private int calculateString(int[] numbersArray){
+		int result = 0;
+		
+		for(int i=0; i < numbersArray.length; i++){
+			if(i < numbersArray.length-1 && numbersArray[i] < numbersArray[i+1]) result-=numbersArray[i];
+			else result += numbersArray[i];
+		}	return result;
+	}
+	
+	private int[] convertToNumberArray(String romanNum){
+		int[] numbersArray = new int[10];
+
+		for(int i = 0; i < romanNum.length(); i++){
+			numbersArray[i] = getMainNumberValue(romanNum.charAt(i));
+		}	return numbersArray;
 	}
-}
+	
+	
+}
\ No newline at end of file
diff --git a/tests/TestRomanNumerals.java b/tests/TestRomanNumerals.java
index 5d1de75..7e9ae69 100644
--- a/tests/TestRomanNumerals.java
+++ b/tests/TestRomanNumerals.java
@@ -1,12 +1,149 @@
 import static org.junit.Assert.*;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 public class TestRomanNumerals {
-
-	@Test
+	@Ignore
 	public void test() {
 		fail("Not yet implemented");
 	}
+	
+	@Test
+	public void testRomanNumeralsVLDRepeatRules(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input VV should return error code -2", -2, test.convertToInteger("VV"));
+		assertEquals("Input VV should return error code -2", -2, test.convertToInteger("LL"));
+		assertEquals("Input VV should return error code -2", -2, test.convertToInteger("DD"));
+	}
+	
+	@Test
+	public void testRomanNumeralsIXCMRepeatRules(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input IIII should return error code -1", -1, test.convertToInteger("IIII"));
+		assertEquals("Input XXXX should return error code -1", -1, test.convertToInteger("XXXX"));
+		assertEquals("Input CCCC should return error code -1", -1, test.convertToInteger("CCCC"));
+		assertEquals("Input MMMM should return error code -1", -1, test.convertToInteger("MMMM"));
+	}
+	
+	@Test
+	public void testRomanNumeralsIXCSubstractRules(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input IL should return error code -3", -3, test.convertToInteger("IL"));
+		assertEquals("Input IC should return error code -3", -3, test.convertToInteger("IC"));
+		assertEquals("Input IC should return error code -3", -3, test.convertToInteger("ID"));
+		assertEquals("Input IC should return error code -3", -3, test.convertToInteger("IM"));
+		assertEquals("Input XD should return error code -3", -3, test.convertToInteger("XD"));
+		assertEquals("Input XM should return error code -3", -3, test.convertToInteger("XM"));
+
+	}
+	
+	@Test
+	public void testRomanNumeralsOnlyOneSubstract(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input IIV should return error code -4", -4, test.convertToInteger("IIV"));
+		assertEquals("Input IIX should return error code -4", -4, test.convertToInteger("IIX"));
+		assertEquals("Input XXL should return error code -4", -4, test.convertToInteger("XXL"));
+		assertEquals("Input XXC should return error code -4", -4, test.convertToInteger("XXC"));
+		assertEquals("Input CCD should return error code -4", -4, test.convertToInteger("CCD"));
+		assertEquals("Input CCM should return error code -4", -4, test.convertToInteger("CCM"));
+		
+	}
+	@Test
+	public void testRomanNumeralsNotSubtractVLD(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input VX should return error code -5", -5, test.convertToInteger("VX"));
+		assertEquals("Input LC should return error code -5", -5, test.convertToInteger("LC"));
+		assertEquals("Input DM should return error code -5", -5, test.convertToInteger("DM"));
+
+		
+	}
+	
+	@Test
+	public void testRomanNumeralsWithBasicElements() {
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input I should return 1", 1, test.convertToInteger("I"));
+		assertEquals("Input X should return 10", 10, test.convertToInteger("X"));
+		assertEquals("Input L should return 50", 50, test.convertToInteger("L"));
+		assertEquals("Input C should return 100", 100, test.convertToInteger("C"));
+		assertEquals("Input D should return 500", 500, test.convertToInteger("D"));
+		assertEquals("Input M should return 1000", 1000, test.convertToInteger("M"));
+		
+	}
+	
+	@Test
+	public void testRomanNumeralsAddTogether(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input MMMIII should return 3003", 3003, test.convertToInteger("MMMIII"));
+	
+	}
+	
+	@Test
+	public void testRomanNumeralsSubstract(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input IV should return 4", 4, test.convertToInteger("IV"));
+		assertEquals("Input IX should return 9", 9, test.convertToInteger("IX"));
+		assertEquals("Input XL should return 40", 40, test.convertToInteger("XL"));
+		assertEquals("Input XC should return 90", 90, test.convertToInteger("XC"));
+		assertEquals("Input CD should return 400", 400, test.convertToInteger("CD"));
+		assertEquals("Input CM should return 900", 900, test.convertToInteger("CM"));
+
+		
+	}
+	
+	@Test
+	public void testRomanNumeralsTotal(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input MMMCMXCIX should return 3999", 3999, test.convertToInteger("MMMCMXCIX"));
+		assertEquals("Empty Input should return 0", 0, test.convertToInteger(""));
+	}
+	
+	@Test
+	public void testRomanNumeralsShouldAcceptLowerCase(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input MMMCMXCIX should return 3999", 3999, test.convertToInteger("mmmcmxcix"));
+	}
+	
+	@Test
+	public void testRomanNumeralsOnlyContainMDCLXVI(){
+		//Setup
+		RomanNumerals test = new RomanNumerals();
+		
+		//Assert
+		assertEquals("Input MMFM should return -6", -6, test.convertToInteger("MMFM"));
+		assertEquals("Input MF should return -6", -6, test.convertToInteger("MF"));
+		assertEquals("Input FM should return -6", -6, test.convertToInteger("FM"));
+		
+	}
 
 }