//go:build amd64
// +build amd64

// Code generated by scripts, DO NOT EDIT.

/**
 * Copyright 2023 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 {{PACKAGE}}

import (
    `bytes`
    `os`
    `runtime`
    `runtime/debug`
    `runtime/pprof`
    `strings`
    `testing`
    `time`
    `unsafe`

    `github.com/bytedance/sonic/internal/native/types`
    `github.com/bytedance/sonic/internal/rt`
)

var (
    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
)


func TestMain(m *testing.M) {
    Use()
    go func ()  {
        if !debugAsyncGC {
            return
        }
        println("Begin GC looping...")
        for {
        runtime.GC()
        debug.FreeOSMemory() 
        }
        println("stop GC looping!")
    }()
    time.Sleep(time.Millisecond*100)
    m.Run()
}

func TestRecover_f64toa(t *testing.T) {
    defer func() {
        if r := recover(); r!= nil {
            t.Log("recover: ", r)
        } else {
            t.Fatal("no panic")
        }
    }()
    _ = f64toa(nil, 123)
}

func TestRecover_f32toa(t *testing.T) {
    defer func() {
        if r := recover(); r!= nil {
            t.Log("recover: ", r)
        } else {
            t.Fatal("no panic")
        }
    }()
    _ = f32toa(nil, 123)
}

func TestRecover_i64toa(t *testing.T) {
    defer func() {
        if r := recover(); r!= nil {
            t.Log("recover: ", r)
        } else {
            t.Fatal("no panic")
        }
    }()
    _ = i64toa(nil, 123)
}

func TestRecover_u64toa(t *testing.T) {
    defer func() {
        if r := recover(); r!= nil {
            t.Log("recover: ", r)
        } else {
            t.Fatal("no panic")
        }
    }()
    _ = u64toa(nil, 123)
}

func TestRecover_lspace(t *testing.T) {
    defer func() {
        if r := recover(); r!= nil {
            t.Log("recover: ", r)
        } else {
            t.Fatal("no panic")
        }
    }()
    _ = lspace(nil, 2, 0)
}

func TestRecover_lspace2(t *testing.T) {
    // generate random space with json
    cases := []string{
        strings.Repeat(" ", 1) + "123",
        strings.Repeat(" ", 1) + "123",
         "123",
    }
    pprof.StartCPUProfile(bytes.NewBuffer(nil))
    defer pprof.StopCPUProfile()
    for i := 0; i < 10000000; i++{
        for _, t := range  cases {
            sp := (*byte)((*rt.GoString)(unsafe.Pointer(&t)).Ptr)
            _ = lspace(sp, len(t), 0)
        }
    }
}

func TestRecover_quote(t *testing.T) {
    var dn = 10
    var dp = make([]byte, dn)
    var sp = []byte("123")
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = quote(nil, 3, unsafe.Pointer(&dp[0]), &dn, 0)
    })
    t.Run("dp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = quote(unsafe.Pointer(&sp[0]), 3, nil, &dn, 0)
    })
    t.Run("dn", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = quote(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil, 0)
    })
}

func TestRecover_html_escape(t *testing.T) {
    var dn = 10
    var dp = make([]byte, dn)
    var sp = []byte("123")
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = html_escape(nil, 3, unsafe.Pointer(&dp[0]), &dn)
    })
    t.Run("dp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = html_escape(unsafe.Pointer(&sp[0]), 3, nil, &dn)
    })
    t.Run("dn", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = html_escape(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil)
    })
}

func TestRecover_unquote(t *testing.T) {
    var ep = 0
    var dp = make([]byte, 10)
    var sp = []byte("12\\x\"3\"4")
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = unquote(nil, len(sp), unsafe.Pointer(&dp[0]), &ep, 0)
    })
    t.Run("dp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = unquote(unsafe.Pointer(&sp[0]), len(sp), nil, &ep, 0)
    })
    t.Run("ep", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = unquote(unsafe.Pointer(&sp[0]), len(sp), unsafe.Pointer(&dp[0]), nil, 0)
    })
}

func TestRecover_value(t *testing.T) {
    var v = new(types.JsonState)
    var sp = []byte("123")
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = value(nil, 3, 0, v, 0)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = value(unsafe.Pointer(&sp[0]), 3, 0, nil, 0)
    })
}

func TestRecover_vstring(t *testing.T) {
    var v = new(types.JsonState)
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vstring(nil, &p, v, 0)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vstring(&sp, nil, v, 0)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vstring(&sp, &p, nil, 0)
    })
}

func TestRecover_vnumber(t *testing.T) {
    var v = new(types.JsonState)
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vnumber(nil, &p, v)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vnumber(&sp, nil, v)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vnumber(&sp, &p, nil)
    })
}

func TestRecover_vsigned(t *testing.T) {
    var v = new(types.JsonState)
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vsigned(nil, &p, v)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vsigned(&sp, nil, v)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vsigned(&sp, &p, nil)
    })
}

func TestRecover_vunsigned(t *testing.T) {
    var v = new(types.JsonState)
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vunsigned(nil, &p, v)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vunsigned(&sp, nil, v)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        vunsigned(&sp, &p, nil)
    })
}

func TestRecover_skip_one(t *testing.T) {
    var v = types.NewStateMachine()
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_one(nil, &p, v, 0)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_one(&sp, nil, v, 0)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_one(&sp, &p, nil, 0)
    })
}

func TestRecover_skip_one_fast(t *testing.T) {
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_one_fast(nil, &p)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_one_fast(&sp, nil)
    })
}

func TestRecover_skip_array(t *testing.T) {
    var v = types.NewStateMachine()
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_array(nil, &p, v, 0)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_array(&sp, nil, v, 0)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_array(&sp, &p, nil, 0)
    })
}

func TestRecover_skip_object(t *testing.T) {
    var v = types.NewStateMachine()
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_object(nil, &p, v, 0)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_object(&sp, nil, v, 0)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_object(&sp, &p, nil, 0)
    })
}

func TestRecover_skip_number(t *testing.T) {
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_number(nil, &p)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = skip_number(&sp, nil)
    })
}

func TestRecover_get_by_path(t *testing.T) {
    var v = []interface{}{}
    var sp = "123"
    var p = 0
    var m = types.NewStateMachine()
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = get_by_path(nil, &p, &v, m)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = get_by_path(&sp, nil, &v, m)
    })
    t.Run("path", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = get_by_path(&sp, &p, nil, m)
    })
}

func TestRecover_validate_one(t *testing.T) {
    var v = types.NewStateMachine()
    var sp = "123"
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = validate_one(nil, &p, v, 0)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = validate_one(&sp, nil, v, 0)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = validate_one(&sp, &p, nil, 0)
    })
}

func TestRecover_validate_utf8(t *testing.T) {
    var v = types.NewStateMachine()
    var sp = string([]byte{0xff, 0xff, 0xff})
    var p = 0
    t.Run("sp", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = validate_utf8(nil, &p, v)
    })
    t.Run("p", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = validate_utf8(&sp, nil, v)
    })
    t.Run("v", func(t *testing.T) {
        defer func() {
            if r := recover(); r!= nil {
                t.Log("recover: ", r)
            } else {
                t.Fatal("no panic")
            }
        }()
        _ = validate_utf8(&sp, &p, nil)
    })
}

func TestRecover_validate_utf8_fast(t *testing.T) {
    defer func() {
        if r := recover(); r!= nil {
            t.Log("recover: ", r)
        } else {
            t.Fatal("no panic")
        }
    }()
    _ = validate_utf8_fast(nil)
}

func TestRecover_parse_with_padding(t *testing.T) {
	defer func() {
		if r := recover(); r!= nil {
			t.Log("recover: ", r)
		} else {
			t.Fatal("no panic")
		}
	}()
	_ = parse_with_padding(nil)
}

func TestRecover_lookup_small_key(t *testing.T) {
	t.Run("key", func(t *testing.T) {
		defer func() {
			if r := recover(); r!= nil {
				t.Log("recover: ", r)
			} else {
				t.Fatal("no panic")
			}
		}()
		b := bytes.Repeat([]byte("a"), 100)
		_ = lookup_small_key(nil, &b, 10)
	})
	t.Run("table", func(t *testing.T) {
		defer func() {
			if r := recover(); r!= nil {
				t.Log("recover: ", r)
			} else {
				t.Fatal("no panic")
			}
		}()
		key := "a"
		_ = lookup_small_key(&key, nil, 10)
	})
}
