buf.append(cpSeparator);
                buf.append(basePath);
                buf.append(file.getName());
            }
        }
    }

    /**
     * Creates a timeout task for this job execution.
     * If timeout is not set or is <= 0, returns null.
     *
     * @return the timeout task, or null if no timeout is configured
     */

	case nil:
		expAt, err = 0, nil
	default:
		expAt, err = 0, ErrInvalidDuration
	}
	if expAt < 0 {
		return 0, ErrInvalidDuration
	}
	return expAt, err
}

// GenerateCredentials - creates randomly generated credentials of maximum
// allowed length.
func GenerateCredentials() (accessKey, secretKey string, err error) {
	accessKey, err = GenerateAccessKey(accessKeyMaxLen, rand.Reader)
	if err != nil {

  public NavigableSet<E> elementSet() {
    return (NavigableSet<E>) super.elementSet();
  }

  @LazyInit private transient @Nullable UnmodifiableSortedMultiset<E> descendingMultiset;

  // TODO(b/418181860): This method creates retain cycles in J2ObjC. In order to break the cycle,
  // there needs to be separate classes for primary and descending multiset, where the primary one

        return PLUGIN_UPGRADES;
    }

    /**
     * Gets or creates the cached Maven 4 session.
     */
    private Session getSession() {
        if (session == null) {
            session = createMaven4Session();
        }
        return session;
    }

    /**
     * Creates a new Maven 4 session for effective POM computation.
     */
    private Session createMaven4Session() {

         *
         * @param registration the expired registration
         */
        void onRegistrationExpired(WitnessRegistration registration);
    }

    /**
     * Creates a new witness client.
     *
     * @param witnessServer the witness server address
     * @param context the CIFS context
     * @throws IOException if initialization fails
     */

          i = nexti;
        } else {
          items[i] = null;
          putIndex = i;
          break;
        }
      }
    }
    --count;
  }

  /**
   * Creates an {@code MonitorBasedArrayBlockingQueue} with the given (fixed) capacity and default
   * access policy.
   *
   * @param capacity the capacity of this queue

 *
 * @author mbechler
 */
public class Smb2TreeConnectRequest extends ServerMessageBlock2Request<Smb2TreeConnectResponse> {

    private int treeFlags;
    private final String path;

    /**
     * Creates a new SMB2 tree connect request to establish a connection to a network share.
     *
     * @param config the CIFS configuration
     * @param path the UNC path to the share to connect to
     */

 *            The type of the second value
 */
public class Pair<T1, T2> {

    /** The first value */
    protected T1 first;

    /** The second value */
    protected T2 second;

    /**
     * Creates and returns a pair of two values.
     *
     * @param <T1>
     *            The type of the first value
     * @param <T2>
     *            The type of the second value
     * @param first

	Listeners   []net.Listener
	Managers    []*Manager
	Mux         []*mux.Router
	Hosts       []string
	cleanupOnce sync.Once
	cancel      context.CancelFunc
}

// SetupTestGrid creates a new grid for testing purposes.
// Select the number of hosts to create.
// Call (TestGrid).Cleanup() when done.
func SetupTestGrid(n int) (*TestGrid, error) {
	hosts, listeners, err := getHosts(n)
	if err != nil {
		return nil, err
	}

  }

  /**
   * Creates a {@link PairedStats} from with the given lists of {@code x} and {@code y} values,
   * which must be of the same size.
   */
  static PairedStats createPairedStatsOf(List<Double> xValues, List<Double> yValues) {
    return createFilledPairedStatsAccumulator(xValues, yValues).snapshot();
  }

  /**