return name;
                } catch (NameNotFoundException nnfe) {
                    uhe = new UnknownHostException(nnfe.getMessage());
                }
                int dot = name.indexOf('.');
                if (dot == -1)
                    break;
                name = name.substring(dot + 1);
            }
        } catch (NamingException ne) {
            if (log.level > 1)

            return;
        }
        for (final String value : values) {
            if (value.indexOf(',') >= 0) {
                action.throwValidationError(messages -> {
                    messages.addErrorsInvalidStrIsIncluded(propertyName, value, ",");
                }, hook);
            }
            if (value.indexOf("=>") >= 0) {
                action.throwValidationError(messages -> {

     */
    private String getDFSShare () throws URISyntaxException {
        URI dfsRoot = new URI(getDFSRootURL());
        String dfsRootPath = dfsRoot.getPath();
        int firstSep = dfsRootPath.indexOf('/', 1);
        String dfsShare;
        if ( firstSep > 0 ) {
            dfsShare = dfsRootPath.substring(1, firstSep);
        }
        else {

        }
        is MappedRange.External -> {
          // Write the mapping.
          val mappingOffset: Int
          val mappedTo = range.mappedTo.utf8()
          val mappingIndex = mappingsBuffer.indexOf(mappedTo)
          if (mappingIndex == -1) {
            mappingOffset = mappingsBuffer.length
            mappingsBuffer.append(mappedTo)
          } else {
            mappingOffset = mappingIndex
          }

            final String[] lines = value.split("[\r\n]");
            for (final String line : lines) {
                if (StringUtil.isNotBlank(line)) {
                    final int pos = line.indexOf('=');
                    if (pos == 0) {
                        paramMap.put("unknown." + (unknownKey + 1), line.substring(pos + 1).trim());
                        unknownKey++;
                    } else if (pos > 0) {

    UnicodeEscaper e = new PercentEscaper("+*/-", false);
    for (char c = 0; c < 128; c++) {
      if ((c >= '0' && c <= '9')
          || (c >= 'a' && c <= 'z')
          || (c >= 'A' && c <= 'Z')
          || "+*/-".indexOf(c) >= 0) {
        assertUnescaped(e, c);
      } else {
        assertEscaping(e, escapeAscii(c), c);
      }
    }
  }

  /** Tests that if specify '%' as safe the result is an idempotent escaper. */

            "Separator (%s) cannot contain alphabet characters",
            separator);
      }
      if (paddingChar != null) {
        checkArgument(
            separator.indexOf(paddingChar.charValue()) < 0,
            "Separator (%s) cannot contain padding character",
            separator);
      }
      return new SeparatedBaseEncoding(this, separator, afterEveryChars);
    }

                        && ((type = parent.getNodeType()) == Node.ELEMENT_NODE || type == Node.ENTITY_REFERENCE_NODE)) {
                    if (type == Node.ELEMENT_NODE) {
                        if (parent.getNodeName().indexOf(prefix + ":") == 0) {
                            return parent.getNamespaceURI();
                        }
                        final NamedNodeMap nnm = parent.getAttributes();

    assertThat(networkString).contains("allowsSelfLoops: " + network.allowsSelfLoops());

    int nodeStart = networkString.indexOf("nodes:");
    int edgeStart = networkString.indexOf("edges:");
    String nodeString = networkString.substring(nodeStart, edgeStart);
    String edgeString = networkString.substring(edgeStart);

    Graph<N> asGraph = network.asGraph();

            parent.add(index, element);
        }

        public E remove(final int index) {
            return parent.remove(index);
        }

        public int indexOf(final Object o) {
            return parent.indexOf(o);
        }

        public int lastIndexOf(final Object o) {
            return parent.lastIndexOf(o);
        }

        public ListIterator<E> listIterator() {