KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use setUpBaseKeys method in wpt

Best JavaScript code snippet using wpt

pbkdf2.js

Source:pbkdf2.js

...8    var salts = testData.salts;9    var derivations = testData.derivations;10    // What kinds of keys can be created with deriveKey? The following:11    var derivedKeyTypes = testData.derivedKeyTypes;12    setUpBaseKeys(passwords)13    .then(function(allKeys) {14        // We get several kinds of base keys. Normal ones that can be used for15        // derivation operations, ones that lack the deriveBits usage, ones16        // that lack the deriveKeys usage, and one key that is for the wrong17        // algorithm (not PBKDF2 in this case).18        var baseKeys = allKeys.baseKeys;19        var noBits = allKeys.noBits;20        var noKey = allKeys.noKey;21        var wrongKey = allKeys.wrongKey;22        // Test each combination of password size, salt size, hash function,23        // and number of iterations. The derivations object is structured in24        // that way, so navigate it to run tests and compare with correct results.25        Object.keys(derivations).forEach(function(passwordSize) {26            if (typeof testPasswordSize != 'undefined' && testPasswordSize != passwordSize) return;27            Object.keys(derivations[passwordSize]).forEach(function(saltSize) {28                if (typeof testSaltSize != 'undefined' && testSaltSize != saltSize) return;29                Object.keys(derivations[passwordSize][saltSize]).forEach(function(hashName) {30                    Object.keys(derivations[passwordSize][saltSize][hashName]).forEach(function(iterations) {31                        var testName = passwordSize + " password, " + saltSize + " salt, " + hashName + ", with " + iterations + " iterations";32                        // Check for correct deriveBits result33                        promise_test(function(test) {34                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], 256)35                            .then(function(derivation) {36                                assert_true(equalBuffers(derivation, derivations[passwordSize][saltSize][hashName][iterations]), "Derived correct key");37                            }, function(err) {38                                assert_unreached("deriveBits failed with error " + err.name + ": " + err.message);39                            });40                        }, testName);41                        // Check for correct deriveKey results for every kind of42                        // key that can be created by the deriveKeys operation.43                        derivedKeyTypes.forEach(function(derivedKeyType) {44                            var testName = "Derived key of type ";45                            Object.keys(derivedKeyType.algorithm).forEach(function(prop) {46                                testName += prop + ": " + derivedKeyType.algorithm[prop] + " ";47                            });48                            testName += " using " + passwordSize + " password, " + saltSize + " salt, " + hashName + ", with " + iterations + " iterations";49                            // Test the particular key derivation.50                            promise_test(function(test) {51                                return subtle.deriveKey({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], derivedKeyType.algorithm, true, derivedKeyType.usages)52                                .then(function(key) {53                                    // Need to export the key to see that the correct bits were set.54                                    return subtle.exportKey("raw", key)55                                    .then(function(buffer) {56                                        assert_true(equalBuffers(buffer, derivations[passwordSize][saltSize][hashName][iterations].slice(0, derivedKeyType.algorithm.length/8)), "Exported key matches correct value");57                                    }, function(err) {58                                        assert_unreached("Exporting derived key failed with error " + err.name + ": " + err.message);59                                    });60                                }, function(err) {61                                    assert_unreached("deriveKey failed with error " + err.name + ": " + err.message);62                                });63                            }, testName);64                            // Test various error conditions for deriveKey:65                            // - illegal name for hash algorithm (NotSupportedError)66                            var badHash = hashName.substring(0, 3) + hashName.substring(4);67                            promise_test(function(test) {68                                return subtle.deriveKey({name: "PBKDF2", salt: salts[saltSize], hash: badHash, iterations: parseInt(iterations)}, baseKeys[passwordSize], derivedKeyType.algorithm, true, derivedKeyType.usages)69                                .then(function(key) {70                                    assert_unreached("bad hash name should have thrown an NotSupportedError");71                                }, function(err) {72                                    assert_equals(err.name, "NotSupportedError", "deriveKey with bad hash name correctly threw NotSupportedError: " + err.message);73                                });74                            }, testName + " with bad hash name " + badHash);75                            // - baseKey usages missing "deriveKey" (InvalidAccessError)76                            promise_test(function(test) {77                                return subtle.deriveKey({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, noKey[passwordSize], derivedKeyType.algorithm, true, derivedKeyType.usages)78                                .then(function(key) {79                                    assert_unreached("missing deriveKey usage should have thrown an InvalidAccessError");80                                }, function(err) {81                                    assert_equals(err.name, "InvalidAccessError", "deriveKey with missing deriveKey usage correctly threw InvalidAccessError: " + err.message);82                                });83                            }, testName + " with missing deriveKey usage");84                            // - baseKey algorithm does not match PBKDF2 (InvalidAccessError)85                            promise_test(function(test) {86                                return subtle.deriveKey({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, wrongKey, derivedKeyType.algorithm, true, derivedKeyType.usages)87                                .then(function(key) {88                                    assert_unreached("wrong (ECDH) key should have thrown an InvalidAccessError");89                                }, function(err) {90                                    assert_equals(err.name, "InvalidAccessError", "deriveKey with wrong (ECDH) key correctly threw InvalidAccessError: " + err.message);91                                });92                            }, testName + " with wrong (ECDH) key");93                        });94                        // Test various error conditions for deriveBits below:95                        // length null (OperationError)96                        promise_test(function(test) {97                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], null)98                            .then(function(derivation) {99                                assert_unreached("null length should have thrown an OperationError");100                            }, function(err) {101                                assert_equals(err.name, "OperationError", "deriveBits with null length correctly threw OperationError: " + err.message);102                            });103                        }, testName + " with null length");104                        // 0 length (OperationError)105                        promise_test(function(test) {106                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], 0)107                            .then(function(derivation) {108                                assert_unreached("0 length should have thrown an OperationError");109                            }, function(err) {110                                assert_equals(err.name, "OperationError", "deriveBits with 0 length correctly threw OperationError: " + err.message);111                            });112                        }, testName + " with 0 length");113                        // length not multiple of 8 (OperationError)114                        promise_test(function(test) {115                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, baseKeys[passwordSize], 44)116                            .then(function(derivation) {117                                assert_unreached("non-multiple of 8 length should have thrown an OperationError");118                            }, function(err) {119                                assert_equals(err.name, "OperationError", "deriveBits with non-multiple of 8 length correctly threw OperationError: " + err.message);120                            });121                        }, testName + " with non-multiple of 8 length");122                        // - illegal name for hash algorithm (NotSupportedError)123                        var badHash = hashName.substring(0, 3) + hashName.substring(4);124                        promise_test(function(test) {125                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: badHash, iterations: parseInt(iterations)}, baseKeys[passwordSize], 256)126                            .then(function(derivation) {127                                assert_unreached("bad hash name should have thrown an NotSupportedError");128                            }, function(err) {129                                assert_equals(err.name, "NotSupportedError", "deriveBits with bad hash name correctly threw NotSupportedError: " + err.message);130                            });131                        }, testName + " with bad hash name " + badHash);132                        // - baseKey usages missing "deriveBits" (InvalidAccessError)133                        promise_test(function(test) {134                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, noBits[passwordSize], 256)135                            .then(function(derivation) {136                                assert_unreached("missing deriveBits usage should have thrown an InvalidAccessError");137                            }, function(err) {138                                assert_equals(err.name, "InvalidAccessError", "deriveBits with missing deriveBits usage correctly threw InvalidAccessError: " + err.message);139                            });140                        }, testName + " with missing deriveBits usage");141                        // - baseKey algorithm does not match PBKDF2 (InvalidAccessError)142                        promise_test(function(test) {143                            return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: parseInt(iterations)}, wrongKey, 256)144                            .then(function(derivation) {145                                assert_unreached("wrong (ECDH) key should have thrown an InvalidAccessError");146                            }, function(err) {147                                assert_equals(err.name, "InvalidAccessError", "deriveBits with wrong (ECDH) key correctly threw InvalidAccessError: " + err.message);148                            });149                        }, testName + " with wrong (ECDH) key");150                    });151                    // Check that 0 iterations throws proper error152                    promise_test(function(test) {153                        return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: 0}, baseKeys[passwordSize], 256)154                        .then(function(derivation) {155                            assert_unreached("0 iterations should have thrown an error");156                        }, function(err) {157                            assert_equals(err.name, "OperationError", "deriveBits with 0 iterations correctly threw OperationError: " + err.message);158                        });159                    }, passwordSize + " password, " + saltSize + " salt, " + hashName + ", with 0 iterations");160                    derivedKeyTypes.forEach(function(derivedKeyType) {161                        var testName = "Derived key of type ";162                        Object.keys(derivedKeyType.algorithm).forEach(function(prop) {163                            testName += prop + ": " + derivedKeyType.algorithm[prop] + " ";164                        });165                        testName += " using " + passwordSize + " password, " + saltSize + " salt, " + hashName + ", with 0 iterations";166                        promise_test(function(test) {167                            return subtle.deriveKey({name: "PBKDF2", salt: salts[saltSize], hash: hashName, iterations: 0}, baseKeys[passwordSize], derivedKeyType.algorithm, true, derivedKeyType.usages)168                            .then(function(derivation) {169                                assert_unreached("0 iterations should have thrown an error");170                            }, function(err) {171                                assert_equals(err.name, "OperationError", "derivekey with 0 iterations correctly threw OperationError: " + err.message);172                            });173                        }, testName);174                    });175                });176                // - legal algorithm name but not digest one (e.g., PBKDF2) (NotSupportedError)177                var nonDigestHash = "PBKDF2";178                [1, 1000, 100000].forEach(function(iterations) {179                    var testName = passwordSize + " password, " + saltSize + " salt, " + nonDigestHash + ", with " + iterations + " iterations";180                    promise_test(function(test) {181                        return subtle.deriveBits({name: "PBKDF2", salt: salts[saltSize], hash: nonDigestHash, iterations: parseInt(iterations)}, baseKeys[passwordSize], 256)182                        .then(function(derivation) {183                            assert_unreached("non-digest algorithm should have thrown an NotSupportedError");184                        }, function(err) {185                            assert_equals(err.name, "NotSupportedError", "deriveBits with non-digest algorithm correctly threw NotSupportedError: " + err.message);186                        });187                    }, testName + " with non-digest algorithm " + nonDigestHash);188                    derivedKeyTypes.forEach(function(derivedKeyType) {189                        var testName = "Derived key of type ";190                        Object.keys(derivedKeyType.algorithm).forEach(function(prop) {191                            testName += prop + ": " + derivedKeyType.algorithm[prop] + " ";192                        });193                        testName += " using " + passwordSize + " password, " + saltSize + " salt, " + nonDigestHash + ", with " + iterations + " iterations";194                        promise_test(function(test) {195                            return subtle.deriveKey({name: "PBKDF2", salt: salts[saltSize], hash: nonDigestHash, iterations: parseInt(iterations)}, baseKeys[passwordSize], derivedKeyType.algorithm, true, derivedKeyType.usages)196                            .then(function(derivation) {197                                assert_unreached("non-digest algorithm should have thrown an NotSupportedError");198                            }, function(err) {199                                assert_equals(err.name, "NotSupportedError", "derivekey with non-digest algorithm correctly threw NotSupportedError: " + err.message);200                            });201                        }, testName);202                    });203                });204            });205        });206        done();207    }, function(err) {208        test(function(test) {209            assert_unreached("setUpBaseKeys failed with error '" + err.message + "'");210        }, "setUpBaseKeys");211        done();212    });213    // Deriving bits and keys requires starting with a base key, which is created214    // by importing a password. setUpBaseKeys returns a promise that yields the215    // necessary base keys.216    function setUpBaseKeys(passwords) {217        var promises = [];218        var baseKeys = {};219        var noBits = {};220        var noKey = {};221        var wrongKey = null;222        Object.keys(passwords).forEach(function(passwordSize) {223            var promise = subtle.importKey("raw", passwords[passwordSize], {name: "PBKDF2"}, false, ["deriveKey", "deriveBits"])224            .then(function(baseKey) {225                baseKeys[passwordSize] = baseKey;226            }, function(err) {227                baseKeys[passwordSize] = null;228            });229            promises.push(promise);230            promise = subtle.importKey("raw", passwords[passwordSize], {name: "PBKDF2"}, false, ["deriveBits"])...

hkdf.js

Source:hkdf.js

...9    var derivations = testData.derivations;10    var infos = testData.infos;11    // What kinds of keys can be created with deriveKey? The following:12    var derivedKeyTypes = testData.derivedKeyTypes;13    setUpBaseKeys(derivedKeys)14    .then(function(allKeys) {15        // We get several kinds of base keys. Normal ones that can be used for16        // derivation operations, ones that lack the deriveBits usage, ones17        // that lack the deriveKeys usage, and one key that is for the wrong18        // algorithm (not HKDF in this case).19        var baseKeys = allKeys.baseKeys;20        var noBits = allKeys.noBits;21        var noKey = allKeys.noKey;22        var wrongKey = allKeys.wrongKey;23        // Test each combination of derivedKey size, salt size, hash function,24        // and number of iterations. The derivations object is structured in25        // that way, so navigate it to run tests and compare with correct results.26        Object.keys(derivations).forEach(function(derivedKeySize) {27            Object.keys(derivations[derivedKeySize]).forEach(function(saltSize) {28                Object.keys(derivations[derivedKeySize][saltSize]).forEach(function(hashName) {29                    Object.keys(derivations[derivedKeySize][saltSize][hashName]).forEach(function(infoSize) {30                        var testName = derivedKeySize + " derivedKey, " + saltSize + " salt, " + hashName + ", with " + infoSize + " info";31                        var algorithm = {name: "HKDF", salt: salts[saltSize], info: infos[infoSize], hash: hashName};32                        // Check for correct deriveBits result33                        promise_test(function(test) {34                            return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], 256)35                            .then(function(derivation) {36                                assert_true(equalBuffers(derivation, derivations[derivedKeySize][saltSize][hashName][infoSize]), "Derived correct key");37                            }, function(err) {38                                assert_unreached("deriveBits failed with error " + err.name + ": " + err.message);39                            });40                        }, testName);41                        // 0 length (OperationError)42                        promise_test(function(test) {43                            return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], 0)44                            .then(function(derivation) {45                                assert_equals(derivation.byteLength, 0, "Derived correctly empty key");46                            }, function(err) {47                                assert_equals(err.name, "OperationError", "deriveBits with 0 length correctly threw OperationError: " + err.message);48                            });49                        }, testName + " with 0 length");50                        // Check for correct deriveKey results for every kind of51                        // key that can be created by the deriveKeys operation.52                        derivedKeyTypes.forEach(function(derivedKeyType) {53                            var testName = "Derived key of type ";54                            Object.keys(derivedKeyType.algorithm).forEach(function(prop) {55                                testName += prop + ": " + derivedKeyType.algorithm[prop] + " ";56                            });57                            testName += " using " + derivedKeySize + " derivedKey, " + saltSize + " salt, " + hashName + ", with " + infoSize + " info";58                            // Test the particular key derivation.59                            promise_test(function(test) {60                                return subtle.deriveKey(algorithm, baseKeys[derivedKeySize], derivedKeyType.algorithm, true, derivedKeyType.usages)61                                .then(function(key) {62                                    // Need to export the key to see that the correct bits were set.63                                    return subtle.exportKey("raw", key)64                                    .then(function(buffer) {65                                        assert_true(equalBuffers(buffer, derivations[derivedKeySize][saltSize][hashName][infoSize].slice(0, derivedKeyType.algorithm.length/8)), "Exported key matches correct value");66                                    }, function(err) {67                                        assert_unreached("Exporting derived key failed with error " + err.name + ": " + err.message);68                                    });69                                }, function(err) {70                                    assert_unreached("deriveKey failed with error " + err.name + ": " + err.message);71                                });72                            }, testName);73                            // Test various error conditions for deriveKey:74                            // - illegal name for hash algorithm (NotSupportedError)75                            var badHash = hashName.substring(0, 3) + hashName.substring(4);76                            promise_test(function(test) {77                                var badAlgorithm = {name: "HKDF", salt: salts[saltSize], hash: badHash};78                                return subtle.deriveKey(badAlgorithm, baseKeys[derivedKeySize], derivedKeyType.algorithm, true, derivedKeyType.usages)79                                .then(function(key) {80                                    assert_unreached("bad hash name should have thrown an NotSupportedError");81                                }, function(err) {82                                    assert_equals(err.name, "NotSupportedError", "deriveKey with bad hash name correctly threw NotSupportedError: " + err.message);83                                });84                            }, testName + " with bad hash name " + badHash);85                            // - baseKey usages missing "deriveKey" (InvalidAccessError)86                            promise_test(function(test) {87                                return subtle.deriveKey(algorithm, noKey[derivedKeySize], derivedKeyType.algorithm, true, derivedKeyType.usages)88                                .then(function(key) {89                                    assert_unreached("missing deriveKey usage should have thrown an InvalidAccessError");90                                }, function(err) {91                                    assert_equals(err.name, "InvalidAccessError", "deriveKey with missing deriveKey usage correctly threw InvalidAccessError: " + err.message);92                                });93                            }, testName + " with missing deriveKey usage");94                            // - baseKey algorithm does not match HKDF (InvalidAccessError)95                            promise_test(function(test) {96                                return subtle.deriveKey(algorithm, wrongKey, derivedKeyType.algorithm, true, derivedKeyType.usages)97                                .then(function(key) {98                                    assert_unreached("wrong (ECDH) key should have thrown an InvalidAccessError");99                                }, function(err) {100                                    assert_equals(err.name, "InvalidAccessError", "deriveKey with wrong (ECDH) key correctly threw InvalidAccessError: " + err.message);101                                });102                            }, testName + " with wrong (ECDH) key");103                        });104                        // Test various error conditions for deriveBits below:105                        // missing salt (TypeError)106                        promise_test(function(test) {107                            return subtle.deriveBits({name: "HKDF", info: infos[infoSize], hash: hashName}, baseKeys[derivedKeySize], 0)108                            .then(function(derivation) {109                                assert_equals(derivation.byteLength, 0, "Derived even with missing salt");110                            }, function(err) {111                                assert_equals(err.name, "TypeError", "deriveBits missing salt correctly threw OperationError: " + err.message);112                            });113                        }, testName + " with missing salt");114                        // missing info (TypeError)115                        promise_test(function(test) {116                            return subtle.deriveBits({name: "HKDF", salt: salts[saltSize], hash: hashName}, baseKeys[derivedKeySize], 0)117                            .then(function(derivation) {118                                assert_equals(derivation.byteLength, 0, "Derived even with missing info");119                            }, function(err) {120                                assert_equals(err.name, "TypeError", "deriveBits missing info correctly threw OperationError: " + err.message);121                            });122                        }, testName + " with missing info");123                        // length null (OperationError)124                        promise_test(function(test) {125                            return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], null)126                            .then(function(derivation) {127                                assert_unreached("null length should have thrown an TypeError");128                            }, function(err) {129                                assert_equals(err.name, "TypeError", "deriveBits with null length correctly threw OperationError: " + err.message);130                            });131                        }, testName + " with null length");132                        // length not multiple of 8 (OperationError)133                        promise_test(function(test) {134                            return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], 44)135                            .then(function(derivation) {136                                assert_unreached("non-multiple of 8 length should have thrown an OperationError");137                            }, function(err) {138                                assert_equals(err.name, "OperationError", "deriveBits with non-multiple of 8 length correctly threw OperationError: " + err.message);139                            });140                        }, testName + " with non-multiple of 8 length");141                        // - illegal name for hash algorithm (NotSupportedError)142                        var badHash = hashName.substring(0, 3) + hashName.substring(4);143                        promise_test(function(test) {144                            var badAlgorithm = {name: "HKDF", salt: salts[saltSize], hash: badHash};145                            return subtle.deriveBits(badAlgorithm, baseKeys[derivedKeySize], 256)146                            .then(function(derivation) {147                                assert_unreached("bad hash name should have thrown an NotSupportedError");148                            }, function(err) {149                                assert_equals(err.name, "NotSupportedError", "deriveBits with bad hash name correctly threw NotSupportedError: " + err.message);150                            });151                        }, testName + " with bad hash name " + badHash);152                        // - baseKey usages missing "deriveBits" (InvalidAccessError)153                        promise_test(function(test) {154                            return subtle.deriveBits(algorithm, noBits[derivedKeySize], 256)155                            .then(function(derivation) {156                                assert_unreached("missing deriveBits usage should have thrown an InvalidAccessError");157                            }, function(err) {158                                assert_equals(err.name, "InvalidAccessError", "deriveBits with missing deriveBits usage correctly threw InvalidAccessError: " + err.message);159                            });160                        }, testName + " with missing deriveBits usage");161                        // - baseKey algorithm does not match HKDF (InvalidAccessError)162                        promise_test(function(test) {163                            return subtle.deriveBits(algorithm, wrongKey, 256)164                            .then(function(derivation) {165                                assert_unreached("wrong (ECDH) key should have thrown an InvalidAccessError");166                            }, function(err) {167                                assert_equals(err.name, "InvalidAccessError", "deriveBits with wrong (ECDH) key correctly threw InvalidAccessError: " + err.message);168                            });169                        }, testName + " with wrong (ECDH) key");170                    });171                });172                // - legal algorithm name but not digest one (e.g., PBKDF2) (NotSupportedError)173                var nonDigestHash = "PBKDF2";174                Object.keys(infos).forEach(function(infoSize) {175                    var testName = derivedKeySize + " derivedKey, " + saltSize + " salt, " + nonDigestHash + ", with " + infoSize + " info";176                    var algorithm = {name: "HKDF", salt: salts[saltSize], hash: nonDigestHash};177                    if (infoSize !== "missing") {178                        algorithm.info = infos[infoSize];179                    }180                    promise_test(function(test) {181                        return subtle.deriveBits(algorithm, baseKeys[derivedKeySize], 256)182                        .then(function(derivation) {183                            assert_unreached("non-digest algorithm should have thrown an NotSupportedError");184                        }, function(err) {185                            assert_equals(err.name, "NotSupportedError", "deriveBits with non-digest algorithm correctly threw NotSupportedError: " + err.message);186                        });187                    }, testName + " with non-digest algorithm " + nonDigestHash);188                    derivedKeyTypes.forEach(function(derivedKeyType) {189                        var testName = "Derived key of type ";190                        Object.keys(derivedKeyType.algorithm).forEach(function(prop) {191                            testName += prop + ": " + derivedKeyType.algorithm[prop] + " ";192                        });193                        testName += " using " + derivedKeySize + " derivedKey, " + saltSize + " salt, " + nonDigestHash + ", with " + infoSize + " info";194                        promise_test(function(test) {195                            return subtle.deriveKey(algorithm, baseKeys[derivedKeySize], derivedKeyType.algorithm, true, derivedKeyType.usages)196                            .then(function(derivation) {197                                assert_unreached("non-digest algorithm should have thrown an NotSupportedError");198                            }, function(err) {199                                assert_equals(err.name, "NotSupportedError", "derivekey with non-digest algorithm correctly threw NotSupportedError: " + err.message);200                            });201                        }, testName);202                    });203                });204            });205        });206        done();207    }, function(err) {208        test(function(test) {209            assert_unreached("setUpBaseKeys failed with error '" + err.message + "'");210        }, "setUpBaseKeys");211        done();212    });213    // Deriving bits and keys requires starting with a base key, which is created214    // by importing a derivedKey. setUpBaseKeys returns a promise that yields the215    // necessary base keys.216    function setUpBaseKeys(derivedKeys) {217        var promises = [];218        var baseKeys = {};219        var noBits = {};220        var noKey = {};221        var wrongKey = null;222        Object.keys(derivedKeys).forEach(function(derivedKeySize) {223            var promise = subtle.importKey("raw", derivedKeys[derivedKeySize], {name: "HKDF"}, false, ["deriveKey", "deriveBits"])224            .then(function(baseKey) {225                baseKeys[derivedKeySize] = baseKey;226            }, function(err) {227                baseKeys[derivedKeySize] = null;228            });229            promises.push(promise);230            promise = subtle.importKey("raw", derivedKeys[derivedKeySize], {name: "HKDF"}, false, ["deriveBits"])...

Using AI Code Generation

1var wptoolkit = require('wptoolkit');2wptoolkit.setUpBaseKeys();3var wptoolkit = require('wptoolkit');4wptoolkit.setUpBaseKeys();5var wptoolkit = require('wptoolkit');6wptoolkit.click('wp-admin-bar-my-account');7var wptoolkit = require('wptoolkit');8wptoolkit.click('wp-admin-bar-my-account');9var wptoolkit = require('wptoolkit');10wptoolkit.click('wp-admin-bar-my-account');11var wptoolkit = require('wptoolkit');12wptoolkit.click('wp-admin-bar-my-account');13var wptoolkit = require('wptoolkit');14wptoolkit.click('wp-admin-bar-my-account');15var wptoolkit = require('wptoolkit');16wptoolkit.click('wp-admin-bar-my-account');17var wptoolkit = require('wptoolkit');18wptoolkit.click('wp-admin-bar-my-account');19var wptoolkit = require('wptoolkit');20wptoolkit.click('wp-admin-bar-my-account');21var wptoolkit = require('wptoolkit');22wptoolkit.click('wp-admin-bar-my-account');23var wptoolkit = require('wptoolkit');24wptoolkit.click('wp-admin-bar-my-account');

Using AI Code Generation

1var wptoolkit = require('wptoolkit');2wptoolkit.setUpBaseKeys();3var wptoolkit = require('wptoolkit');4wptoolkit.setUpBaseKeys();5var wptoolkit = require('wptoolkit');6wptoolkit.setUpBaseKeys();7var wptoolkit = require('wptoolkit');8wptoolkit.setUpBaseKeys();9var wptoolkit = require('wptoolkit');10wptoolkit.setUpBaseKeys();11var wptoolkit = require('wptoolkit');12wptoolkit.setUpBaseKeys();13var wptoolkit = require('wptoolkit');14wptoolkit.setUpBaseKeys();15var wptoolkit = require('wptoolkit');16wptoolkit.setUpBaseKeys();17var wptoolkit = require('wptoolkit');18wptoolkit.setUpBaseKeys();19var wptoolkit = require('wptoolkit');20wptoolkit.setUpBaseKeys();21var wptoolkit = require('wptoolkit');22wptoolkit.setUpBaseKeys();23var wptoolkit = require('wptoolkit');24wptoolkit.setUpBaseKeys();

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.