@ejfdelgado/ejflab-common 1.0.0

package/src/MyTuples.test.js

@@ -0,0 +1,330 @@
+const { MyTuples } = require('./MyTuples.js');
+const sortify = require('./sortify.js');
+
+const test = async () => {
+    const BATCH_SIZE = 3;
+    const reverse = false;
+    const show = false;
+    const useProcessor = ["none", "good", "bad"][0];
+    const pruebas = [
+        {
+            f: { a: 2 },
+            i: {},
+            e: { "+": [{ "k": "a", "v": 2 }], "-": [], "*": [] },//solo agregar
+        },
+        {
+            f: [{}],
+            i: [{ 0: true }],
+            e: { "+": [], "-": [{ "k": "0.0" }], "*": [] },//solo quitar
+        },
+        {
+            f: [true],
+            i: [false],
+            e: { "+": [], "-": [], "*": [{ "k": "0", "v": true }] },//solo modificar
+        },
+        {
+            f: { a: 1, b: "t", c: true, e: null, f: "soy nuevo" },
+            i: { a: 1, b: "t", c: true, d: false, e: null, f: undefined },
+            e: { "+": [{ "k": "f", "v": "soy nuevo" }], "-": [{ "k": "d" }], "*": [] }//agregar y quitar
+        },
+        {
+            f: { a: [], b: { g: 6, h: 7 } },
+            i: { a: [2], b: { g: 5 } },
+            e: { "+": [{ "k": "b.h", "v": 7 }], "-": [{ "k": "a.0" }], "*": [{ "k": "b.g", "v": 6 }] }//agregar, quitar y modificar
+        },
+        {
+            f: { a: { b: { c: [{ h: "hola", i: "como", j: "estas" }] } } },
+            i: { a: { b: { c: [3, { h: "hola" }] } } },
+            e: { "+": [{ "k": "a.b.c.0.h", "v": "hola" }, { "k": "a.b.c.0.i", "v": "como" }, { "k": "a.b.c.0.j", "v": "estas" }], "-": [{ "k": "a.b.c.1" }, { "k": "a.b.c.1.h" }], "*": [{ "k": "a.b.c.0", "v": {} }] }
+        },
+        {
+            f: [{ e: 3 }, 5, 8, [9]],
+            i: [{ e: 3 }, 5, 8, [9]],
+            e: { "+": [], "-": [], "*": [] },
+        },
+        {
+            f: { a: 5, b: [], c: {} },
+            i: { a: 5, b: [], c: {} },
+            e: { "+": [], "-": [], "*": [] },
+        },
+        {
+            f: [1, 2, 3, 4],
+            i: [1, 2, 3, 4],
+            e: { "+": [], "-": [], "*": [] },
+        },
+        {
+            f: ["1", "2", "3"],
+            i: ["1", "2", "3"],
+            e: { "+": [], "-": [], "*": [] },
+        },
+        {
+            f: [true, false, true],
+            i: [true, false, true],
+            e: { "+": [], "-": [], "*": [] },
+        },
+        {
+            f: { a: [5, 6, 7], b: { n: true, h: false, ert: "dzfgfsdgfsdg" }, c: [{ g: 5 }, { g: 6 }, { g: 7 }] },
+            i: { a: [5, 6, 7], b: { n: true, h: false, ert: "dzfggfsdg" }, c: [{ g: 6 }, { g: 7 }] },
+            e: { "*": [{ "k": "b.ert", "v": "dzfgfsdgfsdg" }, { "k": "c.0.g", "v": 5 }, { "k": "c.1.g", "v": 6 }], "+": [{ "k": "c.2", "v": {} }, { "k": "c.2.g", "v": 7 }], "-": [] },
+        },
+        {
+            f: { a: { 1: 6, 4: 5 } },
+            i: { a: { 1: 6, 4: 5 } },
+            e: { "+": [], "-": [], "*": [] },
+        }, //esto no se debe guardar porque pasará a ser un arreglo
+    ];
+
+    const mockProcessorGood = (payload) => {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                console.log(`Processing ${JSON.stringify(payload, null, 4)} OK`);
+                resolve();
+            }, 0);
+        });
+    };
+
+    const getBadProcessor = () => {
+        let count = 0;
+        let maxCount = 3;
+        const mockProcessorBad = (payload) => {
+            return new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    if (count < maxCount) {
+                        console.log(`Processing ${JSON.stringify(payload, null, 4)} ERROR`);
+                        reject();
+                        count++;
+                    } else {
+                        console.log(`Processing ${JSON.stringify(payload, null, 4)} OK`);
+                        resolve();
+                        count = 0;
+                    }
+
+                }, 500);
+            });
+        };
+        return mockProcessorBad;
+    };
+
+    // Las funciones se deben ignorar
+    pruebas[0].i.p = function () { };
+    // Los loops se deben ignorar
+    pruebas[5].i.loop = pruebas[5].i;
+
+    for (let i = 0; i < pruebas.length; i++) {
+        console.log(`Prueba ${i + 1} ----------------------------------------------`);
+        const prueba = pruebas[i];
+        const tuplas = MyTuples.getTuples(prueba.i);
+        const referencia = sortify(prueba.i);
+        const intercambio = sortify(tuplas);
+        let buffer = {};
+        const builder = MyTuples.getBuilder();
+        const builder2 = MyTuples.getBuilder();
+        if (useProcessor == "bad") {
+            builder.setProcesor(getBadProcessor());
+        }
+        if (useProcessor == "good") {
+            builder.setProcesor(mockProcessorGood);
+        }
+        let llaves1 = Object.keys(tuplas);
+        if (reverse) {
+            llaves1 = llaves1.reverse();
+        }
+        llaves1.forEach(element => {
+            buffer[element] = tuplas[element];
+            if (Object.keys(buffer).length >= BATCH_SIZE) {
+                builder.build(buffer);
+                builder2.build(buffer);
+                buffer = {};
+            }
+        });
+        if (Object.keys(buffer).length > 0) {
+            builder.build(buffer);
+            builder2.build(buffer);
+            buffer = {};
+        }
+        const resultadoTxt = sortify(builder.end());
+        builder2.end();
+
+        const indicadorActividad = new Promise((resolve) => {
+            builder.addActivityListener((status) => {
+                if (!status) {
+                    resolve();
+                    console.log("Terminado...");
+                } else {
+                    console.log("Esperando...");
+                }
+            });
+        });
+        const differences = builder.trackDifferences(prueba.f);
+        await indicadorActividad;
+
+        const afectado = builder2.affect(differences);
+
+        const differencesTxt = sortify(differences);
+
+        if (show) {
+            console.log("--------------------------------------------------------");
+            console.log(referencia);
+            console.log(intercambio);
+            console.log(resultadoTxt);
+        }
+
+        if (referencia != resultadoTxt) {
+            throw Error(`referencia ${referencia} \nintercambio ${intercambio}\nresultadoTxt ${resultadoTxt}`);
+        }
+
+        if (sortify(prueba.e) != differencesTxt) {
+            throw Error(`Modificación fallida ${JSON.stringify(prueba)}\n${differencesTxt}`);
+        }
+
+        if (sortify(prueba.f) != sortify(afectado)) {
+            throw Error(`Afectación fallida ${JSON.stringify(prueba)}`);
+        }
+        console.log(`Prueba ${i + 1} OK`);
+    }
+}
+
+const testConverter = () => {
+    const pruebas = [
+        {
+            i: [
+                { k: "6543:fdgfd.ghgf.t", v: 2 },
+                { k: "6543:fdgfd.ghgf", v: {} },
+                { k: "6543:fdgfd", v: {} },
+            ],
+            o: {
+                "6543:fdgfd.ghgf.t": 2,
+                "6543:fdgfd.ghgf": {},
+                "6543:fdgfd": {},
+            }
+        },
+        {
+            i: [],
+            o: {},
+        }
+    ];
+
+    for (let i = 0; i < pruebas.length; i++) {
+        const actual = pruebas[i];
+        const input = actual.i;
+        const o = actual.o;
+        const response = MyTuples.convertFromBD(input);
+
+        const oText = sortify(o);
+        const responseTxt = sortify(response);
+        if (oText != responseTxt) {
+            throw new Error(`Prueba fallida ${oText} != ${responseTxt}`);
+        }
+    }
+};
+
+const testArray = () => {
+    const restas = [
+        { a: [1, 3, 5], b: [3], r: [1, 5] },
+        { a: [], b: [4, 7], r: [] },
+        { a: [3, 4, 5], b: [], r: [3, 4, 5] },
+    ];
+    const interseccion = [
+        { a: [1, 3, 5], b: [3], r: [3] },
+        { a: [], b: [4, 8, 9], r: [] },
+        { a: [4, 8, 9], b: [], r: [] },
+    ];
+    for (let i = 0; i < restas.length; i++) {
+        const prueba = restas[i];
+        const response = MyTuples.restarArreglo(prueba.a, prueba.b);
+        const responseTxt = sortify(response);
+        const refTxt = sortify(prueba.r);
+        if (responseTxt != refTxt) {
+            throw Error(`Resta fallida ${JSON.stringify(prueba)}`);
+        }
+    }
+    for (let i = 0; i < interseccion.length; i++) {
+        const prueba = interseccion[i];
+        const response = MyTuples.intersecionArreglo(prueba.a, prueba.b);
+        const responseTxt = sortify(response);
+        const refTxt = sortify(prueba.r);
+        if (responseTxt != refTxt) {
+            throw Error(`Interseccion fallida ${JSON.stringify(prueba)}`);
+        }
+    }
+}
+
+const testArrayCompress = () => {
+    const casos = [
+        { i: { someArray: [1, 23, 3, 4], maxLength: 5 }, myExpected: ["[1]", "[23]", "[3,4]"] },
+        { i: { someArray: [1, 230, 3, 4], maxLength: 5 }, myExpected: ["[1]", "[230]", "[3,4]"] },
+        { i: { someArray: [1, 2301, 3, 4], maxLength: 5 }, myExpected: "Can't compress with size 5 one item has size 4" },
+        { i: { someArray: [1, 2, 3, 4], maxLength: 5 }, myExpected: ["[1,2]", "[3,4]"] },
+    ];
+
+    for (let i = 0; i < casos.length; i++) {
+        const caso = casos[i];
+        let myActual = null;
+        let myRaw = null;
+        try {
+            myRaw = MyTuples.arrayCompress(caso.i);
+            myActual = sortify(myRaw);
+        } catch (err) {
+            myActual = sortify(err.message);
+        }
+
+        myExpected = sortify(caso.myExpected);
+        if (myExpected != myActual) {
+            throw Error(`Compresion fallida expected: ${myExpected} actual ${myActual}`);
+        } else {
+            console.log(`Case compress ${i + 1} Ok`);
+        }
+
+        if (caso.myExpected instanceof Array) {
+            // Se valida la descompresión
+            const uncompressed = MyTuples.arrayUnCompress(myRaw);
+            const unCompressExpected = sortify(caso.i.someArray);
+            const unCompressActual = sortify(uncompressed);
+            if (unCompressExpected != unCompressActual) {
+                throw Error(`Descompresion fallida expected: ${unCompressExpected} actual ${unCompressActual}`);
+            } else {
+                console.log(`Case uncompress ${i + 1} Ok`);
+            }
+        }
+    }
+}
+
+const testSimple = () => {
+
+    const mockProcessorGood = (payload) => {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                console.log(`Processing ${JSON.stringify(payload, null, 4)} OK`);
+                resolve();
+            }, 0);
+        });
+    };
+
+    let model = { persona: { nombre: "Edgar", edad: 38 } };
+    const builderConfig = { MAX_SEND_SIZE: 1000, LOW_PRESSURE_MS: 0, BACK_OFF_MULTIPLIER: 0 };
+    const builder = MyTuples.getBuilder(builderConfig);
+    builder.setProcesor(mockProcessorGood);
+    builder.build({});
+    const res1 = builder.end();
+    model.persona.nombre = "Edgar Delgado";
+    delete model.persona.edad;
+    model.persona.color = "red";
+    model.persona.animal = "dog";
+    //console.log(res1);
+
+    const differences1 = builder.trackDifferences(model);
+    const afectado1 = builder.affect(differences1);
+    console.log(afectado1);
+
+    const differences2 = builder.trackDifferences({});
+    const afectado2 = builder.affect(differences2);
+    console.log(afectado2);
+
+    const differences3 = builder.trackDifferences({ a: 1 });
+    const afectado3 = builder.affect(differences3);
+    console.log(afectado3);
+}
+
+testSimple();
+//testArrayCompress();
+//testConverter();

package/src/MyUtilities.js

@@ -0,0 +1,137 @@
+class MyUtilities {
+    static MIN_LENGTH_TOKENS = 3;
+    static MAX_LENGTH_TOKENS = 25;
+    static LISTA_NEGRA_TOKENS = [
+        'de', 'en', 'con', 'para', 'el', 'él',
+        'la', 'sin', 'mas', 'ella', 'ellos',
+        'es', 'un', 'una', 'mas', 'pero', 'aún',
+        'aunque', 'sino', 'que', 'no', 'porque', 'pues'];
+
+    static stringify(circ) {
+        const cache = [];
+        const text = JSON.stringify(circ, (key, value) => {
+            if (typeof value === 'object' && value !== null) {
+                if (cache.includes(value)) return;
+                cache.push(value);
+            }
+            return value;
+        });
+        cache = null;
+        return text;
+    };
+    static htmlEntities(str) {
+        return String(str)
+            .replace(/&/g, "&")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;");
+    }
+    static splitPageData(path) {
+        const partes = /(\/[^/]+)(\/\d+|\/)?/ig.exec(path);
+        let pageId = null;
+        if (typeof partes[2] == "string") {
+            pageId = parseInt(partes[2].replace("/", ""));
+        }
+        return {
+            pageId,
+            pageType: partes[1],
+        };
+    }
+    static partirTexto(q, buscable = true, permisivo = false) {
+        //solo minusculas
+        q = q.toLowerCase();
+        //Quito caracteres no validos
+        if (!permisivo) {
+            q = q.replace(/[^\w\d\sá-úü]/g, '');
+        }
+        //Reemplazar tildes dieresis 
+        q = q.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+
+        let tokens = q.split(/\s+/);
+        // Elimino textos con tamaño pequeño
+        tokens = tokens.filter((word) => { return word.length >= MyUtilities.MIN_LENGTH_TOKENS });
+
+        // Elimino textos con tamaño grande
+        tokens = tokens.filter((word) => { return word.length <= MyUtilities.MAX_LENGTH_TOKENS });
+
+        // Elimino los que pertenecen a la lista negra
+        tokens = tokens.filter((word) => { return MyUtilities.LISTA_NEGRA_TOKENS.indexOf(word) < 0 });
+
+        if (buscable) {
+            // Se debe partir en pedazos mas pequeños cada palabra
+            tokens = tokens.reduce((acc, word, index) => {
+                let temp = word;
+                do {
+                    acc.push(temp);
+                    temp = temp.substring(0, temp.length - 1);
+                } while (temp.length >= MyUtilities.MIN_LENGTH_TOKENS);
+                return acc;
+            }, []);
+
+            //Elimino duplicados
+            tokens = tokens.filter((word, index) => { return (index == tokens.indexOf(word)) });
+        } else {
+            tokens = tokens.filter((word, index) => { return (index == tokens.indexOf(word)) });
+        }
+
+        return tokens;
+    }
+    static isHidden(el) {
+        let is = (el.offsetParent === null);
+        if (!is) {
+            const style = window.getComputedStyle(el);
+            return (style.display === 'none');
+        }
+        return is;
+    }
+    static downloadTextData({ text = "", mime = "text/plain", filename = "file.txt" }) {
+        function downloadBlob(blob, name) {
+            const blobUrl = URL.createObjectURL(blob);
+            const link = document.createElement("a");
+            link.href = blobUrl;
+            link.download = name;
+            document.body.appendChild(link);
+            link.dispatchEvent(
+                new MouseEvent('click', {
+                    bubbles: true,
+                    cancelable: true,
+                    view: window
+                })
+            );
+            document.body.removeChild(link);
+        }
+        function text2Blob(bstr, mime) {
+            return new Blob([bstr], { type: mime });
+        }
+        const blob2 = text2Blob(text, mime);
+        downloadBlob(blob2, filename);
+    }
+
+    static async replaceAsync(str, regex, asyncFn) {
+        const promises = [];
+        str.replace(regex, (match, ...args) => {
+            const promise = asyncFn(match, ...args);
+            promises.push(promise);
+        });
+        const data = await Promise.all(promises);
+        return str.replace(regex, () => data.shift());
+    }
+
+    static async replaceAsync2(str, regex, asyncFn) {
+        const promises = [];
+        str.replace(regex, (match, ...args) => {
+            const promise = asyncFn(match, ...args);
+            promises.push(promise);
+        });
+        const data = await Promise.all(promises);
+        const copy = [...data];
+        return {
+            first: str.replace(regex, () => data.shift()[0]),
+            second: str.replace(regex, () => copy.shift()[1]),
+        }
+    }
+}
+
+module.exports = {
+    MyUtilities
+};

package/src/SimpleObj.js

@@ -0,0 +1,153 @@
+class SimpleObj {
+    static convertMapToArray(myMap) {
+        const keys = Object.keys(myMap);
+        const response = [];
+        for (let i = 0; i < keys.length; i++) {
+            const myKey = parseInt(keys[i]);
+            if (!isNaN(myKey)) {
+                response[myKey] = myMap[keys[i]];
+            }
+        }
+        return response;
+    }
+    static transFromModel(model, configList) {
+        const response = {};
+        for (let i = 0; i < configList.length; i++) {
+            const config = configList[i];
+            let { orig, dest, def } = config;
+            if (def === undefined) {
+                def = null;
+            }
+            let valor = SimpleObj.getValue(model, orig);
+            if ([null, undefined].indexOf(valor) >= 0) {
+                valor = def;
+            }
+            response[dest] = valor;
+        }
+        return response;
+    }
+    static getValue(obj, key, myDefault = undefined) {
+        let current = obj;
+        const canIterate = (some) => {
+            return (typeof some == "object" && some !== null);
+        };
+        if (!canIterate(current)) {
+            return myDefault;
+        }
+        const partes = key.split(".");
+        while (canIterate(current) && partes.length > 0) {
+            const firstKey = partes.splice(0, 1)[0];
+            current = current[firstKey];
+        }
+        if (current !== undefined && partes.length == 0) {
+            return current;
+        } else {
+            return myDefault;
+        }
+    }
+    static createBasic(todo, llave, llave2) {
+        const llave2EsNumero = (/^\d+$/.exec(llave2) != null);
+        if (!(llave in todo)) {
+            if (llave2EsNumero) {
+                todo[llave] = [];
+            } else {
+                todo[llave] = {};
+            }
+        } else {
+            const indice = todo[llave];
+            if (indice instanceof Array && !llave2EsNumero) {
+                //migrar de arreglo a objeto
+                const temporal = {};
+                for (let i = 0; i < indice.length; i++) {
+                    temporal[i] = indice[i];
+                }
+                todo[llave] = temporal;
+            }
+        }
+        return todo;
+    }
+    static objectWrite(indice, ultimaLlave, valor) {
+        //console.log(`indice ${JSON.stringify(indice)}, ultimaLlave ${ultimaLlave}, valor ${JSON.stringify(valor)}`);
+        if (typeof indice[ultimaLlave] == "object" && [null, undefined].indexOf(indice[ultimaLlave]) < 0) {
+            //console.log("Caso 1");
+            // El destino es un objeto o arreglo
+            if (typeof valor == "object" && [null, undefined].indexOf(valor) < 0) {
+                // Tanto origen como destino son objetos o arreglos, se podría intentar mezclar
+                if (valor instanceof Array) {
+                    /*
+                    for (let k = 0; k < valor.length; k++) {
+                        const elem = valor[k];
+                        if (elem != undefined) {
+                            indice[ultimaLlave][k] = elem;
+                        }
+                    }
+                    */
+                    indice[ultimaLlave] = valor;
+                } else {
+                    Object.assign(indice[ultimaLlave], valor);
+                }
+            } else if (valor === undefined) {
+                // El valor es indefinido, se entiende que se quiere borrar
+                delete indice[ultimaLlave];
+            } else {
+                // El nuevo valor no es un objeto, se entiende que se desea reemapolzar simplemente
+                indice[ultimaLlave] = valor;
+            }
+        } else {
+            //console.log("Caso 2");
+            // El destino no era un objeto entonces no hay necesidad de mezclar, solo asignar
+            // Sin importar lo que sea el nuevo valor
+            indice[ultimaLlave] = valor;
+        }
+    }
+    static recreate(todo, llave, valor, simple = false) {
+        const partes = llave.split(".");
+        let indice = todo;
+        for (let i = 0; i < partes.length - 1; i++) {
+            const parte = partes[i];
+            if (!(parte in indice)) {
+                SimpleObj.createBasic(indice, parte, partes[i + 1]);
+            }
+            indice = indice[parte];
+        }
+        const ultimaLlave = partes[partes.length - 1];
+        if (simple) {
+            if (valor === undefined) {
+                delete indice[ultimaLlave];
+            } else {
+                SimpleObj.objectWrite(indice, ultimaLlave, valor);
+            }
+            return todo;
+        }
+        if (typeof valor == "object" && valor !== null) {
+            if (!indice[ultimaLlave]) {
+                if (valor instanceof Array) {
+                    indice[ultimaLlave] = [];
+                } else {
+                    indice[ultimaLlave] = {};
+                }
+            } else {
+                if (!(valor instanceof Array) && indice[ultimaLlave] instanceof Array) {
+                    //migrar de arreglo a objeto
+                    const temporal = indice[ultimaLlave];
+                    const nuevo = {};
+                    for (let i = 0; i < temporal.length; i++) {
+                        const valorLocal = temporal[i];
+                        if (valorLocal !== null) {
+                            nuevo[i] = valorLocal;
+                        }
+                    }
+                    indice[ultimaLlave] = nuevo;
+                }
+            }
+            SimpleObj.objectWrite(indice, ultimaLlave, valor);
+        } else {
+            indice[ultimaLlave] = valor;
+        }
+        return todo;
+    }
+};
+
+module.exports = {
+    SimpleObj
+};

package/src/SimpleObj.test.js

@@ -0,0 +1,58 @@
+const { SimpleObj } = require("./SimpleObj");
+const sortify = require("./sortify");
+
+const testGetValue = () => {
+    const MY_CASES = [
+        { obj: { a: 1 }, key: "a", val: 1 },
+        { obj: { a: { b: 4 } }, key: "a.b", val: 4 },
+        { obj: [6], key: "0", val: 6 },
+        { obj: [{ x: 9 }], key: "0.x", val: 9 },
+        { obj: null, key: "noex", val: null, def: null },
+        { obj: { a: ["a", true, false] }, key: "a.2", val: false },
+        { obj: { a: 1 }, key: "b", val: undefined },
+        { obj: { x: { v: { a: null } } }, key: "x.v.a.n.j", val: "nada", def: "nada" },
+    ];
+
+    for (let i = 0; i < MY_CASES.length; i++) {
+        const MY_CASE = MY_CASES[i];
+        const obj = MY_CASE.obj;
+        const key = MY_CASE.key;
+        const def = MY_CASE.def;
+        const myExpected = MY_CASE.val;
+        const response = SimpleObj.getValue(obj, key, def);
+        if (response !== myExpected) {
+            throw Error(`expected ${JSON.stringify(myExpected)} actual ${JSON.stringify(response)}`);
+        } else {
+            console.log(`case ${i + 1} OK! ${JSON.stringify(myExpected)} equals ${JSON.stringify(response)}`);
+        }
+    }
+
+    console.log(JSON.stringify(SimpleObj.convertMapToArray({ "0": "Primero", "1": "Segundo" })));
+    console.log(JSON.stringify(SimpleObj.convertMapToArray({ "1": "Primero", "2": "Segundo" })));
+}
+
+const testWriteValue = () => {
+    const MY_CASES = [
+        { obj: { a: 1 }, key: "a", val: 2, exp: { a: 2 } },
+        { obj: { players: {} }, key: "players.P12", val: { name: "Edgar" }, exp: { players: { P12: { name: "Edgar" } } } },
+    ];
+    for (let i = 0; i < MY_CASES.length; i++) {
+        const MY_CASE = MY_CASES[i];
+        const obj = MY_CASE.obj;
+        const key = MY_CASE.key;
+        const val = MY_CASE.val;
+        const myExpected = MY_CASE.exp;
+        const response = SimpleObj.recreate(obj, key, val);
+        const textoEsperado = sortify(myExpected);
+        const textoCalculado = sortify(response);
+        if (textoCalculado !== textoEsperado) {
+            throw Error(`expected ${JSON.stringify(textoEsperado)} actual ${JSON.stringify(textoCalculado)}`);
+        } else {
+            console.log(`case ${i + 1} OK! ${JSON.stringify(textoEsperado)} equals ${JSON.stringify(textoCalculado)}`);
+        }
+    }
+};
+
+//testGetValue();
+//testWriteValue();
+