this.graph = graph;
    this.node = node;
    this.edgeType = edgeType;
  }

  @Override
  public boolean remove(@Nullable Object o) {
    throw new UnsupportedOperationException();
  }

  @Override
  public int size() {
    if (graph.isDirected()) {
      return predecessorsOrEmpty(node).size()
          + successorsOrEmpty(node).size()

/** An ordering that uses the reverse of the natural order of the values. */
@GwtCompatible
final class ReverseNaturalOrdering extends Ordering<Comparable<?>> implements Serializable {
  static final ReverseNaturalOrdering INSTANCE = new ReverseNaturalOrdering();

  @Override
  @SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
  public int compare(Comparable<?> left, Comparable<?> right) {

	{err: crypto.ErrCustomerKeyMD5Mismatch, errCode: ErrSSECustomerKeyMD5Mismatch},
	{err: errObjectTampered, errCode: ErrObjectTampered},

	{err: nil, errCode: ErrNone},
	{err: errors.New("Custom error"), errCode: ErrInternalError}, // Case where err type is unknown.
}

func TestAPIErrCode(t *testing.T) {
	ctx := t.Context()
	for i, testCase := range toAPIErrorTests {

}

// Returns whole-file bitrot writer.
func newWholeBitrotWriter(disk StorageAPI, volume, filePath string, algo BitrotAlgorithm, shardSize int64) io.WriteCloser {
	return &wholeBitrotWriter{disk, volume, filePath, shardSize, algo.New()}
}

// Implementation to verify bitrot for the whole file.
type wholeBitrotReader struct {
	disk       StorageAPI
	volume     string
	filePath   string
	verifier   *BitrotVerifier // Holds the bit-rot info

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"context"
	"errors"
	"fmt"

	etcd "go.etcd.io/etcd/client/v3"
)

var errEtcdUnreachable = errors.New("etcd is unreachable, please check your endpoints")

func etcdErrToErr(err error, etcdEndpoints []string) error {
	if err == nil {
		return nil
	}
	switch err {
	case context.DeadlineExceeded:

## Verification instructions

### Importing the key

You can import the key into your GPG keyring in one of two ways.

First, copy the public key block below into a new file called `gradle_pubkey.asc`, then import it with this command:

```bash
gpg --import gradle_pubkey.asc
```

Alternatively, you can fetch the key directly from a key server:

```bash

 */

import org.gradle.plugins.ide.idea.model.IdeaModel

/**
 * Test Fixtures Plugin.
 *
 * Configures the Project as a test fixtures producer if `src/testFixtures` is a directory:
 * - adds a new `testFixtures` source set which should contain utilities/fixtures to assist in unit testing
 *   classes from the main source set,
 * - the test fixtures are automatically made available to the test classpath.
 *

            });
            schedulerTime = now;
        }, fessConfig.getSchedulerMonitorIntervalAsInteger(), true);
    }

    @Override
    public LaJobRunner createRunner() {
        return new LaJobRunner().useAccessContext(
                resource -> accessContextLogic.create(resource, OptionalThing::empty, OptionalThing::empty, () -> APP_TYPE));
    }

    /**

    return getDeclaredAnnotationsByType(annotationType);
  }

  /**
   * @since 18.0
   */
  @Override
  public Annotation[] getDeclaredAnnotations() {
    return annotations.toArray(new Annotation[0]);
  }

  /**
   * @since 18.0
   */
  @Override
  public <A extends Annotation> @Nullable A getDeclaredAnnotation(Class<A> annotationType) {
    checkNotNull(annotationType);

        this.managedVersionMap = managedVersionMap;

        return this;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder()
                .append("REQUEST: ")
                .append("\n")
                .append("artifact: ")
                .append(mad)
                .append("\n")