Assumes delimiter to be comma since that covers all the usecase for now.
Will parameterize if use cases differ on delimiter.
@param n
@return
768243
public String getNDelimitedStrings(int n)
    {
        return IntStream.range(0, config.getColsPerRow()).mapToObj(i -> "'" + dataGenerator.getRandomValue() + "'").collect(Collectors.joining(","));
    }
873760
public JcString subLength(int len) {
		JcNumber sub = new JcNumber(len, this.getPredecessor(), OPERATOR.Common.COMMA_SEPARATOR); 
		JcString ret = new JcString(null, sub,
				new FunctionInstance(FUNCTION.String.SUBSTRING, 3));
		QueryRecorder.recordInvocationConditional(this, "subLength", ret, QueryRecorder.literal(len));
		return ret;
	}
695206
public static String stringFor(int n)
    {
        switch (n)
        {
            case CU_RES_VIEW_FORMAT_NONE          : return"CU_RES_VIEW_FORMAT_NONE";
            case CU_RES_VIEW_FORMAT_UINT_1X8      : return"CU_RES_VIEW_FORMAT_UINT_1X8";
            case CU_RES_VIEW_FORMAT_UINT_2X8      : return"CU_RES_VIEW_FORMAT_UINT_2X8";
            case CU_RES_VIEW_FORMAT_UINT_4X8      : return"CU_RES_VIEW_FORMAT_UINT_4X8";
            case CU_RES_VIEW_FORMAT_SINT_1X8      : return"CU_RES_VIEW_FORMAT_SINT_1X8";
            case CU_RES_VIEW_FORMAT_SINT_2X8      : return"CU_RES_VIEW_FORMAT_SINT_2X8";
            case CU_RES_VIEW_FORMAT_SINT_4X8      : return"CU_RES_VIEW_FORMAT_SINT_4X8";
            case CU_RES_VIEW_FORMAT_UINT_1X16     : return"CU_RES_VIEW_FORMAT_UINT_1X16";
            case CU_RES_VIEW_FORMAT_UINT_2X16     : return"CU_RES_VIEW_FORMAT_UINT_2X16";
            case CU_RES_VIEW_FORMAT_UINT_4X16     : return"CU_RES_VIEW_FORMAT_UINT_4X16";
            case CU_RES_VIEW_FORMAT_SINT_1X16     : return"CU_RES_VIEW_FORMAT_SINT_1X16";
            case CU_RES_VIEW_FORMAT_SINT_2X16     : return"CU_RES_VIEW_FORMAT_SINT_2X16";
            case CU_RES_VIEW_FORMAT_SINT_4X16     : return"CU_RES_VIEW_FORMAT_SINT_4X16";
            case CU_RES_VIEW_FORMAT_UINT_1X32     : return"CU_RES_VIEW_FORMAT_UINT_1X32";
            case CU_RES_VIEW_FORMAT_UINT_2X32     : return"CU_RES_VIEW_FORMAT_UINT_2X32";
            case CU_RES_VIEW_FORMAT_UINT_4X32     : return"CU_RES_VIEW_FORMAT_UINT_4X32";
            case CU_RES_VIEW_FORMAT_SINT_1X32     : return"CU_RES_VIEW_FORMAT_SINT_1X32";
            case CU_RES_VIEW_FORMAT_SINT_2X32     : return"CU_RES_VIEW_FORMAT_SINT_2X32";
            case CU_RES_VIEW_FORMAT_SINT_4X32     : return"CU_RES_VIEW_FORMAT_SINT_4X32";
            case CU_RES_VIEW_FORMAT_FLOAT_1X16    : return"CU_RES_VIEW_FORMAT_FLOAT_1X16";
            case CU_RES_VIEW_FORMAT_FLOAT_2X16    : return"CU_RES_VIEW_FORMAT_FLOAT_2X16";
            case CU_RES_VIEW_FORMAT_FLOAT_4X16    : return"CU_RES_VIEW_FORMAT_FLOAT_4X16";
            case CU_RES_VIEW_FORMAT_FLOAT_1X32    : return"CU_RES_VIEW_FORMAT_FLOAT_1X32";
            case CU_RES_VIEW_FORMAT_FLOAT_2X32    : return"CU_RES_VIEW_FORMAT_FLOAT_2X32";
            case CU_RES_VIEW_FORMAT_FLOAT_4X32    : return"CU_RES_VIEW_FORMAT_FLOAT_4X32";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC1  : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC1";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC2  : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC2";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC3  : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC3";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC4  : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC4";
            case CU_RES_VIEW_FORMAT_SIGNED_BC4    : return"CU_RES_VIEW_FORMAT_SIGNED_BC4";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC5  : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC5";
            case CU_RES_VIEW_FORMAT_SIGNED_BC5    : return"CU_RES_VIEW_FORMAT_SIGNED_BC5";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC6H : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC6H";
            case CU_RES_VIEW_FORMAT_SIGNED_BC6H   : return"CU_RES_VIEW_FORMAT_SIGNED_BC6H";
            case CU_RES_VIEW_FORMAT_UNSIGNED_BC7  : return"CU_RES_VIEW_FORMAT_UNSIGNED_BC7";
        }
        return "INVALID CUresourceViewFormat: "+n;
    }
876997
public static String[] split(String string, char delimiter) {
        int delimeterCount = 0;
        int start = 0;
        int end;
        while ((end = string.indexOf(delimiter, start)) != -1) {
            delimeterCount++;
            start = end + 1;
        }

        String[] result = new String[delimeterCount + 1];
        start = 0;
        for (int i = 0; i < delimeterCount; i++) {
            end = string.indexOf(delimiter, start);
            result[i] = string.substring(start, end);
            start = end + 1;
        }
        result[delimeterCount] = string.substring(start, string.length());
        return result;
    }
829136
public static String join(final String[] seq, final String delimiter) {
    if (null == seq || seq.length < 1) return "";
    Assert.notNull(delimiter);
    StringBuilder aim = new StringBuilder();
    for (int i = 0; i < seq.length; i++) {
      if (aim.length() > 0) aim.append(delimiter);
      aim.append(seq[i]);
    }
    return aim.toString();
  }
745302
public <N extends Number> CellFormatResult format(final String formatPattern, final N value) {
        return format(formatPattern, value, Locale.getDefault());
    }
29469
public String text(String delimiter)
    {
        if (delimiter == null) delimiter = "";
        StringBuilder sb = new StringBuilder(size() * 3);
        for (IWord word : this)
        {
            if (word instanceof CompoundWord)
            {
                for (Word child : ((CompoundWord) word).innerList)
                {
                    sb.append(child.getValue()).append(delimiter);
                }
            }
            else
            {
                sb.append(word.getValue()).append(delimiter);
            }
        }
        sb.setLength(sb.length() - delimiter.length());

        return sb.toString();
    }
313443
private static String delimit(String s, char c) {
    int i = s.indexOf(c);
    while (i != -1) {
      if (i == 0 || s.charAt(i - 1) != '\\') {
        s = s.substring(0, i) + '\\' + s.substring(i);
        i = s.indexOf(c, i + 2);
      } else {
        i = s.indexOf(c, i + 1);
      }
    }
    return s;
  }
1322888
@Nonnull
    public static List<String> splitAtCommasAndTrim(Iterable<String> input) {
        if(input==null) {
            return Collections.emptyList();
        }
        Iterable<String> nonEmptyInputs = Iterables.filter(input, Predicates.notNull());
        return Lists.newArrayList(Iterables.concat(Iterables.transform(nonEmptyInputs, COMMA_SPLITTER)));
    }
1149168
public static <C extends Collection<String>> C splitString(String line, char delim, C words) {
		return splitString(line, 0, line.length(), delim, words);
	}
736021
public CsvReader lineDelimiter(String delimiter) {
		if (delimiter == null || delimiter.length() == 0) {
			throw new IllegalArgumentException("The delimiter must not be null or an empty string");
		}

		this.lineDelimiter = delimiter;
		return this;
	}
787817
public StrTokenizer setDelimiterMatcher(final StrMatcher delim) {
        if (delim == null) {
            this.delimMatcher = StrMatcher.noneMatcher();
        } else {
            this.delimMatcher = delim;
        }
        return this;
    }
1148090
public static DelimitRegExIterator<String> defaultDelimitRegExIterator(Reader in, String delimiter) {
    return new DelimitRegExIterator<String>(in, delimiter, new IdentityFunction<String>());
  }
367829
public static String join(final Collection<String> seq, final String delimiter) {
    if (null == seq || seq.size() < 1) {
      return "";
    } else {
      StringBuilder aim = new StringBuilder();
      for (String one : seq) {
        if (null != delimiter && aim.length() > 0) {
          aim.append(delimiter);
        }
        aim.append(one);
      }
      return aim.toString();
    }
  }
199105
public boolean nextIs(PatternConstant constant) {
        char[] cs = constant.getCharArray();
        int length = cs.length;

        if (length > textLength - offset) {
            return false;
        }

        if (!constant.isIgnoreCase()) {
            int i;
            //noinspection StatementWithEmptyBody
            for (i = 0; i < length && text[offset + i] == cs[i]; i++);
            return i == length;
        } else {
            for (int i = 0; i < length; i++) {
                char ct = text[offset + i];
                char cv = cs[i];
                if (
                        ct == cv ||
                                Character.toUpperCase(ct) == Character.toUpperCase(cv) ||
                                Character.toLowerCase(ct) == Character.toLowerCase(cv)
                        ) {
                    continue;
                }
                return false;
            }
            return true;
        }
    }
1352399
private boolean startsWithDelimiter(String word, String[] delimiters) {

        boolean delim = false;
        for (int i = 0; i < delimiters.length; i++) {
            if (word.startsWith(delimiters[i])) {
                delim = true;
                break;
            }
        }
        return delim;
    }
1049511
@Override
    public long skip(final long n) {
        if (n < 0) {
            throw new IllegalArgumentException(
                    "Number of characters to skip is less than zero: " + n);
        }
        if (idx >= charSequence.length()) {
            return EOF;
        }
        final int dest = (int)Math.min(charSequence.length(), idx + n);
        final int count = dest - idx;
        idx = dest;
        return count;
    }