given-names: Lukasz
  - family-names: Kudlur
    given-names: Manjunath
  - family-names: Levenberg
    given-names: Josh
  - family-names: Mané
    given-names: Dan
  - family-names: Schuster
    given-names: Mike
  - family-names: Monga
    given-names: Rajat
  - family-names: Moore
    given-names: Sherry
  - family-names: Murray
    given-names: Derek
  - family-names: Olah
    given-names: Chris

	return errors.Is(err, syscall.EIO)
}

// Check if the given error corresponds to EISDIR (is a directory).
func isSysErrIsDir(err error) bool {
	return errors.Is(err, syscall.EISDIR)
}

// Check if the given error corresponds to ENOTDIR (is not a directory).
func isSysErrNotDir(err error) bool {
	return errors.Is(err, syscall.ENOTDIR)
}

// Check if the given error corresponds to the ENAMETOOLONG (name too long).

    return new AtomicReference<>();
  }

  /**
   * Creates an {@code AtomicReference} instance with the given initial value.
   *
   * @param initialValue the initial value
   * @return a new {@code AtomicReference} with the given initial value
   */
  public static <V extends @Nullable Object> AtomicReference<V> newReference(
      @ParametricNullness V initialValue) {

    /**
     * Add a compilation source root to the given project for the given scope.
     * The path will be transformed into an absolute path and added to the list for the given scope,
     * if not already present.
     *
     * @param project the project
     * @param scope the scope, i.e. usually main or test
     * @param sourceRoot the new source root

          ;
        }
        assertBitEquals(x, aa.get(i));
        prev = x;
      }
    }
  }

  /** getAndSet returns previous value and sets to given value at given index */
  public void testGetAndSet() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i : new int[] {0, SIZE - 1}) {
      double prev = 0.0;
      for (double x : VALUES) {

// NetLocker is dsync compatible locker interface.
type NetLocker interface {
	// Do read lock for given LockArgs.  It should return
	// * a boolean to indicate success/failure of the operation
	// * an error on failure of lock request operation.
	RLock(ctx context.Context, args LockArgs) (bool, error)

	// Do write lock for given LockArgs. It should return
	// * a boolean to indicate success/failure of the operation

some work here to figure out how a dispatching to a particular plugin would occur because everything needs to be mediated through the host application. For a given action that is possible for a user to perform in the UI we need to know the URI that is to be used with its given parameters. That URI in turn must map internally to a method in a given component which belongs to a plugin. This mapping should actually be more generalized and it shouldn’t matter internally whether this maps to the core application...

  /**
   * Creates a new {@code AtomicDoubleArray} of the given length, with all elements initially zero.
   *
   * @param length the length of the array
   */
  public AtomicDoubleArray(int length) {
    this.longs = new AtomicLongArray(length);
  }

  /**
   * Creates a new {@code AtomicDoubleArray} with the same length as, and all elements copied from,
   * the given array.
   *
   * @param array the array to copy elements from

   * ...);} to ensure the compiler knows that it will throw.
   *
   * @return this method does not return; it always throws
   * @throws IOException when the given throwable is an IOException
   * @throws X1 when the given throwable is of the declared type X1
   * @throws X2 when the given throwable is of the declared type X2
   */
  public <X1 extends Exception, X2 extends Exception> RuntimeException rethrow(

	groups, err := l.LDAP.SearchForUserGroups(conn, username, bindDN)
	if err != nil {
		return "", nil, err
	}

	return bindDN, groups, nil
}

// GetValidatedDNForUsername checks if the given username exists in the LDAP directory.
// The given username could be just the short "login" username or the full DN.
//
// When the username/DN is found, the full DN returned by the **server** is