Fix typo in new UTF-8 codepoint length logic.

jruby · Jul 31, 2017 · edb7b8e · edb7b8e
1 parent babe573
commit edb7b8e
Showing 14 changed files with 130 additions and 74 deletions.
diff --git a/src/org/jcodings/AbstractEncoding.java b/src/org/jcodings/AbstractEncoding.java
@@ -22,7 +22,7 @@
 import org.jcodings.ascii.AsciiTables;
 import org.jcodings.constants.PosixBracket;
 import org.jcodings.exception.CharacterPropertyException;
-import org.jcodings.exception.ErrorMessages;
+import org.jcodings.exception.EncodingError;
 
 abstract class AbstractEncoding extends Encoding {
 
@@ -112,6 +112,6 @@ public void applyAllCaseFold(int flag, ApplyAllCaseFoldFunction fun, Object arg)
     public int propertyNameToCType(byte[]bytes, int p, int end) {
         Integer ctype = PosixBracket.PBSTableUpper.get(bytes, p, end);
         if (ctype != null) return ctype;
-        throw new CharacterPropertyException(ErrorMessages.ERR_INVALID_CHAR_PROPERTY_NAME, new String(bytes, p, end - p));
+        throw new CharacterPropertyException(EncodingError.ERR_INVALID_CHAR_PROPERTY_NAME, new String(bytes, p, end - p));
     }
 }
diff --git a/src/org/jcodings/MultiByteEncoding.java b/src/org/jcodings/MultiByteEncoding.java
@@ -20,8 +20,7 @@
 package org.jcodings;
 
 import org.jcodings.ascii.AsciiTables;
-import org.jcodings.exception.EncodingException;
-import org.jcodings.exception.ErrorMessages;
+import org.jcodings.exception.ErrorCodes;
 
 public abstract class MultiByteEncoding extends AbstractEncoding {
 
@@ -164,7 +163,7 @@ protected final int mb2CodeToMbc(int code, byte[]bytes, int p) {
         }
         bytes[p_++] = (byte)(code & 0xff);
 
-        if (length(bytes, p, p_) != (p_ - p)) throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+        if (length(bytes, p, p_) != (p_ - p)) return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
         return p_ - p;
     }
 
@@ -175,7 +174,7 @@ protected final int mb4CodeToMbc(int code, byte[]bytes, int p) {
         if ((code & 0xff00) != 0 || p_ != p)    bytes[p_++] = (byte)((code >>> 8) & 0xff);
         bytes[p_++] = (byte)(code & 0xff);
 
-        if (length(bytes, p, p_) != (p_ - p)) throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+        if (length(bytes, p, p_) != (p_ - p)) return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
         return p_ - p;
     }
 

diff --git a/src/org/jcodings/SingleByteEncoding.java b/src/org/jcodings/SingleByteEncoding.java
@@ -19,8 +19,7 @@
  */
 package org.jcodings;
 
-import org.jcodings.exception.EncodingException;
-import org.jcodings.exception.ErrorMessages;
+import org.jcodings.exception.ErrorCodes;
 
 public abstract class SingleByteEncoding extends AbstractEncoding {
 
@@ -73,7 +72,7 @@ public int mbcToCode(byte[] bytes, int p, int end) {
     public int codeToMbcLength(int code) {
         if (Config.VANILLA) {
             if (code <= codeSize) return 1;
-            throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+            return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
         } else {
             return 1;
         }
@@ -83,7 +82,7 @@ public int codeToMbcLength(int code) {
      */
     @Override
     public final int codeToMbc(int code, byte[] bytes, int p) {
-        if (code > codeSize) throw new EncodingException("out of range char");
+        if (code > codeSize) return ErrorCodes.ERR_TOO_BIG_WIDE_CHAR_VALUE;
 
         bytes[p] = (byte)(code & 0xff); // c implementation also uses mask here
         return 1;

diff --git a/src/org/jcodings/exception/CharacterPropertyException.java b/src/org/jcodings/exception/CharacterPropertyException.java
@@ -20,14 +20,30 @@
 package org.jcodings.exception;
 
 public class CharacterPropertyException extends EncodingException {
+
+    public CharacterPropertyException(EncodingError error) {
+        super(error);
+    }
+
+    public CharacterPropertyException(EncodingError error, String str) {
+        super(error, str);
+    }
+
+    public CharacterPropertyException(EncodingError error, byte[]bytes, int p, int end) {
+        super(error, bytes, p, end);
+    }
+
+    @Deprecated
     public CharacterPropertyException(String message) {
         super(message);
     }
 
+    @Deprecated
     public CharacterPropertyException(String message, String str) {
         super(message, str);
     }
 
+    @Deprecated
     public CharacterPropertyException(String message, byte[]bytes, int p, int end) {
         super(message, bytes, p, end);
     }

diff --git a/src/org/jcodings/exception/EncodingError.java b/src/org/jcodings/exception/EncodingError.java
@@ -0,0 +1,54 @@
+package org.jcodings.exception;
+
+import org.jcodings.util.IntHash;
+
+public enum EncodingError {
+    ERR_TYPE_BUG(ErrorMessages.ERR_TYPE_BUG, ErrorCodes.ERR_TYPE_BUG),
+
+    ERR_TOO_BIG_WIDE_CHAR_VALUE(ErrorMessages.ERR_TOO_BIG_WIDE_CHAR_VALUE, ErrorCodes.ERR_TOO_BIG_WIDE_CHAR_VALUE),
+    ERR_TOO_LONG_WIDE_CHAR_VALUE(ErrorMessages.ERR_TOO_LONG_WIDE_CHAR_VALUE, ErrorCodes.ERR_TOO_LONG_WIDE_CHAR_VALUE),
+
+    ERR_INVALID_CHAR_PROPERTY_NAME(ErrorMessages.ERR_INVALID_CHAR_PROPERTY_NAME, ErrorCodes.ERR_INVALID_CHAR_PROPERTY_NAME),
+    ERR_INVALID_CODE_POINT_VALUE(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE, ErrorCodes.ERR_INVALID_CODE_POINT_VALUE),
+
+    ERR_ENCODING_CLASS_DEF_NOT_FOUND(ErrorMessages.ERR_ENCODING_CLASS_DEF_NOT_FOUND, ErrorCodes.ERR_ENCODING_CLASS_DEF_NOT_FOUND),
+    ERR_ENCODING_LOAD_ERROR(ErrorMessages.ERR_ENCODING_LOAD_ERROR, ErrorCodes.ERR_ENCODING_LOAD_ERROR),
+
+    ERR_ENCODING_ALREADY_REGISTERED(ErrorMessages.ERR_ENCODING_ALREADY_REGISTERED, ErrorCodes.ERR_ENCODING_ALREADY_REGISTERED),
+    ERR_ENCODING_ALIAS_ALREADY_REGISTERED(ErrorMessages.ERR_ENCODING_ALIAS_ALREADY_REGISTERED, ErrorCodes.ERR_ENCODING_ALIAS_ALREADY_REGISTERED),
+    ERR_ENCODING_REPLICA_ALREADY_REGISTERED(ErrorMessages.ERR_ENCODING_REPLICA_ALREADY_REGISTERED, ErrorCodes.ERR_ENCODING_REPLICA_ALREADY_REGISTERED),
+    ERR_NO_SUCH_ENCODNG(ErrorMessages.ERR_NO_SUCH_ENCODNG, ErrorCodes.ERR_NO_SUCH_ENCODNG),
+    ERR_COULD_NOT_REPLICATE(ErrorMessages.ERR_COULD_NOT_REPLICATE, ErrorCodes.ERR_COULD_NOT_REPLICATE),
+
+    // transcoder messages
+    ERR_TRANSCODER_ALREADY_REGISTERED(ErrorMessages.ERR_TRANSCODER_ALREADY_REGISTERED, ErrorCodes.ERR_TRANSCODER_ALREADY_REGISTERED),
+    ERR_TRANSCODER_CLASS_DEF_NOT_FOUND(ErrorMessages.ERR_TRANSCODER_CLASS_DEF_NOT_FOUND, ErrorCodes.ERR_TRANSCODER_CLASS_DEF_NOT_FOUND),
+    ERR_TRANSCODER_LOAD_ERROR(ErrorMessages.ERR_TRANSCODER_LOAD_ERROR, ErrorCodes.ERR_TRANSCODER_LOAD_ERROR);
+
+    EncodingError(String message, int code) {
+        this.message = message;
+        this.code = code;
+    }
+
+    private final String message;
+    private final int code;
+
+    public String getMessage() {
+        return message;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public static EncodingError fromCode(int code) {
+        return CODE_TO_ERROR.get(code);
+    }
+
+    private static final IntHash<EncodingError> CODE_TO_ERROR = new IntHash<EncodingError>();
+    static {
+        for (EncodingError error : EncodingError.values()) {
+            CODE_TO_ERROR.put(error.getCode(), error);
+        }
+    }
+}
diff --git a/src/org/jcodings/exception/EncodingException.java b/src/org/jcodings/exception/EncodingException.java
@@ -20,15 +20,42 @@
 package org.jcodings.exception;
 
 public class EncodingException extends JCodingsException {
+    private final EncodingError error;
+
+    public EncodingException(EncodingError error) {
+        super(error.getMessage());
+        this.error = error;
+    }
+
+    public EncodingException(EncodingError error, String str) {
+        super(error.getMessage());
+        this.error = error;
+    }
+
+    public EncodingException(EncodingError error, byte[]bytes, int p, int end) {
+        super(error.getMessage(), bytes, p, end);
+        this.error = error;
+    }
+
+    public EncodingError getError() {
+        return error;
+    }
+
+    @Deprecated
     public EncodingException(String message) {
         super(message);
+        error = null;
     }
 
+    @Deprecated
     public EncodingException(String message, String str) {
         super(message, str);
+        error = null;
     }
 
+    @Deprecated
     public EncodingException(String message, byte[]bytes, int p, int end) {
         super(message, bytes, p, end);
+        error = null;
     }
 }
diff --git a/src/org/jcodings/exception/ErrorCodes.java b/src/org/jcodings/exception/ErrorCodes.java
@@ -70,4 +70,16 @@ public interface ErrorCodes {
     public static final int ERR_TOO_BIG_WIDE_CHAR_VALUE = -401;
     public static final int ERR_NOT_SUPPORTED_ENCODING_COMBINATION = -402;
     public static final int ERR_INVALID_COMBINATION_OF_OPTIONS = -403;
+
+    // specific to jcodings
+    int ERR_ENCODING_CLASS_DEF_NOT_FOUND = -1000;
+    int ERR_ENCODING_LOAD_ERROR = -1001;
+    int ERR_ENCODING_ALREADY_REGISTERED = -1002;
+    int ERR_ENCODING_ALIAS_ALREADY_REGISTERED = -1003;
+    int ERR_ENCODING_REPLICA_ALREADY_REGISTERED = -1004;
+    int ERR_NO_SUCH_ENCODNG = -1005;
+    int ERR_COULD_NOT_REPLICATE = -1006;
+    int ERR_TRANSCODER_ALREADY_REGISTERED = -1007;
+    int ERR_TRANSCODER_CLASS_DEF_NOT_FOUND = -1008;
+    int ERR_TRANSCODER_LOAD_ERROR = -1009;
 }
diff --git a/src/org/jcodings/exception/IllegalCharacterException.java b/src/org/jcodings/exception/IllegalCharacterException.java
diff --git a/src/org/jcodings/specific/BaseEUCJPEncoding.java b/src/org/jcodings/specific/BaseEUCJPEncoding.java
@@ -25,7 +25,7 @@
 import org.jcodings.IntHolder;
 import org.jcodings.ascii.AsciiTables;
 import org.jcodings.constants.CharacterType;
-import org.jcodings.exception.EncodingException;
+import org.jcodings.exception.ErrorCodes;
 import org.jcodings.exception.ErrorMessages;
 import org.jcodings.exception.InternalException;
 import org.jcodings.util.CaseInsensitiveBytesHash;
@@ -49,12 +49,12 @@ public int codeToMbcLength(int code) {
             if ((code &   0xff00) != 0) return 2;
         } else {
             if (code > 0x00ffffff) {
-                throw new EncodingException(ErrorMessages.ERR_TOO_BIG_WIDE_CHAR_VALUE);
+                return ErrorCodes.ERR_TOO_BIG_WIDE_CHAR_VALUE;
             }
             else if ((code & 0xff808080) == 0x00808080) return 3;
             else if ((code & 0xffff8080) == 0x00008080) return 2;
         }
-        throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+        return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
     }
 
     @Override
@@ -64,7 +64,7 @@ public int codeToMbc(int code, byte[]bytes, int p) {
         if ((code &   0xff00) != 0) bytes[p_++] = (byte)((code >>  8) & 0xff);
         bytes[p_++] = (byte)(code & 0xff);
 
-        if (length(bytes, p, p_) != p_ - p) throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+        if (length(bytes, p, p_) != p_ - p) return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
         return p_ - p;
     }
 

diff --git a/src/org/jcodings/specific/BaseSJISEncoding.java b/src/org/jcodings/specific/BaseSJISEncoding.java
@@ -25,7 +25,6 @@
 import org.jcodings.IntHolder;
 import org.jcodings.ascii.AsciiTables;
 import org.jcodings.constants.CharacterType;
-import org.jcodings.exception.EncodingException;
 import org.jcodings.exception.ErrorCodes;
 import org.jcodings.exception.ErrorMessages;
 import org.jcodings.exception.InternalException;

diff --git a/src/org/jcodings/specific/BaseUTF8Encoding.java b/src/org/jcodings/specific/BaseUTF8Encoding.java
@@ -22,9 +22,7 @@
 import org.jcodings.Config;
 import org.jcodings.IntHolder;
 import org.jcodings.ascii.AsciiTables;
-import org.jcodings.exception.EncodingException;
 import org.jcodings.exception.ErrorCodes;
-import org.jcodings.exception.ErrorMessages;
 import org.jcodings.unicode.UnicodeEncoding;
 
 abstract class BaseUTF8Encoding extends UnicodeEncoding {
@@ -75,7 +73,7 @@ public int codeToMbcLength(int intCode) {
             return 2;
         } else if ((code & 0xffff0000) == 0) {
             return 3;
-        } else if (code < VALID_CODE_LIMIT) {
+        } else if (code <= VALID_CODE_LIMIT) {
             return 4;
         } else if (USE_INVALID_CODE_SCHEME && code == INVALID_CODE_FE) {
             return 1;
@@ -150,7 +148,7 @@ public int codeToMbc(int code, byte[]bytes, int p) {
                 bytes[p_] = (byte)0xff;
                 return 1;
             } else {
-                throw new EncodingException(ErrorMessages.ERR_TOO_BIG_WIDE_CHAR_VALUE);
+                return ErrorCodes.ERR_TOO_BIG_WIDE_CHAR_VALUE;
             }
             bytes[p_++] = trail0(code);
             return p_ - p;

diff --git a/src/org/jcodings/specific/EmacsMuleEncoding.java b/src/org/jcodings/specific/EmacsMuleEncoding.java
@@ -23,8 +23,7 @@
 import org.jcodings.IntHolder;
 import org.jcodings.MultiByteEncoding;
 import org.jcodings.ascii.AsciiTables;
-import org.jcodings.exception.EncodingException;
-import org.jcodings.exception.ErrorMessages;
+import org.jcodings.exception.ErrorCodes;
 
 public final class EmacsMuleEncoding extends MultiByteEncoding {
 
@@ -60,7 +59,7 @@ public int codeToMbcLength(int code) {
         } else if ((code & 0xff00) >= 0x8000) {
             return 2;
         }
-        throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+        return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
     }
 
     @Override
@@ -72,7 +71,7 @@ public int codeToMbc(int code, byte[]bytes, int p) {
         if ((code & 0xff00) != 0 )              bytes[p_++] = (byte)((code >>> 8) & 0xff);
         bytes[p_++] = (byte)(code & 0xff);
 
-        if (length(bytes, p, p_) != (p_ - p)) throw new EncodingException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE);
+        if (length(bytes, p, p_) != (p_ - p)) return ErrorCodes.ERR_INVALID_CODE_POINT_VALUE;
         return p_ - p;
     }
 

diff --git a/test/org/jcodings/specific/TestASCIIEncoding.java b/test/org/jcodings/specific/TestASCIIEncoding.java
@@ -19,20 +19,13 @@
  */
 package org.jcodings.specific;
 
-import org.jcodings.exception.EncodingException;
-import org.jcodings.specific.ASCIIEncoding;
+import org.jcodings.exception.EncodingError;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertArrayEquals;
 
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class TestASCIIEncoding {
-
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
     @Test
     public void testValidCodeToMbcLength() {
         assertEquals(1, ASCIIEncoding.INSTANCE.codeToMbcLength(0xff));
@@ -47,10 +40,7 @@ public void testValidCodeToMbc() {
 
     @Test
     public void testInvalidCodeToMbc() {
-        expectedException.expect(EncodingException.class);
-        expectedException.expectMessage("out of range char");
-
         byte[] buffer = new byte[1];
-        assertEquals(1, ASCIIEncoding.INSTANCE.codeToMbc(0x100, buffer, 0));
+        assertEquals(EncodingError.ERR_TOO_BIG_WIDE_CHAR_VALUE.getCode(), ASCIIEncoding.INSTANCE.codeToMbc(0x100, buffer, 0));
     }
 }
diff --git a/test/org/jcodings/specific/TestUSASCIIEncoding.java b/test/org/jcodings/specific/TestUSASCIIEncoding.java
@@ -19,21 +19,14 @@
  */
 package org.jcodings.specific;
 
-import org.jcodings.exception.EncodingException;
-import org.jcodings.specific.ASCIIEncoding;
+import org.jcodings.exception.EncodingError;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertArrayEquals;
 
-import org.jcodings.specific.USASCIIEncoding;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 public class TestUSASCIIEncoding {
 
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
     /**
      * codeToMbcLength always returns 1, even when codepoint is invalid,
      * as Config.VANILLA == false.
@@ -52,11 +45,8 @@ public void testValidCodeToMbc() {
 
     @Test
     public void testInvalidCodeToMbc() {
-        expectedException.expect(EncodingException.class);
-        expectedException.expectMessage("out of range char");
-
         byte[] buffer = new byte[1];
-        assertEquals(1, USASCIIEncoding.INSTANCE.codeToMbc(0x80, buffer, 0));
+        assertEquals(EncodingError.ERR_TOO_BIG_WIDE_CHAR_VALUE.getCode(), USASCIIEncoding.INSTANCE.codeToMbc(0x80, buffer, 0));
     }