implement MustFromHex, MustFromDecimal (#131)

The PR #128 added MustFromBig, this PR adds two similar helpers: MustFromHex and MustFromDecimal.

	// MustFromHex is a convenience-constructor to create an Int from
	// a hexadecimal string.
	// Returns a new Int and panics if any error occurred.
	func MustFromHex(hex string) *Int
	
	// MustFromDecimal is a convenience-constructor to create an Int from a
	// decimal (base 10) string.
	// Returns a new Int and panics if any error occurred.
	func MustFromDecimal(decimal string) *Int

conversion.go

@@ -127,6 +127,17 @@ func FromHex(hex string) (*Int, error) {
 	return &z, nil
 }
 
+// MustFromHex is a convenience-constructor to create an Int from
+// a hexadecimal string.
+// Returns a new Int and panics if any error occurred.
+func MustFromHex(hex string) *Int {
+	var z Int
+	if err := z.fromHex(hex); err != nil {
+		panic(err)
+	}
+	return &z
+}
+
 // UnmarshalText implements encoding.TextUnmarshaler
 func (z *Int) UnmarshalText(input []byte) error {
 	z.Clear()

conversion_test.go

@@ -81,19 +81,9 @@ func TestFromBig(t *testing.T) {
 	if !b.Eq(new(Int)) {
 		t.Fatalf("got %x exp 0", b.Bytes())
 	}
-	done := make(chan struct{})
-	go func() {
-		defer func() {
-			o = recover() != nil
-			done <- struct{}{}
-		}()
-		MustFromBig(a)
-	}()
-	<-done
-	if !o {
+	if !causesPanic(func() { MustFromBig(a) }) {
 		t.Fatalf("expected overflow")
 	}
-
 	a.Sub(a, big.NewInt(1))
 	b, o = FromBig(a)
 	if o {
@@ -199,16 +189,7 @@ func TestFromBigOverflow(t *testing.T) {
 		t.Errorf("expected overflow, got %v", o)
 	}
 	// Test overflow with panic (recovery is a bit unwieldy)
-	done := make(chan struct{})
-	go func() {
-		defer func() {
-			o = recover() != nil
-			done <- struct{}{}
-		}()
-		MustFromBig(b)
-	}()
-	<-done
-	if !o {
+	if !causesPanic(func() { MustFromBig(b) }) {
 		t.Fatalf("expected overflow")
 	}
 	// Test no overflow
@@ -1159,9 +1140,29 @@ func TestEncode(t *testing.T) {
 	}
 }
 
+// causesPanic returns true if panic occurred when executing fn.
+func causesPanic(fn func()) bool {
+	done := make(chan struct{})
+	var ok bool
+	go func() {
+		defer func() {
+			ok = recover() != nil
+			done <- struct{}{}
+		}()
+		fn()
+	}()
+	<-done
+	return ok
+}
+
 func TestDecode(t *testing.T) {
 	for _, test := range decodeBigTests {
 		dec, err := FromHex(test.input)
+		if err != nil {
+			if !causesPanic(func() { MustFromHex(test.input) }) {
+				t.Fatalf("expected panic")
+			}
+		}
 		if !checkError(t, test.input, err, test.wantErr) {
 			continue
 		}
@@ -1170,6 +1171,10 @@ func TestDecode(t *testing.T) {
 			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, dec, test.want)
 			continue
 		}
+		d2 := MustFromHex(test.input)
+		if !d2.Eq(dec) {
+			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, d2, dec)
+		}
 	}
 	// Some remaining json-tests
 	type jsonStruct struct {

decimal.go

@@ -120,6 +120,17 @@ func FromDecimal(decimal string) (*Int, error) {
 	return &z, nil
 }
 
+// MustFromDecimal is a convenience-constructor to create an Int from a
+// decimal (base 10) string.
+// Returns a new Int and panics if any error occurred.
+func MustFromDecimal(decimal string) *Int {
+	var z Int
+	if err := z.SetFromDecimal(decimal); err != nil {
+		panic(err)
+	}
+	return &z
+}
+
 // SetFromDecimal sets z from the given string, interpreted as a decimal number.
 // OBS! This method is _not_ strictly identical to the (*big.Int).SetString(..., 10) method.
 // Notable differences:

decimal_test.go

@@ -5,6 +5,7 @@
 package uint256
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
 	"testing"
@@ -19,6 +20,14 @@ func testSetFromDec(tc string) error {
 		if (err == nil) != (err2 == nil) {
 			return fmt.Errorf("err != err2: %v %v", err, err2)
 		}
+		// Test the MustFromDecimal too
+		if err != nil {
+			if !causesPanic(func() { MustFromDecimal(tc) }) {
+				return errors.New("expected panic")
+			}
+		} else {
+			MustFromDecimal(tc) // must not manic
+		}
 		if err == nil {
 			if a.Cmp(b) != 0 {
 				return fmt.Errorf("a != b: %v %v", a, b)