lenient().when(mockNameServiceClient.getLocalHost()).thenReturn(mockHost);
        lenient().when(mockHost.getHostName()).thenReturn("TEST_HOSTNAME");

        return mockCtx;
    }

    @Test
    @DisplayName("Should create Type 3 message with authentication data")
    void testType3MessageCreation() throws Exception {
        // Given

			metaArr[i].TransitionStatus = ""
		}
		return metaArr
	}
	mkParities := func(N, agreedParity, disagreedParity, agree int) []int {
		ps := make([]int, N)
		for i := range N {
			if i < agree {
				ps[i] = agreedParity
				continue
			}
			ps[i] = disagreedParity // disagree
		}
		return ps
	}

	mkTest := func(N, parity, agree int) (res struct {

        public TestComponent() {
            this.id = instanceCounter.incrementAndGet();
        }

        public int getId() {
            return id;
        }

        public boolean isDestroyed() {
            return destroyed;
        }

        public void destroy() {
            this.destroyed = true;
        }

        public static void resetCounter() {

        closeFlagsField.setAccessible(true);
        int storedFlags = (int) closeFlagsField.get(request);
        assertEquals(testFlags, storedFlags);
    }

    @Test
    @DisplayName("createResponse should return Smb2CloseResponse with correct parameters")
    void testCreateResponse() throws Exception {
        Smb2CloseResponse response = request.createResponse(mockContext, request);

        assertNotNull(response);

   * collection in setUp(), but that caused problems when a tester changed the
   * value of list or collection but not both.
   */
  protected final List<E> getList() {
    return (List<E>) collection;
  }

  /**
   * {@inheritDoc}
   *
   * <p>The {@code AbstractListTester} implementation overrides {@link

      if (originalRequest.body() == null || originalRequest.header("Content-Encoding") != null) {
        return chain.proceed(originalRequest);
      }

      Request compressedRequest = originalRequest.newBuilder()
          .gzip()
          .build();
      return chain.proceed(compressedRequest);
    }
  }

   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *
   * <p>We sometimes also use {@code sneakyThrow} for testing how our code responds to
   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can
   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue

   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *
   * <p>We sometimes also use {@code sneakyThrow} for testing how our code responds to
   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can
   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue

        if (artifact.isRelease()) {
            versioning.setRelease(artifact.getVersion());
        }

        return new ArtifactRepositoryMetadata(artifact, versioning);
    }

    @Override
    protected String constructVersion(Versioning versioning, String baseVersion) {
        return versioning.getRelease();
    }

}

// MarshalXML encodes expiration date if it is non-zero and encodes
// empty string otherwise
func (t DeleteMarkerMTime) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if t.IsZero() {
		return nil
	}
	return e.EncodeElement(t.Format(time.RFC3339), startElement)
}

// ObjectV object version key/versionId
type ObjectV struct {
	ObjectName string `xml:"Key"`
	VersionID  string `xml:"VersionId"`
}