output[1] = seedB + c;
  }

  /*
   * Compute an 8-byte hash of a byte array of length greater than 64 bytes.
   */
  private static long fullFingerprint(byte[] bytes, int offset, int length) {
    // For lengths over 64 bytes we hash the end first, and then as we
    // loop we keep 56 bytes of state: v, w, x, y, and z.
    long x = load64(bytes, offset);
    long y = load64(bytes, offset + length - 16) ^ K1;

					t.Errorf("Test %d: read returns wrong file content", i)
				}
			}
		}
	}
}

// Test erasureDecode with random offset and lengths.
// This test is t.Skip()ed as it a long time to run, hence should be run
// explicitly after commenting out t.Skip()
func TestErasureDecodeRandomOffsetLength(t *testing.T) {
	if testing.Short() {
		t.Skip()
	}

        }

        if (compareResult < 0) {
          high = mid - 1
        } else if (compareResult > 0) {
          low = mid + end + 1
        } else {
          // We found a match, but are the lengths equal?
          val publicSuffixBytesLeft = publicSuffixLength - publicSuffixByteIndex
          var labelBytesLeft = labels[currentLabelIndex].size - currentLabelByteIndex

        // When
        String scope = mockNetbiosName.getScope();

        // Then
        assertNull(scope);
    }

    @Test
    @DisplayName("Should handle various name lengths")
    void testVariousNameLengths() {
        // NetBIOS names can be up to 15 characters
        String[] testNames = { "A", "SERVER", "LONGSERVERNAME", "EXACTLY15CHARS1" };

        for (String testName : testNames) {

 */
@NullUnmarked
public class Fingerprint2011Test extends TestCase {

  // Length of the sample string to produce
  private static final int MAX_BYTES = 1000;

  // Map from sample string lengths to the fingerprint
  private static final ImmutableSortedMap<Integer, Long> LENGTH_FINGERPRINTS =
      new ImmutableSortedMap.Builder<Integer, Long>(Ordering.natural())
          .put(1000, 0x433109b33e13e6edL)

        if (keyManager == null && (encryptionKey == null || decryptionKey == null)) {
            log.error("No encryption keys available");
            return false;
        }

        // Validate key lengths
        try {
            int expectedKeyLength = getKeyLength();
            byte[] encKey = getEncryptionKey();
            byte[] decKey = getDecryptionKey();

            try {

    output[1] = seedB + c;
  }

  /*
   * Compute an 8-byte hash of a byte array of length greater than 64 bytes.
   */
  private static long fullFingerprint(byte[] bytes, int offset, int length) {
    // For lengths over 64 bytes we hash the end first, and then as we
    // loop we keep 56 bytes of state: v, w, x, y, and z.
    long x = load64(bytes, offset);
    long y = load64(bytes, offset + length - 16) ^ K1;

            return;
        }
        assertNotNull("Expected array is null but actual is not", expected);
        assertNotNull("Actual array is null but expected is not", actual);
        assertEquals("Array lengths differ", expected.length, actual.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals("Arrays differ at index " + i, expected[i], actual[i]);
        }
    }

            baseAuth.close();
            startAuth.close();
            middleAuth.close();
            endAuth.close();
        }
    }

    /**
     * Test constant-time comparison with various password lengths.
     */
    @Test
    public void testConstantTimeWithDifferentLengths() throws Exception {
        char[] password1 = "short".toCharArray();
        char[] password2 = "verylongpasswordthatisdifferent".toCharArray();

        int actualLength = (int) lengthField.get(response);

        assertEquals(expectedLength, actualLength);
    }

    @DisplayName("Test readParametersWireFormat with various lengths")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 100, 1000, 65535, Integer.MAX_VALUE })
    void testReadParametersWireFormatWithVariousLengths(int expectedLength) throws Exception {