response.readBytesWireFormat(buffer, 0);
            });
        }

        @Test
        @DisplayName("Should throw exception with correct message for invalid structure size")
        void testReadBytesWireFormatExceptionMessage() {
            // Given
            byte[] buffer = new byte[60];

        }
    }

    @Nested
    @DisplayName("ToString Tests")
    class ToStringTests {

        @Test
        @DisplayName("Should generate correct string representation")
        void testToString() {
            when(mockReferral.getTtl()).thenReturn(600);
            when(mockReferral.getRFlags()).thenReturn(4);

     */
    @Override
    public boolean equals(final Object obj) {

      checkArgument(service.state() == NEW, "Can only manage NEW services, %s", service);
    }
    // We have installed all of our listeners and after this point any state transition should be
    // correct.
    this.state.markReady();
  }

  /**
   * Registers a {@link Listener} to be {@linkplain Executor#execute executed} on the given

    /**
     * Enable hack to make kerberos auth work with DFS sending short names
     *
     * This works by appending the domain name to the netbios short name and will fail horribly if this mapping is not
     * correct for your domain.
     *
     * Property {@code jcifs.smb.client.dfs.convertToFQDN} (boolean, default false)
     *
     * @return whether to convert NetBIOS names returned by DFS to FQDNs
     */

                            // TODO ick. this forces the OCE that should have come from the previous call. It is still
                            // correct
                            if (newRange.isSelectedVersionKnown(previous.getArtifact())) {
                                fireEvent(
                                        ResolutionListener.RESTRICT_RANGE,

func objectQuorumFromMeta(ctx context.Context, partsMetaData []FileInfo, errs []error, defaultParityCount int) (objectReadQuorum, objectWriteQuorum int, err error) {
	// There should be at least half correct entries, if not return failure
	expectedRQuorum := len(partsMetaData) / 2
	if defaultParityCount == 0 {
		// if parity count is '0', we expected all entries to be present.
		expectedRQuorum = len(partsMetaData)
	}

		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	getObjectInfo := objectAPI.GetObjectInfo

	// Check for auth type to return S3 compatible error.
	// type to return the correct error (NoSuchKey vs AccessDenied)
	if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectAction, bucket, object); s3Error != ErrNone {
		if getRequestAuthType(r) == authTypeAnonymous {
			// As per "Permission" section in

  /*
   * One of the key challenges of this class is to prevent lost signals, while trying hard to
   * minimize unnecessary signals. One simple and correct algorithm is to signal some other waiter
   * with a satisfied guard (if one exists) whenever any thread occupying the monitor exits the
   * monitor, either by unlocking all of its held locks, or by starting to wait for a guard. This

// Returns the latest updated FileInfo files and error in case of failure.
func getLatestFileInfo(ctx context.Context, partsMetadata []FileInfo, defaultParityCount int, errs []error) (FileInfo, error) {
	// There should be at least half correct entries, if not return failure
	expectedRQuorum := len(partsMetadata) / 2
	if defaultParityCount == 0 {
		// if parity count is '0', we expected all entries to be present.
		expectedRQuorum = len(partsMetadata)
	}