diff --git a/.github/workflows/unit_test-linux-x64.yml b/.github/workflows/unit_test-linux-x64.yml
index c6f56b76c..f7197794f 100644
--- a/.github/workflows/unit_test-linux-x64.yml
+++ b/.github/workflows/unit_test-linux-x64.yml
@@ -5,6 +5,7 @@ on: push
 jobs:
   build:
     strategy:
+      max-parallel: 4
       matrix:
         go-version: [1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x, 1.21.x, 1.22.x]
     runs-on: [self-hosted, X64]
@@ -28,9 +29,15 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-go-
 
+      - name: Data Race
+        run: |
+          ./scripts/test_race.sh
+
       - name: PCSP Test
         run: python3 ./scripts/test_pcsp.py
     
+
+
       - name: Unit Test
         run: |
           go test -race -covermode=atomic -coverprofile=coverage.txt ./...
diff --git a/decoder/decoder_test.go b/decoder/decoder_test.go
index 882aa7990..138b1d127 100644
--- a/decoder/decoder_test.go
+++ b/decoder/decoder_test.go
@@ -21,7 +21,6 @@ import (
     `runtime`
     `runtime/debug`
     `strings`
-    `sync`
     `testing`
     `time`
 
@@ -46,40 +45,6 @@ func TestMain(m *testing.M) {
     m.Run()
 }
 
-func TestGC(t *testing.T) {
-    if debugSyncGC {
-        return 
-    }
-    var w interface{}
-    out, err := decode(TwitterJson, &w, true)
-    if err != nil {
-        t.Fatal(err)
-    }
-    if out != len(TwitterJson) {
-        t.Fatal(out)
-    }
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup)  {
-            defer wg.Done()
-            var w interface{}
-            out, err := decode(TwitterJson, &w, true)
-            if err != nil {
-                t.Error(err)
-                return
-            }
-            if out != len(TwitterJson) {
-                t.Error(out)
-                return
-            }
-            runtime.GC()
-        }(wg)
-    }
-    wg.Wait()
-}
-
 var _BindingValue TwitterStruct
 
 func init() {
diff --git a/encoder/encoder_test.go b/encoder/encoder_test.go
index e76c06dad..8c0098454 100644
--- a/encoder/encoder_test.go
+++ b/encoder/encoder_test.go
@@ -23,7 +23,6 @@ import (
     `runtime`
     `runtime/debug`
     `strconv`
-    `sync`
     `testing`
     `time`
 
@@ -47,36 +46,6 @@ func TestMain(m *testing.M) {
     m.Run()
 }
 
-func TestGC(t *testing.T) {
-    if debugSyncGC {
-        return
-    }
-    out, err := Encode(_GenericValue, 0)
-    if err != nil {
-        t.Fatal(err)
-    }
-    n := len(out)
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup, size int)  {
-            defer wg.Done()
-            out, err := Encode(_GenericValue, 0)
-            if err != nil {
-                t.Error(err)
-                return
-            }
-            if len(out) != size {
-                t.Error(len(out), size)
-                return
-            }
-            runtime.GC()
-        }(wg, n)
-    }
-    wg.Wait()
-}
-
 type sample struct {
     M map[string]interface{}
     S []interface{}
diff --git a/internal/decoder/decode_norace.go b/internal/decoder/decode_norace.go
new file mode 100644
index 000000000..714ea093d
--- /dev/null
+++ b/internal/decoder/decode_norace.go
@@ -0,0 +1,73 @@
+//go:build !race
+// +build !race
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `encoding/json`
+    `reflect`
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/utf8`
+)
+
+// Decode parses the JSON-encoded data from current position and stores the result
+// in the value pointed to by val.
+func (self *Decoder) Decode(val interface{}) error {
+    /* validate json if needed */
+    if (self.f & (1 << _F_validate_string)) != 0  && !utf8.ValidateString(self.s){
+        dbuf := utf8.CorrectWith(nil, rt.Str2Mem(self.s), "\ufffd")
+        self.s = rt.Mem2Str(dbuf)
+    }
+
+    vv := rt.UnpackEface(val)
+    vp := vv.Value
+
+    /* check for nil type */
+    if vv.Type == nil {
+        return &json.InvalidUnmarshalError{}
+    }
+
+    /* must be a non-nil pointer */
+    if vp == nil || vv.Type.Kind() != reflect.Ptr {
+        return &json.InvalidUnmarshalError{Type: vv.Type.Pack()}
+    }
+
+    etp := rt.PtrElem(vv.Type)
+
+    /* check the defined pointer type for issue 379 */
+    if vv.Type.IsNamed() {
+        newp := vp
+        etp  = vv.Type
+        vp   = unsafe.Pointer(&newp)
+    }
+
+    /* create a new stack, and call the decoder */
+    sb := newStack()
+    nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f)
+    /* return the stack back */
+    self.i = nb
+    freeStack(sb)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(vv)
+    return err
+}
diff --git a/internal/decoder/decode_race.go b/internal/decoder/decode_race.go
new file mode 100644
index 000000000..88b723231
--- /dev/null
+++ b/internal/decoder/decode_race.go
@@ -0,0 +1,80 @@
+//go:build race
+// +build race
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `encoding/json`
+    `reflect`
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/utf8`
+)
+
+func helpDetectDataRace(val interface{}) {
+    _, _ = json.Marshal(val)
+}
+
+// Decode parses the JSON-encoded data from current position and stores the result
+// in the value pointed to by val.
+func (self *Decoder) Decode(val interface{}) error {
+    /* validate json if needed */
+    if (self.f & (1 << _F_validate_string)) != 0  && !utf8.ValidateString(self.s){
+        dbuf := utf8.CorrectWith(nil, rt.Str2Mem(self.s), "\ufffd")
+        self.s = rt.Mem2Str(dbuf)
+    }
+
+    vv := rt.UnpackEface(val)
+    vp := vv.Value
+
+    /* check for nil type */
+    if vv.Type == nil {
+        return &json.InvalidUnmarshalError{}
+    }
+
+    /* must be a non-nil pointer */
+    if vp == nil || vv.Type.Kind() != reflect.Ptr {
+        return &json.InvalidUnmarshalError{Type: vv.Type.Pack()}
+    }
+
+    etp := rt.PtrElem(vv.Type)
+
+    /* check the defined pointer type for issue 379 */
+    if vv.Type.IsNamed() {
+        newp := vp
+        etp  = vv.Type
+        vp   = unsafe.Pointer(&newp)
+    }
+
+    /* create a new stack, and call the decoder */
+    sb := newStack()
+    nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f)
+    /* return the stack back */
+    self.i = nb
+    freeStack(sb)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(vv)
+
+    /* put last to make the panic from sonic will always be caught at first */
+    helpDetectDataRace(val)
+    return err
+}
diff --git a/internal/decoder/decoder.go b/internal/decoder/decoder.go
index 8453db861..4d5be4834 100644
--- a/internal/decoder/decoder.go
+++ b/internal/decoder/decoder.go
@@ -17,16 +17,12 @@
 package decoder
 
 import (
-    `unsafe`
-    `encoding/json`
     `reflect`
-    `runtime`
 
     `github.com/bytedance/sonic/internal/native`
     `github.com/bytedance/sonic/internal/native/types`
     `github.com/bytedance/sonic/internal/rt`
     `github.com/bytedance/sonic/option`
-    `github.com/bytedance/sonic/utf8`
 )
 
 const (
@@ -106,49 +102,6 @@ func (self *Decoder) CheckTrailings() error {
 }
 
 
-// Decode parses the JSON-encoded data from current position and stores the result
-// in the value pointed to by val.
-func (self *Decoder) Decode(val interface{}) error {
-    /* validate json if needed */
-    if (self.f & (1 << _F_validate_string)) != 0  && !utf8.ValidateString(self.s){
-        dbuf := utf8.CorrectWith(nil, rt.Str2Mem(self.s), "\ufffd")
-        self.s = rt.Mem2Str(dbuf)
-    }
-
-    vv := rt.UnpackEface(val)
-    vp := vv.Value
-
-    /* check for nil type */
-    if vv.Type == nil {
-        return &json.InvalidUnmarshalError{}
-    }
-
-    /* must be a non-nil pointer */
-    if vp == nil || vv.Type.Kind() != reflect.Ptr {
-        return &json.InvalidUnmarshalError{Type: vv.Type.Pack()}
-    }
-
-    etp := rt.PtrElem(vv.Type)
-
-    /* check the defined pointer type for issue 379 */
-    if vv.Type.IsNamed() {
-        newp := vp
-        etp  = vv.Type
-        vp   = unsafe.Pointer(&newp)
-    }
-
-    /* create a new stack, and call the decoder */
-    sb := newStack()
-    nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f)
-    /* return the stack back */
-    self.i = nb
-    freeStack(sb)
-
-    /* avoid GC ahead */
-    runtime.KeepAlive(vv)
-    return err
-}
-
 // UseInt64 indicates the Decoder to unmarshal an integer into an interface{} as an
 // int64 instead of as a float64.
 func (self *Decoder) UseInt64() {
diff --git a/internal/decoder/decoder_norace_test.go b/internal/decoder/decoder_norace_test.go
new file mode 100644
index 000000000..c488e3bf8
--- /dev/null
+++ b/internal/decoder/decoder_norace_test.go
@@ -0,0 +1,60 @@
+//go:build !race
+// +build !race
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `runtime`
+
+    `sync`
+    `testing`
+)
+
+
+func TestGC(t *testing.T) {
+    if debugSyncGC {
+        return 
+    }
+    var w interface{}
+    out, err := decode(TwitterJson, &w, true)
+    if err != nil {
+        t.Fatal(err)
+    }
+    if out != len(TwitterJson) {
+        t.Fatal(out)
+    }
+    wg := &sync.WaitGroup{}
+    N := 10000
+    for i:=0; i<N; i++ {
+        wg.Add(1)
+        go func (wg *sync.WaitGroup)  {
+            defer wg.Done()
+            var w interface{}
+            out, err := decode(TwitterJson, &w, true)
+            if err != nil {
+                t.Fatal(err)
+            }
+            if out != len(TwitterJson) {
+                t.Fatal(out)
+            }
+            runtime.GC()
+        }(wg)
+    }
+    wg.Wait()
+}
\ No newline at end of file
diff --git a/internal/decoder/decoder_test.go b/internal/decoder/decoder_test.go
index f9c86e2b0..6392092f6 100644
--- a/internal/decoder/decoder_test.go
+++ b/internal/decoder/decoder_test.go
@@ -21,7 +21,6 @@ import (
     `runtime`
     `runtime/debug`
     `strings`
-    `sync`
     `testing`
     `time`
     `reflect`
@@ -48,38 +47,6 @@ func TestMain(m *testing.M) {
     m.Run()
 }
 
-func TestGC(t *testing.T) {
-    if debugSyncGC {
-        return 
-    }
-    var w interface{}
-    out, err := decode(TwitterJson, &w, true)
-    if err != nil {
-        t.Fatal(err)
-    }
-    if out != len(TwitterJson) {
-        t.Fatal(out)
-    }
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup)  {
-            defer wg.Done()
-            var w interface{}
-            out, err := decode(TwitterJson, &w, true)
-            if err != nil {
-                t.Fatal(err)
-            }
-            if out != len(TwitterJson) {
-                t.Fatal(out)
-            }
-            runtime.GC()
-        }(wg)
-    }
-    wg.Wait()
-}
-
 var _BindingValue TwitterStruct
 
 func init() {
diff --git a/internal/encoder/encode_norace.go b/internal/encoder/encode_norace.go
new file mode 100644
index 000000000..1b7eea3f8
--- /dev/null
+++ b/internal/encoder/encode_norace.go
@@ -0,0 +1,44 @@
+//go:build !race
+// +build !race
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+
+func encodeInto(buf *[]byte, val interface{}, opts Options) error {
+    stk := newStack()
+    efv := rt.UnpackEface(val)
+    err := encodeTypedPointer(buf, efv.Type, &efv.Value, stk, uint64(opts))
+
+    /* return the stack into pool */
+    if err != nil {
+        resetStack(stk)
+    }
+    freeStack(stk)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(buf)
+    runtime.KeepAlive(efv)
+    return err
+}
diff --git a/internal/encoder/encode_race.go b/internal/encoder/encode_race.go
new file mode 100644
index 000000000..731fa2d26
--- /dev/null
+++ b/internal/encoder/encode_race.go
@@ -0,0 +1,54 @@
+//go:build race
+// +build race
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+
+func helpDetectDataRace(val interface{}) {
+    _, _ = json.Marshal(val)
+}
+
+func encodeInto(buf *[]byte, val interface{}, opts Options) error {
+
+
+    stk := newStack()
+    efv := rt.UnpackEface(val)
+    err := encodeTypedPointer(buf, efv.Type, &efv.Value, stk, uint64(opts))
+
+    /* return the stack into pool */
+    if err != nil {
+        resetStack(stk)
+    }
+    freeStack(stk)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(buf)
+    runtime.KeepAlive(efv)
+
+    /* put last to make the panic from sonic will always be caught at first */
+    helpDetectDataRace(val)
+    return err
+}
diff --git a/internal/encoder/encoder.go b/internal/encoder/encoder.go
index d285c2991..df90b1050 100644
--- a/internal/encoder/encoder.go
+++ b/internal/encoder/encoder.go
@@ -20,7 +20,6 @@ import (
     `bytes`
     `encoding/json`
     `reflect`
-    `runtime`
     `unsafe`
 
     `github.com/bytedance/sonic/internal/native`
@@ -233,23 +232,6 @@ func EncodeInto(buf *[]byte, val interface{}, opts Options) error {
     return err
 }
 
-func encodeInto(buf *[]byte, val interface{}, opts Options) error {
-    stk := newStack()
-    efv := rt.UnpackEface(val)
-    err := encodeTypedPointer(buf, efv.Type, &efv.Value, stk, uint64(opts))
-
-    /* return the stack into pool */
-    if err != nil {
-        resetStack(stk)
-    }
-    freeStack(stk)
-
-    /* avoid GC ahead */
-    runtime.KeepAlive(buf)
-    runtime.KeepAlive(efv)
-    return err
-}
-
 func encodeFinish(buf []byte, opts Options) []byte {
     if opts & EscapeHTML != 0 {
         buf = HTMLEscape(nil, buf)
diff --git a/internal/encoder/encoder_norace_test.go b/internal/encoder/encoder_norace_test.go
new file mode 100644
index 000000000..d119e0fc5
--- /dev/null
+++ b/internal/encoder/encoder_norace_test.go
@@ -0,0 +1,55 @@
+//go:build !race
+// +build !race
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `runtime`
+
+    `sync`
+    `testing`
+)
+
+func TestGC(t *testing.T) {
+    if debugSyncGC {
+        return
+    }
+    out, err := Encode(_GenericValue, 0)
+    if err != nil {
+        t.Fatal(err)
+    }
+    n := len(out)
+    wg := &sync.WaitGroup{}
+    N := 10000
+    for i:=0; i<N; i++ {
+        wg.Add(1)
+        go func (wg *sync.WaitGroup, size int)  {
+            defer wg.Done()
+            out, err := Encode(_GenericValue, 0)
+            if err != nil {
+                t.Fatal(err)
+            }
+            if len(out) != size {
+                t.Fatal(len(out), size)
+            }
+            runtime.GC()
+        }(wg, n)
+    }
+    wg.Wait()
+}
\ No newline at end of file
diff --git a/internal/encoder/encoder_test.go b/internal/encoder/encoder_test.go
index dfdf035ed..b7690bc62 100644
--- a/internal/encoder/encoder_test.go
+++ b/internal/encoder/encoder_test.go
@@ -23,7 +23,6 @@ import (
     `runtime`
     `runtime/debug`
     `strconv`
-    `sync`
     `testing`
     `time`
 
@@ -47,34 +46,6 @@ func TestMain(m *testing.M) {
     m.Run()
 }
 
-func TestGC(t *testing.T) {
-    if debugSyncGC {
-        return
-    }
-    out, err := Encode(_GenericValue, 0)
-    if err != nil {
-        t.Fatal(err)
-    }
-    n := len(out)
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup, size int)  {
-            defer wg.Done()
-            out, err := Encode(_GenericValue, 0)
-            if err != nil {
-                t.Fatal(err)
-            }
-            if len(out) != size {
-                t.Fatal(len(out), size)
-            }
-            runtime.GC()
-        }(wg, n)
-    }
-    wg.Wait()
-}
-
 type sample struct {
     M map[string]interface{}
     S []interface{}
diff --git a/issue_test/issue634_test.go b/issue_test/issue634_test.go
index fec01d44e..86637cb7e 100644
--- a/issue_test/issue634_test.go
+++ b/issue_test/issue634_test.go
@@ -1,3 +1,6 @@
+//go:build !race
+// +build !race
+
 /*
  * Copyright 2024 ByteDance Inc.
  *
diff --git a/issue_test/race_test_go b/issue_test/race_test_go
new file mode 100644
index 000000000..6df2de062
--- /dev/null
+++ b/issue_test/race_test_go
@@ -0,0 +1,71 @@
+
+//go:build race
+// +build race
+
+/*
+ * Copyright 2024 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package issue_test
+
+import (
+    `github.com/bytedance/sonic`
+    `testing`
+)
+
+type MyFoo struct {
+    List []*int64 
+}
+
+func TestRaceEncode(t *testing.T) {
+    f := &MyFoo{
+        List: []*int64{new(int64), new(int64)},
+    }
+
+    go func() {
+        f.List = []*int64{new(int64), new(int64)}
+    }()
+
+    go func() {
+        sonic.Marshal(f)
+    }()
+
+    // encoding/json always detect data race when enabling `-race` here
+    // go func() {
+    //     json.Marshal(f)
+    // }()
+}
+
+
+func TestRaceDecode(t *testing.T) {
+    f := &MyFoo{
+        List: []*int64{new(int64), new(int64), new(int64)},
+    }
+
+    i := int64(200)
+    go func() {
+        f.List[2] = &i
+    }()
+
+    go func() {
+        sonic.Unmarshal([]byte(`{"List":[1,2,3]}`),  f)
+    }()
+
+    // encoding/json always detect data race when enabling `-race` here
+    // go func() {
+    //     json.Unmarshal([]byte(`{"List":[1,2,3]}`),  f)
+    // }()
+}
diff --git a/scripts/test_race.sh b/scripts/test_race.sh
new file mode 100755
index 000000000..f7ddd133c
--- /dev/null
+++ b/scripts/test_race.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -xe
+
+mv ./issue_test/race_test_go ./issue_test/race_test.go
+
+go test -v -run=TestRaceEncode -race -count=100 ./issue_test > test_race.log || true
+
+if ! grep -q "WARNING: DATA RACE" ./test_race.log; then
+    echo "TEST FAILED: should data race here"
+    exit 1
+fi
+
+go test -v -run=TestRaceDecode -race -count=100 ./issue_test > test_race.log || true
+
+if ! grep -q "WARNING: DATA RACE" ./test_race.log; then
+    echo "TEST FAILED: should data race here"
+    exit 1
+fi
+
+mv ./issue_test/race_test.go ./issue_test/race_test_go
\ No newline at end of file