list.subList(0, size - 1),
            list.subList(1, size),
            list.subList(0, 0),
            list.subList(size, size))) {
      assertEquals(subList.size() == 0, subList.isEmpty());
    }
  }

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testSubList_get() {
    List<E> list = getList();
    int size = getNumElements();
    List<E> copy = list.subList(0, size);

	} `json:"streaming"`

	RootCAs *x509.CertPool `json:"-"`
}

// Validate NATSArgs fields
func (n NATSArgs) Validate() error {
	if !n.Enable {
		return nil
	}

	if n.Address.IsEmpty() {
		return errors.New("empty address")
	}

	if n.Subject == "" {
		return errors.New("empty subject")
	}

	if n.ClientCert != "" && n.ClientKey == "" || n.ClientCert == "" && n.ClientKey != "" {

	Password   string          `json:"password"`
}

// Validate ElasticsearchArgs fields
func (a ElasticsearchArgs) Validate() error {
	if !a.Enable {
		return nil
	}
	if a.URL.IsEmpty() {
		return errors.New("empty URL")
	}
	if a.Format != "" {
		f := strings.ToLower(a.Format)
		if f != event.NamespaceFormat && f != event.AccessFormat {
			return errors.New("format value unrecognized")
		}

   * sibling of {@code a} referred to by {@code b}.
   *
   * @since 11.0
   */
  public static String simplifyPath(String pathname) {
    checkNotNull(pathname);
    if (pathname.isEmpty()) {
      return ".";
    }

    // split the path apart
    Iterable<String> components = Splitter.on('/').omitEmptyStrings().split(pathname);
    List<String> path = new ArrayList<>();

 * {@snippet :
 * final WeakHashMap<Object, Object> map = new WeakHashMap<>();
 * map.put(new Object(), Boolean.TRUE);
 * GcFinalization.awaitDone(new FinalizationPredicate() {
 *   public boolean isDone() {
 *     return map.isEmpty();
 *   }
 * });
 * }
 *
 * <p>Even if your non-test code does not use finalization, you can use this class to test for
 * leaks, by ensuring that objects are no longer strongly referenced:
 *
 * {@snippet :

     * @throws SmbException if path is invalid
     */
    public void validatePath(String path) throws SmbException {
        totalValidations.incrementAndGet();

        if (path == null || path.isEmpty()) {
            return; // Empty paths allowed
        }

        // Check overall path length
        if (path.length() > MAX_PATH_SIZE) {
            failedValidations.incrementAndGet();

    }

    private static Method getMostSpecific(List<Method> methods, Class<?>... classes) throws AmbiguousException {
        LinkedList<Method> applicables = getApplicables(methods, classes);

        if (applicables.isEmpty()) {
            return null;
        }

        if (applicables.size() == 1) {
            return applicables.getFirst();
        }

            cb.query().setConfigId_Equal(configId);
            cb.query().setErrorCount_GreaterEqual(count);
            cb.fetchFirst(fessConfig.getPageFailureUrlMaxFetchSizeAsInteger());
        });
        if (list.isEmpty()) {
            return Collections.emptyList();
        }

        Pattern pattern = null;
        if (StringUtil.isNotBlank(ignoreFailureType)) {
            pattern = Pattern.compile(ignoreFailureType);

        protwordsFile.reload(null);

        // Test with offset out of bounds
        PagingList<ProtwordsItem> list = protwordsFile.selectList(100, 10);
        assertEquals(0, list.size());
        assertTrue(list.isEmpty());
    }

    @Test
    public void test_selectList_negativeOffset() {
        // Load data first
        protwordsFile.reload(null);

        // Test with negative offset

    val calls = connection.calls
    val index = calls.indexOfFirst { it.get() == this@RealCall }
    check(index != -1)

    calls.removeAt(index)
    this.connection = null

    if (calls.isEmpty()) {
      connection.idleAtNs = System.nanoTime()
      if (connectionPool.connectionBecameIdle(connection)) {
        return connection.socket()
      }
    }

    return null
  }