add test case & update README:

Author: manhvu

README.md

@@ -4,9 +4,9 @@
 
 A Golang package for supporting worker supervisor model.
 The package help developer easy to run parallel tasks.
-It's scalable with minimum effort.
+It's scalable with minimal effort.
 
-easyworker package is inspired by Erlang OTP.
+easyworker is inspired by Erlang OTP.
 
 # Design
 
@@ -19,7 +19,7 @@ The package has two main part:
 
 Start workers and monitor workers.
 Send task to workers and get result(for task & stream).
-Restart children if they're failed (depends restart strategy).
+Restart(depends restart strategy) children if they're failed to call user function or panic.
 Supervisor has one goroutine for send & manage signal to children.
 
 ## Child
@@ -32,7 +32,7 @@ Each child has a goroutine to run its task.
 
 easyworker support 3 type of workers:
 
-* Supervisor, Start a supervisor for managing custom workers. Workers can run many type of tasks.
+* Supervisor, Start a supervisor for managing children. Children can run many type of tasks.
 * Task, Add a list of task and run workers. Workers run same type of task.
 * Stream, Start workers then push tasks to workers from channel. Workers run same type of task.
 
@@ -63,8 +63,8 @@ Every children has a owner restart strategy.
 
 Currently, child has three type of restart strategy:
 
-* ALWAYS_RESTART, supervisor always restart children if it panic/done.
-* ERROR_RESTART, supervisor will restart if children was panic.
+* ALWAYS_RESTART, supervisor always restart children if it panic or done task.
+* ERROR_RESTART, supervisor will only restart if children was panic.
 * NO_RESTART, supervisor will don't restart children for any reason.
 
 Children will be started after they are added to supervisor.
@@ -250,14 +250,16 @@ fnStr := func(a int, suffix string) string {
  return fmt.Sprintf("%d_%s", a, suffix)
 }
 
+num := easyworker.DefaultNumWorkers()
+
 // input channel.
-inCh := make(chan []any)
+inCh := make(chan []any, num)
 
 // result channel.
-outCh := make(chan any)
+outCh := make(chan any, num)
 
 // number of workers = number of cpu cores (logical cores).
-config, _ := easyworker.NewConfig(fnStr, easyworker.DefaultNumWorkers(), 3, 1000)
+config, _ := easyworker.NewConfig(fnStr, num, 3, 1000)
 
 // test with stream.
 myStream, _ := easyworker.NewStream(config, inCh, outCh)
@@ -291,15 +293,15 @@ myStream.Stop()
 
 ### Monitor Go
 
-A wrapper for goroutine for easy monitor when goroutine was panic or run task done.
+A wrapper for goroutine for easy to monitor when goroutine was panic or run task done.
 
 `Monitor` function will return two params.
 First param is unique reference id.
 Second param is channel that user can receive signal.
 
 Signal is a struct with reference id and kind of end (failed, done).
 
-Go doesn't support return value, you need an other way to get if you neened.
+If you need get result from last run, please call `GetResult`.
 
 Example 1:
 

caller_test.go

@@ -2,6 +2,7 @@ package easyworker
 
 import (
 	"errors"
+	"fmt"
 	"log"
 	"testing"
 )
@@ -43,7 +44,7 @@ func TestInvokeIncorrectNumArg(t *testing.T) {
 
 func TestInvokeIncorrectNumArg2(t *testing.T) {
 	_, err := invokeFun(simpleLoopWithPanic)
-
+	fmt.Println(err)
 	if err == nil {
 		t.Error("test invoke with incorrect argument failed")
 	}
@@ -67,6 +68,17 @@ func TestInvokePanic(t *testing.T) {
 	}
 }
 
+func TestInvokePanic2(t *testing.T) {
+	printLog = true
+	_, err := invokeFun(simpleLoopWithPanic, 5)
+
+	if err == nil {
+		t.Error("expected error but no return error.")
+	} else {
+		log.Println("expected is ok, err: ", err)
+	}
+}
+
 func TestInvokeReturn(t *testing.T) {
 	result, err := invokeFun(simpleLoopReturn, 5)
 

config_test.go

@@ -65,3 +65,11 @@ func TestIncorrectRetryTime(t *testing.T) {
 		t.Error("incorrect retry time is passed, ", err)
 	}
 }
+
+func TestPrintLog(t *testing.T) {
+	EnableLog(true)
+
+	if !printLog {
+		t.Error("Enable Log failed.")
+	}
+}

gomonitor.go

@@ -187,7 +187,7 @@ func (g *Go) run_task() {
 		if r := recover(); r != nil {
 			msg.Signal = SIGNAL_FAILED
 			if printLog {
-				log.Println(g.id, ", goroutine was panic, ", r)
+				log.Println(g.id, ", Go was panic, ", r)
 			}
 		}
 
@@ -212,7 +212,7 @@ func (g *Go) run_task() {
 	if err != nil {
 		msg.Signal = SIGNAL_FAILED
 		if printLog {
-			log.Println(g.id, "goroutine call user function failed, reason:", err)
+			log.Println(g.id, "Go call user function failed, reason:", err)
 		}
 	}
 }

gomonitor_test.go

@@ -339,6 +339,10 @@ func TestGoStop(t *testing.T) {
 
 	g.Stop()
 
+	if g.State() != STOPPED {
+		t.Error("wrong state")
+	}
+
 	if g.GetResult() != nil {
 		t.Error("not reset result")
 		return

supervisor.go

@@ -137,14 +137,27 @@ func (s *Supervisor) AddChild(child *Child) {
 Remove a child to out of supervisor.
 */
 func (s *Supervisor) RemoveChild(child *Child) {
-	delete(s.children, child.id)
+	if child != nil {
+		if child.getState() == RUNNING {
+			child.stop()
+		}
+
+		delete(s.children, child.id)
+	}
+
 }
 
 /*
 Remove a child to out of supervisor by child id.
 */
 func (s *Supervisor) RemoveChildById(id int64) {
-	delete(s.children, id)
+	if child, existed := s.children[id]; existed {
+		if child.getState() == RUNNING {
+			child.stop()
+		}
+
+		delete(s.children, child.id)
+	}
 }
 
 /*

supervisor_test.go

@@ -213,6 +213,27 @@ func TestSupFunNoArg(t *testing.T) {
 	sup.Stop()
 }
 
+func TestSupRemoveChild(t *testing.T) {
+	sup := NewSupervisor()
+
+	id, _ := sup.NewChild(ALWAYS_RESTART, simpleLoopNoArg)
+	child, _ := NewChild(ALWAYS_RESTART, simpleLoopNoArg)
+	sup.AddChild(child)
+
+	time.Sleep(time.Millisecond)
+
+	sup.RemoveChildById(id)
+	sup.RemoveChild(child)
+
+	total, _, _, _ := sup.Stats()
+
+	if total != 0 {
+		t.Error("remove children failed")
+	}
+
+	sup.Stop()
+}
+
 func TestSupStop(t *testing.T) {
 	ch := make(chan int)
 
@@ -301,6 +322,10 @@ func TestSupContext(t *testing.T) {
 
 	sup.NewChild(NO_RESTART, simpleLoopWithContext, 3)
 
+	child, _ := NewChild(ALWAYS_RESTART, simpleLoopWithContext, 3)
+
+	sup.AddChild(child)
+
 	time.Sleep(time.Millisecond * 100)
 
 	sup.Stop()