void constructorMasksValue(int input) {
        NdrShort ns = new NdrShort(input);
        // NdrShort masks to 0xFF (8 bits) in its constructor
        int expected = input & 0xFF;
        assertEquals(expected, ns.value, "value should be masked to 0xFF before storing");
    }

    /**
     * Round-trip encode/decode for a selection of representative values.
     */
    @ParameterizedTest

          .isEqualTo(value);
    }
  }

  public void testFromIntBitsLongValue() {
    for (int value : TEST_INTS) {
      long expected = value & 0xffffffffL;
      assertWithMessage(UnsignedInts.toString(value))
          .that(UnsignedInteger.fromIntBits(value).longValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {
    long min = 0;
    long max = (1L << 32) - 1;

    UncheckedExecutionException expected =
        assertThrows(
            UncheckedExecutionException.class,
            () -> getChecked(FAILED_FUTURE_UNCHECKED_EXCEPTION, TwoArgConstructorException.class));
    assertThat(expected).hasCauseThat().isEqualTo(UNCHECKED_EXCEPTION);
  }

  public void testGetCheckedUntimed_executionExceptionError() throws TwoArgConstructorException {
    ExecutionError expected =
        assertThrows(

		if err != nil {
			t.Fatalf("expected: <nil>, got: %s", err)
		}

		start, length, err1 := rs.GetOffsetLength(objectSize)
		if err1 != nil {
			t.Fatalf("expected: <nil>, got: %s", err1)
		}

		if start != successCase.offsetBegin {
			t.Fatalf("expected: %d, got: %d", successCase.offsetBegin, start)
		}

		if start+length-1 != successCase.offsetEnd {

  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();
    expected.put(k0(), newHashSet(v0(), v3()));
    expected.put(k1(), newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  public void testEntrySetEquals() {

            fail("Should throw ScheduledJobException");
        } catch (ScheduledJobException e) {
            assertEquals("No job.", e.getMessage());
        } catch (Exception e) {
            // Expected due to missing dependencies in test environment
            assertTrue(true);
        }
    }

    public void test_register_with_cron_null_scheduledJob() {
        try {

   * of throwable.
   */
  public void callAndAssertThrows(
      Class<? extends Throwable> expected, String methodName, Object... arguments)
      throws Exception {
    checkNotNull(expected);
    checkNotNull(methodName);
    checkNotNull(arguments);
    sendRequest(methodName, arguments);
    assertEquals(expected, getResponse(methodName).getThrowable().getClass());
  }

  /**

	echo "expected tag removal to have replicated, exiting..."
	exit_1
fi

./mc rm minio3/newbucket/README.md
sleep 5

./mc stat --no-list minio2/newbucket/README.md
if [ $? -eq 0 ]; then
	echo "expected file to be deleted, exiting.."
	exit_1
fi

./mc stat --no-list minio1/newbucket/README.md
if [ $? -eq 0 ]; then
	echo "expected file to be deleted, exiting.."
	exit_1

			},
		},
	}
	CheckIndices(t, expectedIndices, indices)
}

func CheckIndices(t *testing.T, expected, actual []*schema.Index) {
	if len(expected) != len(actual) {
		t.Errorf("expected %d indices, but got %d", len(expected), len(actual))
		return
	}

	for i, ei := range expected {
		t.Run(ei.Name, func(t *testing.T) {
			ai := actual[i]

		if fi.VersionID != versions[i].VersionID {
			t.Fatalf("getFileInfoVersions: versions don't match at %d, version id expected %s but got %s", i, fi.VersionID, versions[i].VersionID)
		}
		if fi.NumVersions != len(fivs.Versions) {
			t.Fatalf("getFileInfoVersions: version with %s version id expected to have %d as NumVersions but got %d", fi.VersionID, len(fivs.Versions), fi.NumVersions)
		}
	}