Convert to Java 5 enhanced loops.

garydgregory · garydgregory · commit acf70b38d27b · 2011-07-11T01:10:36.000Z
git-svn-id: https://svn.apache.org/repos/asf/commons/proper/codec/trunk@1145000 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/src/java/org/apache/commons/codec/binary/BaseNCodec.java b/src/java/org/apache/commons/codec/binary/BaseNCodec.java
@@ -415,8 +415,8 @@ protected boolean containsAlphabetOrPad(byte[] arrayOctet) {
         if (arrayOctet == null) {
             return false;
         }
-        for (int i = 0; i < arrayOctet.length; i++) {
-            if (PAD == arrayOctet[i] || isInAlphabet(arrayOctet[i])) {
+        for (byte element : arrayOctet) {
+            if (PAD == element || isInAlphabet(element)) {
                 return true;
             }
         }
diff --git a/src/java/org/apache/commons/codec/language/ColognePhonetic.java b/src/java/org/apache/commons/codec/language/ColognePhonetic.java
@@ -272,8 +272,8 @@ public char removeNext() {
      * Returns whether the array contains the key, or not.
      */
     private static boolean arrayContains(char[] arr, char key) {
-        for (int i = 0; i < arr.length; i++) {
-            if (arr[i] == key) {
+        for (char element : arr) {
+            if (element == key) {
                 return true;
             }
         }
@@ -406,9 +406,9 @@ private String preprocess(String text) {
 
         for (int index = 0; index < chrs.length; index++) {
             if (chrs[index] > 'Z') {
-                for (int replacement = 0; replacement < PREPROCESS_MAP.length; replacement++) {
-                    if (chrs[index] == PREPROCESS_MAP[replacement][0]) {
-                        chrs[index] = PREPROCESS_MAP[replacement][1];
+                for (char[] element : PREPROCESS_MAP) {
+                    if (chrs[index] == element[0]) {
+                        chrs[index] = element[1];
                         break;
                     }
                 }
diff --git a/src/java/org/apache/commons/codec/language/DoubleMetaphone.java b/src/java/org/apache/commons/codec/language/DoubleMetaphone.java
@@ -905,8 +905,8 @@ private boolean isVowel(char ch) {
      */    
     private boolean isSilentStart(String value) {
         boolean result = false;
-        for (int i = 0; i < SILENT_START.length; i++) {
-            if (value.startsWith(SILENT_START[i])) {
+        for (String element : SILENT_START) {
+            if (value.startsWith(element)) {
                 result = true;
                 break;
             }
@@ -1013,8 +1013,8 @@ protected static boolean contains(String value, int start, int length,
         if (start >= 0 && start + length <= value.length()) {
             String target = value.substring(start, start + length);
 
-            for (int i = 0; i < criteria.length; i++) {
-                if (target.equals(criteria[i])) {
+            for (String element : criteria) {
+                if (target.equals(element)) {
                     result = true;
                     break;
                 }
diff --git a/src/java/org/apache/commons/codec/net/QCodec.java b/src/java/org/apache/commons/codec/net/QCodec.java
@@ -153,8 +153,8 @@ protected byte[] doDecoding(byte[] bytes) throws DecoderException {
             return null;
         }
         boolean hasUnderscores = false;
-        for (int i = 0; i < bytes.length; i++) {
-            if (bytes[i] == UNDERSCORE) {
+        for (byte b : bytes) {
+            if (b == UNDERSCORE) {
                 hasUnderscores = true;
                 break;
             }
diff --git a/src/java/org/apache/commons/codec/net/QuotedPrintableCodec.java b/src/java/org/apache/commons/codec/net/QuotedPrintableCodec.java
@@ -145,8 +145,8 @@ public static final byte[] encodeQuotedPrintable(BitSet printable, byte[] bytes)
             printable = PRINTABLE_CHARS;
         }
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-        for (int i = 0; i < bytes.length; i++) {
-            int b = bytes[i];
+        for (byte c : bytes) {
+            int b = c;
             if (b < 0) {
                 b = 256 + b;
             }
diff --git a/src/java/org/apache/commons/codec/net/URLCodec.java b/src/java/org/apache/commons/codec/net/URLCodec.java
@@ -130,8 +130,8 @@ public static final byte[] encodeUrl(BitSet urlsafe, byte[] bytes) {
         }
 
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-        for (int i = 0; i < bytes.length; i++) {
-            int b = bytes[i];
+        for (byte c : bytes) {
+            int b = c;
             if (b < 0) {
                 b = 256 + b;
             }
diff --git a/src/test/org/apache/commons/codec/StringEncoderAbstractTest.java b/src/test/org/apache/commons/codec/StringEncoderAbstractTest.java
@@ -36,14 +36,14 @@ public void checkEncoding(String expected, String source) throws EncoderExceptio
     }
 
     protected void checkEncodings(String[][] data) throws EncoderException {
-        for (int i = 0; i < data.length; i++) {
-            this.checkEncoding(data[i][1], data[i][0]);
+        for (String[] element : data) {
+            this.checkEncoding(element[1], element[0]);
         }
     }
 
     protected void checkEncodingVariations(String expected, String data[]) throws EncoderException {
-        for (int i = 0; i < data.length; i++) {
-            this.checkEncoding(expected, data[i]);
+        for (String element : data) {
+            this.checkEncoding(expected, element);
         }
     }
 
@@ -93,16 +93,16 @@ public void testLocaleIndependence() throws Exception {
         Locale[] locales = {Locale.ENGLISH, new Locale("tr"), Locale.getDefault()};
 
         try {
-            for (int i = 0; i < data.length; i++) {
+            for (String element : data) {
                 String ref = null;
                 for (int j = 0; j < locales.length; j++) {
                     Locale.setDefault(locales[j]);
                     if (j <= 0) {
-                        ref = encoder.encode(data[i]);
+                        ref = encoder.encode(element);
                     } else {
                         String cur = null;
                         try {
-                            cur = encoder.encode(data[i]);
+                            cur = encoder.encode(element);
                         } catch (Exception e) {
                             Assert.fail(Locale.getDefault().toString() + ": " + e.getMessage());
                         }
diff --git a/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java b/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java
@@ -230,8 +230,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
         // Start with encode.
         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
         OutputStream out = new Base32OutputStream(byteOut, true, chunkSize, seperator);
-        for (int i = 0; i < decoded.length; i++) {
-            out.write(decoded[i]);
+        for (byte element : decoded) {
+            out.write(element);
         }
         out.close();
         byte[] output = byteOut.toByteArray();
@@ -240,8 +240,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
         // Now let's try decode.
         byteOut = new ByteArrayOutputStream();
         out = new Base32OutputStream(byteOut, false);
-        for (int i = 0; i < encoded.length; i++) {
-            out.write(encoded[i]);
+        for (byte element : encoded) {
+            out.write(element);
         }
         out.close();
         output = byteOut.toByteArray();
@@ -250,8 +250,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
         // Now let's try decode with tonnes of flushes.
         byteOut = new ByteArrayOutputStream();
         out = new Base32OutputStream(byteOut, false);
-        for (int i = 0; i < encoded.length; i++) {
-            out.write(encoded[i]);
+        for (byte element : encoded) {
+            out.write(element);
             out.flush();
         }
         out.close();
@@ -265,8 +265,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
             out = new Base32OutputStream(out, false);
             out = new Base32OutputStream(out, true, chunkSize, seperator);
         }
-        for (int i = 0; i < decoded.length; i++) {
-            out.write(decoded[i]);
+        for (byte element : decoded) {
+            out.write(element);
         }
         out.close();
         output = byteOut.toByteArray();
diff --git a/src/test/org/apache/commons/codec/binary/Base32Test.java b/src/test/org/apache/commons/codec/binary/Base32Test.java
@@ -61,24 +61,24 @@ public class Base32Test {
     @Test
     public void testBase32Samples() throws Exception {
         Base32 codec = new Base32();
-        for (int i = 0; i < BASE32_TEST_CASES.length; i++) {
-                assertEquals(BASE32_TEST_CASES[i][1], codec.encodeAsString(BASE32_TEST_CASES[i][0].getBytes("UTF-8")));
+        for (String[] element : BASE32_TEST_CASES) {
+                assertEquals(element[1], codec.encodeAsString(element[0].getBytes("UTF-8")));
         }
     }
 
     @Test
     public void testBase32HexSamples() throws Exception {
         Base32 codec = new Base32(true);
-        for (int i = 0; i < BASE32HEX_TEST_CASES.length; i++) {
-                assertEquals(BASE32HEX_TEST_CASES[i][1], codec.encodeAsString(BASE32HEX_TEST_CASES[i][0].getBytes("UTF-8")));
+        for (String[] element : BASE32HEX_TEST_CASES) {
+                assertEquals(element[1], codec.encodeAsString(element[0].getBytes("UTF-8")));
         }
     }
 
     @Test
     public void testBase32Chunked () throws Exception {
         Base32 codec = new Base32(20);
-        for (int i = 0; i < BASE32_TEST_CASES_CHUNKED.length; i++) {
-                assertEquals(BASE32_TEST_CASES_CHUNKED[i][1], codec.encodeAsString(BASE32_TEST_CASES_CHUNKED[i][0].getBytes("UTF-8")));
+        for (String[] element : BASE32_TEST_CASES_CHUNKED) {
+                assertEquals(element[1], codec.encodeAsString(element[0].getBytes("UTF-8")));
         }        
     }
 
diff --git a/src/test/org/apache/commons/codec/binary/Base32TestData.java b/src/test/org/apache/commons/codec/binary/Base32TestData.java
@@ -116,8 +116,8 @@ static byte[][] randomData(BaseNCodec codec, int size) {
      * @return true if bytes contains c, false otherwise
      */
     static boolean bytesContain(byte[] bytes, byte c) {
-        for (int i = 0; i < bytes.length; i++) {
-            if (bytes[i] == c) { return true; }
+        for (byte b : bytes) {
+            if (b == c) { return true; }
         }
         return false;
     }
diff --git a/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java b/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java
@@ -242,8 +242,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
         // Start with encode.
         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
         OutputStream out = new Base64OutputStream(byteOut, true, chunkSize, seperator);
-        for (int i = 0; i < decoded.length; i++) {
-            out.write(decoded[i]);
+        for (byte element : decoded) {
+            out.write(element);
         }
         out.close();
         byte[] output = byteOut.toByteArray();
@@ -252,8 +252,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
         // Now let's try decode.
         byteOut = new ByteArrayOutputStream();
         out = new Base64OutputStream(byteOut, false);
-        for (int i = 0; i < encoded.length; i++) {
-            out.write(encoded[i]);
+        for (byte element : encoded) {
+            out.write(element);
         }
         out.close();
         output = byteOut.toByteArray();
@@ -262,8 +262,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
         // Now let's try decode with tonnes of flushes.
         byteOut = new ByteArrayOutputStream();
         out = new Base64OutputStream(byteOut, false);
-        for (int i = 0; i < encoded.length; i++) {
-            out.write(encoded[i]);
+        for (byte element : encoded) {
+            out.write(element);
             out.flush();
         }
         out.close();
@@ -277,8 +277,8 @@ private void testByteByByte(byte[] encoded, byte[] decoded, int chunkSize, byte[
             out = new Base64OutputStream(out, false);
             out = new Base64OutputStream(out, true, chunkSize, seperator);
         }
-        for (int i = 0; i < decoded.length; i++) {
-            out.write(decoded[i]);
+        for (byte element : decoded) {
+            out.write(element);
         }
         out.close();
         output = byteOut.toByteArray();
diff --git a/src/test/org/apache/commons/codec/binary/Base64TestData.java b/src/test/org/apache/commons/codec/binary/Base64TestData.java
@@ -214,8 +214,8 @@ static byte[][] randomData(int size, boolean urlSafe) {
      * @return true if bytes contains c, false otherwise
      */
     static boolean bytesContain(byte[] bytes, byte c) {
-        for (int i = 0; i < bytes.length; i++) {
-            if (bytes[i] == c) { return true; }
+        for (byte b : bytes) {
+            if (b == c) { return true; }
         }
         return false;
     }
diff --git a/src/test/org/apache/commons/codec/language/ColognePhoneticTest.java b/src/test/org/apache/commons/codec/language/ColognePhoneticTest.java
@@ -142,8 +142,8 @@ public void testIsEncodeEquals() {
             {"ganz", "Gans"},
             {"ganz", "Gänse"},
             {"Miyagi", "Miyako"}};
-        for (int i = 0; i < data.length; i++) {
-            ((ColognePhonetic) this.getStringEncoder()).isEncodeEqual(data[i][1], data[i][0]);
+        for (String[] element : data) {
+            ((ColognePhonetic) this.getStringEncoder()).isEncodeEqual(element[1], element[0]);
         }
     }
 
diff --git a/src/test/org/apache/commons/codec/language/DoubleMetaphoneTest.java b/src/test/org/apache/commons/codec/language/DoubleMetaphoneTest.java
@@ -1029,9 +1029,9 @@ public void assertDoubleMetaphoneAlt(String expected, String source) {
 
     public void doubleMetaphoneEqualTest(String[][] pairs, boolean useAlternate) {
         this.validateFixture(pairs);
-        for (int i = 0; i < pairs.length; i++) {
-            String name0 = pairs[i][0];
-            String name1 = pairs[i][1];
+        for (String[] pair : pairs) {
+            String name0 = pair[0];
+            String name1 = pair[1];
             String failMsg = "Expected match between " + name0 + " and " + name1 + " (use alternate: " + useAlternate + ")";
             assertTrue(failMsg, this.getDoubleMetaphone().isDoubleMetaphoneEqual(name0, name1, useAlternate));
             assertTrue(failMsg, this.getDoubleMetaphone().isDoubleMetaphoneEqual(name1, name0, useAlternate));
diff --git a/src/test/org/apache/commons/codec/language/MetaphoneTest.java b/src/test/org/apache/commons/codec/language/MetaphoneTest.java
@@ -33,23 +33,23 @@ public class MetaphoneTest extends StringEncoderAbstractTest {
 
     public void assertIsMetaphoneEqual(String source, String[] matches) {
         // match source to all matches
-        for (int i = 0; i < matches.length; i++) {
-            assertTrue("Source: " + source + ", should have same Metaphone as: " + matches[i],
-                       this.getMetaphone().isMetaphoneEqual(source, matches[i]));
+        for (String matche : matches) {
+            assertTrue("Source: " + source + ", should have same Metaphone as: " + matche,
+                       this.getMetaphone().isMetaphoneEqual(source, matche));
         }
         // match to each other
-        for (int i = 0; i < matches.length; i++) {
-            for (int j = 0; j < matches.length; j++) {
-                assertTrue(this.getMetaphone().isMetaphoneEqual(matches[i], matches[j]));
+        for (String matche : matches) {
+            for (String matche2 : matches) {
+                assertTrue(this.getMetaphone().isMetaphoneEqual(matche, matche2));
             }
         }
     }
 
     public void assertMetaphoneEqual(String[][] pairs) {
         this.validateFixture(pairs);
-        for (int i = 0; i < pairs.length; i++) {
-            String name0 = pairs[i][0];
-            String name1 = pairs[i][1];
+        for (String[] pair : pairs) {
+            String name0 = pair[0];
+            String name1 = pair[1];
             String failMsg = "Expected match between " + name0 + " and " + name1;
             assertTrue(failMsg, this.getMetaphone().isMetaphoneEqual(name0, name1));
             assertTrue(failMsg, this.getMetaphone().isMetaphoneEqual(name1, name0));
diff --git a/src/test/org/apache/commons/codec/net/BCodecTest.java b/src/test/org/apache/commons/codec/net/BCodecTest.java
@@ -43,8 +43,8 @@ public class BCodecTest {
     private String constructString(int[] unicodeChars) {
         StringBuffer buffer = new StringBuffer();
         if (unicodeChars != null) {
-            for (int i = 0; i < unicodeChars.length; i++) {
-                buffer.append((char) unicodeChars[i]);
+            for (int unicodeChar : unicodeChars) {
+                buffer.append((char) unicodeChar);
             }
         }
         return buffer.toString();
diff --git a/src/test/org/apache/commons/codec/net/QCodecTest.java b/src/test/org/apache/commons/codec/net/QCodecTest.java
@@ -49,8 +49,8 @@ public class QCodecTest {
     private String constructString(int [] unicodeChars) {
         StringBuffer buffer = new StringBuffer();
         if (unicodeChars != null) {
-            for (int i = 0; i < unicodeChars.length; i++) {
-                buffer.append((char)unicodeChars[i]); 
+            for (int unicodeChar : unicodeChars) {
+                buffer.append((char)unicodeChar); 
             }
         }
         return buffer.toString();
diff --git a/src/test/org/apache/commons/codec/net/QuotedPrintableCodecTest.java b/src/test/org/apache/commons/codec/net/QuotedPrintableCodecTest.java
@@ -47,8 +47,8 @@ public class QuotedPrintableCodecTest {
     private String constructString(int [] unicodeChars) {
         StringBuffer buffer = new StringBuffer();
         if (unicodeChars != null) {
-            for (int i = 0; i < unicodeChars.length; i++) {
-                buffer.append((char)unicodeChars[i]); 
+            for (int unicodeChar : unicodeChars) {
+                buffer.append((char)unicodeChar); 
             }
         }
         return buffer.toString();
diff --git a/src/test/org/apache/commons/codec/net/URLCodecTest.java b/src/test/org/apache/commons/codec/net/URLCodecTest.java
@@ -52,8 +52,8 @@ private void validateState(URLCodec urlCodec) {
     private String constructString(int [] unicodeChars) {
         StringBuffer buffer = new StringBuffer();
         if (unicodeChars != null) {
-            for (int i = 0; i < unicodeChars.length; i++) {
-                buffer.append((char)unicodeChars[i]); 
+            for (int unicodeChar : unicodeChars) {
+                buffer.append((char)unicodeChar); 
             }
         }
         return buffer.toString();

Original file line number	Diff line number	Diff line change
`@@ -415,8 +415,8 @@ protected boolean containsAlphabetOrPad(byte[] arrayOctet) {`
`415`	`415`	`if (arrayOctet == null) {`
`416`	`416`	`return false;`
`417`	`417`	`}`
`418`		`- for (int i = 0; i < arrayOctet.length; i++) {`
`419`		`- if (PAD == arrayOctet[i] \|\| isInAlphabet(arrayOctet[i])) {`
	`418`	`+ for (byte element : arrayOctet) {`
	`419`	`+ if (PAD == element \|\| isInAlphabet(element)) {`
`420`	`420`	`return true;`
`421`	`421`	`}`
`422`	`422`	`}`
Original file line number	Diff line number	Diff line change
`@@ -272,8 +272,8 @@ public char removeNext() {`
`272`	`272`	`* Returns whether the array contains the key, or not.`
`273`	`273`	`*/`
`274`	`274`	`private static boolean arrayContains(char[] arr, char key) {`
`275`		`- for (int i = 0; i < arr.length; i++) {`
`276`		`- if (arr[i] == key) {`
	`275`	`+ for (char element : arr) {`
	`276`	`+ if (element == key) {`
`277`	`277`	`return true;`
`278`	`278`	`}`
`279`	`279`	`}`
`@@ -406,9 +406,9 @@ private String preprocess(String text) {`
`406`	`406`
`407`	`407`	`for (int index = 0; index < chrs.length; index++) {`
`408`	`408`	`if (chrs[index] > 'Z') {`
`409`		`- for (int replacement = 0; replacement < PREPROCESS_MAP.length; replacement++) {`
`410`		`- if (chrs[index] == PREPROCESS_MAP[replacement][0]) {`
`411`		`- chrs[index] = PREPROCESS_MAP[replacement][1];`
	`409`	`+ for (char[] element : PREPROCESS_MAP) {`
	`410`	`+ if (chrs[index] == element[0]) {`
	`411`	`+ chrs[index] = element[1];`
`412`	`412`	`break;`
`413`	`413`	`}`
`414`	`414`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,8 +153,8 @@ protected byte[] doDecoding(byte[] bytes) throws DecoderException {`
`153`	`153`	`return null;`
`154`	`154`	`}`
`155`	`155`	`boolean hasUnderscores = false;`
`156`		`- for (int i = 0; i < bytes.length; i++) {`
`157`		`- if (bytes[i] == UNDERSCORE) {`
	`156`	`+ for (byte b : bytes) {`
	`157`	`+ if (b == UNDERSCORE) {`
`158`	`158`	`hasUnderscores = true;`
`159`	`159`	`break;`
`160`	`160`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,8 +145,8 @@ public static final byte[] encodeQuotedPrintable(BitSet printable, byte[] bytes)`
`145`	`145`	`printable = PRINTABLE_CHARS;`
`146`	`146`	`}`
`147`	`147`	`ByteArrayOutputStream buffer = new ByteArrayOutputStream();`
`148`		`- for (int i = 0; i < bytes.length; i++) {`
`149`		`- int b = bytes[i];`
	`148`	`+ for (byte c : bytes) {`
	`149`	`+ int b = c;`
`150`	`150`	`if (b < 0) {`
`151`	`151`	`b = 256 + b;`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,8 +130,8 @@ public static final byte[] encodeUrl(BitSet urlsafe, byte[] bytes) {`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`ByteArrayOutputStream buffer = new ByteArrayOutputStream();`
`133`		`- for (int i = 0; i < bytes.length; i++) {`
`134`		`- int b = bytes[i];`
	`133`	`+ for (byte c : bytes) {`
	`134`	`+ int b = c;`
`135`	`135`	`if (b < 0) {`
`136`	`136`	`b = 256 + b;`
`137`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,14 +36,14 @@ public void checkEncoding(String expected, String source) throws EncoderExceptio`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`protected void checkEncodings(String[][] data) throws EncoderException {`
`39`		`- for (int i = 0; i < data.length; i++) {`
`40`		`- this.checkEncoding(data[i][1], data[i][0]);`
	`39`	`+ for (String[] element : data) {`
	`40`	`+ this.checkEncoding(element[1], element[0]);`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`protected void checkEncodingVariations(String expected, String data[]) throws EncoderException {`
`45`		`- for (int i = 0; i < data.length; i++) {`
`46`		`- this.checkEncoding(expected, data[i]);`
	`45`	`+ for (String element : data) {`
	`46`	`+ this.checkEncoding(expected, element);`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`@@ -93,16 +93,16 @@ public void testLocaleIndependence() throws Exception {`
`93`	`93`	`Locale[] locales = {Locale.ENGLISH, new Locale("tr"), Locale.getDefault()};`
`94`	`94`
`95`	`95`	`try {`
`96`		`- for (int i = 0; i < data.length; i++) {`
	`96`	`+ for (String element : data) {`
`97`	`97`	`String ref = null;`
`98`	`98`	`for (int j = 0; j < locales.length; j++) {`
`99`	`99`	`Locale.setDefault(locales[j]);`
`100`	`100`	`if (j <= 0) {`
`101`		`- ref = encoder.encode(data[i]);`
	`101`	`+ ref = encoder.encode(element);`
`102`	`102`	`} else {`
`103`	`103`	`String cur = null;`
`104`	`104`	`try {`
`105`		`- cur = encoder.encode(data[i]);`
	`105`	`+ cur = encoder.encode(element);`
`106`	`106`	`} catch (Exception e) {`
`107`	`107`	`Assert.fail(Locale.getDefault().toString() + ": " + e.getMessage());`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,24 +61,24 @@ public class Base32Test {`
`61`	`61`	`@Test`
`62`	`62`	`public void testBase32Samples() throws Exception {`
`63`	`63`	`Base32 codec = new Base32();`
`64`		`- for (int i = 0; i < BASE32_TEST_CASES.length; i++) {`
`65`		`- assertEquals(BASE32_TEST_CASES[i][1], codec.encodeAsString(BASE32_TEST_CASES[i][0].getBytes("UTF-8")));`
	`64`	`+ for (String[] element : BASE32_TEST_CASES) {`
	`65`	`+ assertEquals(element[1], codec.encodeAsString(element[0].getBytes("UTF-8")));`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`@Test`
`70`	`70`	`public void testBase32HexSamples() throws Exception {`
`71`	`71`	`Base32 codec = new Base32(true);`
`72`		`- for (int i = 0; i < BASE32HEX_TEST_CASES.length; i++) {`
`73`		`- assertEquals(BASE32HEX_TEST_CASES[i][1], codec.encodeAsString(BASE32HEX_TEST_CASES[i][0].getBytes("UTF-8")));`
	`72`	`+ for (String[] element : BASE32HEX_TEST_CASES) {`
	`73`	`+ assertEquals(element[1], codec.encodeAsString(element[0].getBytes("UTF-8")));`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`@Test`
`78`	`78`	`public void testBase32Chunked () throws Exception {`
`79`	`79`	`Base32 codec = new Base32(20);`
`80`		`- for (int i = 0; i < BASE32_TEST_CASES_CHUNKED.length; i++) {`
`81`		`- assertEquals(BASE32_TEST_CASES_CHUNKED[i][1], codec.encodeAsString(BASE32_TEST_CASES_CHUNKED[i][0].getBytes("UTF-8")));`
	`80`	`+ for (String[] element : BASE32_TEST_CASES_CHUNKED) {`
	`81`	`+ assertEquals(element[1], codec.encodeAsString(element[0].getBytes("UTF-8")));`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
Original file line number	Diff line number	Diff line change
`@@ -116,8 +116,8 @@ static byte[][] randomData(BaseNCodec codec, int size) {`
`116`	`116`	`* @return true if bytes contains c, false otherwise`
`117`	`117`	`*/`
`118`	`118`	`static boolean bytesContain(byte[] bytes, byte c) {`
`119`		`- for (int i = 0; i < bytes.length; i++) {`
`120`		`- if (bytes[i] == c) { return true; }`
	`119`	`+ for (byte b : bytes) {`
	`120`	`+ if (b == c) { return true; }`
`121`	`121`	`}`
`122`	`122`	`return false;`
`123`	`123`	`}`