github.com/xg0n/routine@v0.0.0-20240119033701-c364deb94aee/api_routine_test.go (about)

     1  package routine
     2  
     3  import (
     4  	"io"
     5  	"os"
     6  	"path"
     7  	"strconv"
     8  	"strings"
     9  	"sync"
    10  	"testing"
    11  	"time"
    12  
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  func TestRunnable(t *testing.T) {
    17  	count := 0
    18  	var runnable Runnable = func() {
    19  		count++
    20  	}
    21  	runnable()
    22  	assert.Equal(t, 1, count)
    23  	//
    24  	var fun func() = runnable
    25  	fun()
    26  	assert.Equal(t, 2, count)
    27  }
    28  
    29  func TestCallable(t *testing.T) {
    30  	var callable Callable[string] = func() string {
    31  		return "Hello"
    32  	}
    33  	assert.Equal(t, "Hello", callable())
    34  	//
    35  	var fun func() string = callable
    36  	assert.Equal(t, "Hello", fun())
    37  }
    38  
    39  func TestCancelRunnable(t *testing.T) {
    40  	count := 0
    41  	var cancelRunnable CancelRunnable = func(token CancelToken) {
    42  		count++
    43  	}
    44  	cancelRunnable(nil)
    45  	assert.Equal(t, 1, count)
    46  	//
    47  	var fun func(CancelToken) = cancelRunnable
    48  	fun(nil)
    49  	assert.Equal(t, 2, count)
    50  }
    51  
    52  func TestCancelCallable(t *testing.T) {
    53  	var cancelCallable CancelCallable[string] = func(token CancelToken) string {
    54  		return "Hello"
    55  	}
    56  	assert.Equal(t, "Hello", cancelCallable(nil))
    57  	//
    58  	var fun func(CancelToken) string = cancelCallable
    59  	assert.Equal(t, "Hello", fun(nil))
    60  }
    61  
    62  func TestWrapTask_NoContext(t *testing.T) {
    63  	run := false
    64  	wrappedRun := false
    65  	wg := &sync.WaitGroup{}
    66  	wg.Add(1)
    67  	tls := NewThreadLocal[string]()
    68  	tlsInherit := NewInheritableThreadLocal[string]()
    69  	tls.Set("hello")
    70  	tlsInherit.Set("inherit hello")
    71  	assert.Equal(t, "hello", tls.Get())
    72  	assert.Equal(t, "inherit hello", tlsInherit.Get())
    73  	task := WrapTask(func() {
    74  		assert.Equal(t, "", tls.Get())
    75  		assert.Equal(t, "inherit hello", tlsInherit.Get())
    76  		tls.Set("世界")
    77  		tlsInherit.Set("inherit 世界")
    78  		assert.Equal(t, "世界", tls.Get())
    79  		assert.Equal(t, "inherit 世界", tlsInherit.Get())
    80  		wrappedRun = true
    81  	})
    82  	tls.Set("world")
    83  	tlsInherit.Set("inherit world")
    84  	assert.Equal(t, "world", tls.Get())
    85  	assert.Equal(t, "inherit world", tlsInherit.Get())
    86  	go func() {
    87  		task.Run()
    88  		assert.Equal(t, "", tls.Get())
    89  		assert.Equal(t, "", tlsInherit.Get())
    90  		run = true
    91  		wg.Done()
    92  	}()
    93  	assert.Equal(t, "world", tls.Get())
    94  	assert.Equal(t, "inherit world", tlsInherit.Get())
    95  	wg.Wait()
    96  	assert.True(t, wrappedRun)
    97  	assert.True(t, run)
    98  }
    99  
   100  func TestWrapTask_HasContext(t *testing.T) {
   101  	run := false
   102  	wrappedRun := false
   103  	wg := &sync.WaitGroup{}
   104  	wg.Add(1)
   105  	tls := NewThreadLocal[string]()
   106  	tlsInherit := NewInheritableThreadLocal[string]()
   107  	tls.Set("hello")
   108  	tlsInherit.Set("inherit hello")
   109  	assert.Equal(t, "hello", tls.Get())
   110  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   111  	task := WrapTask(func() {
   112  		assert.Equal(t, "", tls.Get())
   113  		assert.Equal(t, "inherit hello", tlsInherit.Get())
   114  		tls.Set("世界")
   115  		tlsInherit.Set("inherit 世界")
   116  		assert.Equal(t, "世界", tls.Get())
   117  		assert.Equal(t, "inherit 世界", tlsInherit.Get())
   118  		wrappedRun = true
   119  	})
   120  	tls.Set("world")
   121  	tlsInherit.Set("inherit world")
   122  	assert.Equal(t, "world", tls.Get())
   123  	assert.Equal(t, "inherit world", tlsInherit.Get())
   124  	go func() {
   125  		tls.Set("你好")
   126  		tlsInherit.Set("inherit 你好")
   127  		task.Run()
   128  		assert.Equal(t, "你好", tls.Get())
   129  		assert.Equal(t, "inherit 你好", tlsInherit.Get())
   130  		run = true
   131  		wg.Done()
   132  	}()
   133  	assert.Equal(t, "world", tls.Get())
   134  	assert.Equal(t, "inherit world", tlsInherit.Get())
   135  	wg.Wait()
   136  	assert.True(t, wrappedRun)
   137  	assert.True(t, run)
   138  }
   139  
   140  func TestWrapTask_Complete_ThenFail(t *testing.T) {
   141  	newStdout, oldStdout := captureStdout()
   142  	defer restoreStdout(newStdout, oldStdout)
   143  	//
   144  	run := false
   145  	wg := &sync.WaitGroup{}
   146  	wg.Add(1)
   147  	wg2 := &sync.WaitGroup{}
   148  	wg2.Add(1)
   149  	wg3 := &sync.WaitGroup{}
   150  	wg3.Add(1)
   151  	task := WrapTask(func() {
   152  		wg.Done()  //1
   153  		wg2.Wait() //4
   154  		run = true
   155  		wg3.Done() //5
   156  		panic(1)
   157  	})
   158  	go task.Run()
   159  	wg.Wait() //2
   160  	task.Complete(nil)
   161  	assert.Nil(t, task.Get())
   162  	wg2.Done() //3
   163  	wg3.Wait() //6
   164  	assert.True(t, task.IsDone())
   165  	assert.False(t, task.IsFailed())
   166  	assert.False(t, task.IsCanceled())
   167  	assert.True(t, run)
   168  	//
   169  	time.Sleep(10 * time.Millisecond)
   170  	output := readAll(newStdout)
   171  	assert.Equal(t, "", output)
   172  }
   173  
   174  func TestWrapWaitTask_NoContext(t *testing.T) {
   175  	run := false
   176  	wrappedRun := false
   177  	wg := &sync.WaitGroup{}
   178  	wg.Add(1)
   179  	tls := NewThreadLocal[string]()
   180  	tlsInherit := NewInheritableThreadLocal[string]()
   181  	tls.Set("hello")
   182  	tlsInherit.Set("inherit hello")
   183  	assert.Equal(t, "hello", tls.Get())
   184  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   185  	task := WrapWaitTask(func(token CancelToken) {
   186  		assert.Equal(t, "", tls.Get())
   187  		assert.Equal(t, "inherit hello", tlsInherit.Get())
   188  		tls.Set("世界")
   189  		tlsInherit.Set("inherit 世界")
   190  		assert.Equal(t, "世界", tls.Get())
   191  		assert.Equal(t, "inherit 世界", tlsInherit.Get())
   192  		wrappedRun = true
   193  	})
   194  	tls.Set("world")
   195  	tlsInherit.Set("inherit world")
   196  	assert.Equal(t, "world", tls.Get())
   197  	assert.Equal(t, "inherit world", tlsInherit.Get())
   198  	go func() {
   199  		task.Run()
   200  		assert.Equal(t, "", tls.Get())
   201  		assert.Equal(t, "", tlsInherit.Get())
   202  		run = true
   203  		wg.Done()
   204  	}()
   205  	assert.Equal(t, "world", tls.Get())
   206  	assert.Equal(t, "inherit world", tlsInherit.Get())
   207  	assert.Nil(t, task.Get())
   208  	assert.True(t, wrappedRun)
   209  	wg.Wait()
   210  	assert.True(t, wrappedRun)
   211  	assert.True(t, run)
   212  }
   213  
   214  func TestWrapWaitTask_NoContext_Cancel(t *testing.T) {
   215  	run := false
   216  	wrappedRun := false
   217  	wg := &sync.WaitGroup{}
   218  	wg.Add(1)
   219  	tls := NewThreadLocal[string]()
   220  	tlsInherit := NewInheritableThreadLocal[string]()
   221  	tls.Set("hello")
   222  	tlsInherit.Set("inherit hello")
   223  	assert.Equal(t, "hello", tls.Get())
   224  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   225  	task := WrapWaitTask(func(token CancelToken) {
   226  		for i := 0; i < 1000; i++ {
   227  			if token.IsCanceled() {
   228  				return
   229  			}
   230  			time.Sleep(1 * time.Millisecond)
   231  		}
   232  		wrappedRun = true
   233  	})
   234  	tls.Set("world")
   235  	tlsInherit.Set("inherit world")
   236  	assert.Equal(t, "world", tls.Get())
   237  	assert.Equal(t, "inherit world", tlsInherit.Get())
   238  	go func() {
   239  		task.Run()
   240  		assert.Equal(t, "", tls.Get())
   241  		assert.Equal(t, "", tlsInherit.Get())
   242  		run = true
   243  		wg.Done()
   244  	}()
   245  	assert.Equal(t, "world", tls.Get())
   246  	assert.Equal(t, "inherit world", tlsInherit.Get())
   247  	task.Cancel()
   248  	assert.True(t, task.IsCanceled())
   249  	assert.Panics(t, func() {
   250  		task.Get()
   251  	})
   252  	assert.False(t, wrappedRun)
   253  	wg.Wait()
   254  	assert.False(t, wrappedRun)
   255  	assert.True(t, run)
   256  }
   257  
   258  func TestWrapWaitTask_HasContext(t *testing.T) {
   259  	run := false
   260  	wrappedRun := false
   261  	wg := &sync.WaitGroup{}
   262  	wg.Add(1)
   263  	tls := NewThreadLocal[string]()
   264  	tlsInherit := NewInheritableThreadLocal[string]()
   265  	tls.Set("hello")
   266  	tlsInherit.Set("inherit hello")
   267  	assert.Equal(t, "hello", tls.Get())
   268  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   269  	task := WrapWaitTask(func(token CancelToken) {
   270  		assert.Equal(t, "", tls.Get())
   271  		assert.Equal(t, "inherit hello", tlsInherit.Get())
   272  		tls.Set("世界")
   273  		tlsInherit.Set("inherit 世界")
   274  		assert.Equal(t, "世界", tls.Get())
   275  		assert.Equal(t, "inherit 世界", tlsInherit.Get())
   276  		wrappedRun = true
   277  	})
   278  	tls.Set("world")
   279  	tlsInherit.Set("inherit world")
   280  	assert.Equal(t, "world", tls.Get())
   281  	assert.Equal(t, "inherit world", tlsInherit.Get())
   282  	go func() {
   283  		tls.Set("你好")
   284  		tlsInherit.Set("inherit 你好")
   285  		task.Run()
   286  		assert.Equal(t, "你好", tls.Get())
   287  		assert.Equal(t, "inherit 你好", tlsInherit.Get())
   288  		run = true
   289  		wg.Done()
   290  	}()
   291  	assert.Equal(t, "world", tls.Get())
   292  	assert.Equal(t, "inherit world", tlsInherit.Get())
   293  	assert.Nil(t, task.Get())
   294  	assert.True(t, wrappedRun)
   295  	wg.Wait()
   296  	assert.True(t, wrappedRun)
   297  	assert.True(t, run)
   298  }
   299  
   300  func TestWrapWaitTask_HasContext_Cancel(t *testing.T) {
   301  	run := false
   302  	wrappedRun := false
   303  	wg := &sync.WaitGroup{}
   304  	wg.Add(1)
   305  	tls := NewThreadLocal[string]()
   306  	tlsInherit := NewInheritableThreadLocal[string]()
   307  	tls.Set("hello")
   308  	tlsInherit.Set("inherit hello")
   309  	assert.Equal(t, "hello", tls.Get())
   310  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   311  	task := WrapWaitTask(func(token CancelToken) {
   312  		for i := 0; i < 1000; i++ {
   313  			if token.IsCanceled() {
   314  				return
   315  			}
   316  			time.Sleep(1 * time.Millisecond)
   317  		}
   318  		wrappedRun = true
   319  	})
   320  	tls.Set("world")
   321  	tlsInherit.Set("inherit world")
   322  	assert.Equal(t, "world", tls.Get())
   323  	assert.Equal(t, "inherit world", tlsInherit.Get())
   324  	go func() {
   325  		tls.Set("你好")
   326  		tlsInherit.Set("inherit 你好")
   327  		task.Run()
   328  		assert.Equal(t, "你好", tls.Get())
   329  		assert.Equal(t, "inherit 你好", tlsInherit.Get())
   330  		run = true
   331  		wg.Done()
   332  	}()
   333  	assert.Equal(t, "world", tls.Get())
   334  	assert.Equal(t, "inherit world", tlsInherit.Get())
   335  	task.Cancel()
   336  	assert.True(t, task.IsCanceled())
   337  	assert.Panics(t, func() {
   338  		task.Get()
   339  	})
   340  	assert.False(t, wrappedRun)
   341  	wg.Wait()
   342  	assert.False(t, wrappedRun)
   343  	assert.True(t, run)
   344  }
   345  
   346  func TestWrapWaitTask_Complete_ThenFail(t *testing.T) {
   347  	newStdout, oldStdout := captureStdout()
   348  	defer restoreStdout(newStdout, oldStdout)
   349  	//
   350  	run := false
   351  	wg := &sync.WaitGroup{}
   352  	wg.Add(1)
   353  	wg2 := &sync.WaitGroup{}
   354  	wg2.Add(1)
   355  	wg3 := &sync.WaitGroup{}
   356  	wg3.Add(1)
   357  	task := WrapWaitTask(func(token CancelToken) {
   358  		wg.Done()  //1
   359  		wg2.Wait() //4
   360  		run = true
   361  		wg3.Done() //5
   362  		panic(1)
   363  	})
   364  	go task.Run()
   365  	wg.Wait() //2
   366  	task.Complete(nil)
   367  	assert.Nil(t, task.Get())
   368  	wg2.Done() //3
   369  	wg3.Wait() //6
   370  	assert.True(t, task.IsDone())
   371  	assert.False(t, task.IsFailed())
   372  	assert.False(t, task.IsCanceled())
   373  	assert.True(t, run)
   374  	//
   375  	time.Sleep(10 * time.Millisecond)
   376  	output := readAll(newStdout)
   377  	assert.Equal(t, "", output)
   378  }
   379  
   380  func TestWrapWaitResultTask_NoContext(t *testing.T) {
   381  	run := false
   382  	wrappedRun := false
   383  	wg := &sync.WaitGroup{}
   384  	wg.Add(1)
   385  	tls := NewThreadLocal[string]()
   386  	tlsInherit := NewInheritableThreadLocal[string]()
   387  	tls.Set("hello")
   388  	tlsInherit.Set("inherit hello")
   389  	assert.Equal(t, "hello", tls.Get())
   390  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   391  	task := WrapWaitResultTask(func(token CancelToken) any {
   392  		assert.Equal(t, "", tls.Get())
   393  		assert.Equal(t, "inherit hello", tlsInherit.Get())
   394  		tls.Set("世界")
   395  		tlsInherit.Set("inherit 世界")
   396  		assert.Equal(t, "世界", tls.Get())
   397  		assert.Equal(t, "inherit 世界", tlsInherit.Get())
   398  		wrappedRun = true
   399  		return 1
   400  	})
   401  	tls.Set("world")
   402  	tlsInherit.Set("inherit world")
   403  	assert.Equal(t, "world", tls.Get())
   404  	assert.Equal(t, "inherit world", tlsInherit.Get())
   405  	go func() {
   406  		task.Run()
   407  		assert.Equal(t, "", tls.Get())
   408  		assert.Equal(t, "", tlsInherit.Get())
   409  		run = true
   410  		wg.Done()
   411  	}()
   412  	assert.Equal(t, "world", tls.Get())
   413  	assert.Equal(t, "inherit world", tlsInherit.Get())
   414  	assert.Equal(t, 1, task.Get())
   415  	assert.True(t, wrappedRun)
   416  	wg.Wait()
   417  	assert.True(t, wrappedRun)
   418  	assert.True(t, run)
   419  }
   420  
   421  func TestWrapWaitResultTask_NoContext_Cancel(t *testing.T) {
   422  	run := false
   423  	wrappedRun := false
   424  	wg := &sync.WaitGroup{}
   425  	wg.Add(1)
   426  	tls := NewThreadLocal[string]()
   427  	tlsInherit := NewInheritableThreadLocal[string]()
   428  	tls.Set("hello")
   429  	tlsInherit.Set("inherit hello")
   430  	assert.Equal(t, "hello", tls.Get())
   431  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   432  	task := WrapWaitResultTask(func(token CancelToken) any {
   433  		for i := 0; i < 1000; i++ {
   434  			if token.IsCanceled() {
   435  				return 0
   436  			}
   437  			time.Sleep(1 * time.Millisecond)
   438  		}
   439  		wrappedRun = true
   440  		return 1
   441  	})
   442  	tls.Set("world")
   443  	tlsInherit.Set("inherit world")
   444  	assert.Equal(t, "world", tls.Get())
   445  	assert.Equal(t, "inherit world", tlsInherit.Get())
   446  	go func() {
   447  		task.Run()
   448  		assert.Equal(t, "", tls.Get())
   449  		assert.Equal(t, "", tlsInherit.Get())
   450  		run = true
   451  		wg.Done()
   452  	}()
   453  	assert.Equal(t, "world", tls.Get())
   454  	assert.Equal(t, "inherit world", tlsInherit.Get())
   455  	task.Cancel()
   456  	assert.True(t, task.IsCanceled())
   457  	assert.Panics(t, func() {
   458  		task.Get()
   459  	})
   460  	assert.False(t, wrappedRun)
   461  	wg.Wait()
   462  	assert.False(t, wrappedRun)
   463  	assert.True(t, run)
   464  }
   465  
   466  func TestWrapWaitResultTask_HasContext(t *testing.T) {
   467  	run := false
   468  	wrappedRun := false
   469  	wg := &sync.WaitGroup{}
   470  	wg.Add(1)
   471  	tls := NewThreadLocal[string]()
   472  	tlsInherit := NewInheritableThreadLocal[string]()
   473  	tls.Set("hello")
   474  	tlsInherit.Set("inherit hello")
   475  	assert.Equal(t, "hello", tls.Get())
   476  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   477  	task := WrapWaitResultTask(func(token CancelToken) any {
   478  		assert.Equal(t, "", tls.Get())
   479  		assert.Equal(t, "inherit hello", tlsInherit.Get())
   480  		tls.Set("世界")
   481  		tlsInherit.Set("inherit 世界")
   482  		assert.Equal(t, "世界", tls.Get())
   483  		assert.Equal(t, "inherit 世界", tlsInherit.Get())
   484  		wrappedRun = true
   485  		return 1
   486  	})
   487  	tls.Set("world")
   488  	tlsInherit.Set("inherit world")
   489  	assert.Equal(t, "world", tls.Get())
   490  	assert.Equal(t, "inherit world", tlsInherit.Get())
   491  	go func() {
   492  		tls.Set("你好")
   493  		tlsInherit.Set("inherit 你好")
   494  		task.Run()
   495  		assert.Equal(t, "你好", tls.Get())
   496  		assert.Equal(t, "inherit 你好", tlsInherit.Get())
   497  		run = true
   498  		wg.Done()
   499  	}()
   500  	assert.Equal(t, "world", tls.Get())
   501  	assert.Equal(t, "inherit world", tlsInherit.Get())
   502  	assert.Equal(t, 1, task.Get())
   503  	assert.True(t, wrappedRun)
   504  	wg.Wait()
   505  	assert.True(t, wrappedRun)
   506  	assert.True(t, run)
   507  }
   508  
   509  func TestWrapWaitResultTask_HasContext_Cancel(t *testing.T) {
   510  	run := false
   511  	wrappedRun := false
   512  	wg := &sync.WaitGroup{}
   513  	wg.Add(1)
   514  	tls := NewThreadLocal[string]()
   515  	tlsInherit := NewInheritableThreadLocal[string]()
   516  	tls.Set("hello")
   517  	tlsInherit.Set("inherit hello")
   518  	assert.Equal(t, "hello", tls.Get())
   519  	assert.Equal(t, "inherit hello", tlsInherit.Get())
   520  	task := WrapWaitResultTask(func(token CancelToken) any {
   521  		for i := 0; i < 1000; i++ {
   522  			if token.IsCanceled() {
   523  				return 0
   524  			}
   525  			time.Sleep(1 * time.Millisecond)
   526  		}
   527  		wrappedRun = true
   528  		return 1
   529  	})
   530  	tls.Set("world")
   531  	tlsInherit.Set("inherit world")
   532  	assert.Equal(t, "world", tls.Get())
   533  	assert.Equal(t, "inherit world", tlsInherit.Get())
   534  	go func() {
   535  		tls.Set("你好")
   536  		tlsInherit.Set("inherit 你好")
   537  		task.Run()
   538  		assert.Equal(t, "你好", tls.Get())
   539  		assert.Equal(t, "inherit 你好", tlsInherit.Get())
   540  		run = true
   541  		wg.Done()
   542  	}()
   543  	assert.Equal(t, "world", tls.Get())
   544  	assert.Equal(t, "inherit world", tlsInherit.Get())
   545  	task.Cancel()
   546  	assert.True(t, task.IsCanceled())
   547  	assert.Panics(t, func() {
   548  		task.Get()
   549  	})
   550  	assert.False(t, wrappedRun)
   551  	wg.Wait()
   552  	assert.False(t, wrappedRun)
   553  	assert.True(t, run)
   554  }
   555  
   556  func TestWrapWaitResultTask_Complete_ThenFail(t *testing.T) {
   557  	newStdout, oldStdout := captureStdout()
   558  	defer restoreStdout(newStdout, oldStdout)
   559  	//
   560  	run := false
   561  	wg := &sync.WaitGroup{}
   562  	wg.Add(1)
   563  	wg2 := &sync.WaitGroup{}
   564  	wg2.Add(1)
   565  	wg3 := &sync.WaitGroup{}
   566  	wg3.Add(1)
   567  	task := WrapWaitResultTask(func(token CancelToken) any {
   568  		wg.Done()  //1
   569  		wg2.Wait() //4
   570  		run = true
   571  		wg3.Done() //5
   572  		panic(1)
   573  	})
   574  	go task.Run()
   575  	wg.Wait() //2
   576  	task.Complete(nil)
   577  	assert.Nil(t, task.Get())
   578  	wg2.Done() //3
   579  	wg3.Wait() //6
   580  	assert.True(t, task.IsDone())
   581  	assert.False(t, task.IsFailed())
   582  	assert.False(t, task.IsCanceled())
   583  	assert.True(t, run)
   584  	//
   585  	time.Sleep(10 * time.Millisecond)
   586  	output := readAll(newStdout)
   587  	assert.Equal(t, "", output)
   588  }
   589  
   590  func TestGo_Error(t *testing.T) {
   591  	newStdout, oldStdout := captureStdout()
   592  	defer restoreStdout(newStdout, oldStdout)
   593  	//
   594  	run := false
   595  	assert.NotPanics(t, func() {
   596  		wg := &sync.WaitGroup{}
   597  		wg.Add(1)
   598  		Go(func() {
   599  			run = true
   600  			wg.Done()
   601  			panic("error")
   602  		})
   603  		wg.Wait()
   604  	})
   605  	assert.True(t, run)
   606  	//
   607  	time.Sleep(10 * time.Millisecond)
   608  	output := readAll(newStdout)
   609  	lines := strings.Split(output, newLine)
   610  	assert.Equal(t, 7, len(lines))
   611  	//
   612  	line := lines[0]
   613  	assert.Equal(t, "RuntimeError: error", line)
   614  	//
   615  	line = lines[1]
   616  	assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.TestGo_Error."))
   617  	assert.True(t, strings.HasSuffix(line, "api_routine_test.go:601"))
   618  	//
   619  	line = lines[2]
   620  	assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.inheritedTask.run()"))
   621  	assert.True(t, strings.HasSuffix(line, "routine.go:31"))
   622  	//
   623  	line = lines[3]
   624  	assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.(*futureTask[...]).Run()"))
   625  	assert.True(t, strings.HasSuffix(line, "future_task.go:108"))
   626  	//
   627  	line = lines[4]
   628  	assert.Equal(t, "   --- End of error stack trace ---", line)
   629  	//
   630  	line = lines[5]
   631  	assert.True(t, strings.HasPrefix(line, "   created by github.com/xg0n/routine.Go()"))
   632  	assert.True(t, strings.HasSuffix(line, "api_routine.go:49"))
   633  	//
   634  	line = lines[6]
   635  	assert.Equal(t, "", line)
   636  }
   637  
   638  func TestGo_Nil(t *testing.T) {
   639  	assert.Nil(t, createInheritedMap())
   640  	//
   641  	run := false
   642  	wg := &sync.WaitGroup{}
   643  	wg.Add(1)
   644  	Go(func() {
   645  		assert.Nil(t, createInheritedMap())
   646  		run = true
   647  		wg.Done()
   648  	})
   649  	wg.Wait()
   650  	assert.True(t, run)
   651  }
   652  
   653  func TestGo_Value(t *testing.T) {
   654  	tls := NewThreadLocal[string]()
   655  	tls.Set("Hello")
   656  	assert.Equal(t, "Hello", tls.Get())
   657  	//
   658  	inheritableTls := NewInheritableThreadLocal[string]()
   659  	inheritableTls.Set("World")
   660  	assert.Equal(t, "World", inheritableTls.Get())
   661  	//
   662  	assert.NotNil(t, createInheritedMap())
   663  	//
   664  	run := false
   665  	wg := &sync.WaitGroup{}
   666  	wg.Add(1)
   667  	Go(func() {
   668  		assert.NotNil(t, createInheritedMap())
   669  		//
   670  		assert.Equal(t, "", tls.Get())
   671  		assert.Equal(t, "World", inheritableTls.Get())
   672  		//
   673  		tls.Set("Hello2")
   674  		assert.Equal(t, "Hello2", tls.Get())
   675  		//
   676  		inheritableTls.Remove()
   677  		assert.Equal(t, "", inheritableTls.Get())
   678  		//
   679  		run = true
   680  		wg.Done()
   681  	})
   682  	wg.Wait()
   683  	assert.True(t, run)
   684  	//
   685  	assert.Equal(t, "Hello", tls.Get())
   686  	assert.Equal(t, "World", inheritableTls.Get())
   687  }
   688  
   689  func TestGo_Cross(t *testing.T) {
   690  	tls := NewThreadLocal[string]()
   691  	tls.Set("Hello")
   692  	assert.Equal(t, "Hello", tls.Get())
   693  	//
   694  	wg := &sync.WaitGroup{}
   695  	wg.Add(1)
   696  	Go(func() {
   697  		assert.Equal(t, "", tls.Get())
   698  		wg.Done()
   699  	})
   700  	wg.Wait()
   701  }
   702  
   703  func TestGoWait_Error(t *testing.T) {
   704  	run := false
   705  	task := GoWait(func(token CancelToken) {
   706  		run = true
   707  		panic("error")
   708  	})
   709  	assert.Panics(t, func() {
   710  		task.Get()
   711  	})
   712  	assert.True(t, run)
   713  	//
   714  	defer func() {
   715  		cause := recover()
   716  		assert.NotNil(t, cause)
   717  		assert.Implements(t, (*RuntimeError)(nil), cause)
   718  		err := cause.(RuntimeError)
   719  		lines := strings.Split(err.Error(), newLine)
   720  		assert.Equal(t, 6, len(lines))
   721  		//
   722  		line := lines[0]
   723  		assert.Equal(t, "RuntimeError: error", line)
   724  		//
   725  		line = lines[1]
   726  		assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.TestGoWait_Error."))
   727  		assert.True(t, strings.HasSuffix(line, "api_routine_test.go:707"))
   728  		//
   729  		line = lines[2]
   730  		assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.inheritedWaitTask.run()"))
   731  		assert.True(t, strings.HasSuffix(line, "routine.go:70"))
   732  		//
   733  		line = lines[3]
   734  		assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.(*futureTask[...]).Run()"))
   735  		assert.True(t, strings.HasSuffix(line, "future_task.go:108"))
   736  		//
   737  		line = lines[4]
   738  		assert.Equal(t, "   --- End of error stack trace ---", line)
   739  		//
   740  		line = lines[5]
   741  		assert.True(t, strings.HasPrefix(line, "   created by github.com/xg0n/routine.GoWait()"))
   742  		assert.True(t, strings.HasSuffix(line, "api_routine.go:57"))
   743  	}()
   744  	task.Get()
   745  }
   746  
   747  func TestGoWait_Nil(t *testing.T) {
   748  	assert.Nil(t, createInheritedMap())
   749  	//
   750  	run := false
   751  	task := GoWait(func(token CancelToken) {
   752  		assert.Nil(t, createInheritedMap())
   753  		run = true
   754  	})
   755  	assert.Nil(t, task.Get())
   756  	assert.True(t, run)
   757  }
   758  
   759  func TestGoWait_Value(t *testing.T) {
   760  	tls := NewThreadLocal[string]()
   761  	tls.Set("Hello")
   762  	assert.Equal(t, "Hello", tls.Get())
   763  	//
   764  	inheritableTls := NewInheritableThreadLocal[string]()
   765  	inheritableTls.Set("World")
   766  	assert.Equal(t, "World", inheritableTls.Get())
   767  	//
   768  	assert.NotNil(t, createInheritedMap())
   769  	//
   770  	run := false
   771  	task := GoWait(func(token CancelToken) {
   772  		assert.NotNil(t, createInheritedMap())
   773  		//
   774  		assert.Equal(t, "", tls.Get())
   775  		assert.Equal(t, "World", inheritableTls.Get())
   776  		//
   777  		tls.Set("Hello2")
   778  		assert.Equal(t, "Hello2", tls.Get())
   779  		//
   780  		inheritableTls.Remove()
   781  		assert.Equal(t, "", inheritableTls.Get())
   782  		//
   783  		run = true
   784  	})
   785  	assert.Nil(t, task.Get())
   786  	assert.True(t, run)
   787  	//
   788  	assert.Equal(t, "Hello", tls.Get())
   789  	assert.Equal(t, "World", inheritableTls.Get())
   790  }
   791  
   792  func TestGoWait_Cross(t *testing.T) {
   793  	tls := NewThreadLocal[string]()
   794  	tls.Set("Hello")
   795  	assert.Equal(t, "Hello", tls.Get())
   796  	//
   797  	GoWait(func(token CancelToken) {
   798  		assert.Equal(t, "", tls.Get())
   799  	}).Get()
   800  }
   801  
   802  func TestGoWaitResult_Error(t *testing.T) {
   803  	run := false
   804  	task := GoWaitResult(func(token CancelToken) int {
   805  		run = true
   806  		if run {
   807  			panic("error")
   808  		}
   809  		return 1
   810  	})
   811  	assert.Panics(t, func() {
   812  		task.Get()
   813  	})
   814  	assert.True(t, run)
   815  	//
   816  	defer func() {
   817  		cause := recover()
   818  		assert.NotNil(t, cause)
   819  		assert.Implements(t, (*RuntimeError)(nil), cause)
   820  		err := cause.(RuntimeError)
   821  		lines := strings.Split(err.Error(), newLine)
   822  		assert.True(t, len(lines) == 6 || len(lines) == 7)
   823  		//
   824  		line := lines[0]
   825  		assert.Equal(t, "RuntimeError: error", line)
   826  		//
   827  		line = lines[1]
   828  		assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.TestGoWaitResult_Error."))
   829  		assert.True(t, strings.HasSuffix(line, "api_routine_test.go:807"))
   830  		//
   831  		line = lines[2]
   832  		assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.inheritedWaitResultTask[...].run()"))
   833  		assert.True(t, strings.HasSuffix(line, "routine.go:109"))
   834  		//
   835  		lineOffset := 0
   836  		if len(lines) == 7 {
   837  			line = lines[3+lineOffset]
   838  			lineOffset = 1
   839  			assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.WrapWaitResultTask[...].func1()"))
   840  			assert.True(t, strings.HasSuffix(line, "api_routine.go:41"))
   841  		}
   842  		//
   843  		line = lines[3+lineOffset]
   844  		assert.True(t, strings.HasPrefix(line, "   at github.com/xg0n/routine.(*futureTask[...]).Run()"))
   845  		assert.True(t, strings.HasSuffix(line, "future_task.go:108"))
   846  		//
   847  		line = lines[4+lineOffset]
   848  		assert.Equal(t, "   --- End of error stack trace ---", line)
   849  		//
   850  		line = lines[5+lineOffset]
   851  		assert.True(t, strings.HasPrefix(line, "   created by github.com/xg0n/routine.GoWaitResult[...]()"))
   852  		assert.True(t, strings.HasSuffix(line, "api_routine.go:66"))
   853  	}()
   854  	task.Get()
   855  }
   856  
   857  func TestGoWaitResult_Nil(t *testing.T) {
   858  	assert.Nil(t, createInheritedMap())
   859  	//
   860  	run := false
   861  	task := GoWaitResult(func(token CancelToken) bool {
   862  		assert.Nil(t, createInheritedMap())
   863  		run = true
   864  		return true
   865  	})
   866  	assert.True(t, task.Get())
   867  	assert.True(t, run)
   868  }
   869  
   870  func TestGoWaitResult_Value(t *testing.T) {
   871  	tls := NewThreadLocal[string]()
   872  	tls.Set("Hello")
   873  	assert.Equal(t, "Hello", tls.Get())
   874  	//
   875  	inheritableTls := NewInheritableThreadLocal[string]()
   876  	inheritableTls.Set("World")
   877  	assert.Equal(t, "World", inheritableTls.Get())
   878  	//
   879  	assert.NotNil(t, createInheritedMap())
   880  	//
   881  	run := false
   882  	task := GoWaitResult(func(token CancelToken) bool {
   883  		assert.NotNil(t, createInheritedMap())
   884  		//
   885  		assert.Equal(t, "", tls.Get())
   886  		assert.Equal(t, "World", inheritableTls.Get())
   887  		//
   888  		tls.Set("Hello2")
   889  		assert.Equal(t, "Hello2", tls.Get())
   890  		//
   891  		inheritableTls.Remove()
   892  		assert.Equal(t, "", inheritableTls.Get())
   893  		//
   894  		run = true
   895  		return true
   896  	})
   897  	assert.True(t, task.Get())
   898  	assert.True(t, run)
   899  	//
   900  	assert.Equal(t, "Hello", tls.Get())
   901  	assert.Equal(t, "World", inheritableTls.Get())
   902  }
   903  
   904  func TestGoWaitResult_Cross(t *testing.T) {
   905  	tls := NewThreadLocal[string]()
   906  	tls.Set("Hello")
   907  	assert.Equal(t, "Hello", tls.Get())
   908  	//
   909  	result := GoWaitResult(func(token CancelToken) string {
   910  		assert.Equal(t, "", tls.Get())
   911  		return tls.Get()
   912  	}).Get()
   913  	assert.Equal(t, "", result)
   914  }
   915  
   916  func captureStdout() (newStdout, oldStdout *os.File) {
   917  	oldStdout = os.Stdout
   918  	fileName := path.Join(os.TempDir(), "go_test_"+strconv.FormatInt(time.Now().UnixNano(), 10)+".txt")
   919  	file, err := os.Create(fileName)
   920  	if err != nil {
   921  		panic(err)
   922  	}
   923  	os.Stdout = file
   924  	newStdout = file
   925  	return
   926  }
   927  
   928  func restoreStdout(newStdout, oldStdout *os.File) {
   929  	os.Stdout = oldStdout
   930  	if err := newStdout.Close(); err != nil {
   931  		panic(err)
   932  	}
   933  	if err := os.Remove(newStdout.Name()); err != nil {
   934  		panic(err)
   935  	}
   936  }
   937  
   938  func readAll(rs io.ReadSeeker) string {
   939  	if _, err := rs.Seek(0, io.SeekStart); err != nil {
   940  		panic(err)
   941  	}
   942  	b := make([]byte, 0, 512)
   943  	for {
   944  		if len(b) == cap(b) {
   945  			b = append(b, 0)[:len(b)]
   946  		}
   947  		n, err := rs.Read(b[len(b):cap(b)])
   948  		b = b[:len(b)+n]
   949  		if err != nil {
   950  			if err == io.EOF {
   951  				return string(b)
   952  			}
   953  			panic(err)
   954  		}
   955  	}
   956  }