Biblioteca utils

fontes/bibliotecas/index.ts

@@ -1,2 +0,0 @@
-export * from './matematica';
-export * from './calendario'

fontes/bibliotecas/util.ts

@@ -0,0 +1,44 @@
+import * as os from 'os';
+
+const horaInicial: number = Date.now();
+
+export async function obter_diretorio_usuario(): Promise<string> {
+    try {
+        return os.homedir();
+    } catch (error) {
+        throw new Error("Não foi possível obter o diretório do usuário");
+    }
+}
+
+export async function numero_elementos(vetor: any[]): Promise<number> {
+    return vetor.length;
+}
+
+export async function numero_linhas(matriz: any[][]): Promise<number> {
+    return matriz.length;
+}
+
+export async function numero_colunas(matriz: any[][]): Promise<number> {
+    return matriz[0].length;
+}
+
+export async function sorteia(minimo: number, maximo: number): Promise<number> {
+    if (minimo > maximo) {
+        throw new Error(`O valor mínimo (${minimo}) é maior do que o valor máximo (${maximo})`);
+    } 
+
+    if (minimo === maximo) {
+        throw new Error(`Os valores mínimo e máximo são iguais: ${minimo}`);
+    }
+
+    return Math.floor(Math.random() * (maximo + 1 - minimo)) + minimo;
+}
+
+export async function aguarde(intervalo: number): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, intervalo));
+}
+
+export async function tempo_decorrido(): Promise<number> {
+    const tempoAtual = Date.now();
+    return Math.floor(tempoAtual - horaInicial);
+}

fontes/interpretador/comum.ts

@@ -6,6 +6,7 @@ import { ErroEmTempoDeExecucao } from '@designliquido/delegua/excecoes';
 
 import * as matematica from '../bibliotecas/matematica';
 import * as texto from '../bibliotecas/texto';
+import * as util from '../bibliotecas/util';
 
 function carregarBibliotecaMatematica(): DeleguaModulo {
     const metodos: { [nome: string]: FuncaoPadrao } = {
@@ -43,12 +44,30 @@ function carregarBibliotecaTexto(): DeleguaModulo {
     return objetoTexto;
 }
 
+function carregarBibliotecaUtil(): DeleguaModulo {
+    const metodos: { [nome: string]: FuncaoPadrao } = {
+        obter_diretorio_usuario: new FuncaoPadrao(0, util.obter_diretorio_usuario),
+        numero_elementos: new FuncaoPadrao(1, util.numero_elementos),
+        numero_linhas: new FuncaoPadrao(1, util.numero_linhas),
+        numero_colunas: new FuncaoPadrao(1, util.numero_colunas),
+        sorteia: new FuncaoPadrao(2, util.sorteia),
+        aguarde: new FuncaoPadrao(1, util.aguarde),
+        tempo_decorrido: new FuncaoPadrao(0, util.tempo_decorrido)
+    }
+
+    const objetoUtil = new DeleguaModulo('Util');
+    objetoUtil.componentes = metodos;
+    return objetoUtil;
+}
+
 export async function visitarExpressaoImportarComum(expressao: Importar): Promise<any> {
     switch (expressao.caminho.valor) {
         case 'Matematica':
             return carregarBibliotecaMatematica();
         case 'Texto':
             return carregarBibliotecaTexto();
+        case 'Util':
+            return carregarBibliotecaUtil();
         default:
             throw new ErroEmTempoDeExecucao(null, `Biblioteca não implementada: ${expressao.caminho}.`);
     }

testes/bibliotecas/util.test.ts

@@ -0,0 +1,110 @@
+import os from 'os';
+import {
+    obter_diretorio_usuario,
+    numero_colunas,
+    numero_elementos,
+    numero_linhas,
+    sorteia,
+    aguarde,
+    tempo_decorrido,
+} from '../../fontes/bibliotecas/util';
+
+describe('Biblioteca Util', () => {
+    describe('Obter Diretório do Usuário', () => {
+        it('Trivial', async () => {
+            const resultado = await obter_diretorio_usuario();
+            expect(resultado).toBe(os.homedir());
+        });
+
+        it('Falha ao obter Diretório', async () => {
+            jest.spyOn(os, 'homedir').mockImplementation(() => {
+                throw new Error('Erro para testes');
+            });
+            await expect(obter_diretorio_usuario()).rejects.toThrow('Não foi possível obter o diretório do usuário');
+        });
+    });
+
+    describe('Número de Elementos', () => {
+        it('Trivial', async () => {
+            const vetor = [1, 2, 3, 4, 5];
+            const resultado = await numero_elementos(vetor);
+            expect(resultado).toBe(5);
+        });
+    });
+
+    describe('Número de Linhas', () => {
+        it('Trivial', async () => {
+            const matriz = [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+            ];
+            const resultado = await numero_linhas(matriz);
+            expect(resultado).toBe(3);
+        });
+    });
+
+    describe('Número de Colunas', () => {
+        it('Trivial', async () => {
+            const matriz = [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+            ];
+            const resultado = await numero_colunas(matriz);
+            expect(resultado).toBe(3);
+        });
+    });
+
+    describe('Sorteia', () => {
+        it('Trivial', async () => {
+            const minimo = 1;
+            const maximo = 10;
+            const resultado = await sorteia(minimo, maximo);
+            expect(resultado).toBeGreaterThanOrEqual(minimo);
+            expect(resultado).toBeLessThanOrEqual(maximo);
+        });
+
+        it('Falha - Minimo maior que Maximo', async () => {
+            const minimo = 10;
+            const maximo = 1;
+            await expect(sorteia(minimo, maximo)).rejects.toThrow(
+                `O valor mínimo (${minimo}) é maior do que o valor máximo (${maximo})`
+            );
+        });
+
+        it('Falha - Minimo é igual a Maximo', async () => {
+            const minimo = 5;
+            const maximo = 5;
+            await expect(sorteia(minimo, maximo)).rejects.toThrow(`Os valores mínimo e máximo são iguais: ${minimo}`);
+        });
+    });
+
+    describe('Aguarde', () => {
+        it('Trivial', async () => {
+            const startTime = new Date().getTime();
+            const intervalo = 50;
+            await aguarde(intervalo);
+            const endTime = new Date().getTime();
+            const elapsedTime = endTime - startTime;
+            expect(elapsedTime).toBeGreaterThanOrEqual(intervalo * 0.9);
+            expect(elapsedTime).toBeLessThanOrEqual(intervalo * 1.3);
+        });
+    });
+
+    let horaInicial: number;
+    beforeAll(() => {
+        horaInicial = Date.now();
+    });
+
+    describe('Tempo Decorrido', () => {
+        it('Trivial', async () => {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            const resultado = await tempo_decorrido();
+            const tempoAtual = Date.now();
+            const tempoDecorridoEsperado = tempoAtual - horaInicial;
+            expect(resultado).toBeGreaterThanOrEqual(tempoDecorridoEsperado * 0.9);
+            expect(resultado).toBeLessThanOrEqual(tempoDecorridoEsperado * 1.3);
+        });
+    });
+});