}

    @Test
    public void testDifferentKeys() {
        final CachedCipher cipher1 = new CachedCipher();
        cipher1.setKey("key1");

        final CachedCipher cipher2 = new CachedCipher();
        cipher2.setKey("key2");

        final String original = "Hello World";
        final String encrypted1 = cipher1.encryptText(original);

 * cipher.setKey("mySecretKey");
 *
 * // Encrypt text
 * String encrypted = cipher.encryptText("Hello World");
 *
 * // Decrypt text
 * String decrypted = cipher.decryptText(encrypted);
 *
 * // For AES encryption
 * CachedCipher aesCipher = new CachedCipher();
 * aesCipher.setAlgorithm("AES");
 * aesCipher.setTransformation("AES");
 * aesCipher.setKey("0123456789abcdef"); // 16-byte key for AES-128

      assertFalse(
          "Inverse should not contain entry " + reversed, inv.entrySet().contains(reversed));
      assertFalse(
          "Inverse should not contain key " + reversed.getKey(),
          inv.containsKey(reversed.getKey()));
      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*

   */
  void insertEntry(
      int entryIndex, @ParametricNullness K key, @ParametricNullness V value, int hash, int mask) {
    this.setEntry(entryIndex, CompactHashing.maskCombine(hash, UNSET, mask));
    this.setKey(entryIndex, key);
    this.setValue(entryIndex, value);
  }

  /** Resizes the entries storage if necessary. */
  private void resizeMeMaybe(int newSize) {
    int entriesSize = requireEntries().length;

    assertEquals(c.getKey(), navigableMap.lastKey());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapExclusive() {
    assertFalse(navigableMap.headMap(a.getKey()).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapInclusive() {
    assertTrue(navigableMap.tailMap(a.getKey()).containsKey(a.getKey()));
  }

  public void testHeadMap() {

    resetWithHole();
    assertEquals(a, navigableMap.floorEntry(a.getKey()));
    assertEquals(a.getKey(), navigableMap.floorKey(a.getKey()));
    assertEquals(a, navigableMap.floorEntry(b.getKey()));
    assertEquals(a.getKey(), navigableMap.floorKey(b.getKey()));
    assertEquals(c, navigableMap.floorEntry(c.getKey()));
    assertEquals(c.getKey(), navigableMap.floorKey(c.getKey()));
  }

  @CollectionSize.Require(SEVERAL)

            KerberosCredentials credentials = new KerberosCredentials(LOGIN_CONTEXT_NAME);
            KerberosKey foundKey = credentials.getKey(KEY_TYPE_1);
            assertNotNull(foundKey);
            assertEquals(key1, foundKey);
        }
    }

    /**
     * Test getKey method when the requested key type does not exist.
     *
     * @throws LoginException if login fails.
     */
    @Test

                writer.accept("\t--- init fork of " + fork.getKey() + " for " + mojoExecId + " ---");

                for (MojoExecution forkedExecution : fork.getValue()) {
                    mojo(writer, forkedExecution);
                }

                writer.accept("\t--- exit fork of " + fork.getKey() + " for " + mojoExecId + " ---");
            }
        }

        Objects.requireNonNull(model, "model cannot be null");

        ClassLoader parent = getMavenApiRealm();

        return createRealm(getKey(model), RealmType.Project, parent, null, null, artifacts);
    }

    private static String getKey(Model model) {
        return "project>" + model.getGroupId() + ":" + model.getArtifactId() + ":" + model.getVersion();
    }

    @Override

        decodedContext.decode(buffer, 0, buffer.length);

        // Verify decoded values
        assertArrayEquals(originalKey.getKey(), decodedContext.getLeaseKey().getKey());
        assertEquals(originalLeaseState, decodedContext.getLeaseState());
        assertEquals(originalScope, decodedContext.getCacheScope());
        assertEquals(60000L, decodedContext.getMaxCacheAge());