diff --git a/ptr/ptr.go b/ptr/ptr.go new file mode 100644 index 0000000000000000000000000000000000000000..fd522b7a70d7449dccc01ee3b2b3181eb9e7600e --- /dev/null +++ b/ptr/ptr.go @@ -0,0 +1,91 @@ +/* +Package ptr contains utility functions for converting values to pointer values. +*/ +package ptr + +import "time" + +// Bool returns a pointer to a bool value. +func Bool(b bool) *bool { + return &b +} + +// Byte returns a pointer to a byte value. +func Byte(b byte) *byte { + return &b +} + +// Int returns a pointer to an int value. +func Int(i int) *int { + return &i +} + +// Int8 returns a pointer to an int8 value. +func Int8(i int8) *int8 { + return &i +} + +// Int16 returns a pointer to an int16 value. +func Int16(i int16) *int16 { + return &i +} + +// Int32 returns a pointer to an int32 value. +func Int32(i int32) *int32 { + return &i +} + +// Int64 returns a pointer to an int64 value. +func Int64(i int64) *int64 { + return &i +} + +// Uint returns a pointer to a uint value. +func Uint(u uint) *uint { + return &u +} + +// Uint8 returns a pointer to a uint8 value. +func Uint8(u uint8) *uint8 { + return &u +} + +// Uint16 returns a pointer to a uint16 value. +func Uint16(u uint16) *uint16 { + return &u +} + +// Uint32 returns a pointer to a uint32 value. +func Uint32(u uint32) *uint32 { + return &u +} + +// Uint64 returns a pointer to a uint64 value. +func Uint64(u uint64) *uint64 { + return &u +} + +// Float32 returns a pointer to a float32 value. +func Float32(f float32) *float32 { + return &f +} + +// Float64 returns a pointer to a float64 value. +func Float64(f float64) *float64 { + return &f +} + +// Rune returns a pointer to a rune value. +func Rune(r rune) *rune { + return &r +} + +// String returns a pointer to a string value. +func String(s string) *string { + return &s +} + +// Time returns a pointer to a time.Time value. +func Time(t time.Time) *time.Time { + return &t +} diff --git a/ptr/ptr_test.go b/ptr/ptr_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0d67554570f38ed8d4bb0383604b2e7d4d17215f --- /dev/null +++ b/ptr/ptr_test.go @@ -0,0 +1,80 @@ +package ptr_test + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "code.vereign.com/gaiax/tsa/golib/ptr" +) + +func TestBool(t *testing.T) { + assert.True(t, *ptr.Bool(true)) + assert.False(t, *ptr.Bool(false)) +} + +func TestByte(t *testing.T) { + assert.Equal(t, byte(64), *ptr.Byte(64)) +} + +func TestInt(t *testing.T) { + assert.Equal(t, int(64), *ptr.Int(64)) +} + +func TestInt8(t *testing.T) { + assert.Equal(t, int8(64), *ptr.Int8(64)) +} + +func TestInt16(t *testing.T) { + assert.Equal(t, int16(64), *ptr.Int16(64)) +} + +func TestInt32(t *testing.T) { + assert.Equal(t, int32(64), *ptr.Int32(64)) +} + +func TestInt64(t *testing.T) { + assert.Equal(t, int64(64), *ptr.Int64(64)) +} + +func TestUint(t *testing.T) { + assert.Equal(t, uint(64), *ptr.Uint(64)) +} + +func TestUint8(t *testing.T) { + assert.Equal(t, uint8(64), *ptr.Uint8(64)) +} + +func TestUint16(t *testing.T) { + assert.Equal(t, uint16(64), *ptr.Uint16(64)) +} + +func TestUint32(t *testing.T) { + assert.Equal(t, uint32(64), *ptr.Uint32(64)) +} + +func TestUint64(t *testing.T) { + assert.Equal(t, uint64(64), *ptr.Uint64(64)) +} + +func TestFloat32(t *testing.T) { + assert.Equal(t, float32(42.5), *ptr.Float32(42.5)) +} + +func TestFloat64(t *testing.T) { + assert.Equal(t, float64(42.5), *ptr.Float64(42.5)) +} + +func TestRune(t *testing.T) { + assert.Equal(t, 'r', *ptr.Rune('r')) +} + +func TestString(t *testing.T) { + assert.Equal(t, "mystring", *ptr.String("mystring")) +} + +func TestTime(t *testing.T) { + now := time.Now() + assert.Equal(t, now, *ptr.Time(now)) +}