Added Ignore annotation to all tests but the first one in all-your-base.

exercises/all-your-base/src/test/java/BaseConverterTest.java

+import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testBinaryToSingleDecimal() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testSingleDecimalToBinary() {
         final BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testBinaryToMultipleDecimal() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testDecimalToBinary() {
         final BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testTrinaryToHexadecimal() {
         final BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testHexadecimalToTrinary() {
         final BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void test15BitInteger() {
         final BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testEmptyDigits() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(2, new int[]{});
     }
 
+    @Ignore
     @Test
     public void testSingleZero() {
         final BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
                 actualDigits);
     }
 
+    @Ignore
     @Test
     public void testMultipleZeros() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(10, new int[]{0, 0, 0});
     }
 
+    @Ignore
     @Test
     public void testLeadingZeros() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(7, new int[]{0, 6, 0});
     }
 
+    @Ignore
     @Test
     public void testNegativeDigit() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(2, new int[]{1, -1, 1, 0, 1, 0});
     }
 
+    @Ignore
     @Test
     public void testInvalidPositiveDigit() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(2, new int[]{1, 2, 1, 0, 1, 0});
     }
 
+    @Ignore
     @Test
     public void testFirstBaseIsOne() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(1, new int[]{});
     }
 
+    @Ignore
     @Test
     public void testSecondBaseIsOne() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
         baseConverter.convertToBase(1);
     }
 
+    @Ignore
     @Test
     public void testFirstBaseIsZero() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(0, new int[]{});
     }
 
+    @Ignore
     @Test
     public void testSecondBaseIsZero() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
         baseConverter.convertToBase(0);
     }
 
+    @Ignore
     @Test
     public void testFirstBaseIsNegative() {
         expectedException.expect(IllegalArgumentException.class);
         new BaseConverter(-2, new int[]{});
     }
 
+    @Ignore
     @Test
     public void testSecondBaseIsNegative() {
         final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});