package utils

import (
	"github.com/shopspring/decimal"
	"reflect"
	"testing"
	"time"
)

func TestCheckTime(t *testing.T) {
	type args struct {
		start string
		end   string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CheckTime(tt.args.start, tt.args.end); got != tt.want {
				t.Errorf("CheckTime() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCheckTimeUTC(t *testing.T) {
	type args struct {
		start string
		end   string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CheckTimeUTC(tt.args.start, tt.args.end); got != tt.want {
				t.Errorf("CheckTimeUTC() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDealPrice(t *testing.T) {
	type args struct {
		types       int
		limitPrice  string
		marketPrice string
	}
	tests := []struct {
		name string
		args args
		want decimal.Decimal
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := DealPrice(tt.args.types, tt.args.limitPrice, tt.args.marketPrice); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DealPrice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDecimalsPrice(t *testing.T) {
	type args struct {
		price string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := DecimalsPrice(tt.args.price); got != tt.want {
				t.Errorf("DecimalsPrice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDecimalsStrInt(t *testing.T) {
	tests := []struct {
		name string
		want decimal.Decimal
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := DecimalsStrInt(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DecimalsStrInt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDifference(t *testing.T) {
	tests := []struct {
		name string
		want decimal.Decimal
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Difference(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Difference() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGZipDecompress(t *testing.T) {
	type args struct {
		input []byte
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := GZipDecompress(tt.args.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("GZipDecompress() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("GZipDecompress() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetAddTime(t *testing.T) {
	type args struct {
		st string
		t  string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := GetAddTime(tt.args.st, tt.args.t); got != tt.want {
				t.Errorf("GetAddTime() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetTime(t *testing.T) {
	tests := []struct {
		name string
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := GetTime(); got != tt.want {
				t.Errorf("GetTime() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHttpGet(t *testing.T) {
	type args struct {
		url string
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := HttpGet(tt.args.url)
			if (err != nil) != tt.wantErr {
				t.Errorf("HttpGet() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("HttpGet() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHttpGetApi(t *testing.T) {
	type args struct {
		url string
	}
	tests := []struct {
		name    string
		args    args
		want    map[string]interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := HttpGetApi(tt.args.url)
			if (err != nil) != tt.wantErr {
				t.Errorf("HttpGetApi() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("HttpGetApi() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHttpGetDoKey(t *testing.T) {
	type args struct {
		url string
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := HttpGetDoKey(tt.args.url)
			if (err != nil) != tt.wantErr {
				t.Errorf("HttpGetDoKey() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("HttpGetDoKey() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHttpGetDoKeyMap(t *testing.T) {
	type args struct {
		url string
	}
	tests := []struct {
		name    string
		args    args
		want    map[string]interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := HttpGetDoKeyMap(tt.args.url)
			if (err != nil) != tt.wantErr {
				t.Errorf("HttpGetDoKeyMap() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("HttpGetDoKeyMap() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHttpPost(t *testing.T) {
	type args struct {
		url  string
		body string
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := HttpPost(tt.args.url, tt.args.body)
			if (err != nil) != tt.wantErr {
				t.Errorf("HttpPost() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("HttpPost() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestIntegerInit(t *testing.T) {
	type args struct {
		value string
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := IntegerInit(tt.args.value); got != tt.want {
				t.Errorf("IntegerInit() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestIsNumber(t *testing.T) {
	type args struct {
		input string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := IsNumber(tt.args.input); got != tt.want {
				t.Errorf("IsNumber() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestIsNumberInt(t *testing.T) {
	type args struct {
		input string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := IsNumberInt(tt.args.input); got != tt.want {
				t.Errorf("IsNumberInt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMapToString(t *testing.T) {
	type args struct {
		m map[string]string
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MapToString(tt.args.m)
			if (err != nil) != tt.wantErr {
				t.Errorf("MapToString() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("MapToString() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRandFloat64(t *testing.T) {
	type args struct {
		min float64
		max float64
	}
	tests := []struct {
		name string
		args args
		want float64
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := RandFloat64(tt.args.min, tt.args.max); got != tt.want {
				t.Errorf("RandFloat64() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRandInt(t *testing.T) {
	tests := []struct {
		name string
		want decimal.Decimal
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := RandInt(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("RandInt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRandInt64(t *testing.T) {
	type args struct {
		min int64
		max int64
	}
	tests := []struct {
		name string
		args args
		want int64
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := RandInt64(tt.args.min, tt.args.max); got != tt.want {
				t.Errorf("RandInt64() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestReplaceStr(t *testing.T) {
	type args struct {
		value string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ReplaceStr(tt.args.value); got != tt.want {
				t.Errorf("ReplaceStr() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestReplaceStrByValue(t *testing.T) {
	type args struct {
		str   string
		value string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ReplaceStrByValue(tt.args.str, tt.args.value); got != tt.want {
				t.Errorf("ReplaceStrByValue() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestStrReplace(t *testing.T) {
	type args struct {
		str string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := StrReplace(tt.args.str); got != tt.want {
				t.Errorf("StrReplace() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestStringToInt(t *testing.T) {
	type args struct {
		str string
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := StringToInt(tt.args.str); got != tt.want {
				t.Errorf("StringToInt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeAddDay(t *testing.T) {
	type args struct {
		day string
	}
	tests := []struct {
		name    string
		args    args
		want    time.Time
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := TimeAddDay(tt.args.day)
			if (err != nil) != tt.wantErr {
				t.Errorf("TimeAddDay() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("TimeAddDay() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeAddDaySend(t *testing.T) {
	type args struct {
		day string
	}
	tests := []struct {
		name    string
		args    args
		want    time.Time
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := TimeAddDaySend(tt.args.day)
			if (err != nil) != tt.wantErr {
				t.Errorf("TimeAddDaySend() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("TimeAddDaySend() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeAddDayZero(t *testing.T) {
	type args struct {
		dayInt int
	}
	tests := []struct {
		name string
		args args
		want time.Time
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := TimeAddDayZero(tt.args.dayInt); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("TimeAddDayZero() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeComparison(t *testing.T) {
	type args struct {
		stopTime time.Time
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := TimeComparison(tt.args.stopTime); got != tt.want {
				t.Errorf("TimeComparison() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeDateToMaoSend(t *testing.T) {
	type args struct {
		t time.Time
	}
	tests := []struct {
		name string
		args args
		want int64
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := TimeDateToMaoSend(tt.args.t); got != tt.want {
				t.Errorf("TimeDateToMaoSend() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeMaoSendToString(t *testing.T) {
	type args struct {
		i int64
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := TimeMaoSendToString(tt.args.i); got != tt.want {
				t.Errorf("TimeMaoSendToString() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeStopTime(t *testing.T) {
	type args struct {
		day string
	}
	tests := []struct {
		name    string
		args    args
		want    time.Time
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := TimeStopTime(tt.args.day)
			if (err != nil) != tt.wantErr {
				t.Errorf("TimeStopTime() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("TimeStopTime() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeStringToIn64(t *testing.T) {
	type args struct {
		t string
	}
	tests := []struct {
		name string
		args args
		want int64
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := TimeStringToIn64(tt.args.t); got != tt.want {
				t.Errorf("TimeStringToIn64() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeStringToTime(t *testing.T) {
	type args struct {
		t string
	}
	tests := []struct {
		name string
		args args
		want time.Time
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := TimeStringToTime(tt.args.t); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("TimeStringToTime() = %v, want %v", got, tt.want)
			}
		})
	}
}