matchmaking-system/internal/data/convert/order_test.go

package convert

import (
	"context"
	"matchmaking-system/internal/biz/structure"
	models "matchmaking-system/internal/pkg/model"
	"reflect"
	"testing"
	"time"
)

func TestBotContractCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotContractTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotContractCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotContractCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotContractClosingByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotContractTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotContractClosingByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotContractClosingByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotContractSecTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ContractOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotContractSecTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotContractSecTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotContractSecTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotContractStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotContractTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotContractStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotContractStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotContractTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ContractOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotContractTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotContractTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotContractTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotDigitalTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.SpotsOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotDigitalTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotDigitalTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotDigitalTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockHkdCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockHkdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockHkdCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockHkdCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockHkdTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockHkdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockHkdTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockHkdTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockHkdTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockHkdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockHkdTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockHkdTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockIdnCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockIdnTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockIdnCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockIdnCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockIdnStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockIdnTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockIdnStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockIdnStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockIdnTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockIdnTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockIdnTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockIdnTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockIdnTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockIdnTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockIdnTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockIdnTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockInCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockInTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockInCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockInCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockInStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockInTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockInStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockInStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockInTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockInTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockInTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockInTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockInrTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockInTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockInrTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockInrTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockMysCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockMysTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockMysCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockMysCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockMysStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockMysTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockMysStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockMysStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockMysTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockMysTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockMysTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockMysTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockMysTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockMysTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockMysTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockMysTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockOptionInrCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockOptionInrTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockOptionInrCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockOptionInrCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockOptionInrStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockOptionInrTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockOptionInrStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockOptionInrStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockOptionInrTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockOptionInrTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockOptionInrTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockOptionInrTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockSgdCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockSgdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockSgdCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockSgdCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockSgdStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockSgdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockSgdStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockSgdStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockSgdTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockSgdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockSgdTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockSgdTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockSgdTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockSgdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockSgdTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockSgdTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockStopHkdByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockHkdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockStopHkdByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockStopHkdByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockThaCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotStockThaTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockThaCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockThaCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockThaStopByOrderId(t *testing.T) {
	type args struct {
		ctx   context.Context
		order structure.StopOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockThaTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockThaStopByOrderId(tt.args.ctx, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockThaStopByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockThaTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockThaTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockThaTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockThaTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockThaTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockThaTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockThaTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockThaTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockTrade(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockTrade(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotStockTradePre(t *testing.T) {
	type args struct {
		ctx     context.Context
		userId  int64
		orderId string
		order   structure.ShareOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotStockTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotStockTradePre(tt.args.ctx, tt.args.userId, tt.args.orderId, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotStockTradePre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestBotUserDigital(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		usableNum string
		frozenNum string
		order     structure.SpotsOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotUserDigital
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := BotUserDigital(tt.args.ctx, tt.args.userId, tt.args.usableNum, tt.args.frozenNum, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("BotUserDigital() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotTradeFee(t *testing.T) {
	type args struct {
		ctx        context.Context
		userId     int
		code       int
		marketCode int
		fee        string
		orderId    string
	}
	tests := []struct {
		name string
		args args
		want models.BotTradeFee
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotTradeFee(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.marketCode, tt.args.fee, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotTradeFee() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserBrokerage(t *testing.T) {
	type args struct {
		ctx          context.Context
		backType     int
		userId       int
		LevelType    int
		fee          string
		brokerageNum string
		orderId      string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserBrokerage
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserBrokerage(tt.args.ctx, tt.args.backType, tt.args.userId, tt.args.LevelType, tt.args.fee, tt.args.brokerageNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserBrokerage() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserContract(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		usableNum string
		frozenNum string
		order     structure.ContractOrder
	}
	tests := []struct {
		name string
		args args
		want models.BotUserContract
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserContract(tt.args.ctx, tt.args.userId, tt.args.usableNum, tt.args.frozenNum, tt.args.order); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserContract() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserContractLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserContractLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserContractLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserContractLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserContractSecLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserContractSecLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserContractSecLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserContractSecLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserDigitalLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserDigitalLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserDigitalLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserDigitalLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockHkdLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockHkdLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockHkdLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockHkdLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockHkdPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockHkd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockHkdPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockHkdPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockIdnLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIdnLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockIdnLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockIdnLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockIdnPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIdn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockIdnPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockIdnPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockInLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockInLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockInLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockInLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockInPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockInPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockInPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockMysLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockMysLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockMysLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockMysLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockMysPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockMys
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockMysPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockMysPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockOptionInrLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockOptionInrLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockOptionInrLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockOptionInrLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStock
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockSgdLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockSgdLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockSgdLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockSgdLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockSgdPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockSgd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockSgdPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockSgdPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockThaLog(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		code      int64
		symbol    string
		changeNum string
		orderId   string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockThaLog
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockThaLog(tt.args.ctx, tt.args.userId, tt.args.code, tt.args.symbol, tt.args.changeNum, tt.args.orderId); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockThaLog() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreatBotUserStockThaPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockTha
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreatBotUserStockThaPre(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreatBotUserStockThaPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStock(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStock
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStock(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStock() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockHkd(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockHkd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockHkd(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockHkd() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockIdn(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIdn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockIdn(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockIdn() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockIn(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockIn(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockIn() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockMys(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockMys
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockMys(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockMys() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockOptionInr(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockOptionInr
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockOptionInr(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockOptionInr() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockSgd(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockSgd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockSgd(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockSgd() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateBotUserStockTha(t *testing.T) {
	type args struct {
		ctx       context.Context
		userId    int64
		stockId   string
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockTha
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateBotUserStockTha(tt.args.ctx, tt.args.userId, tt.args.stockId, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateBotUserStockTha() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateRandCodeOrder(t *testing.T) {
	type args struct {
		n int
	}
	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 := CreateRandCodeOrder(tt.args.n); got != tt.want {
				t.Errorf("CreateRandCodeOrder() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotDigitalCancelByOrderId(t *testing.T) {
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name string
		args args
		want models.BotDigitalTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotDigitalCancelByOrderId(tt.args.ctx); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotDigitalCancelByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotDigitalStatusByOrderId(t *testing.T) {
	type args struct {
		ctx             context.Context
		closingPrice    string
		closingCost     string
		orderMoneyPrice string
		totalMoneyPrice string
		OrderNumber     string
	}
	tests := []struct {
		name string
		args args
		want models.BotDigitalTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotDigitalStatusByOrderId(tt.args.ctx, tt.args.closingPrice, tt.args.closingCost, tt.args.orderMoneyPrice, tt.args.totalMoneyPrice, tt.args.OrderNumber); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotDigitalStatusByOrderId() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserContract(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserContract
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserContract(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserContract() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserContractSec(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserContractSec
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserContractSec(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserContractSec() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserDigital(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserDigital
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserDigital(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserDigital() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserDigitalByFrozenNum(t *testing.T) {
	type args struct {
		ctx       context.Context
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserDigital
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserDigitalByFrozenNum(tt.args.ctx, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserDigitalByFrozenNum() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserDigitalByUsableNum(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserDigital
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserDigitalByUsableNum(tt.args.ctx, tt.args.usableNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserDigitalByUsableNum() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStock(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStock
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStock(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStock() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockHkd(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockHkd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockHkd(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockHkd() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockHkdPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockHkd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockHkdPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockHkdPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockIdn(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIdn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockIdn(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockIdn() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockIdnPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIdn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockIdnPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockIdnPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockIn(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockIn(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockIn() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockInPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockIn
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockInPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockInPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockMys(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockMys
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockMys(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockMys() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockMysPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockMys
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockMysPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockMysPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockOptionInr(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockOptionInr
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockOptionInr(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockOptionInr() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStock
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockSgd(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockSgd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockSgd(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockSgd() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockSgdPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockSgd
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockSgdPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockSgdPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockTha(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockTha
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockTha(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockTha() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateBotUserStockThaPre(t *testing.T) {
	type args struct {
		ctx       context.Context
		usableNum string
		frozenNum string
	}
	tests := []struct {
		name string
		args args
		want models.BotUserStockTha
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateBotUserStockThaPre(tt.args.ctx, tt.args.usableNum, tt.args.frozenNum); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateBotUserStockThaPre() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotContractSecTrade(t *testing.T) {
	type args struct {
		ctx          context.Context
		price        string
		earnestMoney string
		totalMoney   string
		serviceCost  string
		orderValue   string
		orderStatus  int
		closeTime    time.Time
	}
	tests := []struct {
		name string
		args args
		want models.BotContractSecTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotContractSecTrade(tt.args.ctx, tt.args.price, tt.args.earnestMoney, tt.args.totalMoney, tt.args.serviceCost, tt.args.orderValue, tt.args.orderStatus, tt.args.closeTime); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotContractSecTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotContractTrade(t *testing.T) {
	type args struct {
		ctx          context.Context
		price        string
		earnestMoney string
		totalMoney   string
		serviceCost  string
	}
	tests := []struct {
		name string
		args args
		want models.BotContractTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotContractTrade(tt.args.ctx, tt.args.price, tt.args.earnestMoney, tt.args.totalMoney, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotContractTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockHkdTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockHkdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockHkdTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockHkdTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockIdnTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockIdnTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockIdnTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockIdnTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockInTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockInTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockInTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockInTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockMysTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockMysTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockMysTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockMysTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockOptionInrTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockOptionInrTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockOptionInrTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockOptionInrTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockSgdTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockSgdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockSgdTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockSgdTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockThaTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockThaTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockThaTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockThaTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateCloseBotStockTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateCloseBotStockTrade(tt.args.ctx, tt.args.price, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateCloseBotStockTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotContractSecTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		orderNumber string
		totalMoney  string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotContractSecTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotContractSecTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotContractSecTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotContractTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		orderNumber string
		totalMoney  string
		serviceCost string
	}
	tests := []struct {
		name string
		args args
		want models.BotContractTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotContractTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotContractTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockHkdTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		orderNumber string
		totalMoney  string
		serviceCost string
		marketMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockHkdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockHkdTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.marketMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockHkdTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockIdnTrade(t *testing.T) {
	type args struct {
		ctx             context.Context
		price           string
		orderNumber     string
		totalMoney      string
		serviceCost     string
		openMarketMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockIdnTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockIdnTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.openMarketMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockIdnTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockInTrade(t *testing.T) {
	type args struct {
		ctx             context.Context
		price           string
		orderNumber     string
		totalMoney      string
		serviceCost     string
		openMarketMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockInTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockInTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.openMarketMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockInTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockMysTrade(t *testing.T) {
	type args struct {
		ctx             context.Context
		price           string
		orderNumber     string
		totalMoney      string
		serviceCost     string
		openMarkerMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockMysTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockMysTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.openMarkerMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockMysTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockOptionInrTrade(t *testing.T) {
	type args struct {
		ctx             context.Context
		price           string
		orderNumber     string
		totalMoney      string
		serviceCost     string
		openMarketMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockOptionInrTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockOptionInrTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.openMarketMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockOptionInrTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockSgdTrade(t *testing.T) {
	type args struct {
		ctx             context.Context
		price           string
		orderNumber     string
		totalMoney      string
		serviceCost     string
		openMarkerMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockSgdTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockSgdTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.openMarkerMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockSgdTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockThaTrade(t *testing.T) {
	type args struct {
		ctx             context.Context
		price           string
		orderNumber     string
		totalMoney      string
		serviceCost     string
		openMarkerMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockThaTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockThaTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.openMarkerMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockThaTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestUpdateOpenBotStockTrade(t *testing.T) {
	type args struct {
		ctx         context.Context
		price       string
		orderNumber string
		totalMoney  string
		serviceCost string
		marketMoney string
	}
	tests := []struct {
		name string
		args args
		want models.BotStockTrade
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := UpdateOpenBotStockTrade(tt.args.ctx, tt.args.price, tt.args.orderNumber, tt.args.totalMoney, tt.args.serviceCost, tt.args.marketMoney); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UpdateOpenBotStockTrade() = %v, want %v", got, tt.want)
			}
		})
	}
}