diff --git a/src/RomanNumerals.java b/src/RomanNumerals.java
index 20904f0..a31acbe 100644
--- a/src/RomanNumerals.java
+++ b/src/RomanNumerals.java
@@ -1,8 +1,94 @@
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class RomanNumerals {
 	public int convertToInteger(String romanNum) {
-		// To be Implemented
-		return 0;
+		this.checkInput(romanNum);
+		ArrayList<Integer> list = new ArrayList<Integer>();
+		String c1; String c2="";
+		int n1; int n2=0;
 		
+		for (int i=0; i<romanNum.length(); i++) {
+			c1 = Character.toString(romanNum.charAt(i));
+			n1 = this.convertSingles(c1);
+			
+			if (i<(romanNum.length()-1)) {
+				c2 = Character.toString(romanNum.charAt(i+1));
+				n2 = this.convertSingles(c2);
+				}
+				if (n1<n2) {
+					int n = this.subtraction(c1,c2);
+					list.add(n);
+					i++;
+					}
+				
+			else {
+				list.add(n1);
+			}
+		}
+		
+		int result = 0;
+		for(int i : list)
+		    result += i;
+		return result;
+		
+	}
+	public void checkInput(String romanNum) throws IllegalArgumentException{
+		Pattern p1 = Pattern.compile("([ixcm])\\1\\1\\1", Pattern.CASE_INSENSITIVE);
+	    Matcher m1 = p1.matcher(romanNum);
+	    if (m1.find()) throw new IllegalArgumentException();
+	    							//V, L, or D 2 times
+	    Pattern p2 = Pattern.compile("([vld])\\1", Pattern.CASE_INSENSITIVE);
+	    Matcher m2 = p2.matcher(romanNum);
+	    if (m2.find()) throw new IllegalArgumentException();
+		
+	}
+	
+	public int convertSingles(String romanDigit) {
+		int i = 0;
+		String rd = romanDigit.toLowerCase();
+		
+		switch (rd){
+		case "i": i=1;
+			break;
+		case "v": i=5;
+			break;
+		case "x": i=10;
+			break;
+		case "l": i=50;
+			break;
+		case "c": i=100;
+			break;
+		case "d": i=500;
+			break;
+		case "m": i=1000;
+			break;
+		}
+		
+		return i;
+	}
+	
+	public int subtraction(String c1, String c2) throws IllegalArgumentException{
+		String str = c1+c2;
+		
+		Pattern p1 = Pattern.compile("^[i][lcdm]", Pattern.CASE_INSENSITIVE);
+	    Matcher m1 = p1.matcher(str);
+	    if (m1.find()) throw new IllegalArgumentException();
+	    
+	    Pattern p2 = Pattern.compile("^[x][dm]", Pattern.CASE_INSENSITIVE);
+	    Matcher m2 = p2.matcher(str);
+	    if (m2.find()) throw new IllegalArgumentException();
+	    
+	    Pattern p3 = Pattern.compile("^[vld]", Pattern.CASE_INSENSITIVE);
+	    Matcher m3 = p3.matcher(str);
+	    if (m3.find()) throw new IllegalArgumentException();
+	    
+	    int n1 = this.convertSingles(c1);
+	    int n2 = this.convertSingles(c2);
+	    int subd = n2 - n1;
+		
+	    return subd;
 	}
+	
 }
diff --git a/tests/TestRomanNumerals.java b/tests/TestRomanNumerals.java
index 5d1de75..7967dff 100644
--- a/tests/TestRomanNumerals.java
+++ b/tests/TestRomanNumerals.java
@@ -3,10 +3,92 @@
 import org.junit.Test;
 
 public class TestRomanNumerals {
-
+	@Test(expected = IllegalArgumentException.class)
+	public void testCheckInputIXCM() throws IllegalArgumentException{
+		RomanNumerals rm = new RomanNumerals();
+		String roman1 = "IIII";
+		String roman2 = "IIIXXXMMMM";
+		String roman3 = "mcmxxxx";
+		
+		//rm.checkInput(roman1);
+		//rm.checkInput(roman2);
+		rm.checkInput(roman3);
+		/*Uncomment the one you wish to test in isolation*/
+		
+	}
+	
+	@Test(expected = IllegalArgumentException.class)
+	public void testCheckInputVLD() throws IllegalArgumentException{
+		RomanNumerals rm = new RomanNumerals();
+		String roman1 = "VV";
+		String roman2 = "MLL";
+		String roman3 = "ddd";
+		
+		//rm.checkInput(roman1);
+		rm.checkInput(roman2);
+		//rm.checkInput(roman3);
+		/*Uncomment the one you wish to test in isolation*/
+		
+	}
+	
+	@Test
+	public void testConvertSingles() {
+		RomanNumerals rm = new RomanNumerals();
+		String roman1 = "MMXIv";
+		String romanC1 = Character.toString(roman1.charAt(0)); //M
+		String romanC2 = Character.toString(roman1.charAt(2)); //X
+		String romanC3 = Character.toString(roman1.charAt(4)); //V
+		
+		assertEquals(1000, rm.convertSingles(romanC1));
+		assertEquals(10, rm.convertSingles(romanC2));
+		assertEquals(5, rm.convertSingles(romanC3));
+	}
+	
+	@Test(expected = IllegalArgumentException.class)
+	public void testSubtractionThrows() throws IllegalArgumentException{
+		RomanNumerals rm = new RomanNumerals();
+		String x1 = "I"; String x2 = "L";
+		String y1 = "x"; String y2 = "d";
+		String z1 = "I"; String z2 = "D";
+		String a1 = "v"; String a2 = "m";
+		
+		rm.subtraction(x1, x2);
+		//rm.subtraction(y1, y2);
+		//rm.subtraction(z1, z2);
+		//rm.subtraction(a1, a2);
+		/*Uncomment the one you wish to test in isolation*/
+		
+	}
+	
+	@Test
+	public void testSubtraction() {
+		RomanNumerals rm = new RomanNumerals();
+		
+		String x1 = "I"; String x2 = "V";
+		int result1 = rm.subtraction(x1, x2);
+		assertEquals(4, result1);
+		
+		String y1 = "x"; String y2 = "c";
+		assertEquals(90, rm.subtraction(y1, y2));
+		
+		String z1 = "C"; String z2 = "m";
+		assertEquals(900, rm.subtraction(z1, z2));
+	}
+	
 	@Test
-	public void test() {
-		fail("Not yet implemented");
+	public void testConvertToInteger() {
+		RomanNumerals rm = new RomanNumerals();
+		String romanNum1 = "mmxiv";
+		String romanNum2 = "MCMLXXXIV";
+		String romanNum3 = "MCMXCII";
+		String romanNum4 = "MMMDCCCLXXXVIII";
+		String romanNum5 = "cdxliv";
+		
+		assertEquals(2014, rm.convertToInteger(romanNum1));
+		assertEquals(1984, rm.convertToInteger(romanNum2));
+		assertEquals(1992, rm.convertToInteger(romanNum3));
+		assertEquals(3888, rm.convertToInteger(romanNum4));
+		assertEquals(444, rm.convertToInteger(romanNum5));
 	}
 
 }