import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.Internal;

import java.util.List;
import java.util.Objects;

/**
 * A transformation to inject an expected warning for a given test.
 */
public class InjectWarnings extends FeatureInjector implements RestTestTransformByParentObject {

    private static JsonNodeFactory jsonNodeFactory = JsonNodeFactory.withExactBigDecimals(false);

	Relations         map[string]Relation
	EmbeddedRelations map[string]EmbeddedRelations
}

func checkEmbeddedRelations(t *testing.T, actual map[string]*schema.Relationships, expected map[string]EmbeddedRelations) {
	for name, relations := range actual {
		rs := expected[name]
		t.Run("CheckEmbeddedRelations/"+name, func(t *testing.T) {
			if len(relations.Relations) != len(rs.Relations) {

  public void testFailsToForward() {
    try {
      ForwardingObjectTester.testForwardingObject(FailToForward.class);
    } catch (AssertionError | UnsupportedOperationException expected) {
      // UnsupportedOperationException is what we see on Android.
      return;
    }
    fail("Should have thrown");
  }

     * Test that interface constants are correctly defined
     */
    @Test
    @DisplayName("Test FileInformation constants are correctly defined")
    void testInterfaceConstants() {
        // Verify all constants have expected values
        assertEquals((byte) 20, FileInformation.FILE_ENDOFFILE_INFO);
        assertEquals((byte) 0x4, FileInformation.FILE_BASIC_INFO);
        assertEquals((byte) 0x5, FileInformation.FILE_STANDARD_INFO);

			return &cr.WebIdentityToken{
				Token: oidcToken,
			}, nil
		},
		RoleARN: roleARN,
	}

	value, err := webID.Retrieve()
	if err != nil {
		log.Fatalf("Expected to generate credentials: %v", err)
	}

	// Print credentials separated by colons:
	fmt.Printf("%s:%s:%s\n", value.AccessKeyID, value.SecretAccessKey, value.SessionToken)

            fileFsSizeInfo.decode(buffer.array(), 0, 24);
            String result = fileFsSizeInfo.toString();

            // Then
            String expected = "SmbInfoAllocation[alloc=123456,free=78910,sectPerAlloc=16,bytesPerSect=4096]";
            assertEquals(expected, result);
        }

        @Test
        @DisplayName("Should handle negative values in toString")

/**
 * Tests for SmbEndOfFileException focusing on message, status, and throwability.
 */
@ExtendWith(MockitoExtension.class)
class SmbEndOfFileExceptionTest {

    /**
     * Verifies the no-arg constructor sets the expected message, status, and no cause.
     */
    @Test
    void defaultConstructorSetsMessageAndStatus() {
        // Arrange & Act
        SmbEndOfFileException ex = new SmbEndOfFileException();

        // Assert

        if (structureSize == 9) {
            return super.readErrorResponse(buffer, bufferIndex);
        }
        if (structureSize != 49) {
            throw new SMBProtocolDecodingException("Expected structureSize = 49");
        }
        bufferIndex += 4;
        this.ctlCode = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.fileId = new byte[16];

      source: Buffer,
      byteCount: Long,
    ) {
      check(!closed) { "closed" }
      if (contentLength != -1L && bytesReceived + byteCount > contentLength) {
        throw ProtocolException(
          "expected $contentLength bytes but received ${bytesReceived + byteCount}",
        )
      }
      try {
        if (invokeStartEvent) {
          invokeStartEvent = false
          call.eventListener.requestBodyStart(call)

    assertBitEquals(1.0, at.get());
    for (double x : VALUES) {
      at.lazySet(x);
      assertBitEquals(x, at.get());
    }
  }

  /** compareAndSet succeeds in changing value if equal to expected else fails */
  public void testCompareAndSet() {
    double prev = Math.E;
    double unused = Math.E + Math.PI;
    AtomicDouble at = new AtomicDouble(prev);
    for (double x : VALUES) {