* Fix security holes in GCE metadata proxy. ([#51302](https://github.com/kubernetes/kubernetes/pull/51302), [@ihmccreery](https://github.com/ihmccreery))
* Fixed an issue looking up cronjobs when they existed in more than one API version ([#52227](https://github.com/kubernetes/kubernetes/pull/52227), [@liggitt](https://github.com/liggitt))

        }

        assertTrue(sourceFile.exists(), "Source file should exist");
        assertFalse(targetFile.exists(), "Target file should not exist initially");

        // Copy file
        sourceFile.copyTo(targetFile);

        assertTrue(sourceFile.exists(), "Source file should still exist after copy");
        assertTrue(targetFile.exists(), "Target file should exist after copy");

        // Test operations on empty service
        assertEquals(0, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration("non-existent"));
        assertFalse(mockService.unregisterWitness("non-existent"));
        assertFalse(mockService.processHeartbeat("non-existent", 1));

        // Test registration with null/empty values
        String regId1 = mockService.registerWitness(null, "192.168.1.100", 1);

            // Expected - file no longer exists
        }
    }

    @Test
    public void testFileBasedCacheCloseNonExistentFile() {
        tempFile = new File(Curl.tmpDir, "non-existent-file.tmp");
        assertFalse(tempFile.exists());

        ContentCache cache = new ContentCache(tempFile);

        // Should throw IOException when file doesn't exist
        try {
            cache.close();

            }
        }
    }

    public void test_fileNotFoundException() {
        // Test with non-existent file
        File nonExistentFile = new File("/tmp/non-existent-file-" + System.currentTimeMillis() + ".tmp");

        try {
            new TemporaryFileInputStream(nonExistentFile);
            fail("Should throw FileNotFoundException");

        // Test the pattern used in getDefaultMappings/getDefaultIndexSettings
        // with a non-existent resource
        try {
            try (final InputStream is = getClass().getClassLoader().getResourceAsStream("non/existent/resource.json")) {
                if (is == null) {
                    throw new IOException("Resource not found: non/existent/resource.json");
                }
                // This line should not be reached

        // Should not throw exception
        lenientService.updatePreauthHash("non-existent", "test".getBytes());

        // With enforcement enabled, should throw exception
        assertThrows(CIFSException.class, () -> {
            preauthService.updatePreauthHash("non-existent", "test".getBytes());
        });
    }

    @Test
    @DisplayName("Test context invalidation")

                errorMessage.set("SetException call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.cancel(true);
              if (!future.isDone()) {
                errorMessage.set("Cancel call exited before future was complete.");
              }

      throws InterruptedException {
    while (!isThreadBlockedOnInstanceOf(t, blocker)) {
      if (t.getState() == Thread.State.TERMINATED) {
        throw new RuntimeException("Thread " + t + " exited unexpectedly");
      }
      Thread.sleep(1);
    }
  }

  private static boolean isThreadBlockedOnInstanceOf(Thread t, Class<?> blocker) {

import java.util.concurrent.ExecutionException;

/**
 * A semi-persistent mapping from keys to values. Values are automatically loaded by the cache, and
 * are stored in the cache until either evicted or manually invalidated. The common way to build
 * instances is using {@link CacheBuilder}.
 *
 * <p>Implementations of this interface are expected to be thread-safe, and can be safely accessed
 * by multiple concurrent threads.