no err output on try wrapper funcs

2 files changed, 24 insertions, 42 deletions

diff --git a/bitreader.go b/bitreader.go
index aeade92..b84dd1b 100644
--- a/bitreader.go
+++ b/bitreader.go
@@ -24,52 +24,52 @@ func Reader(stream io.Reader, le bool) *ReaderType {
         }
 }
 
-func (reader *ReaderType) TryReadInt8() (uint8, error) {
+func (reader *ReaderType) TryReadInt8() uint8 {
         value, err := reader.ReadBits(8)
         if err != nil {
-                return 0, err
+                panic(err)
         }
-        return uint8(value), nil
+        return uint8(value)
 }
 
-func (reader *ReaderType) TryReadInt16() (uint16, error) {
+func (reader *ReaderType) TryReadInt16() uint16 {
         value, err := reader.ReadBits(16)
         if err != nil {
-                return 0, err
+                panic(err)
         }
-        return uint16(value), nil
+        return uint16(value)
 }
 
-func (reader *ReaderType) TryReadInt32() (uint32, error) {
+func (reader *ReaderType) TryReadInt32() uint32 {
         value, err := reader.ReadBits(32)
         if err != nil {
-                return 0, err
+                panic(err)
         }
-        return uint32(value), nil
+        return uint32(value)
 }
 
-func (reader *ReaderType) TryReadInt64() (uint64, error) {
+func (reader *ReaderType) TryReadInt64() uint64 {
         value, err := reader.ReadBits(64)
         if err != nil {
-                return 0, err
+                panic(err)
         }
-        return value, nil
+        return value
 }
 
-func (reader *ReaderType) TryReadFloat32() (float32, error) {
+func (reader *ReaderType) TryReadFloat32() float32 {
         value, err := reader.ReadBits(32)
         if err != nil {
-                return 0, err
+                panic(err)
         }
-        return math.Float32frombits(uint32(value)), nil
+        return math.Float32frombits(uint32(value))
 }
 
-func (reader *ReaderType) TryReadFloat64() (float64, error) {
+func (reader *ReaderType) TryReadFloat64() float64 {
         value, err := reader.ReadBits(64)
         if err != nil {
-                return 0, err
+                panic(err)
         }
-        return math.Float64frombits(value), nil
+        return math.Float64frombits(value)
 }
 
 func (reader *ReaderType) SkipBits(bits int) error {
diff --git a/bitreader_test.go b/bitreader_test.go
index d0460c7..85b0c98 100644
--- a/bitreader_test.go
+++ b/bitreader_test.go
@@ -12,10 +12,7 @@ func TestTryReadFloat32(t *testing.T) {
         bitreader := Reader(bytes.NewReader(TestArray[:]), false)
         expected := []float32{6.98198182157e+29, -2.10064170919e-18}
         for i := range expected {
-                value, err := bitreader.TryReadFloat32()
-                if err != nil {
-                        t.Fatal(err)
-                }
+                value := bitreader.TryReadFloat32()
                 if value != expected[i] {
                         t.Fatalf("TryReadFloat32 FAIL for index %d: Expected %f, Got %f", i, expected[i], value)
                 }
@@ -26,10 +23,7 @@ func TestTryReadFloat64(t *testing.T) {
         bitreader := Reader(bytes.NewReader(TestArray[:]), false)
         expected := []float64{3.68828741038253948851462939603e+236}
         for i := range expected {
-                value, err := bitreader.TryReadFloat64()
-                if err != nil {
-                        t.Fatal(err)
-                }
+                value := bitreader.TryReadFloat64()
                 if value != expected[i] {
                         t.Fatalf("TryReadFloat64 FAIL for index %d: Expected %f, Got %f", i, expected[i], value)
                 }
@@ -40,10 +34,7 @@ func TestTryReadInt8(t *testing.T) {
         bitreader := Reader(bytes.NewReader(TestArray[:]), false)
         expected := []int{113, 13, 0}
         for i := range expected {
-                value, err := bitreader.TryReadInt8()
-                if err != nil {
-                        t.Fatal(err)
-                }
+                value := bitreader.TryReadInt8()
                 if int(value) != expected[i] {
                         t.Fatalf("TryReadInt8 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
                 }
@@ -54,10 +45,7 @@ func TestTryReadInt16(t *testing.T) {
         bitreader := Reader(bytes.NewReader(TestArray[:]), false)
         expected := []int{28941, 0, 41499, 0}
         for i := range expected {
-                value, err := bitreader.TryReadInt16()
-                if err != nil {
-                        t.Fatal(err)
-                }
+                value := bitreader.TryReadInt16()
                 if int(value) != expected[i] {
                         t.Fatalf("TryReadInt16 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
                 }
@@ -68,10 +56,7 @@ func TestTryReadInt32(t *testing.T) {
         bitreader := Reader(bytes.NewReader(TestArray[:]), false)
         expected := []int{1896677376, 2719678464}
         for i := range expected {
-                value, err := bitreader.TryReadInt32()
-                if err != nil {
-                        t.Fatal(err)
-                }
+                value := bitreader.TryReadInt32()
                 if int(value) != expected[i] {
                         t.Fatalf("TryReadInt32 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
                 }
@@ -82,10 +67,7 @@ func TestTryReadInt64(t *testing.T) {
         bitreader := Reader(bytes.NewReader(TestArray[:]), false)
         expected := []int{8146167303702773760}
         for i := range expected {
-                value, err := bitreader.TryReadInt64()
-                if err != nil {
-                        t.Fatal(err)
-                }
+                value := bitreader.TryReadInt64()
                 if int(value) != expected[i] {
                         t.Fatalf("TryReadInt64 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
                 }