update doc

Author: sunxfancy

Readme.en.md

@@ -8,7 +8,7 @@ Hope you get 0 errors and 0 warnings everyday!
 ![](./docs/fig/zeroerr.jpg)
 
 
-ZeroErr is a smart assert library, a lightweight unit test framework and a quick logging framework. It integrates those features and provided an unite and clear interface for seperate using or joint using. 
+ZeroErr is a smart assertion library, a lightweight unit testing framework and a structure logging framework. It integrates those features and provided an unite and clear interface for seperate using or joint using. 
 
 [English Documentation](https://sunxfancy.github.io/zeroerr/en/) | [项目文档](https://sunxfancy.github.io/zeroerr/zh/)
 
@@ -96,7 +96,7 @@ This functin `PrintExt` will match all the class who's base class is `Value` and
 
 ### 2. Joint using of assert, log and unit testing
 
-If you use a logger, an unit testing framework and a smart assert libary, you can joint use them and some macros may conflict. In `zeroerr`, if an assertion is failed, the logger will recevie an event and stored in your log file. If you are using an assertion in unit testing, the assertion can be recorded and reported in the end. 
+If you use one logging framework, an unit testing framework and a smart assertion libary, you can not easily combine them together. In `zeroerr`, if an assertion is failed, the logger will recevie an event and stored the event in your log file. If you are using an assertion in unit testing, the assertion failure, logged fatal events can be recorded and reported.
 
 ```c++
 int fib(int n) {
@@ -121,12 +121,12 @@ TEST_CASE("fib function test") {
 
 ![joint1](docs/fig/joint1.png)
 
-Further more, the unit testing can check the log result matches the previous running result to avoid writing code to check it.
+Further more, the unit testing can check the logged result if it matches the previous running result (a golden file) to avoid writing any code in the test case.
 
 ```c++
 TEST_CASE("match ostream") {
     // match output can be done in the following workflow
-    // 1. user mark the test case which are comparing output use 'have_same_output'
+    // 1. user mark the test case which are comparing output use 'ZEROERR_HAVE_SAME_OUTPUT'
     // 2. If the output is not exist, the result has been used as a correct verifier.
     // 3. If the output is exist, compare with it and report error if output is not match.
     std::cerr << "a = 100" << std::endl;
@@ -137,7 +137,6 @@ TEST_CASE("match ostream") {
 
 Once you set `ZEROERR_HAVE_SAME_OUTPUT` marco, the system will check the output stream and save the first run result into a file. Then, the next run will compare the result to see if it the same. (Currently experimental)
 
-
 Finally, for the log system, the unit testing can access the log data to ensure that the function has executed the expected logic and results.
 
 ```c++
@@ -159,16 +158,40 @@ TEST_CASE("access log in Test case") {
 
 In order to access the log, we need to pause the log system first, to avoid the data being output to the file, then call the function, access the data in the log through the `LOG_GET` macro, and finally resume the log system. (Currently experimental, only the first call of each log point can be accessed)
 
+## 3. Fuzzing Support
+
+Most Unit Testing frameworks do not support fuzzing. However, it's a powerful feature to automatically detect faults in the software and can greatly reduce the work to write test cases.
+
+Different than other fuzzing framework, `zeroerr` can also support logging and assertion in the code, so the fuzzing result not only contains corpus but also with the logging and assertion information.
+
+Here is an example of using `zeroerr` to do structured fuzzing:
+
+```c++
+FUZZ_TEST_CASE("fuzz_test") {
+    LOG("Run fuzz_test");
+    FUZZ_FUNC([=](int k, std::string num) {
+        int t = atoi(num.c_str());
+        LOG("k: {k}, num:{num}, t: {t}", k, num, t);
+        REQUIRE(k == t);
+    })
+        .WithDomains(InRange<int>(0, 10), Arbitrary<std::string>())
+        .WithSeeds({{5, "Foo"}, {10, "Bar"}})
+        .Run(10);
+}
+```
+
+Inspired by [fuzztest](https://github.com/google/fuzztest), Domain is a concept to specify the input data range (or patterns) for the target function. Here, we use `InRange` to specify the range of `k` is 0 to 10, and `Arbitrary` to specify the data of `num` can be any random string. Then, we use `WithSeeds` to specify the initial seeds for the fuzzing. 
+
+The macro `FUZZ_TEST_CASE` will generate a test case which can connect with `libFuzzer` to run the fuzzing. Finally, we use `Run(10)` to call `libFuzzer` to run the target for 10 times.
 
 
-## Features
+## Other Good Features
 
 
-Using ZeroErr, you can catch your assert error, log fatal event in the unit testing.
-The fatal condition will be recorded and printed. Here are a list of features we provided:
+Here are a list of features we provided:
 
-1. Minimal Requirement
-You can only include what you need. If you need assert but no unit testing, no problem.
+1. Partially include
+You can only include what you need. If you need only assertion but no unit testing, no problem.
 
 2. Optional thread safety 
 You can choose to build with/without thread safety. For some simple single thread program, log is no need to be multithread safed.
@@ -177,15 +200,15 @@ You can choose to build with/without thread safety. For some simple single threa
 Using a lock-free queue for logging and multiple level of log writing policies. You can choose to only write to disk with the most important events.
 
 4. Customized print / log / assert printing format
-You can customize your printing format for everything. There is a callback function for the printing.
+You can customize your printing format for everything. There is a templated callback function for the printing.
 
 5. Quickly debug something
-You can use dbg macro to quickly see the output, it can print the expression also.
+You can use dbg macro to quickly see the output, it can be applied to any expression.
 
 6. Colorful output
-You can have default colorful output to terminal and no color for file 
+You can have default colorful output to terminal and no color for file output
 
-7. Print struct/stl/special library data structure
+7. Print struct/stl/pointers without any extra code
 
 8. Doctest like assertion and unit test feature
 You can use your unit test as a documentation of function behavior. The output of unittest can be a documented report.
@@ -197,10 +220,10 @@ After assertion failed, the logging result will print automatically even if you
 Logging information can have customized category and only display one categroy based on your assertion or configuration
 
 11. Logging for Unit Testing
-You can use a correct logging result as your unit testing comparsion. So you just need to manually verify your log once and setup it as baseline comparsion. The unit testing framework will use that as the result to verify unit testing
+You can use a correct logging result as your unit testing golden file. So you just need to manually verify your log once and save it. The unit testing framework will use the golden file to verify your unit testing result.
 
 12. Structured Logging
-We can support output structured information directly into plain text, json, logfmt, or other custom format
+We can support output structured information directly into plain text or lisp format (json, logfmt, or other custom format should be the next step to support)
 
 13. Automatic Tracing with logging
 While logging at the end, we can record the time consuming for this function.