text: const mockFunctions = require('../src/mockFunctions');
  
  /*
  Criamos uma série de funções com eficiência duvidosa.
  Elas estão no arquivo 'src/mockFunctions.js'.
  Crie mock functions para cada uma das operações de modo que os cálculos sejam feitos corretamente,
  não como estão sendo feitos no arquivo original.
  A idéia é que os novos testes sobrescrevam os testes
  importados apenas na suite de testes abaixo.
  
  Importante! A correção de código via mock functions não é uma aplicação usual.
  O foco aqui é a utilização de mock functions.
  
  ATENÇÃO!!! Edite apenas este arquivo. Não altere os arquivos da pasta 'src'.
  */
  jest.mock('../src/mockFunctions')
  // para mockar todo o arquivo de uma vez
  describe('verifica as funções e os mocks', () => {
    
    test('testa função add', () => {
  
      mockFunctions.add.mockImplementation((a, b) => a + b);
      // para re-escrever as funções
  
      expect(mockFunctions.add(1, 2)).toEqual(3);
      expect(mockFunctions.add(8, 37)).toEqual(45);
      expect(mockFunctions.add(-11, 25)).toEqual(14);
      expect(mockFunctions.add(13, -188)).toEqual(-175);
      expect(mockFunctions.add(7, 26)).toEqual(33);
    });
    test('testa função subtract', () => {
  
      mockFunctions.subtract.mockImplementation((a, b) => a - b);
  
      expect(mockFunctions.subtract(899, 35)).toEqual(864);
      expect(mockFunctions.subtract(-17, 333)).toEqual(-350);
      expect(mockFunctions.subtract(45, 97)).toEqual(-52);
      expect(mockFunctions.subtract(23, -108)).toEqual(131);
      expect(mockFunctions.subtract(-133, -29)).toEqual(-104);
    });
    test('testa função multiply', () => {
  
      mockFunctions.multiply.mockImplementation((a, b) => a * b);
  
      expect(mockFunctions.multiply(1, 2)).toEqual(2);
      expect(mockFunctions.multiply(0, 5)).toEqual(0);
      expect(mockFunctions.multiply(-4, 9)).toEqual(-36);
      expect(mockFunctions.multiply(-12, -7)).toEqual(84);
      expect(mockFunctions.multiply(19, 23)).toEqual(437);
    });
    test('testa função divide', () => {
  
      mockFunctions.divide.mockImplementation((a, b) => a / b);
  
      expect(mockFunctions.divide(169, 13)).toEqual(13);
      expect(mockFunctions.divide(-1900, 5)).toEqual(-380);
      expect(mockFunctions.divide(42, 7)).toEqual(6);
      expect(mockFunctions.divide(729, 243)).toEqual(3);
      expect(mockFunctions.divide(1331, 11)).toEqual(121);
    });
    test('testa função power', () => {
  
      mockFunctions.power.mockImplementation((a, b) => a ** b);
  
      expect(mockFunctions.power(10, 2)).toEqual(100);
      expect(mockFunctions.power(2, 10)).toEqual(1024);
      expect(mockFunctions.power(5, 5)).toEqual(3125);
      expect(mockFunctions.power(1, 10)).toEqual(1);
      expect(mockFunctions.power(0, 0)).toEqual(1);
    });
    test('testa função factorial', () => {
  
      mockFunctions.factorial.mockImplementation((a) => {
        if(a === 0) return 1;
        return a * mockFunctions.factorial(a - 1)
      });
      // referência: http://devfuria.com.br/logica-de-programacao/recursividade-fatorial/
      expect(mockFunctions.factorial(5)).toEqual(120);
      expect(mockFunctions.factorial(10)).toEqual(3628800);
      expect(mockFunctions.factorial(3)).toEqual(6);
      expect(mockFunctions.factorial(8)).toEqual(40320);
      expect(mockFunctions.factorial(2)).toEqual(2);
    });
  });
  