Quelle indexeddb_write.js Sprache: JAVA

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* eslint-env node */

const { logTest } = require("./utils/profiling");

module.exports = logTest(
  "indexedDB write test",
  async function (context, commands) {
    context.log.info("Starting a indexedDB write");
    const post_startup_delay = context.options.browsertime.post_startup_delay;
    console.log("context options", context.options);

    const test_url = context.options.browsertime.url;
    const chunk_size = context.options.browsertime.chunk_size;
    const iterations = context.options.browsertime.iterations;
    const buffer_type = context.options.browsertime.buffer_type;
    const atomic_value = context.options.browsertime.atomic;
    if (atomic_value * atomic_value != atomic_value) {
      throw Error("Value of atomic shall be 0 for falsehood, 1 for truth.");
    }
    const atomic = 0 != atomic_value;

    const accepted_buffers = ["Array", "ArrayBuffer", "Blob"];
    if (!accepted_buffers.includes(buffer_type)) {
      throw Error("Buffer type " + buffer_type + " is unknown.");
    }

    context.log.info("IndexedDB write URL = " + test_url);
    context.log.info("IndexedDB write chunk size = " + chunk_size);
    context.log.info("IndexedDB write iterations = " + iterations);
    context.log.info(
      "IndexedDB writes " +
        (atomic ? "all in one big transaction" : "in separate transactions")
    );
    context.log.info("IndexedDB write data format " + buffer_type);

    context.log.info(
      "Waiting for %d ms (post_startup_delay)",
      post_startup_delay
    );

    await commands.navigate(test_url);

    const seleniumDriver = context.selenium.driver;

    await commands.wait.byTime(post_startup_delay);

    await commands.measure.start();
    const time_duration = await seleniumDriver.executeAsyncScript(`
        const notifyDone = arguments[arguments.length - 1];

        const iterations = ${iterations};
        const sizeInBytes = ${chunk_size};
        const bufferType = "${buffer_type}";
        const atomic = ${atomic};

        const makeData = (() => {
          if (bufferType === "ArrayBuffer") {
            return () => {
              const valueBuffer = new ArrayBuffer(sizeInBytes);

              const charCodeView = new Uint16Array(valueBuffer);
              const sizeInUint16 = sizeInBytes / 2;
              for (let i=0; i < sizeInUint16; ++i) {
                charCodeView[i] = "qwerty".charCodeAt(i % 6);
              }

              return valueBuffer;
            };
          }

          if (bufferType === "Array") {
            return () => {
              return Array.from({length: sizeInBytes}, (_, i) => "qwerty"[i % 6]);
            };
          }

          if (bufferType !== "Blob") {
            throw Error("Unknown buffer type " + bufferType);
          }

          return () => {
            return new Blob([Array.from({length: sizeInBytes}, (_, i) => "qwerty"[i % 6])]);
          };
        })();

        function addData(txSource, txProvider, i) {
          try {
            const keyName = "doc_" + i;
            const valueData = makeData();
            const record = { key: keyName, property: valueData };

            const rq = txProvider(txSource).add(record);

            return new Promise((res_ad, rej_ad) => {
              rq.onsuccess = () => { res_ad(); };
              rq.onerror = e => { rej_ad(e); };
            });
          } catch (e) {
            return new Promise((_, rej_ad) => rej_ad(e));
          }
        }

        function waitForData(txSource) {
          try {
            if (!atomic) {
              const txProvider = src => src.transaction("store", "readwrite").objectStore("store");
              return Promise.all(
                Array.from({ length: iterations }, (_, i) => {
                  return addData(txSource, txProvider, i);
                }));
            }

            const currentTx = txSource.transaction("store", "readwrite").objectStore("store");
            return Promise.all(
              Array.from({ length: iterations }, (_, i) => {
                return addData(currentTx, src => src, i);
              }));
          } catch (e) {
            return new Promise((_, rej_tx) => rej_tx(e));
          }
        }

        function upgradePromise() {
          try {
            const open_db = indexedDB.open("rootsdb");
            return new Promise((res_upgrade, rej_upgrade) => {
              open_db.onupgradeneeded = e => {
                e.target.result.createObjectStore("store", { keyPath: "key" });
              };
              open_db.onsuccess = e => { res_upgrade(e.target.result); };
              open_db.onerror = e => { rej_upgrade(e); };
            });
          } catch (e) {
            return new Promise((_, rej_upgrade) => rej_upgrade(e));
          }
        }

        const startTime = performance.now();
        upgradePromise().then(waitForData).then(() => {
          notifyDone(performance.now() - startTime);
        });
      `);
    await commands.measure.stop();

    console.log("Time duration was ", time_duration);

    await commands.measure.addObject({
      custom_data: { time_duration },
    });

    context.log.info("IndexedDB write ended.");
    return true;
  }
);

quality98%

¤ Dauer der Verarbeitung: 0.32 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.