From cf16bc67debcf4aaeae4cca4c9b9dbae1b6b73e2 Mon Sep 17 00:00:00 2001
From: Yves Junqueira <yves.junqueira@gmail.com>
Date: Mon, 16 Jul 2012 02:29:17 +0200
Subject: [PATCH] Start fixing TestUnmarshal.

Fixed unmarshalling for int, strings and slices. TODO: Fix maps.

Related to issue #4.
---
 bencode_test.go | 20 +++++++++-----------
 struct.go       |  8 +++++---
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/bencode_test.go b/bencode_test.go
index 91e9f6b..504d980 100644
--- a/bencode_test.go
+++ b/bencode_test.go
@@ -53,8 +53,7 @@ func fuzzyEqual(a, b any) bool {
 
 func checkFuzzyEqualValue(a, b reflect.Value) (err error) {
 	if !fuzzyEqualValue(a, b) {
-		err = errors.New(fmt.Sprint(a, " != ", b,
-			": ", a.Interface(), "!=", b.Interface()))
+		err = fmt.Errorf("Wanted %v(%v) got %v(%v)", a, a.Interface(), b, b.Interface())
 	}
 	return
 }
@@ -189,9 +188,9 @@ func checkUnmarshal(expected string, data any) (err error) {
 		return
 	}
 	dataValue := reflect.ValueOf(data)
-	newOne := reflect.New(dataValue.Type())
+	newOne := reflect.New(reflect.TypeOf(data))
 	buf := bytes.NewBufferString(expected)
-	if err = Unmarshal(buf, newOne.Interface()); err != nil {
+	if err = UnmarshalValue(buf, newOne); err != nil {
 		return
 	}
 	if err = checkFuzzyEqualValue(dataValue, newOne.Elem()); err != nil {
@@ -235,15 +234,15 @@ type structA struct {
 
 // TODO: make this test pass.
 
-func xTestUnmarshal(t *testing.T) {
+func TestUnmarshal(t *testing.T) {
 	type structNested struct {
 		T string            "t"
 		Y string            "y"
 		Q string            "q"
 		A map[string]string "a"
 	}
-	innerDict := map[string]string{"id": "abcdefghij0123456789"}
-	nestedDictionary := structNested{"aa", "q", "ping", innerDict}
+	//innerDict := map[string]string{"id": "abcdefghij0123456789"}
+	//nestedDictionary := structNested{"aa", "q", "ping", innerDict}
 
 	tests := []SVPair{
 		SVPair{"i100e", 100},
@@ -256,12 +255,11 @@ func xTestUnmarshal(t *testing.T) {
 		SVPair{"l3:abc3:defe", []string{"abc", "def"}},
 		SVPair{"li42e3:abce", []any{42, "abc"}},
 		SVPair{"de", map[string]any{}},
-		SVPair{"d3:cati1e3:dogi2ee", map[string]any{"cat": 1, "dog": 2}},
-		SVPair{"d1:ai10e1:b3:fooe", structA{10, "foo"}},
-		SVPair{"d1:ad2:id20:abcdefghij0123456789e1:q4:ping1:t2:aa1:y1:qe", nestedDictionary},
+		//SVPair{"d3:cati1e3:dogi2ee", map[string]any{"cat": 1, "dog": 2}},
+		//SVPair{"d1:ai10e1:b3:fooe", structA{10, "foo"}},
+		//SVPair{"d1:ad2:id20:abcdefghij0123456789e1:q4:ping1:t2:aa1:y1:qe", nestedDictionary},
 	}
 	for _, sv := range tests {
-		println(sv.s)
 		if err := checkUnmarshal(sv.s, sv.v); err != nil {
 			t.Error(err.Error())
 		}
diff --git a/struct.go b/struct.go
index 4576759..f7e231b 100644
--- a/struct.go
+++ b/struct.go
@@ -52,6 +52,8 @@ func setint(val reflect.Value, i int64) {
 		v.SetUint(uint64(i))
 	case reflect.Interface:
 		v.Set(reflect.ValueOf(i))
+	default:
+		panic("setint called for bogus type: " + val.Kind().String())
 	}
 }
 
@@ -266,7 +268,7 @@ func Unmarshal(r io.Reader, val interface{}) (err error) {
 		err = errors.New("Attempt to unmarshal into a non-pointer")
 		return
 	}
-	err = UnmarshalValue(r, reflect.ValueOf(val))
+	err = UnmarshalValue(r, reflect.Indirect(reflect.ValueOf(val)))
 	return
 }
 
@@ -276,9 +278,9 @@ func Unmarshal(r io.Reader, val interface{}) (err error) {
 func UnmarshalValue(r io.Reader, v reflect.Value) (err error) {
 	var b *structBuilder
 
-	// If val is a pointer to a slice, we append to the slice.
+	// XXX: Decide if the extra codnitions are needed. Affect map?
 	if ptr := v; ptr.Kind() == reflect.Ptr {
-		if slice := ptr.Elem(); slice.Kind() == reflect.Slice {
+		if slice := ptr.Elem(); slice.Kind() == reflect.Slice || slice.Kind() == reflect.Int || slice.Kind() == reflect.String {
 			b = &structBuilder{val: slice}
 		}
 	}