ASSERT_EQ(errors::OK, s.code()) << s.message();
    y.reset(y_raw);
  }

  float expected_dx[1] = {7.0f};
  ASSERT_NO_FATAL_FAILURE(CompareNumericalAndManualGradients(
      MulModel, ctx_.get(), {x.get(), y.get()}, 0, expected_dx, 1,
      UseFunction()));
}

#ifdef PLATFORM_GOOGLE
INSTANTIATE_TEST_SUITE_P(
    UnifiedCAPI, GradientCheckerTest,

func (r *Reader) SetExpectedMin(expectedMin int64) {
	r.expectedMin = expectedMin
}

// SetExpectedMax set expected max data expected from reader
func (r *Reader) SetExpectedMax(expectedMax int64) {
	r.expectedMax = expectedMax
}

// AddChecksum will add checksum checks as specified in
// https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html

			expectedError: hash.BadDigest{ExpectedMD5: invalidMD5, CalculatedMD5: getMD5Hash(nilBytes)},
		},
		25: {
			bucketName: bucket, objName: object, inputData: fiveMBBytes, inputMeta: invalidMD5Header, inputDataSize: int64(len(fiveMBBytes)), expectedMd5: getMD5Hash(fiveMBBytes),
			expectedError: hash.BadDigest{ExpectedMD5: invalidMD5, CalculatedMD5: getMD5Hash(fiveMBBytes)},

      for (double x : VALUES) {
        for (double y : VALUES) {
          aa.set(i, x);
          double z = aa.accumulateAndGet(i, y, Double::max);
          double expectedMax = max(x, y);
          assertBitEquals(expectedMax, z);
          assertBitEquals(expectedMax, aa.get(i));
        }
      }
    }
  }

  /** getAndUpdate adds given value to current, and returns previous value */

      for (double y : VALUES) {
        AtomicDouble a = new AtomicDouble(x);
        double z = a.accumulateAndGet(y, Double::max);
        double expectedMax = max(x, y);
        assertBitEquals(expectedMax, z);
        assertBitEquals(expectedMax, a.get());
      }
    }
  }

  /** getAndUpdate with sum stores sum of given value to current, and returns previous value */

            listOfVersions.stream().map(this::formatVersionToLine).collect(Collectors.toList()),
            Version.fromString("8.0.0")
        );
        expectedEx.expect(IllegalStateException.class);
        expectedEx.expectMessage("but they are released");
        vc.compareToAuthoritative(authoritativeReleasedVersions);
    }

    public void testCompareToAuthoritativeNotReallyRelesed() {

}

// BadDigest - Content-MD5 you specified did not match what we received.
type BadDigest struct {
	ExpectedMD5   string
	CalculatedMD5 string
}

func (e BadDigest) Error() string {
	return "Bad digest: Expected " + e.ExpectedMD5 + " does not match calculated " + e.CalculatedMD5
}

// SizeTooSmall reader size too small
type SizeTooSmall struct {
	Want int64
	Got  int64
}

		t.Errorf("Expected size 4, got %d", r.Size())
	}
	if r.ActualSize() != 4 {
		t.Errorf("Expected size 4, got %d", r.ActualSize())
	}
	expectedMD5, err := hex.DecodeString("e2fc714c4727ee9395f324cd2e7f331f")
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(r.MD5Current(), expectedMD5) {
		t.Errorf("Expected md5hex \"e2fc714c4727ee9395f324cd2e7f331f\", got %s", hex.EncodeToString(r.MD5Current()))
	}

        assertNotNull(str);
        assertTrue(str.contains("type=0x"));
        // The type should be formatted as 8-character hex
        String expectedHex = String.format("%08x", type);
        assertTrue(str.toLowerCase().contains(expectedHex));
    }

    @Test
    @DisplayName("Test with empty strings")
    void testWithEmptyStrings() {
        SmbShareInfo info = new SmbShareInfo("", 0, "");

        assertTrue(result.contains("file=" + fileName));
        // Hexdump.toHexString produces 4-character padded uppercase hex
        String expectedHex = String.format("%04X", action);
        assertTrue(result.contains("0x" + expectedHex));
    }

    @Test
    @DisplayName("Test toString with empty object")
    void testToStringEmpty() {
        String result = notifyInfo.toString();