diff --git a/asterixdb/asterix-om/src/test/java/org/apache/asterix/test/om/typecomputer/ExceptionTest.java b/asterixdb/asterix-om/src/test/java/org/apache/asterix/test/om/typecomputer/ExceptionTest.java
index 95e669f..91752f7 100644
--- a/asterixdb/asterix-om/src/test/java/org/apache/asterix/test/om/typecomputer/ExceptionTest.java
+++ b/asterixdb/asterix-om/src/test/java/org/apache/asterix/test/om/typecomputer/ExceptionTest.java
@@ -26,9 +26,12 @@
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
+import org.apache.asterix.om.functions.BuiltinFunctions;
 import org.apache.asterix.om.typecomputer.base.IResultTypeComputer;
 import org.apache.asterix.om.types.ATypeTag;
 import org.apache.asterix.om.types.BuiltinType;
@@ -40,6 +43,7 @@
 import org.apache.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
 import org.apache.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
 import org.apache.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
+import org.apache.hyracks.algebricks.core.algebra.functions.IFunctionInfo;
 import org.apache.hyracks.algebricks.core.algebra.metadata.IMetadataProvider;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.LogManager;
@@ -59,18 +63,25 @@
  *
  * Care needs to be taken when deciding the number of arguments, below is how the tests are calculated:
  * The number of combinations is = n ^ m
- * n = number of arguments
- * m = number of types available
+ * n = number of types available
+ * m = number of arguments to pass
  *
  * Example:
- * 2 arguments, 40 types = 1600 combinations per type computer
- * 3 arguments, 40 types = 64000 combinations per type computer
+ * 2 arguments, 40 types = 40 ^ 2 = 1,600 combinations per type computer
+ * 3 arguments, 40 types = 40 ^ 3 = 64,000 combinations per type computer
+ * 4 arguments, 40 types = 40 ^ 4 = 2,560,000 combinations per type computer
  *
- * TODO There are 2 functions that expect a minimum arguments of 3, so passing them 2 arguments will cause them
- * to return an exception, so they're really not being tested properly now. Probably need to add an exception list
- * for such functions.
- * Ideally, making the arguments in the test to be 3 will solve the issue, but that would push the tests to 64000 each
- * and that takes too long and times out the test apparently.
+ * Choice of number of arguments:
+ * 1- To know the proper number of arguments for each type computer, we are going over all the available functions,
+ *    getting their arity and their type computer and comparing them as follows:
+ *     - If a function has VARARGS, that type computer is marked as VARARGS.
+ *     - If multiple functions use the same type computer, the highest arity of all functions is used for that computer.
+ * 2- In case of VARARGS or type computers that handle more than 3 arguments, we will use only 3 arguments, for the
+ *    following reasons:
+ *     - Going over 3 arguments will result in over 2,500,000 test cases, which will time out and fail the test.
+ *     - (As of now) all the type computers using VARARGS need a minimum of 3 arguments or less to function properly,
+ *       so passing 3 arguments will suffice to include all cases.
+ *     - (As of now) all the type computers that handle more than 3 arguments return a constant type, nothing to test.
  */
 
 @RunWith(Parameterized.class)
@@ -78,9 +89,11 @@
 
     private static final Logger LOGGER = LogManager.getLogger();
 
-    // Number of arguments to be passed. Number of combinations depends on number of arguments
-    private static int numberOfArguments = 2;
-    private static int numberOfCombinations = (int) Math.pow(ATypeTag.values().length, numberOfArguments);
+    // Caution: Using more than 3 arguments will generate millions of combinations and the test will timeout and fail
+    private static final int MAXIMUM_ARGUMENTS_ALLOWED = 3;
+
+    // This map will hold each used type computer and its highest arity, which represents arguments number to pass
+    private static Map<String, Integer> typeComputerToArgsCountMap = new HashMap<>();
 
     // Test parameters
     @Parameter
@@ -95,6 +108,55 @@
         // Prepare tests
         List<Object[]> tests = new ArrayList<>();
 
+        // First, we will go over all the functions available, get their arity and type computers to know the number
+        // of arguments to pass for each type computer
+        Map<IFunctionInfo, IResultTypeComputer> funTypeComputerMap;
+        try {
+            Field field = BuiltinFunctions.class.getDeclaredField("funTypeComputer");
+            field.setAccessible(true);
+            funTypeComputerMap = (HashMap<IFunctionInfo, IResultTypeComputer>) field.get(null);
+        } catch (Exception ex) {
+            // this should never fail
+            throw new IllegalStateException();
+        }
+
+        if (funTypeComputerMap != null) {
+            // Note: If a type computer handles both known and VARARGS, VARARGS will be used
+            for (HashMap.Entry<IFunctionInfo, IResultTypeComputer> entry : funTypeComputerMap.entrySet()) {
+                // Some functions have a null type computer for some reason, ignore them
+                if (entry.getValue() == null) {
+                    continue;
+                }
+
+                // Type computer does not exist, add it with its arity to the map
+                if (typeComputerToArgsCountMap.get(entry.getValue().getClass().getSimpleName()) == null) {
+                    typeComputerToArgsCountMap.put(entry.getValue().getClass().getSimpleName(),
+                            entry.getKey().getFunctionIdentifier().getArity());
+                    continue;
+                }
+
+                // VARARGS functions, these are kept as is, put/update, no need for any comparison
+                if (entry.getKey().getFunctionIdentifier().getArity() == FunctionIdentifier.VARARGS) {
+                    typeComputerToArgsCountMap.put(entry.getValue().getClass().getSimpleName(),
+                            entry.getKey().getFunctionIdentifier().getArity());
+                    continue;
+                }
+
+                // We have it already, and it is of type VARARGS, we are not going to change it
+                if (typeComputerToArgsCountMap
+                        .get(entry.getValue().getClass().getSimpleName()) == FunctionIdentifier.VARARGS) {
+                    continue;
+                }
+
+                // We have it already, if it has larger arity than our existing one, we will update it
+                if (typeComputerToArgsCountMap.get(entry.getValue().getClass().getSimpleName()) < entry.getKey()
+                        .getFunctionIdentifier().getArity()) {
+                    typeComputerToArgsCountMap.put(entry.getValue().getClass().getSimpleName(),
+                            entry.getKey().getFunctionIdentifier().getArity());
+                }
+            }
+        }
+
         // Tests all usual type computers.
         Reflections reflections = new Reflections("org.apache.asterix.om.typecomputer", new SubTypesScanner(false));
         Set<Class<? extends IResultTypeComputer>> classes = reflections.getSubTypesOf(IResultTypeComputer.class);
@@ -113,8 +175,27 @@
 
     @Test
     public void test() throws Exception {
+        // If a type computer is not found in the map, then it is not used by any function
+        if (typeComputerToArgsCountMap.get(clazz.getSimpleName()) == null) {
+            LOGGER.log(Level.INFO, "TypeComputer " + clazz.getSimpleName() + " is not used by any functions");
+            return;
+        }
 
+        // Refer to documentation on the top for the details of choosing the arguments count
         // Arguments list
+        int typeComputerMaxArgs = typeComputerToArgsCountMap.get(clazz.getSimpleName());
+
+        // If type computer takes zero arguments, there is nothing to do
+        if (typeComputerMaxArgs == 0) {
+            return;
+        }
+
+        // Calculate number of arguments and number of combinations
+        int numberOfArguments =
+                (typeComputerMaxArgs > MAXIMUM_ARGUMENTS_ALLOWED || typeComputerMaxArgs == FunctionIdentifier.VARARGS)
+                        ? MAXIMUM_ARGUMENTS_ALLOWED : typeComputerMaxArgs;
+        int numberOfCombinations = (int) Math.pow(ATypeTag.values().length, numberOfArguments);
+
         Object[] opaqueParameters = new Object[numberOfArguments];
         List<Mutable<ILogicalExpression>> argumentsList = new ArrayList<>(numberOfArguments);
         for (int i = 0; i < numberOfArguments; i++) {