public static String getDateOrTimeString(String dateTimeRequest) {
		/*
		 * .z.d+.z.t Below code has been added to handle specific kdb formats to
		 * allow for easier testing. .z.d, .z.d+1, .z.d-1 .z.t,
		 * .z.t-00:20:00.000 The .z.t can be enhances to account for any +/-
		 * time frame, the test set only contained -20 so I have set it to this,
		 * moving forward this could be made more generic/dynamic
		 */
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        DateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
        Calendar cal = Calendar.getInstance();
        Calendar tCal = Calendar.getInstance();

        switch (dateTimeRequest) {
            case "sqlDateToday":
                String sqlDateToday = dateFormat.format(cal.getTime());
                return sqlDateToday;
            case "sqlDateTomorrow":
                cal.add(Calendar.DATE, 1);
                String sqlDateTomorrow = dateFormat.format(cal.getTime());
                return sqlDateTomorrow;
            case "sqlDateYesterday":
                cal.add(Calendar.DATE, -2);
                String sqlDateYesterday = dateFormat.format(cal.getTime());
                return sqlDateYesterday;

            case "sqlTimeNow":
                String sqlTimeNow = timeFormat.format(tCal.getTime());
                return sqlTimeNow;
            case "sqlTimeMinus20":
                tCal.add(Calendar.MINUTE, -20);
                String sqlTimeMinus20 = timeFormat.format(tCal.getTime());
                return sqlTimeMinus20;
            default:
                return "Not a valid request!";
        }
    }

    private void testDeltaStreamAPI(Properties properties) throws IOException, DeltaStreamException {
        boolean cleanParams = true;
        Map<String, IDeltaAPI> apiMap = apiService.getAPI();
        apiService.setStrictTypeChecking(false);
        // Print out all available API
        LOG.info("Found {} available API functions", apiMap.size());
        for (IDeltaAPI api : apiMap.values()) {
            LOG.info(api.getAlias());
        }

        // Execute a specific API from properties
        String queryStr = "getTicks[`symList`dataType`startDate`endDate`startTime`endTime`timeZone`time`assetClass!(`1306.T;`trade;.z.d-1;.z.d-1;10:00:00;11:00:00;`Japan;`exchangeTime;`equity)]";
        String access = (String) properties.get(DeltaStreamDemoHelper.USERPASS_KEY);

        Map<String, Object> params = new HashMap<String, Object>();
        String[] querySplit = queryStr.split("\\[");
        String analyticName = querySplit[0];
        Set<String> exposedAnalytics = apiMap.keySet();
        String dict = querySplit[1].substring(0, querySplit[1].length() - 1);
        String[] dictSplit = dict.split("\\!");
        String[] dictKeys = dictSplit[0].substring(1, dictSplit[0].length()).split("`");
        String[] dictValues = dictSplit[1].substring(1, dictSplit[1].length() - 1).split("\\;");


        IDeltaAPI api = apiMap.get(analyticName);
        IDeltaQuery query = apiService.createDeltaQuery(api);
        List<IAPIParameter> apiParams = api.getInputParameters();
        String[] apiParamNames = new String[apiParams.size()];
        HashMap<String, String> apiParamsNamesTypes = new HashMap<String, String>();

        // for each of the params get the corresponding api param type
        for (int j = 0; j < apiParams.size(); j++) {
            apiParamsNamesTypes.put(apiParams.get(j).getName(), apiParams.get(j).getType().toString());
            apiParamNames[j] = apiParams.get(j).getName();
        }

        // for each of the params
        for (int i = 0; i < dictKeys.length; i++) {
            // if the paramName exists in the apiPArams
            if (apiParamsNamesTypes.containsKey(dictKeys[i])) {
                // get the corresponding data type for the param
                String type = apiParamsNamesTypes.get(dictKeys[i]);
				/*
				 * Enter the switch statement and based on the datatype and the
				 * condition for each value cast the param value to the
				 * corresponding type
				 */
                switch (type) {
                    case "STRING":
                        if (dictValues[i].toString().contains("`$")) {
                            String noTick = dictValues[i].toString().replace("\"", "").substring(2,
                                    dictValues[i].toString().replace("\"", "").length());
                            params.put(dictKeys[i], noTick);
                        } else if (dictValues[i].toString().contains("`")) {
                            String noTick = dictValues[i].toString().substring(1, dictValues[i].toString().length());
                            params.put(dictKeys[i], noTick);
                        }
                        break;
                    case "INTEGER":
                        params.put(dictKeys[i], Integer.valueOf(dictValues[i].toString().replace("i", "")));
                        break;
                    case "STRING_ARRAY":
                        String[] strSplit = dictValues[i].replace("(","").split("`");
                        ArrayList strArray = new ArrayList();

                        if(strSplit.length == 0 && (dictValues[i].equals("(`") || dictValues[i].equals("`")))
                            strSplit = new String[] {"",""};

                        if (strSplit[1].startsWith("asc") || strSplit[1].startsWith("desc") || dictKeys[i].equals("sortCols"))
                        {
                            strArray.add(strSplit[1]);
                            strArray.add(dictValues[i + 1].replace("`", "").replace(")",""));
                            ArrayList temp = new ArrayList();
                            for(int j=0;j<dictValues.length;j++){
                                if(j==dictValues.length-1)
                                    temp.add(dictValues[j]);
                                else if(dictValues[j]!=dictValues[j+1])
                                    temp.add(dictValues[j]);
                            }
                            dictValues = (String[])temp.stream().toArray(String[]::new);
                        }
                        else
                        {
                            if (strSplit[1].startsWith("$\"") && dictValues[i].startsWith("`$("))
                            {
                                int j = i;
                                while (!dictValues[j - 1].endsWith("\")") && j != dictValues.length)
                                {
                                    strArray.add(StringUtils.stripEnd(StringUtils.stripStart(dictValues[j].toString().replace("\"", ""), "`$("), ")"));
                                    //strArray.add(dictValues[j].toString().replace("\"", "").TrimStart('`').TrimStart('$').TrimStart('(').TrimEnd(')'));
                                    j++;
                                }
                                List<String> temp = new ArrayList(Arrays.asList(dictValues));
                                for(int k=1;k<strArray.size();k++){
                                    temp.remove(i+1);
                                }
                                dictValues = temp.toArray(new String[0]);

//							ArrayList temp = new ArrayList();
//							for(int k=1;k<dictValues.length;k++){
//								if(dictValues[k-1]!=dictValues[k])
//									temp.add(dictValues[k-1]);
//							}
//							dictValues = (String[])temp.stream().toArray(String[]::new);
                            }
                            else if (strSplit[1].startsWith("`$"))
                            {
                                strArray.add(StringUtils.stripStart(dictValues[i].toString().replace("\"", ""),"`$"));
                            }
                            else
                            {
                                for (String s : strSplit)
                                {
                                    if (s != null && s.length() > 0)
                                    {
                                        strArray.add(StringUtils.stripStart(s.replace("\"", ""), "`$"));
                                    }
                                }
                            }
                        }
                        params.put(dictKeys[i], strArray.stream().toArray(String[]::new));
                        if (strArray.size() == 0)
                        {
                            params.put(dictKeys[i], new String[]{});
                        }
                        break;
                    case "SQL_DATE":
                        // TODO: is it works with '-'?
                        if (dictValues[i].toString().equals(".z.d")) {
                            params.put(dictKeys[i], java.sql.Date.valueOf(getDateOrTimeString("sqlDateToday")));
                        } else if (dictValues[i].toString().equals(".z.d+1".toLowerCase())) {
                            params.put(dictKeys[i], java.sql.Date.valueOf(getDateOrTimeString("sqlDateTomorrow")));
                        } else if (dictValues[i].toString().equals(".z.d-1".toLowerCase())) {
                            params.put(dictKeys[i], java.sql.Date.valueOf(getDateOrTimeString("sqlDateYesterday")));
                        } else if (dictValues[i].toString().startsWith(".z.d-")) {
                            int days = Integer.parseInt(dictValues[i].split("-")[1]);
                            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                            DateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
                            Calendar cal = Calendar.getInstance();
                            Calendar tCal = Calendar.getInstance();
                            cal.add(Calendar.DATE, -days);
                            String sqlDateYesterday = dateFormat.format(cal.getTime());
                            params.put(dictKeys[i], java.sql.Date.valueOf(sqlDateYesterday));
                        } else if (dictValues[i].toString().startsWith(".z.d+")) {
                            int days = Integer.parseInt(dictValues[i].split("-")[1]);
                            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                            DateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
                            Calendar cal = Calendar.getInstance();
                            cal.add(Calendar.DATE, +days);
                            String sqlDateYesterday = dateFormat.format(cal.getTime());
                            params.put(dictKeys[i], java.sql.Date.valueOf(sqlDateYesterday));
                        }
                        else {
                            if (dictValues[i].toString().contains("-")) {
                                // accepts 2016-10-27
                                params.put(dictKeys[i], java.sql.Date.valueOf(dictValues[i].toString()));
                            } else {
                                // accepts 2016.10.27
                                params.put(dictKeys[i], java.sql.Date.valueOf(dictValues[i].toString().replace(".", "-")));
                            }
                        }
                        break;
                    case "SQL_TIME":
                        if (dictValues[i].toString().equals(".z.t")) {
                            params.put(dictKeys[i], Time.valueOf(getDateOrTimeString("sqlTimeNow")));
                        } else if (dictValues[i].toString().equals(".z.t-00:20:00.000")) {
                            params.put(dictKeys[i], Time.valueOf(getDateOrTimeString("sqlTimeMinus20")));
                        }
//					else if(dictValues[i].toString().startsWith(".z.p")){
//						params.put(dictKeys[i], Time.valueOf(getDateOrTimeString("")));
//					}
                        else {

                            if (dictValues[i].length() == 12) {
                                dictValues[i] = dictValues[i].substring(0, 8);
                            }
                            params.put(dictKeys[i], Time.valueOf(dictValues[i].toString().replace(")", "")));
                        }
                        break;
                    case "BOOLEAN":
                        if (dictValues[i].toString().equals("1b")) {
                            params.put(dictKeys[i], true);
                        }
                        else {
                            params.put(dictKeys[i], false);
                        }
                        break;
                    default:
                        params.put(dictKeys[i], dictValues[i]);
                        LOG.warn("The parameters " + dictKeys[i].toString() + " value " + dictValues[i].toString()
                                + " was not cast to the correct type.");
                        break;
                }

            } else {
                cleanParams = false;
                LOG.error("Parameter key specified: " + dictKeys[i] + " does not exists for the selected analytic");
            }
        }
        if (cleanParams) {
            query.addParameterValues(params);
            LOG.info("Running query \n" + query.toString());
            // Expects a user who is running the query.
            Object result = apiService.runQuery(query, access.split(":")[0]);
            LOG.info("Received Result of type {} ", result.getClass().getSimpleName());
            System.exit(1);
        }
    }