Java 类javax.crypto.KeyAgreementSpi 实例源码

/**
 * Test for <code>KeyAgreement</code> constructor Assertion: returns
 * KeyAgreement object
 */
public void testKeyAgreement() throws NoSuchAlgorithmException,
        InvalidKeyException, IllegalStateException {
    if (!DEFSupported) {
        fail(NotSupportMsg);
        return;
    }
    KeyAgreementSpi spi = new MyKeyAgreementSpi();
    KeyAgreement keyA = new myKeyAgreement(spi, defaultProvider,
            defaultAlgorithm);
    assertEquals("Incorrect algorithm", keyA.getAlgorithm(),
            defaultAlgorithm);
    assertEquals("Incorrect provider", keyA.getProvider(), defaultProvider);
    assertNull("Incorrect result", keyA.doPhase(null, true));
    assertEquals("Incorrect result", keyA.generateSecret().length, 0);

    keyA = new myKeyAgreement(null, null, null);
    assertNull("Algorithm must be null", keyA.getAlgorithm());
    assertNull("Provider must be null", keyA.getProvider());
    try {
        keyA.doPhase(null, true);
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
    }
}

/**
 * Test for <code>KeyAgreement</code> constructor Assertion: returns
 * KeyAgreement object
 */
public void testKeyAgreement() throws NoSuchAlgorithmException,
        InvalidKeyException, IllegalStateException {
    if (!DEFSupported) {
        fail(NotSupportMsg);
        return;
    }
    KeyAgreementSpi spi = new MyKeyAgreementSpi();
    KeyAgreement keyA = new myKeyAgreement(spi, defaultProvider,
            defaultAlgorithm);
    assertEquals("Incorrect algorithm", keyA.getAlgorithm(),
            defaultAlgorithm);
    assertEquals("Incorrect provider", keyA.getProvider(), defaultProvider);
    assertNull("Incorrect result", keyA.doPhase(null, true));
    assertEquals("Incorrect result", keyA.generateSecret().length, 0);

    keyA = new myKeyAgreement(null, null, null);
    assertNull("Algorithm must be null", keyA.getAlgorithm());
    assertNull("Provider must be null", keyA.getProvider());
    try {
        keyA.doPhase(null, true);
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
    }
}

/**
 * Test for <code>KeyAgreement</code> constructor Assertion: returns
 * KeyAgreement object
 */
public void testKeyAgreement() throws NoSuchAlgorithmException,
        InvalidKeyException, IllegalStateException {
    if (!DEFSupported) {
        fail(NotSupportMsg);
        return;
    }
    KeyAgreementSpi spi = new MyKeyAgreementSpi();
    KeyAgreement keyA = new myKeyAgreement(spi, defaultProvider,
            defaultAlgorithm);
    assertEquals("Incorrect algorithm", keyA.getAlgorithm(),
            defaultAlgorithm);
    assertEquals("Incorrect provider", keyA.getProvider(), defaultProvider);
    assertNull("Incorrect result", keyA.doPhase(null, true));
    assertEquals("Incorrect result", keyA.generateSecret().length, 0);

    keyA = new myKeyAgreement(null, null, null);
    assertNull("Algorithm must be null", keyA.getAlgorithm());
    assertNull("Provider must be null", keyA.getProvider());
    try {
        keyA.doPhase(null, true);
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
    }
}

@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "",
    method = "KeyAgreement",
    args = {javax.crypto.KeyAgreementSpi.class, java.security.Provider.class, java.lang.String.class}
)
public void test_constructor() {
    assertNotNull(new Mock_KeyAgreement(null, null, null));
}

/** @ar.org.fitc.spec_ref */
protected KeyAgreement(KeyAgreementSpi keyAgreeSpi, Provider provider,
        String algorithm) {
    this.keyAgreementSpi = keyAgreeSpi;
    this.provider = provider;
    this.algorithm = algorithm;
}

/**
 * Test for the methods: <code>init(Key key)</code>
 * <code>generateSecret()</code>
 * <code>generateSecret(byte[] sharedsecret, int offset)</code>
 * <code>generateSecret(String algorithm)</code>
 * Assertions: initializes KeyAgreement; returns sharedSecret; puts
 * sharedsecret in buffer and return numbers of bytes; returns SecretKey
 * object
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        method = "init",
        args = {java.security.Key.class}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        method = "generateSecret",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        method = "generateSecret",
        args = {byte[].class, int.class}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        method = "generateSecret",
        args = {java.lang.String.class}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        clazz = KeyAgreementSpi.class,
        method = "engineGenerateSecret",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        clazz = KeyAgreementSpi.class,
        method = "engineGenerateSecret",
        args = {byte[].class, int.class}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks functionality only.",
        clazz = KeyAgreementSpi.class,
        method = "engineGenerateSecret",
        args = {java.lang.String.class}
    )
})
public void testGenerateSecret03() throws Exception {
    if (!DEFSupported) {
        fail(NotSupportMsg);
        return;
    }
    createKeys();
    KeyAgreement[] kAgs = createKAs();

    byte[] bb;
    byte[] bb1 = new byte[10];
    for (int i = 0; i < kAgs.length; i++) {
        kAgs[i].init(privKey);
        kAgs[i].doPhase(publKey, true);
        bb = kAgs[i].generateSecret();
        kAgs[i].init(privKey);
        kAgs[i].doPhase(publKey, true);
        bb1 = new byte[bb.length + 10];
        kAgs[i].generateSecret(bb1, 9);
        kAgs[i].init(privKey);
        kAgs[i].doPhase(publKey, true);
        kAgs[i].generateSecret("DES");
    }
}

protected Mock_KeyAgreement(KeyAgreementSpi arg0, Provider arg1, String arg2) {
    super(arg0, arg1, arg2);
}

public myKeyAgreement(KeyAgreementSpi keyAgreeSpi, Provider provider,
        String algorithm) {
    super(keyAgreeSpi, provider, algorithm);
}

public myKeyAgreement(KeyAgreementSpi keyAgreeSpi, Provider provider,
        String algorithm) {
    super(keyAgreeSpi, provider, algorithm);
}

public myKeyAgreement(KeyAgreementSpi keyAgreeSpi, Provider provider,
        String algorithm) {
    super(keyAgreeSpi, provider, algorithm);
}

/**
 * It's used as a factory method
 * 
 * @param algorithm
 *            the algorithm
 * @param provider
 *            the provider
 * @return a new KeyAgreement object
 * @throws NoSuchAlgorithmException
 *             if the specified algorithm is not available in the default
 *             package or any of the others providers that were searched
 */
private static final KeyAgreement newInstance(String algorithm,
        Provider provider) throws NoSuchAlgorithmException {
    Service service = Util.getService(Types.KEY_AGREEMENT, algorithm,
            provider);
    if (service == null) {
        throw new NoSuchAlgorithmException("No such algorithm: "
                + algorithm);
    }
    return new KeyAgreement((KeyAgreementSpi) service.newInstance(null),
            service.getProvider(), algorithm);
}