write first two sections

Author: louisrli

module5-testing/r1-what-is-a-test/README.md

@@ -0,0 +1,20 @@
+# What is a test?
+In programming, a test refers to a piece of code that can be run to verify the
+behavior of a program. For example, if you write a function, and you want to be
+sure that it works for various inputs and outputs, you can write a test for this
+function.
+
+Tests themselves are code. At larger companies, every piece of submitted code
+needs to submitted with a corresponding test. A general rule of thumb is that,
+if you change a line of your code so that the behavior is wrong, a test
+somewhere should fail, so that such a mistake can be caught.
+
+Tests are an important part of many companies' infrastructure for development.
+Generally, humans are not manually running these tests, though you may manually
+run it before sending a PR or while working on the test. In a process called
+**continuous integration** (CI), these tests will automatically run after every
+pull request is proposed. This means that generally, if your code and pull
+request are not passing the tests, it cannot be merged in.
+
+Suppose you had a function called `square(n)`, that is supposed to square a
+number.

module5-testing/r1.1-why-is-testing-important/README.md

@@ -0,0 +1,53 @@
+# Why is testing important?
+
+You may think it is sufficient simply to manually test your code.
+
+There are a few reasons testing is very important when it comes to a growing
+codebase. You should not imagine the situation where you are working on a
+project with one or two people, but a situation where you are working with a
+larger team and with code that the company will use the code long after you leave. You
+may not be at the company five years later, or you may forget what the code does
+in six months.
+
+## Correctness
+Most obviously, a test is used to verify the correctness of the code. If you
+have ever changed your code then had to test three or more cases manually, then
+you are familiar with the fact that it is quite cumbersome to repeatedly check
+manually. Not only that, it's very easy to forget to check some case when a
+human is doing it by hand.
+
+In contract, when you write a test, you simply need to run a command in order to
+initiate the tests again, rather than repeating some steps to ensure that your
+code is working.
+
+If you work at a company with code review, consider the perspective of the
+person reviewing your code: how do they know your code doesn't have bugs? How do
+they know it works correctly? If your code is submitted along with tests, the
+reviewer can be aware of exactly what you have or haven't verified about your
+code.
+
+## Ease of change
+Have you ever
+felt scared to change code, because you weren't sure if it would still work for
+all the cases after you changed it? With a good test suite, this fear generally
+doesn't exist. Even if the code is rewritten but the same tests pass, indicating
+that the new code has the same behavior, one can feel a lot more secure about
+rewriting the code.
+
+Having good tests allows code to be changed in a more robust fashion. When the
+same tests pass, a developer can be more sure (perhaps not completely sure,
+depending on the tests) that changing the code did not break anything.
+Additionally, it allows people who are not familiar with the code (say, your
+teammates who work on related code, or someone who is responsible for your code
+five years later) to more easily work with the code.
+
+## Documentation
+A well-written test suite serves as documentation. Again, imagine you have just
+joined a company, and you don't know what a function or component does. In fact, if you want to
+understand what a piece of code does, it's often more productive to go read the
+tests first, rather than the code itself.
+
+In the next section, we'll look an
+example of a test, which will help illustrate how the tests themselves can be
+used to document the code.
+