byte[] buffer1 = new byte[1024];
            int bytesRead1 = stream1.read(buffer1);
            assertEquals(testContent, new String(buffer1, 0, bytesRead1, "UTF-8"));
        }

        // Second read - should work independently
        try (InputStream stream2 = cache.getInputStream()) {
            byte[] buffer2 = new byte[1024];
            int bytesRead2 = stream2.read(buffer2);

        assertEquals(4, written, "Setup should write 4 bytes");
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0], "First byte should be subCommand");
        assertEquals(0, dst[1], "Second byte should be 0");
        assertEquals(0, dst[2], "Third byte should be 0 (no FID)");
        assertEquals(0, dst[3], "Fourth byte should be 0 (no FID)");
    }

    @Test
    public void testReadSetupWireFormat() {

            // Get local midnight boundary
            Calendar cal = Calendar.getInstance();

            cal.set(Calendar.HOUR_OF_DAY, 0);
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            cal.set(Calendar.MILLISECOND, 0);

            if (cal.getTime().after(lastModified)) {
                checkForUpdates = true;
            }

* **`300 - 399`** are for "Redirection".  Responses with these status codes may or may not have a body, except for `304`, "Not Modified", which must not have one.
* **`400 - 499`** are for "Client error" responses. These are the second type you would probably use the most.
    * An example is `404`, for a "Not Found" response.
    * For generic errors from the client, you can just use `400`.

	pcs := [13]uintptr{}
	// skip is caller-path sensitive and should be selected by each public helper.
	len := runtime.Callers(skip, pcs[:])
	frames := runtime.CallersFrames(pcs[:len])
	for i := 0; i < len; i++ {
		// second return value is "more", not "ok"
		frame, _ := frames.Next()
		if (!strings.HasPrefix(frame.File, gormSourceDir) ||
			strings.HasSuffix(frame.File, "_test.go")) && !strings.HasSuffix(frame.File, ".gen.go") {
			return frame

Esto es bastante simple (no muy útil), pero nos ayudará a centrarnos en cómo funcionan las sub-dependencias.

## Segunda dependencia, "dependable" y "dependant" { #second-dependency-dependable-and-dependant }

Luego puedes crear otra función de dependencia (un "dependable") que al mismo tiempo declare una dependencia propia (por lo que también es un "dependant"):

    @Keep public static final WithPublicConstants SECOND = new WithPublicConstants();
  }

  private static class FirstConstantIsNull {
    // To test that null constant is ignored
    @Keep public static final @Nullable FirstConstantIsNull FIRST = null;

    @Keep public static final FirstConstantIsNull SECOND = new FirstConstantIsNull();
  }

  public static class NonFinalFieldIgnored {

	obj, _, err := initObjectLayer(context.Background(), mustGetPoolEndpoints(0, fsDirs...))
	if err != nil {
		return nil, "", err
	}

	initAllSubsystems(ctx)

	globalIAMSys.Init(ctx, obj, globalEtcdClient, 2*time.Second)
	return obj, fsDirs[0], nil
}

func prepareErasureSets32(ctx context.Context) (ObjectLayer, []string, error) {
	return prepareErasure(ctx, 32)
}

        // When & Then
        assertTrue(negotiationRequest.isSigningEnforced(), "First call should return true");
        assertFalse(negotiationRequest.isSigningEnforced(), "Second call should return false");
        assertTrue(negotiationRequest.isSigningEnforced(), "Third call should return true");

        verify(negotiationRequest, times(3)).isSigningEnforced();
    }

    @Test

        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */
    @Test
    void decodeFromEncodedBuffer() throws NdrException {