From cfcb3925bb647eff4edb15a94d82bc54fd7fbe78 Mon Sep 17 00:00:00 2001
From: Jonathan Schweder <jonathanschweder@gmail.com>
Date: Sun, 25 Dec 2022 11:13:23 +0000
Subject: [PATCH] [FEATURE] Add methods for uints (#127)

Fixes #125

Signed-off-by: Jonathan Schweder <jonathanschweder@amazon.com>
---
 faker.go      | 41 +++++++++++++++++++++++++++++++++---
 faker_test.go | 58 ++++++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 93 insertions(+), 6 deletions(-)

diff --git a/faker.go b/faker.go
index e9b909f..d154492 100644
--- a/faker.go
+++ b/faker.go
@@ -173,9 +173,14 @@ func (f Faker) IntBetween(min, max int) int {
 	return f.Generator.Intn(diff+1) + min
 }
 
-// Int64Between returns a fake Int64 between a given minimum and maximum values for Faker
-func (f Faker) Int64Between(min, max int64) int64 {
-	return int64(f.IntBetween(int(min), int(max)))
+// Int8Between returns a fake Int8 between a given minimum and maximum values for Faker
+func (f Faker) Int8Between(min, max int8) int8 {
+	return int8(f.IntBetween(int(min), int(max)))
+}
+
+// Int16Between returns a fake Int16 between a given minimum and maximum values for Faker
+func (f Faker) Int16Between(min, max int16) int16 {
+	return int16(f.IntBetween(int(min), int(max)))
 }
 
 // Int32Between returns a fake Int32 between a given minimum and maximum values for Faker
@@ -183,6 +188,36 @@ func (f Faker) Int32Between(min, max int32) int32 {
 	return int32(f.IntBetween(int(min), int(max)))
 }
 
+// Int64Between returns a fake Int64 between a given minimum and maximum values for Faker
+func (f Faker) Int64Between(min, max int64) int64 {
+	return int64(f.IntBetween(int(min), int(max)))
+}
+
+// UIntBetween returns a fake UInt between a given minimum and maximum values for Faker
+func (f Faker) UIntBetween(min, max uint) uint {
+	return uint(f.IntBetween(int(min), int(max)))
+}
+
+// UInt8Between returns a fake UInt8 between a given minimum and maximum values for Faker
+func (f Faker) UInt8Between(min, max int8) uint8 {
+	return uint8(f.IntBetween(int(min), int(max)))
+}
+
+// UInt16Between returns a fake UInt16 between a given minimum and maximum values for Faker
+func (f Faker) UInt16Between(min, max int16) uint16 {
+	return uint16(f.IntBetween(int(min), int(max)))
+}
+
+// UInt32Between returns a fake UInt32 between a given minimum and maximum values for Faker
+func (f Faker) UInt32Between(min, max uint32) uint32 {
+	return uint32(f.IntBetween(int(min), int(max)))
+}
+
+// UInt64Between returns a fake UInt64 between a given minimum and maximum values for Faker
+func (f Faker) UInt64Between(min, max uint64) uint64 {
+	return uint64(f.IntBetween(int(min), int(max)))
+}
+
 // Letter returns a fake single letter for Faker
 func (f Faker) Letter() string {
 	return f.RandomLetter()
diff --git a/faker_test.go b/faker_test.go
index e9db5f8..bbe3c77 100644
--- a/faker_test.go
+++ b/faker_test.go
@@ -118,10 +118,16 @@ func TestInt(t *testing.T) {
 	Expect(t, fmt.Sprintf("%T", value), "int")
 }
 
-func TestInt64(t *testing.T) {
+func TestInt8(t *testing.T) {
 	f := New()
-	value := f.Int64()
-	Expect(t, fmt.Sprintf("%T", value), "int64")
+	value := f.Int8()
+	Expect(t, fmt.Sprintf("%T", value), "int8")
+}
+
+func TestInt16(t *testing.T) {
+	f := New()
+	value := f.Int16()
+	Expect(t, fmt.Sprintf("%T", value), "int16")
 }
 
 func TestInt32(t *testing.T) {
@@ -130,6 +136,12 @@ func TestInt32(t *testing.T) {
 	Expect(t, fmt.Sprintf("%T", value), "int32")
 }
 
+func TestInt64(t *testing.T) {
+	f := New()
+	value := f.Int64()
+	Expect(t, fmt.Sprintf("%T", value), "int64")
+}
+
 func TestIntBetween(t *testing.T) {
 	f := New()
 	value := f.IntBetween(1, 100)
@@ -216,6 +228,46 @@ func TestUint64(t *testing.T) {
 	Expect(t, fmt.Sprintf("%T", value), "uint64")
 }
 
+func TestUIntBetween(t *testing.T) {
+	f := New()
+	value := f.UIntBetween(1, 100)
+	Expect(t, fmt.Sprintf("%T", value), "uint")
+	Expect(t, true, value >= 1)
+	Expect(t, true, value <= 100)
+}
+
+func TestUInt8Between(t *testing.T) {
+	f := New()
+	value := f.UInt8Between(1, 100)
+	Expect(t, fmt.Sprintf("%T", value), "uint8")
+	Expect(t, true, value >= 1)
+	Expect(t, true, value <= 100)
+}
+
+func TestUInt16Between(t *testing.T) {
+	f := New()
+	value := f.UInt16Between(1, 100)
+	Expect(t, fmt.Sprintf("%T", value), "uint16")
+	Expect(t, true, value >= 1)
+	Expect(t, true, value <= 100)
+}
+
+func TestUInt32Between(t *testing.T) {
+	f := New()
+	value := f.UInt32Between(1, 100)
+	Expect(t, fmt.Sprintf("%T", value), "uint32")
+	Expect(t, true, value >= 1)
+	Expect(t, true, value <= 100)
+}
+
+func TestUInt64Between(t *testing.T) {
+	f := New()
+	value := f.UInt64Between(1, 100)
+	Expect(t, fmt.Sprintf("%T", value), "uint64")
+	Expect(t, true, value >= 1)
+	Expect(t, true, value <= 100)
+}
+
 func TestRandomFloat(t *testing.T) {
 	f := New()
 	value := f.RandomFloat(1, 1, 100)