From 78363e9036968d6639fac5e657aa8416f3d4d6d5 Mon Sep 17 00:00:00 2001
From: Dima Gordenko <1.e4.kc6@gmail.com>
Date: Mon, 8 Jun 2026 15:56:02 +0300
Subject: [PATCH] added WriteVarInt64 ReadVarInt64

---
 bin_test.go           |  7 +++++--
 little/little.go      | 38 +++++++++++++++++++++++++-------------
 little/little_test.go | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 76 insertions(+), 15 deletions(-)

diff --git a/bin_test.go b/bin_test.go
index 9f8c052..8b623bb 100644
--- a/bin_test.go
+++ b/bin_test.go
@@ -3,7 +3,6 @@ package bin
 import (
 	"bytes"
 	"fmt"
-	"math"
 	"strconv"
 	"testing"
 	"time"
@@ -655,7 +654,11 @@ func TestInt32(t *testing.T) {
 
 	byteOrder := HL
 
-	err := WriteInt32(buf, ^math.MaxInt32, byteOrder)
+	//var origin int32 = -2147483648
+	//var origin int32 = math.MaxInt32
+	var origin int32 = 12141132
+
+	err := WriteInt32(buf, origin, byteOrder)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/little/little.go b/little/little.go
index e06f0a1..fe85d58 100644
--- a/little/little.go
+++ b/little/little.go
@@ -917,7 +917,24 @@ func GetBool(a []byte) (bool, error) {
 	}
 }
 
-// VAR
+func WriteBool(w io.Writer, flag bool) (err error) {
+	var b byte
+	if flag {
+		b = 1
+	}
+	_, err = w.Write([]byte{b})
+	return
+}
+
+func ReadBool(src io.Reader) (bool, error) {
+	b, err := ReadByte(src)
+	if err != nil {
+		return false, err
+	}
+	return b == 1, nil
+}
+
+// WRITE & READ VAR INT/UINT
 
 // WriteVarUint32 - записывает в Writer от 1 до 5 байт, возвращает количество
 // записанных байт. Порядок байт - от младшего к старшему. Значение последнего
@@ -940,7 +957,7 @@ func WriteVarUint32(w io.Writer, num uint32) (i int) {
 // ReadVarUint32 - читает из io.Reader от 1 до 5 байт, и декодирует их в uint32.
 func ReadVarUint32(src io.Reader) (num uint32, err error) {
 	var b byte
-	for i := 0; i < 5; i++ {
+	for i := range 5 {
 		b, err = ReadByte(src)
 		if err != nil {
 			return
@@ -997,21 +1014,16 @@ func ReadVarUint64(src io.Reader) (num uint64, err error) {
 	return
 }
 
-func WriteBool(w io.Writer, flag bool) (err error) {
-	var b byte
-	if flag {
-		b = 1
-	}
-	_, err = w.Write([]byte{b})
-	return
+func WriteVarInt64(w io.Writer, num int64) (int, error) {
+	return WriteVarUint64(w, EncodeZigZag(num))
 }
 
-func ReadBool(src io.Reader) (bool, error) {
-	b, err := ReadByte(src)
+func ReadVarInt64(r io.Reader) (int64, error) {
+	u64, err := ReadVarUint64(r)
 	if err != nil {
-		return false, err
+		return 0, err
 	}
-	return b == 1, nil
+	return DecodeZigZag(u64), nil
 }
 
 // READ/WRITE VAR SIZE
diff --git a/little/little_test.go b/little/little_test.go
index d90388c..8faff9d 100644
--- a/little/little_test.go
+++ b/little/little_test.go
@@ -907,6 +907,52 @@ func TestPutGetVarUint64(t *testing.T) {
 	}
 }
 
+// WRITE & READ VAR UINT64
+
+func TestWriteReadVarUint64(t *testing.T) {
+	for _, testCase := range varUint64TestCases {
+		w := bytes.NewBuffer(nil)
+		putCount, err := WriteVarUint64(w, testCase.Num)
+		if err != nil {
+			t.Fatalf("put %d: %s\n", testCase.Num, err)
+		}
+		decoded, err := ReadVarUint64(w)
+		if err != nil {
+			t.Fatalf("get %d: %s\n", testCase.Num, err)
+		}
+		if decoded != testCase.Num {
+			t.Fatalf("num %d not equal decoded %d", testCase.Num, decoded)
+		}
+		if putCount != testCase.Count {
+			t.Fatalf("count %d not equal put count %d of num %d",
+				testCase.Count, putCount, testCase.Num)
+		}
+	}
+}
+
+// WRITE & READ VAR INT64
+
+func TestWriteReadVarInt64(t *testing.T) {
+	for _, testCase := range varInt64TestCases {
+		w := bytes.NewBuffer(nil)
+		putCount, err := WriteVarInt64(w, testCase.Num)
+		if err != nil {
+			t.Fatalf("put %d: %s\n", testCase.Num, err)
+		}
+		decoded, err := ReadVarInt64(w)
+		if err != nil {
+			t.Fatalf("get %d: %s\n", testCase.Num, err)
+		}
+		if decoded != testCase.Num {
+			t.Fatalf("num %d not equal decoded %d", testCase.Num, decoded)
+		}
+		if putCount != testCase.Count {
+			t.Fatalf("count %d not equal put count %d of num %d",
+				testCase.Count, putCount, testCase.Num)
+		}
+	}
+}
+
 // WRITE & READ VAR SIZE
 
 func TestWriteReadVarSize(t *testing.T) {