From 6ce08710103a81a867a7101625b8ed5d50b360ac Mon Sep 17 00:00:00 2001
From: Xu <1556638868@qq.com>
Date: Wed, 12 Oct 2022 17:16:26 +0800
Subject: [PATCH 1/5] first test xcg

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 64538a65..6003b95e 100644
--- a/readme.md
+++ b/readme.md
@@ -1,6 +1,6 @@
 # 从零开始的 JSON 库教程
 
-* Milo Yip
+* Milo Yip dl
 * 2016/9/15
 
 也许有很多同学上过 C/C++ 的课后，可以完成一些简单的编程练习，又能在一些网站刷题，但对于如何开发有实际用途的程序可能感到束手无策。本教程希望能以一个简单的项目开发形式，让同学能逐步理解如何从无到有去开发软件。

From 97a546b486d072110a593c47aa6933e372eecf61 Mon Sep 17 00:00:00 2001
From: Xu <1556638868@qq.com>
Date: Thu, 13 Oct 2022 11:12:47 +0800
Subject: [PATCH 2/5] my_homework01

---
 tutorial01/leptjson.c | 22 +++++++++++++++++++++-
 tutorial01/test.c     | 18 +++++++++++++++++-
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/tutorial01/leptjson.c b/tutorial01/leptjson.c
index 5299fe1d..d39b546e 100644
--- a/tutorial01/leptjson.c
+++ b/tutorial01/leptjson.c
@@ -6,7 +6,7 @@
 
 typedef struct {
     const char* json;
-}lept_context;
+}lept_context;//Ϊ�˼��ٺ���֮�䴫�ݶ������
 
 static void lept_parse_whitespace(lept_context* c) {
     const char *p = c->json;
@@ -24,9 +24,29 @@ static int lept_parse_null(lept_context* c, lept_value* v) {
     return LEPT_PARSE_OK;
 }
 
+static int lept_parse_true(lept_context* c, lept_value* v) {
+    EXPECT(c, 't');
+    if (c->json[0] != 'r' || c->json[1] != 'u' || c->json[2] != 'e')
+        return LEPT_PARSE_INVALID_VALUE;
+    c->json += 3;
+    v->type = LEPT_TRUE;
+    return LEPT_PARSE_OK;
+}
+
+static int lept_parse_false(lept_context* c, lept_value* v) {
+    EXPECT(c, 'f');
+    if (c->json[0] != 'a' || c->json[1] != 'l' || c->json[2] != 's' || c->json[3] != 'e')
+        return LEPT_PARSE_INVALID_VALUE;
+    c->json += 4;
+    v->type = LEPT_FALSE;
+    return LEPT_PARSE_OK;
+}
+
 static int lept_parse_value(lept_context* c, lept_value* v) {
     switch (*c->json) {
         case 'n':  return lept_parse_null(c, v);
+        case 't':  return lept_parse_true(c, v);
+        case 'f':  return lept_parse_false(c, v);
         case '\0': return LEPT_PARSE_EXPECT_VALUE;
         default:   return LEPT_PARSE_INVALID_VALUE;
     }
diff --git a/tutorial01/test.c b/tutorial01/test.c
index e7672181..ec709f06 100644
--- a/tutorial01/test.c
+++ b/tutorial01/test.c
@@ -27,6 +27,20 @@ static void test_parse_null() {
     EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
 }
 
+static void test_parse_true() {
+    lept_value v;
+    v.type = LEPT_FALSE;
+    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "true"));
+    EXPECT_EQ_INT(LEPT_TRUE, lept_get_type(&v));
+}
+
+static void test_parse_false() {
+    lept_value v;
+    v.type = LEPT_FALSE;
+    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "false"));
+    EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(&v));
+}
+
 static void test_parse_expect_value() {
     lept_value v;
 
@@ -53,12 +67,14 @@ static void test_parse_invalid_value() {
 static void test_parse_root_not_singular() {
     lept_value v;
     v.type = LEPT_FALSE;
-    EXPECT_EQ_INT(LEPT_PARSE_ROOT_NOT_SINGULAR, lept_parse(&v, "null x"));
+    EXPECT_EQ_INT(LEPT_PARSE_ROOT_NOT_SINGULAR, lept_parse(&v, "null x"));//to do:x��Ϊ�����ַ�
     EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
 }
 
 static void test_parse() {
     test_parse_null();
+    test_parse_true();
+    test_parse_false();
     test_parse_expect_value();
     test_parse_invalid_value();
     test_parse_root_not_singular();

From 996de5b2d31ea0339db4cf96fd3e620a4bf7836a Mon Sep 17 00:00:00 2001
From: Xu <1556638868@qq.com>
Date: Fri, 14 Oct 2022 12:11:51 +0800
Subject: [PATCH 3/5] =?UTF-8?q?=E9=9D=9E=E6=B3=95=E6=B5=8B=E8=AF=95?=
 =?UTF-8?q?=E5=90=88=E5=B9=B6=E4=B8=BAtest=5Ferror?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tutorial01/leptjson.c | 12 +++++++++++-
 tutorial01/leptjson.h |  2 +-
 tutorial01/test.c     | 34 +++++++++++++---------------------
 3 files changed, 25 insertions(+), 23 deletions(-)

diff --git a/tutorial01/leptjson.c b/tutorial01/leptjson.c
index d39b546e..9263ae57 100644
--- a/tutorial01/leptjson.c
+++ b/tutorial01/leptjson.c
@@ -42,6 +42,10 @@ static int lept_parse_false(lept_context* c, lept_value* v) {
     return LEPT_PARSE_OK;
 }
 
+static int lept_parse_literal(lept_context* c, lept_value* v) {
+    // to do;
+}
+
 static int lept_parse_value(lept_context* c, lept_value* v) {
     switch (*c->json) {
         case 'n':  return lept_parse_null(c, v);
@@ -54,11 +58,17 @@ static int lept_parse_value(lept_context* c, lept_value* v) {
 
 int lept_parse(lept_value* v, const char* json) {
     lept_context c;
+    int ret;
     assert(v != NULL);
     c.json = json;
     v->type = LEPT_NULL;
     lept_parse_whitespace(&c);
-    return lept_parse_value(&c, v);
+    if ((ret = lept_parse_value(&c, v)) == LEPT_PARSE_OK) {
+        lept_parse_whitespace(&c);
+        if (*c.json != '\0')
+            ret = LEPT_PARSE_ROOT_NOT_SINGULAR;
+    }
+    return ret;
 }
 
 lept_type lept_get_type(const lept_value* v) {
diff --git a/tutorial01/leptjson.h b/tutorial01/leptjson.h
index 9b65d22a..eb7232e9 100644
--- a/tutorial01/leptjson.h
+++ b/tutorial01/leptjson.h
@@ -5,7 +5,7 @@ typedef enum { LEPT_NULL, LEPT_FALSE, LEPT_TRUE, LEPT_NUMBER, LEPT_STRING, LEPT_
 
 typedef struct {
     lept_type type;
-}lept_value;
+}lept_value; //���нڵ�
 
 enum {
     LEPT_PARSE_OK = 0,
diff --git a/tutorial01/test.c b/tutorial01/test.c
index ec709f06..668edf22 100644
--- a/tutorial01/test.c
+++ b/tutorial01/test.c
@@ -41,34 +41,26 @@ static void test_parse_false() {
     EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(&v));
 }
 
-static void test_parse_expect_value() {
-    lept_value v;
-
-    v.type = LEPT_FALSE;
-    EXPECT_EQ_INT(LEPT_PARSE_EXPECT_VALUE, lept_parse(&v, ""));
-    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
+#define TEST_ERROR(error, json)\
+    do {\
+        lept_value v;\
+        v.type = LEPT_FALSE;\
+        EXPECT_EQ_INT(error, lept_parse(&v, json));\
+        EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));\
+    } while (0)
 
-    v.type = LEPT_FALSE;
-    EXPECT_EQ_INT(LEPT_PARSE_EXPECT_VALUE, lept_parse(&v, " "));
-    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
+static void test_parse_expect_value() {
+    TEST_ERROR(LEPT_PARSE_EXPECT_VALUE, "");
+    TEST_ERROR(LEPT_PARSE_EXPECT_VALUE, " ");
 }
 
 static void test_parse_invalid_value() {
-    lept_value v;
-    v.type = LEPT_FALSE;
-    EXPECT_EQ_INT(LEPT_PARSE_INVALID_VALUE, lept_parse(&v, "nul"));
-    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
-
-    v.type = LEPT_FALSE;
-    EXPECT_EQ_INT(LEPT_PARSE_INVALID_VALUE, lept_parse(&v, "?"));
-    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "nul");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "?");
 }
 
 static void test_parse_root_not_singular() {
-    lept_value v;
-    v.type = LEPT_FALSE;
-    EXPECT_EQ_INT(LEPT_PARSE_ROOT_NOT_SINGULAR, lept_parse(&v, "null x"));//to do:x��Ϊ�����ַ�
-    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
+    TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "null x");
 }
 
 static void test_parse() {

From 24a291304feeabdbfbf7dab8bef8524d902cc34d Mon Sep 17 00:00:00 2001
From: Xu <1556638868@qq.com>
Date: Tue, 18 Oct 2022 14:42:56 +0800
Subject: [PATCH 4/5] =?UTF-8?q?=E5=8A=A0=E5=85=A5=E6=95=B0=E5=AD=97?=
 =?UTF-8?q?=E8=A7=A3=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tutorial01/leptjson.c | 20 ++++++++++++++++--
 tutorial01/leptjson.h |  3 +++
 tutorial01/test.c     | 47 +++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 66 insertions(+), 4 deletions(-)

diff --git a/tutorial01/leptjson.c b/tutorial01/leptjson.c
index 9263ae57..58f5c6df 100644
--- a/tutorial01/leptjson.c
+++ b/tutorial01/leptjson.c
@@ -1,6 +1,6 @@
 #include "leptjson.h"
 #include <assert.h>  /* assert() */
-#include <stdlib.h>  /* NULL */
+#include <stdlib.h>  /* NULL, strtod() */
 
 #define EXPECT(c, ch)       do { assert(*c->json == (ch)); c->json++; } while(0)
 
@@ -46,13 +46,24 @@ static int lept_parse_literal(lept_context* c, lept_value* v) {
     // to do;
 }
 
+static int lept_parse_number(lept_context* c, lept_value* v) {
+    char* end;
+    // to do: validate number
+    v->n = strtod(c->json, &end);
+    if (c->json == end) 
+        return LEPT_PARSE_INVALID_VALUE;
+    c->json = end;
+    v->type = LEPT_NUMBER;
+    return LEPT_PARSE_OK;
+}
+
 static int lept_parse_value(lept_context* c, lept_value* v) {
     switch (*c->json) {
         case 'n':  return lept_parse_null(c, v);
         case 't':  return lept_parse_true(c, v);
         case 'f':  return lept_parse_false(c, v);
         case '\0': return LEPT_PARSE_EXPECT_VALUE;
-        default:   return LEPT_PARSE_INVALID_VALUE;
+        default:   return lept_parse_number(c, v);
     }
 }
 
@@ -75,3 +86,8 @@ lept_type lept_get_type(const lept_value* v) {
     assert(v != NULL);
     return v->type;
 }
+
+double lept_get_number(const lept_value* v) {
+    assert(v != NULL && v->type == LEPT_NUMBER);
+    return v->n;
+}
diff --git a/tutorial01/leptjson.h b/tutorial01/leptjson.h
index eb7232e9..75c725cd 100644
--- a/tutorial01/leptjson.h
+++ b/tutorial01/leptjson.h
@@ -4,6 +4,7 @@
 typedef enum { LEPT_NULL, LEPT_FALSE, LEPT_TRUE, LEPT_NUMBER, LEPT_STRING, LEPT_ARRAY, LEPT_OBJECT } lept_type;
 
 typedef struct {
+    double n;
     lept_type type;
 }lept_value; //���нڵ�
 
@@ -18,4 +19,6 @@ int lept_parse(lept_value* v, const char* json);
 
 lept_type lept_get_type(const lept_value* v);
 
+double lept_get_number(const lept_value* v);
+
 #endif /* LEPTJSON_H__ */
diff --git a/tutorial01/test.c b/tutorial01/test.c
index 668edf22..8803d511 100644
--- a/tutorial01/test.c
+++ b/tutorial01/test.c
@@ -19,6 +19,15 @@ static int test_pass = 0;
     } while(0)
 
 #define EXPECT_EQ_INT(expect, actual) EXPECT_EQ_BASE((expect) == (actual), expect, actual, "%d")
+#define EXPECT_EQ_DOUBLE(expect, actual) EXPECT_EQ_BASE((expect) == (actual), expect, actual, "%.17g")
+
+#define TEST_NUMBER(expect, json) \
+    do {\
+        lept_value v;\
+        EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json));\
+        EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(&v));\
+        EXPECT_EQ_DOUBLE(expect, lept_get_number(&v));\
+    } while (0)
 
 static void test_parse_null() {
     lept_value v;
@@ -41,7 +50,7 @@ static void test_parse_false() {
     EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(&v));
 }
 
-#define TEST_ERROR(error, json)\
+#define TEST_ERROR(error, json) \
     do {\
         lept_value v;\
         v.type = LEPT_FALSE;\
@@ -57,16 +66,50 @@ static void test_parse_expect_value() {
 static void test_parse_invalid_value() {
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "nul");
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "?");
+
+#if 0
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+0");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+1");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, ".123");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "1.");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "INF");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "inf");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "NAN");
+    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "nan");
+#endif
 }
 
 static void test_parse_root_not_singular() {
     TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "null x");
 }
 
+static void test_parse_number() {
+    TEST_NUMBER(0.0, "0");
+    TEST_NUMBER(0.0, "-0");
+    TEST_NUMBER(0.0, "-0.0");
+    TEST_NUMBER(1.0, "1");
+    TEST_NUMBER(-1.0, "-1");
+    TEST_NUMBER(1.5, "1.5");
+    TEST_NUMBER(-1.5, "-1.5");
+    TEST_NUMBER(3.1416, "3.1416");
+    TEST_NUMBER(1E10, "1E10");
+    TEST_NUMBER(1e10, "1e10");
+    TEST_NUMBER(1E+10, "1E+10");
+    TEST_NUMBER(1E-10, "1E-10");
+    TEST_NUMBER(-1E10, "-1E10");
+    TEST_NUMBER(-1e10, "-1e10");
+    TEST_NUMBER(-1E+10, "-1E+10");
+    TEST_NUMBER(-1E-10, "-1E-10");
+    TEST_NUMBER(1.234E+10, "1.234E+10");
+    TEST_NUMBER(1.234E-10, "1.234E-10");
+    TEST_NUMBER(0.0, "1e-10000"); /* must underflow */
+}
+
 static void test_parse() {
     test_parse_null();
     test_parse_true();
     test_parse_false();
+    test_parse_number();
     test_parse_expect_value();
     test_parse_invalid_value();
     test_parse_root_not_singular();
@@ -76,4 +119,4 @@ int main() {
     test_parse();
     printf("%d/%d (%3.2f%%) passed\n", test_pass, test_count, test_pass * 100.0 / test_count);
     return main_ret;
-}
+}
\ No newline at end of file

From c62290afa779388701ccb85a5d01cc9097b9f493 Mon Sep 17 00:00:00 2001
From: Xu <1556638868@qq.com>
Date: Fri, 21 Oct 2022 15:24:09 +0800
Subject: [PATCH 5/5] =?UTF-8?q?=E8=A7=A3=E6=9E=90=E5=B9=B6=E9=AA=8C?=
 =?UTF-8?q?=E8=AF=81=E6=95=B0=E5=AD=97=EF=BC=8C=E5=B9=B6=E5=8A=A0=E5=85=A5?=
 =?UTF-8?q?=E6=95=B0=E5=AD=97=E6=B5=8B=E8=AF=95=E5=8D=95=E5=85=83?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tutorial01/leptjson.c | 87 ++++++++++++++++++++++---------------------
 tutorial01/leptjson.h |  3 +-
 tutorial01/test.c     | 23 +++++++++++-
 3 files changed, 69 insertions(+), 44 deletions(-)

diff --git a/tutorial01/leptjson.c b/tutorial01/leptjson.c
index 58f5c6df..7a3a361a 100644
--- a/tutorial01/leptjson.c
+++ b/tutorial01/leptjson.c
@@ -1,8 +1,12 @@
 #include "leptjson.h"
-#include <assert.h>  /* assert() */
-#include <stdlib.h>  /* NULL, strtod() */
+#include <assert.h>     /* assert() */
+#include <stdlib.h>     /* NULL, strtod() */
+#include <errno.h>      /* errno, ERANGE */
+#include <math.h>       /* HUGE_VAL */
 
 #define EXPECT(c, ch)       do { assert(*c->json == (ch)); c->json++; } while(0)
+#define ISDIGIT(ch)         ((ch) >= '0' && (ch) <= '9')
+#define ISDIGIT1TO9(ch)     ((ch) >= '1' && (ch) <= '9')
 
 typedef struct {
     const char* json;
@@ -15,55 +19,52 @@ static void lept_parse_whitespace(lept_context* c) {
     c->json = p;
 }
 
-static int lept_parse_null(lept_context* c, lept_value* v) {
-    EXPECT(c, 'n');
-    if (c->json[0] != 'u' || c->json[1] != 'l' || c->json[2] != 'l')
-        return LEPT_PARSE_INVALID_VALUE;
-    c->json += 3;
-    v->type = LEPT_NULL;
-    return LEPT_PARSE_OK;
-}
-
-static int lept_parse_true(lept_context* c, lept_value* v) {
-    EXPECT(c, 't');
-    if (c->json[0] != 'r' || c->json[1] != 'u' || c->json[2] != 'e')
-        return LEPT_PARSE_INVALID_VALUE;
-    c->json += 3;
-    v->type = LEPT_TRUE;
+static int lept_parse_literal(lept_context* c, lept_value* v, const char* literal, lept_type type) {
+    size_t i;
+    EXPECT(c, literal[0]);
+    for (i = 0; literal[i + 1]; i++)
+        if (c->json[i] != literal[i + 1])
+            return LEPT_PARSE_INVALID_VALUE;
+    c->json += i;
+    v->type = type;
     return LEPT_PARSE_OK;
 }
 
-static int lept_parse_false(lept_context* c, lept_value* v) {
-    EXPECT(c, 'f');
-    if (c->json[0] != 'a' || c->json[1] != 'l' || c->json[2] != 's' || c->json[3] != 'e')
-        return LEPT_PARSE_INVALID_VALUE;
-    c->json += 4;
-    v->type = LEPT_FALSE;
-    return LEPT_PARSE_OK;
-}
-
-static int lept_parse_literal(lept_context* c, lept_value* v) {
-    // to do;
-}
-
 static int lept_parse_number(lept_context* c, lept_value* v) {
-    char* end;
-    // to do: validate number
-    v->n = strtod(c->json, &end);
-    if (c->json == end) 
-        return LEPT_PARSE_INVALID_VALUE;
-    c->json = end;
+    const char* p = c->json;
+    if (*p == '-') p++;
+    if (*p == '0') p++;
+    else {
+        if (!ISDIGIT1TO9(*p)) return LEPT_PARSE_INVALID_VALUE;
+        for (p++; ISDIGIT(*p); p++);
+    }
+    if (*p == '.') {
+        p++;
+        if (!ISDIGIT(*p)) return LEPT_PARSE_INVALID_VALUE;
+        for (p++; ISDIGIT(*p); p++);
+    }
+    if (*p == 'e' || *p == 'E') {
+        p++;
+        if (*p == '+' || *p == '-') p++;
+        if (!ISDIGIT(*p)) return LEPT_PARSE_INVALID_VALUE;
+        for (p++; ISDIGIT(*p); p++);
+    }
+    errno = 0;
+    v->n = strtod(c->json, NULL);
+    if (errno = ERANGE && (v->n == HUGE_VAL || v->n == -HUGE_VAL))
+        return LEPT_PARSE_NUMBER_TOO_BIG;
     v->type = LEPT_NUMBER;
+    c->json = p;
     return LEPT_PARSE_OK;
 }
 
 static int lept_parse_value(lept_context* c, lept_value* v) {
     switch (*c->json) {
-        case 'n':  return lept_parse_null(c, v);
-        case 't':  return lept_parse_true(c, v);
-        case 'f':  return lept_parse_false(c, v);
-        case '\0': return LEPT_PARSE_EXPECT_VALUE;
-        default:   return lept_parse_number(c, v);
+        case 't':   return lept_parse_literal(c, v, "true", LEPT_TRUE);
+        case 'f':   return lept_parse_literal(c, v, "false", LEPT_FALSE);
+        case 'n':   return lept_parse_literal(c, v, "null", LEPT_NULL);
+        case '\0':  return LEPT_PARSE_EXPECT_VALUE;
+        default:    return lept_parse_number(c, v);
     }
 }
 
@@ -76,8 +77,10 @@ int lept_parse(lept_value* v, const char* json) {
     lept_parse_whitespace(&c);
     if ((ret = lept_parse_value(&c, v)) == LEPT_PARSE_OK) {
         lept_parse_whitespace(&c);
-        if (*c.json != '\0')
+        if (*c.json != '\0') {
+            v->type = LEPT_NULL;
             ret = LEPT_PARSE_ROOT_NOT_SINGULAR;
+        }
     }
     return ret;
 }
diff --git a/tutorial01/leptjson.h b/tutorial01/leptjson.h
index 75c725cd..6af790a7 100644
--- a/tutorial01/leptjson.h
+++ b/tutorial01/leptjson.h
@@ -12,7 +12,8 @@ enum {
     LEPT_PARSE_OK = 0,
     LEPT_PARSE_EXPECT_VALUE,
     LEPT_PARSE_INVALID_VALUE,
-    LEPT_PARSE_ROOT_NOT_SINGULAR
+    LEPT_PARSE_ROOT_NOT_SINGULAR,
+    LEPT_PARSE_NUMBER_TOO_BIG
 };
 
 int lept_parse(lept_value* v, const char* json);
diff --git a/tutorial01/test.c b/tutorial01/test.c
index 8803d511..f166d6d4 100644
--- a/tutorial01/test.c
+++ b/tutorial01/test.c
@@ -67,7 +67,7 @@ static void test_parse_invalid_value() {
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "nul");
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "?");
 
-#if 0
+#if 1
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+0");
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+1");
     TEST_ERROR(LEPT_PARSE_INVALID_VALUE, ".123");
@@ -81,6 +81,16 @@ static void test_parse_invalid_value() {
 
 static void test_parse_root_not_singular() {
     TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "null x");
+
+    /* invalid number */
+    TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0123"); /* after zero should be '.' or nothing */
+    TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0x0");
+    TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0x123");
+}
+
+static void test_parse_number_too_big() {
+    TEST_ERROR(LEPT_PARSE_NUMBER_TOO_BIG, "1e309");
+    TEST_ERROR(LEPT_PARSE_NUMBER_TOO_BIG, "-1e309");
 }
 
 static void test_parse_number() {
@@ -103,6 +113,16 @@ static void test_parse_number() {
     TEST_NUMBER(1.234E+10, "1.234E+10");
     TEST_NUMBER(1.234E-10, "1.234E-10");
     TEST_NUMBER(0.0, "1e-10000"); /* must underflow */
+
+    TEST_NUMBER(1.0000000000000002, "1.0000000000000002"); /* the smallest number > 1 */
+    TEST_NUMBER(4.9406564584124654e-324, "4.9406564584124654e-324"); /* minimum denormal */
+    TEST_NUMBER(-4.9406564584124654e-324, "-4.9406564584124654e-324");
+    TEST_NUMBER(2.2250738585072009e-308, "2.2250738585072009e-308");  /* Max subnormal double */
+    TEST_NUMBER(-2.2250738585072009e-308, "-2.2250738585072009e-308");
+    TEST_NUMBER(2.2250738585072014e-308, "2.2250738585072014e-308");  /* Min normal positive double */
+    TEST_NUMBER(-2.2250738585072014e-308, "-2.2250738585072014e-308");
+    TEST_NUMBER(1.7976931348623157e+308, "1.7976931348623157e+308");  /* Max double */
+    TEST_NUMBER(-1.7976931348623157e+308, "-1.7976931348623157e+308");
 }
 
 static void test_parse() {
@@ -113,6 +133,7 @@ static void test_parse() {
     test_parse_expect_value();
     test_parse_invalid_value();
     test_parse_root_not_singular();
+    test_parse_number_too_big();
 }
 
 int main() {