add helper functions in js utils

Signed-off-by: Jeeva Kandasamy <jkandasa@gmail.com>

Author: jkandasa

pkg/utils/javascript/js_helper/convert.go

@@ -51,19 +51,68 @@ func (ll *Convert) ToStringFromBase64(data interface{}) string {
 	return string(bytes)
 }
 
+// ToUInt16LE converts a 2-byte little-endian slice to a uint16.
 func (ll *Convert) ToUInt16LE(bytes []byte) uint16 {
 	return binary.LittleEndian.Uint16(bytes)
 }
 
+// ToUInt32LE converts a 4-byte little-endian slice to a uint32.
+func (ll *Convert) ToUInt32LE(bytes []byte) uint32 {
+	return binary.LittleEndian.Uint32(bytes)
+}
+
+// ToUInt64LE converts an 8-byte little-endian slice to a uint64.
+func (ll *Convert) ToUInt64LE(bytes []byte) uint64 {
+	return binary.LittleEndian.Uint64(bytes)
+}
+
+// ToInt16LE converts a 2-byte little-endian slice to an int16,
+// preserving the sign using two's complement representation.
 func (ll *Convert) ToInt16LE(bytes []byte) int16 {
-	ref := ll.ToUInt16LE(bytes)
-	if ref > 0x7fff {
-		return int16(-65536 + int(ref))
-	} else {
-		return int16(ref)
-	}
+	return int16(binary.LittleEndian.Uint16(bytes))
 }
 
+// ToInt32LE converts a 4-byte little-endian slice to an int32,
+// preserving the sign using two's complement representation.
+func (ll *Convert) ToInt32LE(bytes []byte) int32 {
+	return int32(binary.LittleEndian.Uint32(bytes))
+}
+
+// ToInt64LE converts an 8-byte little-endian slice to an int64,
+// preserving the sign using two's complement representation.
+func (ll *Convert) ToInt64LE(bytes []byte) int64 {
+	return int64(binary.LittleEndian.Uint64(bytes))
+}
+
+// ToUInt16BE converts a 2-byte big-endian slice to a uint16.
 func (ll *Convert) ToUInt16BE(bytes []byte) uint16 {
 	return binary.BigEndian.Uint16(bytes)
 }
+
+// ToUInt32BE converts a 4-byte big-endian slice to a uint32.
+func (ll *Convert) ToUInt32BE(bytes []byte) uint32 {
+	return binary.BigEndian.Uint32(bytes)
+}
+
+// ToUInt64BE converts an 8-byte big-endian slice to a uint64.
+func (ll *Convert) ToUInt64BE(bytes []byte) uint64 {
+	return binary.BigEndian.Uint64(bytes)
+}
+
+// ToInt16BE converts a 2-byte big-endian slice to an int16,
+// preserving the sign using two's complement representation.
+func (ll *Convert) ToInt16BE(bytes []byte) int16 {
+	return int16(binary.BigEndian.Uint16(bytes))
+}
+
+// ToInt32BE converts a 4-byte big-endian slice to an int32,
+// preserving the sign using two's complement representation.
+func (ll *Convert) ToInt32BE(bytes []byte) int32 {
+	return int32(binary.BigEndian.Uint32(bytes))
+}
+
+// ToInt64BE converts an 8-byte big-endian slice to an int64,
+// preserving the sign using two's complement representation.
+func (ll *Convert) ToInt64BE(bytes []byte) int64 {
+	return int64(binary.BigEndian.Uint64(bytes))
+}

pkg/utils/javascript/js_helper/convert_test.go

@@ -0,0 +1,91 @@
+package javascript_helper
+
+import (
+	"testing"
+)
+
+func TestEndianConversions(t *testing.T) {
+	conv := &Convert{}
+
+	// test data
+	leBytes16 := []byte{0x34, 0x12}                                     // 0x1234
+	leBytes32 := []byte{0x78, 0x56, 0x34, 0x12}                         // 0x12345678
+	leBytes64 := []byte{0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12} // 0x123456789ABCDEF0
+
+	beBytes16 := []byte{0x12, 0x34}
+	beBytes32 := []byte{0x12, 0x34, 0x56, 0x78}
+	beBytes64 := []byte{0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}
+
+	t.Run("ToUInt16LE", func(t *testing.T) {
+		want := uint16(0x1234)
+		got := conv.ToUInt16LE(leBytes16)
+		if got != want {
+			t.Errorf("ToUInt16LE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToUInt32LE", func(t *testing.T) {
+		want := uint32(0x12345678)
+		got := conv.ToUInt32LE(leBytes32)
+		if got != want {
+			t.Errorf("ToUInt32LE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToUInt64LE", func(t *testing.T) {
+		want := uint64(0x123456789ABCDEF0)
+		got := conv.ToUInt64LE(leBytes64)
+		if got != want {
+			t.Errorf("ToUInt64LE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToUInt16BE", func(t *testing.T) {
+		want := uint16(0x1234)
+		got := conv.ToUInt16BE(beBytes16)
+		if got != want {
+			t.Errorf("ToUInt16BE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToUInt32BE", func(t *testing.T) {
+		want := uint32(0x12345678)
+		got := conv.ToUInt32BE(beBytes32)
+		if got != want {
+			t.Errorf("ToUInt32BE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToUInt64BE", func(t *testing.T) {
+		want := uint64(0x123456789ABCDEF0)
+		got := conv.ToUInt64BE(beBytes64)
+		if got != want {
+			t.Errorf("ToUInt64BE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToInt16LE", func(t *testing.T) {
+		bytes := []byte{0xFF, 0x7F} // 0x7FFF -> 32767
+		want := int16(32767)
+		got := conv.ToInt16LE(bytes)
+		if got != want {
+			t.Errorf("ToInt16LE() = %d, want %d", got, want)
+		}
+
+		bytes = []byte{0x00, 0x80} // 0x8000 -> -32768
+		want = -32768
+		got = conv.ToInt16LE(bytes)
+		if got != want {
+			t.Errorf("ToInt16LE() = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("ToInt32BE", func(t *testing.T) {
+		bytes := []byte{0xFF, 0xFF, 0xFF, 0xFF} // -1
+		want := int32(-1)
+		got := conv.ToInt32BE(bytes)
+		if got != want {
+			t.Errorf("ToInt32BE() = %d, want %d", got, want)
+		}
+	})
+}