Add support for more strings to Utils.parseBoolean() and use it in more places

h2/src/main/org/h2/tools/SimpleResultSet.java

@@ -38,6 +38,7 @@ import org.h2.util.Bits;
 import org.h2.util.JdbcUtils;
 import org.h2.util.MathUtils;
 import org.h2.util.New;
+import org.h2.util.Utils;
 import org.h2.value.DataType;
 
 /**
@@ -498,7 +499,7 @@ public class SimpleResultSet implements ResultSet, ResultSetMetaData,
             }
             return n.longValue() != 0;
         }
-        return Boolean.parseBoolean(o.toString());
+        return Utils.parseBoolean(o.toString(), false, true);
     }
 
     /**

h2/src/main/org/h2/util/Utils.java

@@ -14,6 +14,7 @@ import java.lang.management.OperatingSystemMXBean;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -659,11 +660,39 @@ public class Utils {
         if (value == null) {
             return defaultValue;
         }
-        if (value.equalsIgnoreCase("true") || value.equals("1")) {
-            return true;
+        switch (value.length()) {
+        case 1:
+            if (value.equals("1") || value.equalsIgnoreCase("t") || value.equalsIgnoreCase("y")) {
+                return true;
+            }
+            if (value.equals("0") || value.equalsIgnoreCase("f") || value.equalsIgnoreCase("n")) {
+                return false;
+            }
+            break;
+        case 2:
+            if (value.equalsIgnoreCase("no")) {
+                return false;
+            }
+            break;
+        case 3:
+            if (value.equalsIgnoreCase("yes")) {
+                return true;
+            }
+            break;
+        case 4:
+            if (value.equalsIgnoreCase("true")) {
+                return true;
+            }
+            break;
+        case 5:
+            if (value.equalsIgnoreCase("false")) {
+                return false;
+            }
         }
-        if (value.equalsIgnoreCase("false") || value.equals("0")) {
-            return false;
+        try {
+            return new BigDecimal(value).signum() != 0;
+        } catch (NumberFormatException e) {
+            // Nothing to do
         }
         if (throwException) {
             throw new IllegalArgumentException(value);

h2/src/main/org/h2/value/Value.java

@@ -31,6 +31,7 @@ import org.h2.util.DateTimeUtils;
 import org.h2.util.JdbcUtils;
 import org.h2.util.MathUtils;
 import org.h2.util.StringUtils;
+import org.h2.util.Utils;
 
 /**
  * This is the base class for all value classes.
@@ -1011,19 +1012,10 @@ public abstract class Value {
             case NULL:
                 return ValueNull.INSTANCE;
             case BOOLEAN: {
-                if (s.equalsIgnoreCase("true") ||
-                        s.equalsIgnoreCase("t") ||
-                        s.equalsIgnoreCase("yes") ||
-                        s.equalsIgnoreCase("y")) {
-                    return ValueBoolean.get(true);
-                } else if (s.equalsIgnoreCase("false") ||
-                        s.equalsIgnoreCase("f") ||
-                        s.equalsIgnoreCase("no") ||
-                        s.equalsIgnoreCase("n")) {
-                    return ValueBoolean.get(false);
-                } else {
-                    // convert to a number, and if it is not 0 then it is true
-                    return ValueBoolean.get(new BigDecimal(s).signum() != 0);
+                try {
+                    return ValueBoolean.get(Utils.parseBoolean(s, false, true));
+                } catch (IllegalArgumentException e) {
+                    throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, s);
                 }
             }
             case BYTE:

h2/src/test/org/h2/test/unit/TestUtils.java

@@ -52,6 +52,7 @@ public class TestUtils extends TestBase {
         testGetNonPrimitiveClass();
         testGetNonPrimitiveClass();
         testReflectionUtils();
+        testParseBoolean();
     }
 
     private void testIOUtils() throws IOException {
@@ -221,4 +222,69 @@ public class TestUtils extends TestBase {
                 ArrayList.class));
     }
 
+    private void testParseBooleanCheckFalse(String value) {
+        assertFalse(Utils.parseBoolean(value, false, false));
+        assertFalse(Utils.parseBoolean(value, false, true));
+        assertFalse(Utils.parseBoolean(value, true, false));
+        assertFalse(Utils.parseBoolean(value, true, true));
+    }
+
+    private void testParseBooleanCheckTrue(String value) {
+        assertTrue(Utils.parseBoolean(value, false, false));
+        assertTrue(Utils.parseBoolean(value, false, true));
+        assertTrue(Utils.parseBoolean(value, true, false));
+        assertTrue(Utils.parseBoolean(value, true, true));
+    }
+
+    private void testParseBoolean() {
+        // Test for default value in case of null
+        assertFalse(Utils.parseBoolean(null, false, false));
+        assertFalse(Utils.parseBoolean(null, false, true));
+        assertTrue(Utils.parseBoolean(null, true, false));
+        assertTrue(Utils.parseBoolean(null, true, true));
+        // Test assorted valid strings
+        testParseBooleanCheckFalse("0");
+        testParseBooleanCheckFalse("f");
+        testParseBooleanCheckFalse("F");
+        testParseBooleanCheckFalse("n");
+        testParseBooleanCheckFalse("N");
+        testParseBooleanCheckFalse("no");
+        testParseBooleanCheckFalse("No");
+        testParseBooleanCheckFalse("NO");
+        testParseBooleanCheckFalse("false");
+        testParseBooleanCheckFalse("False");
+        testParseBooleanCheckFalse("FALSE");
+        testParseBooleanCheckTrue("1");
+        testParseBooleanCheckTrue("t");
+        testParseBooleanCheckTrue("T");
+        testParseBooleanCheckTrue("y");
+        testParseBooleanCheckTrue("Y");
+        testParseBooleanCheckTrue("yes");
+        testParseBooleanCheckTrue("Yes");
+        testParseBooleanCheckTrue("YES");
+        testParseBooleanCheckTrue("true");
+        testParseBooleanCheckTrue("True");
+        testParseBooleanCheckTrue("TRUE");
+        // Test numbers
+        testParseBooleanCheckFalse("0.0");
+        testParseBooleanCheckFalse("-0.0");
+        testParseBooleanCheckTrue("0.1");
+        testParseBooleanCheckTrue("-0.1");
+        // Test other values
+        assertFalse(Utils.parseBoolean("BAD", false, false));
+        assertTrue(Utils.parseBoolean("BAD", true, false));
+        try {
+            Utils.parseBoolean("BAD", false, true);
+            fail();
+        } catch (IllegalArgumentException e) {
+            // OK
+        }
+        try {
+            Utils.parseBoolean("BAD", true, true);
+            fail();
+        } catch (IllegalArgumentException e) {
+            // OK
+        }
+    }
+
 }