diff --git a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
index 6f0dec964..2ee207fc3 100644
--- a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
+++ b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
@@ -1,10 +1,10 @@
 O teste demonstra uma das tentações que um desenvolvedor encontra ao escrever testes.
 
-O que temos aqui são na verdade 3 testes, mas colocados numa única função com 3 *asserts*.
+O que aqui temos são na verdade 3 testes, mas colocados numa única função com 3 *asserts*.
 
-Por vezes, é mais fácil escrever desta forma mas, se ocorrer um erro, é menos óbvio ver o que há de errado.
+Por vezes, é mais fácil escrever dessa forma mas, se ocorrer um erro, é menos óbvio ver o que está errado.
 
-Se houver um erro dentro de um fluxo de execução complexo, então teremos que procurar entender os dados nessa altura. Teremos, na verdade, que *debug o teste*.
+Se houver um erro dentro de um fluxo de execução complexo, então teremos que procurar entender os dados nessa altura. Teremos, na verdade, que fazer o *debug do teste*.
 
 Seria muito melhor repartir o teste em múltiplos blocos `it`, com claramente escritas entradas e saídas.
 
@@ -25,9 +25,9 @@ describe("Eleva x à potência n", function() {
 });
 ```
 
-Nós substituimos o único `it` por `describe` e um grupo de blocos `it`. Agora, se algo falhasse, veríamos claramente que dados estariam errados.
+Nós substituímos o único `it` por `describe` e um grupo de blocos `it`. Agora, se algo falhar, vemos claramente que dados estão errados.
 
-Também, podemos isolar um único teste e executá-lo num modo à parte (*standalone*) escrevendo `it.only` em vez de `it`:
+Também, podemos isolar um único teste e executá-lo à parte (*standalone*) escrevendo `it.only` em vez de `it`:
 
 
 ```js
diff --git a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md
index 579669730..2395e4862 100644
--- a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md
+++ b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md
@@ -1,4 +1,4 @@
-importância: 5
+importance: 5
 
 ---
 
@@ -21,4 +21,4 @@ it("Eleva x à potência n", function() {
 });
 ```
 
-P.S. Sintáticamente, o teste está correto e passa.
+P.S. Sintaticamente, o teste está correto e passa.
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index e5a3ab6b4..850df1a00 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -4,7 +4,7 @@ Teste automatizado será utilizado nos exercícios seguintes, e também é ampla
 
 ## Porque precisamos de testes?
 
-Quando escrevemos uma função, nós geralmente podemos imaginar o que ela deveria fazer: que parâmetros dariam que resultados.
+Quando escrevemos uma função, podemos geralmente imaginar o que ela deveria fazer: que parâmetros iriam dar que resultados.
 
 Durante o desenvolvimento, podemos analisar a função executando-a e comparando o resultado obtido ao esperado. Por exemplo, podemos fazê-lo na consola.
 
@@ -12,7 +12,7 @@ Se algo estiver errado -- então corrigimos o código, executamos de novo, verif
 
 Mas, tais "re-execuções" manuais são imperfeitas.
 
-**Ao testar código com re-execuções manuais, é fácil olvidar alguma coisa.**
+**Ao testar código com re-execuções manuais, é fácil esquecer alguma coisa.**
 
 Por exemplo, estamos a criar uma função `f`. Escrevemos algum código, e testamos: `f(1)` funciona, mas `f(2)` não. Corrigimos o código e agora `f(2)` funciona. Parece completo? Mas, nos esquecemos de re-testar `f(1)`. Que pode estar agora a produzir um erro.
 
@@ -20,7 +20,7 @@ Isso é muito comum. Quando desenvolvemos algo, mantemos uma quantidade de poss
 
 **Teste automatizado significa que testes são escritos separadamente, adicionalmente ao código. Eles correm as nossas funções de várias maneiras e comparam os resultados obtidos aos esperados.**
 
-## Desenvolvimento Guiado por Comportamento (Behavior Driven Desenvolvimento [BDD])
+## Desenvolvimento Guiado por Comportamento (Behavior Driven Development [BDD])
 
 Vamos começar por uma técnica chamada [Desenvolvimento Guiado por Comportamento](https://pt.wikipedia.org/wiki/Behavior_Driven_Development), ou abreviadamente BDD (em Inglês).
 
@@ -36,7 +36,7 @@ Essa tarefa é apenas um exemplo: existe o operador `**` em JavaScript que pode
 
 Antes de criarmos o código de `pow`, podemos imaginar o que a função deveria fazer e descrevê-lo (*describe it*).
 
-Tal descrição é chamada de *especificação*, ou abreviadamente uma *spec*, e contém descrições de casos exemplo (*use cases*) acompanhados de testes para eles, como por exemplo:
+Tal descrição é chamada de *especificação*, ou abreviadamente uma *spec*, e contém descrições de casos exemplo (*use cases*) acompanhadas de testes para eles, como por exemplo:
 
 ```js
 describe("pow", function() {
@@ -51,7 +51,7 @@ describe("pow", function() {
 Uma *spec* tem três principais blocos construtores, como pode ver acima:
 
 `describe("título", function() { ... })`
-: Que funcionalidade estamos a descrever. No nosso caso, estamos a descrever a função `pow`. São usados para agrupar "executores" ("*workers*") -- os blocos `it`.
+: Que funcionalidade estamos a descrever. No nosso caso, estamos a descrever a função `pow`. É usado para agrupar "executores" ("*workers*") -- os blocos `it`.
 
 `it("descrição do caso exemplo", function() { ... })`
 : No título de `it` nós, *de uma forma claramente legível*, descrevemos o caso exemplo em questão, e no segundo argumento está uma função que o testa.
@@ -59,9 +59,7 @@ Uma *spec* tem três principais blocos construtores, como pode ver acima:
 `assert.equal(valor1, valor2)`
 : O código dentro do bloco `it`, se a implementação estiver correta, não deverá mostrar erros.
 
-```text
 Funções `assert.*` são usadas para verificar se `pow` funciona como esperado. Aqui mesmo, estamos a usar uma delas -- `assert.equal`, que compara argumentos e dá como resultado um erro se eles não forem iguais. Aqui, ela verifica se o resultado de `pow(2, 3)` é `8`. Existem outros tipos de comparações e verificações, que adicionaremos mais adiante.
-```
 
 A especificação pode ser executada, e irá correr o teste especificado no bloco `it`. O que veremos mais adiante.
 
@@ -71,9 +69,9 @@ Geralmente, o fluxo de desenvolvimento se assemelha a:
 
 1. Uma *spec* inicial é escrita, com testes para a mais básica funcionalidade.
 2. Uma implementação inicial é criada.
-3. Para verificar se ela funciona, nós corremos a infraestrutura de teste [Mocha](http://mochajs.org/) (mais detalhes em breve) que corre a *spec*. Enquanto a funcionalidade não estiver completa, erros são mostrados. Nós a corrigimos até que tudo funcione.
+3. Para verificar se ela funciona, nós corremos a infraestrutura de testes [Mocha](http://mochajs.org/) (mais detalhes em breve) que corre a *spec*. Enquanto a funcionalidade não estiver completa, erros são mostrados. Nós a corrigimos até que tudo funcione.
 4. Agora, temos uma implementação inicial a funcionar com testes.
-5. Adicionamos mais casos exemplo (*use cases*) à *spec*, provávelmente ainda não suportados pelas implementações. Testes começam a falhar.
+5. Adicionamos mais casos exemplo (*use cases*) à *spec*, provavelmente ainda não suportados pelas implementações. Os testes começam a falhar.
 6. Vamos para 3, atualizamos a implementação até que os testes nâo forneçam erros.
 7. Repetimos os passos 3-6 até que a funcionalidade esteja pronta.
 
@@ -81,27 +79,26 @@ Assim, o desenvolvimento é *iterativo*. Nós escrevemos a *spec*, a implementam
 
 Vejamos este fluxo de desenvolvimento no nosso caso prático.
 
-O primeiro passo já está completo: nós temos uma *spec* inicial para `pow`. Agora, antes de fazer a implementação, vamos utilizar umas poucas bibliotecas (*libraries*) de JavaScript para executar os testes, apenas para ver se eles estão a funcionar (todos irão falhar).
+O primeiro passo já está completo: nós temos uma *spec* inicial para `pow`. Agora, antes de fazermos a implementação, vamos utilizar umas poucas bibliotecas (*libraries*) de JavaScript para executar os testes, apenas para ver se eles estão a funcionar (todos irão falhar).
 
 ## A *spec* em ação
 
 Aqui, no tutorial, nós iremos usar as seguintes bibliotecas de JavaScript para testes:
 
 - [Mocha](http://mochajs.org/) -- a infraestrutura principal: ela fornece funções de teste comuns, incluindo `describe` e `it` e a principal função que executa os testes.
-- [Chai](http://chaijs.com) -- a biblioteca (*library*) com muitas *asserções*. Ela permite usar muitas diferentes *asserções*; por ora, nós precisamos de apenas `assert.equal`.
-- [Sinon](http://sinonjs.org/) -- a biblioteca para espiar sobre funções, simular funções incorporadas (built-in) e mais; nós a vamos precisar muito mais tarde.
+- [Chai](http://chaijs.com) -- uma biblioteca (*library*) com muitas *asserções*. Ela permite usar muitas diferentes *asserções*; por ora, nós apenas precisamos de `assert.equal`.
+- [Sinon](http://sinonjs.org/) -- uma biblioteca para espiar sobre funções, simular funções incorporadas (built-in) e mais; nós a vamos precisar muito mais tarde.
 
-Estas bibliotecas, são adequadas a testes quer usando um navegador (*in-browser*) como efetuados num servidor (*server-side*). Aqui, nós vamos considerar a variante do navegador.
+Estas bibliotecas, são adequadas a testes quer num navegador (*in-browser*) como num servidor (*server-side*). Aqui, nós vamos considerar a variante do navegador.
 
 A página HTML completa, com estas infraestruturas e a *spec* `pow`:
 
-```html
-  src="index.html"
+```html src="index.html"
 ```
 
 A página pode ser dividida em cinco partes:
 
-1. A `<head>` -- adiciona bibliotecas de terceiros (*third-party*) e estilos para testes.
+1. A `<head>` -- adiciona bibliotecas de terceiros (*third-party*) e estilos para os testes.
 2. O `<script>` com a função para o teste, no nosso caso -- com o código para `pow`.
 3. Os testes -- no nosso caso um programa externo `test.js`, que tem o `describe("pow", ...)` visto acima.
 4. O elemento HTML `<div id="mocha">`, será usado por Mocha para a saída dos resultados.
@@ -113,15 +110,15 @@ O resultado:
 
 Por ora, o teste falha, existe um erro. O que é lógico: nós temos uma função sem código em `pow`; assim, `pow(2,3)` retorna `undefined` em vez de `8`.
 
-Para o futuro, vamos tomar nota de que existem executadores de testes (*test-runners*) de nível mais elevado, como [karma](https://karma-runner.github.io/) e outros, que tornam fácil correr automáticamente (*autorun*) muitos testes diferentes.
+Para trabalho futuro, vamos tomar nota de que existem executadores de testes (*test-runners*) de nível mais elevado, como [karma](https://karma-runner.github.io/) e outros, que tornam fácil correr automaticamente (*autorun*) muitos testes diferentes.
 
 ## Implementação inicial
 
-Vamos fazer uma implementação simples de `pow`, para passar os testes:
+Vamos fazer uma implementação simples de `pow`, para passar nos testes:
 
 ```js
 function pow(x, n) {
-  return 8; // :) nós fizémos batota!
+  return 8; // :) nós fizemos batota!
 }
 ```
 
@@ -131,9 +128,9 @@ Wow, agora ela funciona!
 
 ## Melhorando a *spec*
 
-O que nós fizémos é definitivamente uma batota. A função não funciona: uma tentativa para calcular `pow(3,4)` daria um resultado incorreto, mas os testes passam.
+O que nós fizemos é definitivamente uma batota. A função não funciona: uma tentativa para calcular `pow(3,4)` daria um resultado incorreto, mas os testes passam.
 
-...Mas a situação é muito comum, acontece na prática. Testes passam, mas a função funciona de forma errada. A nossa *spec* está imperfeita. Nós precisamos de lhe adicionar mais casos exemplo (*use cases*).
+...Contudo, a situação é muito comum, e acontece na prática. Testes passam, mas a função funciona de forma errada. A nossa *spec* está imperfeita. Nós precisamos de lhe adicionar mais casos exemplo (*use cases*).
 
 Vamos adicionar mais um teste para verificar se `pow(3, 4) = 81`.
 
@@ -153,7 +150,6 @@ Aqui, nós podemos selecionar uma das duas formas para organizar o teste:
 
     });
     ```
-
 2. A segunda -- faça dois testes:
 
     ```js
@@ -178,9 +174,9 @@ E para além disso, é mais uma boa regra para se seguir.
 
 **Um teste verifica uma coisa.**
 
-Se olharmos para o teste e virmos duas verificações independentes, o melhor é reparti-lo em dois mais simples.
+Se olharmos para um teste e virmos duas verificações independentes, o melhor é reparti-lo em dois mais simples.
 
-Assim, vamos prosseguir pela segunda variante.
+Assim, vamos prosseguir com a segunda variante.
 
 O resultado:
 
@@ -194,13 +190,13 @@ Vamos escrever algo mais real para os testes passarem:
 
 ```js
 function pow(x, n) {
-  let resultado = 1;
+  let result = 1;
 
   for (let i = 0; i < n; i++) {
-    resultado *= x;
+    result *= x;
   }
 
-  return resultado;
+  return result;
 }
 ```
 
@@ -229,7 +225,7 @@ O resultado:
 
 ## describe aninhados
 
-Agora, vamos adicionar ainda mais testes. Mas, antes tomemos nota de que a função auxiliar `makeTest` e o `for` deveriam estar juntos agrupados. Nós não precisaremos de `makeTest` em outros testes, apenas é necessária no `for`: a sua tarefa comum é verificar como `pow` eleva à potência pretendida.
+Agora, vamos adicionar ainda mais testes. Mas, antes tomemos nota de que a função auxiliar `makeTest` e o `for` deveriam estar agrupados juntos. Nós não precisaremos de `makeTest` em outros testes, apenas é necessária no `for`: a tarefa de ambos é verificar como `pow` eleva à potência pretendida.
 
 O agrupamento é feito com `describe` aninhados:
 
@@ -265,10 +261,8 @@ O `describe` aninhado define um novo "subgrupo" de testes. No resultado mostrado
 
 No futuro, nós podemos adicionar mais `it` e `describe` ao nível de topo com outras funções auxiliares, elas não irão ver `makeTest`.
 
-```smart header="'before/after' e 'beforeEach/afterEach'"
-Nós podemos definir funções `before/after`, que corram antes/após os testes serem executados, e também funções `beforeEach/afterEach` que corram antes/após *cada* `it`.
-
-```
+````smart header="`before/after` and `beforeEach/afterEach`"
+Nós podemos definir funções `before/after`, que corram antes/após testes serem executados, e também funções `beforeEach/afterEach` que corram antes/após *cada* `it`.
 
 Por exemplo:
 
@@ -289,7 +283,7 @@ describe("test", function() {
 
 A sequência da execução será:
 
-```text
+```
 Testes iniciados – antes de todos os testes (before)
 Antes de um teste - entrando para um teste (beforeEach)
 1
@@ -300,19 +294,20 @@ Após um teste - saindo de um teste   (afterEach)
 Testes terminados – após todos os testes (after)
 ```
 
-[edit src="beforeafter" title="Open the example in the sandbox."]
+[edit src="beforeafter" title="Abra o exemplo no ambiente isolado de processos (*sandbox*)."]
 
-Geralmente, `beforeEach/afterEach` e `before/after` são usadas para executar a  inicialização, zerar contadores ou fazer mais alguma coisa entre os testes (ou grupos de testes).
+Geralmente, `beforeEach/afterEach` e `before/after` são usadas para executar a inicialização, zerar contadores, ou fazer mais alguma coisa entre os testes (ou grupos de testes).
+````
 
-## Aumentando a *spec*
+## Estendendo a *spec*
 
-A funcionalidade básica de `pow` está completa. A primeira parte do desenvolvimento está feita. Quando acabarmos de celebrar e de beber champagne -- vamos a tornar melhor.
+A funcionalidade básica de `pow` está completa. A primeira iteração do desenvolvimento está feita. Quando acabarmos de celebrar e de beber champagne -- vamos torná-la melhor.
 
 Como foi dito, a função `pow(x, n)` foi feita para trabalhar com valores inteiros positivos de `n`.
 
 Para indicar um erro matemático, geralmente as funções de JavaScript retornam `NaN`. Vamos fazer o mesmo para valores inválidos de `n`.
 
-Primeiro vamos adicionar a funcionalidade à spec(!):
+Primeiro vamos adicionar esse comportamento à spec(!):
 
 ```js
 describe("pow", function() {
@@ -341,13 +336,12 @@ O resultado com novos testes:
 Os testes agora adicionados falham, porque a nossa implementação não possui suporte para eles. É assim como BDD é feito: primeiro nós escrevemos testes que falham, e depois fazemos uma implementação para eles.
 
 ```smart header="Outras asserções"
-
 Por favor, observe a asserção `assert.isNaN`: ela verifica por `NaN`.
 
 Existem ainda outras asserções em [Chai](http://chaijs.com), como por exemplo:
 
 - `assert.equal(valor1, valor2)` -- verifica a igualdade `valor1 == valor2`.
-- `assert.strictEqual(valor1, valor2)` -- verifica a igualdade exata (*strict*) `valor1 === valor2`.
+- `assert.strictEqual(valor1, valor2)` -- verifica a igualdade exata (estrita) `valor1 === valor2`.
 - `assert.notEqual`, `assert.notStrictEqual` -- verificação inversa às de acima.
 - `assert.isTrue(valor)` -- verifica se `valor === true`
 - `assert.isFalse(valor)` -- verifica se `valor === false`
@@ -385,31 +379,31 @@ Em BDD, a *spec* vem primeiro, seguida pela implementação. No final, nós temo
 
 A *spec* pode ser usada de três formas:
 
-1. Como **Testes** - eles guarantem que o código funciona corretamente.
+1. Como **Testes** - eles garantem que o código funciona corretamente.
 2. Como **Docs** -- os títulos de `describe` e `it` dizem o que a função faz.
 3. Como **Exemplos** -- os testes são, na verdade, exemplos práticos mostrando como a função pode ser usada.
 
-Com a *spec*, nós podemos com segurança melhorar, alterar, e até reescrever a função do início e ter a certeza de que ainda funciona corretamente.
+Com a *spec*, nós podemos com segurança melhorar, alterar, e até reescrever a função do início e ter a certeza de que ela ainda funciona corretamente.
 
-Isso é especialmente importante em grandes projetos, quando uma função é usada em muitos lugares. Quando nós alteramos essa função, simplesmente não há forma de manualmente verificar se ainda funciona corretamente em cada lugar em que é usada.
+Isso é especialmente importante em grandes projetos, quando uma função é usada em muitos lugares. Quando nós alteramos essa função, não há uma forma simples de manualmente verificar se ainda funciona corretamente em cada lugar em que é usada.
 
 Sem testes, as pessoas têm duas formas:
 
-1. Executar a alteração, não importa o que aconteça. E aí, os nossos utilizadores encontram *bugs*, porque provavelmente falhámos ao não testar algo manualmente.
-2. Ou, se a punição por erros for severa, como não existem testes, as pessoas ficam com receio de modificar tais funções, e aí o código se torna obsoleto, ninguém quer se involver nele. Nada bom para o desenvolvimento.
+1. Executar a alteração, não importa o que aconteça. E aí, os nossos utilizadores encontram *bugs*, porque provavelmente nós falhámos ao não testar algo manualmente.
+2. Ou, se a punição por erros for severa, e como não existem testes, as pessoas ficam com receio de modificar tais funções, e aí o código se torna obsoleto, ninguém quer se involver nele. Nada bom para o desenvolvimento.
 
 **Testes automáticos ajudam a evitar estes problemas!**
 
-Se o projeto estiver coberto por testes, simplesmente não existe tal problema. Depois de quaisquer alterações, nós podemos correr testes e observar muitas análises numa questão de segundos.
+Se o projeto estiver coberto por testes, simplesmente não existe tal problema. Depois de quaisquer alterações, nós podemos correr testes e efetuar muitas verificações numa questão de segundos.
 
 **Adicionalmente, um código bem testado tem melhor arquitetura.**
 
 Naturalmente, isto porque código auto-testado é mais fácil de modificar e melhorar. Mas, também há outro motivo.
 
-Para se escrever testes, o código deverá estar organizado de tal forma que cada função tenha uma tarefa claramente descrita, e entrada e saida de dados bem definidas. Isso, significa uma boa arquitetura a partir do início.
+Para se escrever testes, o código deverá estar organizado de tal forma que cada função tenha uma tarefa claramente descrita, e entrada e saída de dados bem definidas. Isso significa uma boa arquitetura a partir do início.
 
-Na vida real, por vezes isto não é tão fácil. Ás vezes, é dificil escrever uma *spec* antes do respetivo código, por ainda não estar claro como ele se deveria comportar. Mas, em geral, escrever testes torna o desenvolvimento mais rápido e mais estável.
+Na vida real, por vezes isto não é tão fácil. Ás vezes, é difícil escrever uma *spec* antes do respetivo código, por ainda não estar claro como ele se deveria comportar. Mas, em geral, escrever testes torna o desenvolvimento mais rápido e mais estável.
 
-Mais adiante, no tutorial, você irá encontrar muitas tarefas com testes preparados. Assim, poderá ver mais exemplos práticos.
+Mais adiante, no tutorial, você irá encontrar muitas tarefas com testes preparados. Desta forma, poderá ver mais exemplos práticos.
 
-Escrever testes, requere um bom conhecimento de JavaScript. Mas, estamos a começar a aprender. Assim, para facilitar, por ora não se pede que escreva testes, mas você já deveria ser capaz de os ler, mesmo que sejam um pouco mais complexos que os deste capítulo.
+Escrever testes, requere um bom conhecimento de JavaScript. Mas, estamos a começar a aprender. Deste modo, para facilitar, por ora não se pede que você escreva testes, contudo você já deveria ser capaz de os ler, mesmo que eles sejam um pouco mais complexos que os deste capítulo.
diff --git a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html
index 1670c8a58..93224e823 100644
--- a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,17 +12,17 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
 
 <body>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js
index 08e27c9fd..5c2767f2e 100644
--- a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js
@@ -1,15 +1,16 @@
 describe("teste", function() {
+
   // Mocha, geralmente espera pelos testes por 2 segundos antes de os considerar errados
 
   this.timeout(200000); // Com este código nós aumentamos esse tempo - neste caso, para 200,000 
   
-  // Isto, por causa da função "alert", porque se você se demorar a pressionar o botão "OK" oos testes não irão passar!
-
-  before(() => alert("Testes iniciados – antes de todos os testes"));
-  after(() => alert("Testes terminados – depois de todos os testes"));
+  // Isto, por causa da função "alert", porque se você se demorar a pressionar o botão "OK" os testes não irão passar!
+  
+  before(() => alert("Testes começam – antes de todos os testes"));
+  after(() => alert("Testes terminam – depois de todos os testes"));
 
-  beforeEach(() => alert("antes de um teste – entrando para um teste"));
-  afterEach(() => alert("depois de um teste – saindo de um teste"));
+  beforeEach(() => alert("Antes de um teste – entrando para um teste"));
+  afterEach(() => alert("Depois de um teste – saindo de um teste"));
 
   it('teste 1', () => alert(1));
   it('teste 2', () => alert(2));
diff --git a/1-js/03-code-quality/05-testing-mocha/index.html b/1-js/03-code-quality/05-testing-mocha/index.html
index 1670c8a58..6326c9751 100644
--- a/1-js/03-code-quality/05-testing-mocha/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/index.html
@@ -1,28 +1,33 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // ative o teste no estilo-bdd (bdd-style)
-    mocha.setup('bdd');
+    mocha.setup('bdd'); // setup mínimo
   </script>
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
 
 <body>
 
-  <!-- o código com testes (describe, it...) -->
+  <script>
+    function pow(x, n) {
+      /* código da função a ser escrito, vazio agora */
+    }
+  </script>
+
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html
index c96134b83..d201104a5 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -25,10 +25,10 @@
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
index adbd7a482..611225ee1 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
@@ -1,9 +1,9 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- adicione código da infraestrutura (framework) mochae -->
+  <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
     // ative o teste no estilo-bdd (bdd-style)
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -21,14 +21,14 @@
 
   <script>
     function pow(x, n) {
-      return 8; // :) aldrabámos!
+      return 8; // :) nós fizemos trapaça!
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-2.view/test.js b/1-js/03-code-quality/05-testing-mocha/pow-2.view/test.js
index e75c688d4..d36916796 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-2.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/pow-2.view/test.js
@@ -1,10 +1,10 @@
 describe("pow", function() {
 
-  it("2 elevado à potência 3 é 8", function() {
+  it("2 elevado à potência 3 são 8", function() {
     assert.equal(pow(2, 3), 8);
   });
 
-  it("3 elevado à potência 4 é 81", function() {
+  it("3 elevado à potência 4 são 81", function() {
     assert.equal(pow(3, 4), 81);
   });
 
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html
index 29263c61c..c7db38942 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -31,10 +31,10 @@
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html
index 29263c61c..c7db38942 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -31,10 +31,10 @@
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html
index 9a7ae12ca..6044d0527 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -32,10 +32,10 @@
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html
index 9af5ba188..4f9171d28 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -21,14 +21,14 @@
 
   <script>
     function pow() {
-      return 8; // :) aldrabámos!
+      return 8; // :) nós fizemos trapaça!
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html
index f582f3cde..342c354aa 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- adicione css mocha, para mostrar resultados -->
+  <!-- adicione css mocha, para mostrar os resultados -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
   <!-- adicione código da infraestrutura (framework) mocha -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
@@ -12,7 +12,7 @@
   <!-- adicione chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai possui muitas funcionalidades, façamos um 'assert' global
+    // chai possui muitas funcionalidades, vamos fazer um 'assert' global
     let assert = chai.assert;
   </script>
 </head>
@@ -29,10 +29,10 @@
     }
   </script>
 
-  <!-- o código com testes (describe, it...) -->
+  <!-- o script com os testes (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- o elemento com id="mocha" irá conter resultados dos testes -->
+  <!-- o elemento com id="mocha" irá conter os resultados dos testes -->
   <div id="mocha"></div>
 
   <!-- execute os testes! -->
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js
index 02b18647f..a18e60ed5 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/test.js
@@ -4,7 +4,7 @@ describe("pow", function() {
 
     function makeTest(x) {
       let expected = x * x * x;
-      it(`${x} na potência 3 é ${expected}`, function() {
+      it(`${x} na potência 3 são ${expected}`, function() {
         assert.equal(pow(x, 3), expected);
       });
     }