From c2889d7e1be1f399d05e6ba5047737890aaa4ed0 Mon Sep 17 00:00:00 2001
From: KaserChan <chankaser@gmail.com>
Date: Sat, 15 Aug 2020 07:16:29 +0800
Subject: [PATCH 1/2] feat: add MustSet function and its test

---
 defaults.go      |  8 ++++++++
 defaults_test.go | 18 ++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/defaults.go b/defaults.go
index 3a825fa..f35adf8 100644
--- a/defaults.go
+++ b/defaults.go
@@ -42,6 +42,14 @@ func Set(ptr interface{}) error {
 	return nil
 }
 
+// MustSet function is a wrapper of Set function
+// It will call Set and panic if err not equals nil.
+func MustSet(ptr interface{}) {
+	if err := Set(ptr); err != nil {
+		panic(err)
+	}
+}
+
 func setField(field reflect.Value, defaultVal string) error {
 	if !field.CanSet() {
 		return nil
diff --git a/defaults_test.go b/defaults_test.go
index 9b4a2d3..aa39d6e 100644
--- a/defaults_test.go
+++ b/defaults_test.go
@@ -142,6 +142,24 @@ type Emmbeded struct {
 	Int int `default:"1"`
 }
 
+func TestMustSet(t *testing.T) {
+	sample := &Sample{
+		NonInitialString:            "string",
+		NonInitialSlice:             []int{1, 2, 3},
+		NonInitialStruct:            Struct{Foo: 123},
+		NonInitialStructPtr:         &Struct{Foo: 123},
+		DeepSliceOfStructsWithNoTag: [][][]Struct{{{{Foo: 123}}}},
+	}
+
+	MustSet(sample)
+	go func() {
+		if err := recover(); err != nil {
+			t.Fatalf("it should not panic error: %v", err)
+		}
+	}()
+	t.Log("it works.")
+}
+
 func TestInit(t *testing.T) {
 	sample := &Sample{
 		NonInitialString:            "string",

From ea4c44f56e34d3c0321e8a3b0e9dbd520e45e939 Mon Sep 17 00:00:00 2001
From: KaserChan <chankaser@gmail.com>
Date: Sat, 15 Aug 2020 07:36:02 +0800
Subject: [PATCH 2/2] test: add some tests for MustSet function

---
 defaults_test.go | 56 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 42 insertions(+), 14 deletions(-)

diff --git a/defaults_test.go b/defaults_test.go
index aa39d6e..c6e2fa5 100644
--- a/defaults_test.go
+++ b/defaults_test.go
@@ -143,21 +143,49 @@ type Emmbeded struct {
 }
 
 func TestMustSet(t *testing.T) {
-	sample := &Sample{
-		NonInitialString:            "string",
-		NonInitialSlice:             []int{1, 2, 3},
-		NonInitialStruct:            Struct{Foo: 123},
-		NonInitialStructPtr:         &Struct{Foo: 123},
-		DeepSliceOfStructsWithNoTag: [][][]Struct{{{{Foo: 123}}}},
-	}
 
-	MustSet(sample)
-	go func() {
-		if err := recover(); err != nil {
-			t.Fatalf("it should not panic error: %v", err)
-		}
-	}()
-	t.Log("it works.")
+	t.Run("right way", func(t *testing.T) {
+		defer func() {
+			if err := recover(); err != nil {
+				t.Fatalf("it should not panic error: %v", err)
+			}
+		}()
+		sample := &Sample{
+			NonInitialString:            "string",
+			NonInitialSlice:             []int{1, 2, 3},
+			NonInitialStruct:            Struct{Foo: 123},
+			NonInitialStructPtr:         &Struct{Foo: 123},
+			DeepSliceOfStructsWithNoTag: [][][]Struct{{{{Foo: 123}}}},
+		}
+		MustSet(sample)
+	})
+
+	t.Run("not struct", func(t *testing.T) {
+		defer func() {
+			if err := recover(); err != nil {
+				t.Logf("panic error: %v", err)
+			}
+		}()
+		var a int
+		MustSet(&a)
+	})
+
+	t.Run("not pointer", func(t *testing.T) {
+		defer func() {
+			if err := recover(); err != nil {
+				t.Logf("panic error: %v", err)
+			}
+		}()
+		sample := Sample{
+			NonInitialString:            "string",
+			NonInitialSlice:             []int{1, 2, 3},
+			NonInitialStruct:            Struct{Foo: 123},
+			NonInitialStructPtr:         &Struct{Foo: 123},
+			DeepSliceOfStructsWithNoTag: [][][]Struct{{{{Foo: 123}}}},
+		}
+		MustSet(sample)
+	})
+
 }
 
 func TestInit(t *testing.T) {