remove semis after statements in one-statement statement lists

R=rsc, r
http://go/go-review/1025029

1 files changed, 114 insertions, 114 deletions

diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
index f2e2f92bc..b0ed9e411 100644
--- a/src/pkg/reflect/all_test.go
+++ b/src/pkg/reflect/all_test.go
@@ -29,7 +29,7 @@ func isDigit(c uint8) bool	{ return '0' <= c && c <= '9' }
 
 func assert(t *testing.T, s, want string) {
 	if s != want {
-		t.Errorf("have %#q want %#q", s, want);
+		t.Errorf("have %#q want %#q", s, want)
 	}
 }
 
@@ -202,13 +202,13 @@ var valueTests = []pair{
 func testType(t *testing.T, i int, typ Type, want string) {
 	s := typ.String();
 	if s != want {
-		t.Errorf("#%d: have %#q, want %#q", i, s, want);
+		t.Errorf("#%d: have %#q, want %#q", i, s, want)
 	}
 }
 
 func TestTypes(t *testing.T) {
 	for i, tt := range typeTests {
-		testType(t, i, NewValue(tt.i).(*StructValue).Field(0).Type(), tt.s);
+		testType(t, i, NewValue(tt.i).(*StructValue).Field(0).Type(), tt.s)
 	}
 }
 
@@ -217,39 +217,39 @@ func TestSet(t *testing.T) {
 		v := NewValue(tt.i);
 		switch v := v.(type) {
 		case *IntValue:
-			v.Set(132);
+			v.Set(132)
 		case *Int8Value:
-			v.Set(8);
+			v.Set(8)
 		case *Int16Value:
-			v.Set(16);
+			v.Set(16)
 		case *Int32Value:
-			v.Set(32);
+			v.Set(32)
 		case *Int64Value:
-			v.Set(64);
+			v.Set(64)
 		case *UintValue:
-			v.Set(132);
+			v.Set(132)
 		case *Uint8Value:
-			v.Set(8);
+			v.Set(8)
 		case *Uint16Value:
-			v.Set(16);
+			v.Set(16)
 		case *Uint32Value:
-			v.Set(32);
+			v.Set(32)
 		case *Uint64Value:
-			v.Set(64);
+			v.Set(64)
 		case *FloatValue:
-			v.Set(3200.0);
+			v.Set(3200.0)
 		case *Float32Value:
-			v.Set(32.1);
+			v.Set(32.1)
 		case *Float64Value:
-			v.Set(64.2);
+			v.Set(64.2)
 		case *StringValue:
-			v.Set("stringy cheese");
+			v.Set("stringy cheese")
 		case *BoolValue:
-			v.Set(true);
+			v.Set(true)
 		}
 		s := valueToString(v);
 		if s != tt.s {
-			t.Errorf("#%d: have %#q, want %#q", i, s, tt.s);
+			t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
 		}
 	}
 }
@@ -259,39 +259,39 @@ func TestSetValue(t *testing.T) {
 		v := NewValue(tt.i);
 		switch v := v.(type) {
 		case *IntValue:
-			v.SetValue(NewValue(int(132)));
+			v.SetValue(NewValue(int(132)))
 		case *Int8Value:
-			v.SetValue(NewValue(int8(8)));
+			v.SetValue(NewValue(int8(8)))
 		case *Int16Value:
-			v.SetValue(NewValue(int16(16)));
+			v.SetValue(NewValue(int16(16)))
 		case *Int32Value:
-			v.SetValue(NewValue(int32(32)));
+			v.SetValue(NewValue(int32(32)))
 		case *Int64Value:
-			v.SetValue(NewValue(int64(64)));
+			v.SetValue(NewValue(int64(64)))
 		case *UintValue:
-			v.SetValue(NewValue(uint(132)));
+			v.SetValue(NewValue(uint(132)))
 		case *Uint8Value:
-			v.SetValue(NewValue(uint8(8)));
+			v.SetValue(NewValue(uint8(8)))
 		case *Uint16Value:
-			v.SetValue(NewValue(uint16(16)));
+			v.SetValue(NewValue(uint16(16)))
 		case *Uint32Value:
-			v.SetValue(NewValue(uint32(32)));
+			v.SetValue(NewValue(uint32(32)))
 		case *Uint64Value:
-			v.SetValue(NewValue(uint64(64)));
+			v.SetValue(NewValue(uint64(64)))
 		case *FloatValue:
-			v.SetValue(NewValue(float(3200.0)));
+			v.SetValue(NewValue(float(3200.0)))
 		case *Float32Value:
-			v.SetValue(NewValue(float32(32.1)));
+			v.SetValue(NewValue(float32(32.1)))
 		case *Float64Value:
-			v.SetValue(NewValue(float64(64.2)));
+			v.SetValue(NewValue(float64(64.2)))
 		case *StringValue:
-			v.SetValue(NewValue("stringy cheese"));
+			v.SetValue(NewValue("stringy cheese"))
 		case *BoolValue:
-			v.SetValue(NewValue(true));
+			v.SetValue(NewValue(true))
 		}
 		s := valueToString(v);
 		if s != tt.s {
-			t.Errorf("#%d: have %#q, want %#q", i, s, tt.s);
+			t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
 		}
 	}
 }
@@ -315,7 +315,7 @@ func TestValueToString(t *testing.T) {
 	for i, test := range valueToStringTests {
 		s := valueToString(NewValue(test.i));
 		if s != test.s {
-			t.Errorf("#%d: have %#q, want %#q", i, s, test.s);
+			t.Errorf("#%d: have %#q, want %#q", i, s, test.s)
 		}
 	}
 }
@@ -326,7 +326,7 @@ func TestArrayElemSet(t *testing.T) {
 	s := valueToString(v);
 	const want = "[10]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}";
 	if s != want {
-		t.Errorf("[10]int: have %#q want %#q", s, want);
+		t.Errorf("[10]int: have %#q want %#q", s, want)
 	}
 
 	v = NewValue([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
@@ -334,7 +334,7 @@ func TestArrayElemSet(t *testing.T) {
 	s = valueToString(v);
 	const want1 = "[]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}";
 	if s != want1 {
-		t.Errorf("[]int: have %#q want %#q", s, want1);
+		t.Errorf("[]int: have %#q want %#q", s, want1)
 	}
 }
 
@@ -345,7 +345,7 @@ func TestPtrPointTo(t *testing.T) {
 	vi := NewValue(i);
 	vip.(*PtrValue).Elem().(*PtrValue).PointTo(vi);
 	if *ip != 1234 {
-		t.Errorf("got %d, want 1234", *ip);
+		t.Errorf("got %d, want 1234", *ip)
 	}
 }
 
@@ -366,13 +366,13 @@ func TestAll(t *testing.T) {
 
 	f, present := styp.FieldByName("d");
 	if !present {
-		t.Errorf("FieldByName says present field is absent");
+		t.Errorf("FieldByName says present field is absent")
 	}
 	testType(t, 6, f.Type, "float32");
 
 	f, present = styp.FieldByName("absent");
 	if present {
-		t.Errorf("FieldByName says absent field is present");
+		t.Errorf("FieldByName says absent field is present")
 	}
 
 	typ = Typeof([32]int32{});
@@ -422,14 +422,14 @@ func TestInterfaceValue(t *testing.T) {
 
 	i3 := v2.Interface();
 	if _, ok := i3.(float); !ok {
-		t.Error("v2.Interface() did not return float, got ", Typeof(i3));
+		t.Error("v2.Interface() did not return float, got ", Typeof(i3))
 	}
 }
 
 func TestFunctionValue(t *testing.T) {
 	v := NewValue(func() {});
 	if v.Interface() != v.Interface() {
-		t.Fatalf("TestFunction != itself");
+		t.Fatalf("TestFunction != itself")
 	}
 	assert(t, v.Type().String(), "func()");
 }
@@ -442,7 +442,7 @@ func TestCopyArray(t *testing.T) {
 	vb := NewValue(&b);
 	for i := 0; i < len(b); i++ {
 		if b[i] != c[i] {
-			t.Fatalf("b != c before test");
+			t.Fatalf("b != c before test")
 		}
 	}
 	aa := va.(*PtrValue).Elem().(*SliceValue);
@@ -454,20 +454,20 @@ func TestCopyArray(t *testing.T) {
 		for i := 0; i < tocopy; i++ {
 			if a[i] != b[i] {
 				t.Errorf("(i) tocopy=%d a[%d]=%d, b[%d]=%d",
-					tocopy, i, a[i], i, b[i]);
+					tocopy, i, a[i], i, b[i])
 			}
 		}
 		for i := tocopy; i < len(b); i++ {
 			if b[i] != c[i] {
 				if i < len(a) {
 					t.Errorf("(ii) tocopy=%d a[%d]=%d, b[%d]=%d, c[%d]=%d",
-						tocopy, i, a[i], i, b[i], i, c[i]);
+						tocopy, i, a[i], i, b[i], i, c[i])
 				} else {
 					t.Errorf("(iii) tocopy=%d b[%d]=%d, c[%d]=%d",
-						tocopy, i, b[i], i, c[i]);
+						tocopy, i, b[i], i, c[i])
 				}
 			} else {
-				t.Logf("tocopy=%d elem %d is okay\n", tocopy, i);
+				t.Logf("tocopy=%d elem %d is okay\n", tocopy, i)
 			}
 		}
 	}
@@ -480,7 +480,7 @@ func TestBigUnnamedStruct(t *testing.T) {
 		a, b, c, d int64;
 	});
 	if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d {
-		t.Errorf("NewValue(%v).Interface().(*Big) = %v", b, b1);
+		t.Errorf("NewValue(%v).Interface().(*Big) = %v", b, b1)
 	}
 }
 
@@ -493,7 +493,7 @@ func TestBigStruct(t *testing.T) {
 	v := NewValue(b);
 	b1 := v.Interface().(big);
 	if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d || b1.e != b.e {
-		t.Errorf("NewValue(%v).Interface().(big) = %v", b, b1);
+		t.Errorf("NewValue(%v).Interface().(big) = %v", b, b1)
 	}
 }
 
@@ -552,7 +552,7 @@ var deepEqualTests = []DeepEqualTest{
 func TestDeepEqual(t *testing.T) {
 	for _, test := range deepEqualTests {
 		if r := DeepEqual(test.a, test.b); r != test.eq {
-			t.Errorf("DeepEqual(%v, %v) = %v, want %v", test.a, test.b, r, test.eq);
+			t.Errorf("DeepEqual(%v, %v) = %v, want %v", test.a, test.b, r, test.eq)
 		}
 	}
 }
@@ -561,11 +561,11 @@ func TestTypeof(t *testing.T) {
 	for _, test := range deepEqualTests {
 		v := NewValue(test.a);
 		if v == nil {
-			continue;
+			continue
 		}
 		typ := Typeof(test.a);
 		if typ != v.Type() {
-			t.Errorf("Typeof(%v) = %v, but NewValue(%v).Type() = %v", test.a, typ, test.a, v.Type());
+			t.Errorf("Typeof(%v) = %v, but NewValue(%v).Type() = %v", test.a, typ, test.a, v.Type())
 		}
 	}
 }
@@ -580,7 +580,7 @@ func TestDeepEqualRecursiveStruct(t *testing.T) {
 	*a = Recursive{12, a};
 	*b = Recursive{12, b};
 	if !DeepEqual(a, b) {
-		t.Error("DeepEqual(recursive same) = false, want true");
+		t.Error("DeepEqual(recursive same) = false, want true")
 	}
 }
 
@@ -598,7 +598,7 @@ func TestDeepEqualComplexStruct(t *testing.T) {
 	*a = Complex{5, [3]*Complex{a, b, a}, &stra, m};
 	*b = Complex{5, [3]*Complex{b, a, a}, &strb, m};
 	if !DeepEqual(a, b) {
-		t.Error("DeepEqual(complex same) = false, want true");
+		t.Error("DeepEqual(complex same) = false, want true")
 	}
 }
 
@@ -609,7 +609,7 @@ func TestDeepEqualComplexStructInequality(t *testing.T) {
 	*a = Complex{5, [3]*Complex{a, b, a}, &stra, m};
 	*b = Complex{5, [3]*Complex{b, a, a}, &strb, m};
 	if DeepEqual(a, b) {
-		t.Error("DeepEqual(complex different) = true, want false");
+		t.Error("DeepEqual(complex different) = true, want false")
 	}
 }
 
@@ -618,7 +618,7 @@ func check2ndField(x interface{}, offs uintptr, t *testing.T) {
 	s := NewValue(x).(*StructValue);
 	f := s.Type().(*StructType).Field(1);
 	if f.Offset != offs {
-		t.Error("mismatched offsets in structure alignment:", f.Offset, offs);
+		t.Error("mismatched offsets in structure alignment:", f.Offset, offs)
 	}
 }
 
@@ -654,14 +654,14 @@ type IsNiller interface {
 func Nil(a interface{}, t *testing.T) {
 	n := NewValue(a).(*StructValue).Field(0).(IsNiller);
 	if !n.IsNil() {
-		t.Errorf("%v should be nil", a);
+		t.Errorf("%v should be nil", a)
 	}
 }
 
 func NotNil(a interface{}, t *testing.T) {
 	n := NewValue(a).(*StructValue).Field(0).(IsNiller);
 	if n.IsNil() {
-		t.Errorf("value of type %v should not be nil", NewValue(a).Type().String());
+		t.Errorf("value of type %v should not be nil", NewValue(a).Type().String())
 	}
 }
 
@@ -672,7 +672,7 @@ func TestIsNil(t *testing.T) {
 		ty := Typeof(ts);
 		v := MakeZero(ty);
 		if _, ok := v.(IsNiller); ok {
-			t.Errorf("%s is nilable; should not be", ts);
+			t.Errorf("%s is nilable; should not be", ts)
 		}
 	}
 
@@ -690,7 +690,7 @@ func TestIsNil(t *testing.T) {
 		ty := Typeof(ts).(*StructType).Field(0).Type;
 		v := MakeZero(ty);
 		if _, ok := v.(IsNiller); !ok {
-			t.Errorf("%s %T is not nilable; should be", ts, v);
+			t.Errorf("%s %T is not nilable; should be", ts, v)
 		}
 	}
 
@@ -746,7 +746,7 @@ func TestInterfaceExtraction(t *testing.T) {
 	s.w = os.Stdout;
 	v := Indirect(NewValue(&s)).(*StructValue).Field(0).Interface();
 	if v != s.w.(interface{}) {
-		t.Error("Interface() on interface: ", v, s.w);
+		t.Error("Interface() on interface: ", v, s.w)
 	}
 }
 
@@ -766,7 +766,7 @@ func TestInterfaceEditing(t *testing.T) {
 	// not change the value stored in i.
 	v.(*StringValue).Set("bye");
 	if i.(string) != "hello" {
-		t.Errorf(`Set("bye") changed i to %s`, i.(string));
+		t.Errorf(`Set("bye") changed i to %s`, i.(string))
 	}
 
 	// the same should be true of smaller items.
@@ -774,14 +774,14 @@ func TestInterfaceEditing(t *testing.T) {
 	v = NewValue(i);
 	v.(*IntValue).Set(234);
 	if i.(int) != 123 {
-		t.Errorf("Set(234) changed i to %d", i.(int));
+		t.Errorf("Set(234) changed i to %d", i.(int))
 	}
 }
 
 func TestNilPtrValueSub(t *testing.T) {
 	var pi *int;
 	if pv := NewValue(pi).(*PtrValue); pv.Elem() != nil {
-		t.Error("NewValue((*int)(nil)).(*PtrValue).Elem() != nil");
+		t.Error("NewValue((*int)(nil)).(*PtrValue).Elem() != nil")
 	}
 }
 
@@ -789,7 +789,7 @@ func TestMap(t *testing.T) {
 	m := map[string]int{"a": 1, "b": 2};
 	mv := NewValue(m).(*MapValue);
 	if n := mv.Len(); n != len(m) {
-		t.Errorf("Len = %d, want %d", n, len(m));
+		t.Errorf("Len = %d, want %d", n, len(m))
 	}
 	keys := mv.Keys();
 	i := 0;
@@ -800,16 +800,16 @@ func TestMap(t *testing.T) {
 		// but they are in this implementation, which makes
 		// the test easier.
 		if i >= len(keys) {
-			t.Errorf("Missing key #%d %q", i, k);
+			t.Errorf("Missing key #%d %q", i, k)
 		} else if kv := keys[i].(*StringValue); kv.Get() != k {
-			t.Errorf("Keys[%d] = %q, want %q", i, kv.Get(), k);
+			t.Errorf("Keys[%d] = %q, want %q", i, kv.Get(), k)
 		}
 		i++;
 
 		// Check that value lookup is correct.
 		vv := mv.Elem(NewValue(k));
 		if vi := vv.(*IntValue).Get(); vi != v {
-			t.Errorf("Key %q: have value %d, want %d", vi, v);
+			t.Errorf("Key %q: have value %d, want %d", vi, v)
 		}
 
 		// Copy into new map.
@@ -817,25 +817,25 @@ func TestMap(t *testing.T) {
 	}
 	vv := mv.Elem(NewValue("not-present"));
 	if vv != nil {
-		t.Errorf("Invalid key: got non-nil value %s", valueToString(vv));
+		t.Errorf("Invalid key: got non-nil value %s", valueToString(vv))
 	}
 
 	newm := newmap.Interface().(map[string]int);
 	if len(newm) != len(m) {
-		t.Errorf("length after copy: newm=%d, m=%d", newm, m);
+		t.Errorf("length after copy: newm=%d, m=%d", newm, m)
 	}
 
 	for k, v := range newm {
 		mv, ok := m[k];
 		if mv != v {
-			t.Errorf("newm[%q] = %d, but m[%q] = %d, %v", k, v, k, mv, ok);
+			t.Errorf("newm[%q] = %d, but m[%q] = %d, %v", k, v, k, mv, ok)
 		}
 	}
 
 	newmap.SetElem(NewValue("a"), nil);
 	v, ok := newm["a"];
 	if ok {
-		t.Errorf("newm[\"a\"] = %d after delete", v);
+		t.Errorf("newm[\"a\"] = %d after delete", v)
 	}
 }
 
@@ -857,28 +857,28 @@ func TestChan(t *testing.T) {
 		// Send
 		cv.Send(NewValue(2));
 		if i := <-c; i != 2 {
-			t.Errorf("reflect Send 2, native recv %d", i);
+			t.Errorf("reflect Send 2, native recv %d", i)
 		}
 
 		// Recv
 		c <- 3;
 		if i := cv.Recv().(*IntValue).Get(); i != 3 {
-			t.Errorf("native send 3, reflect Recv %d", i);
+			t.Errorf("native send 3, reflect Recv %d", i)
 		}
 
 		// TryRecv fail
 		val := cv.TryRecv();
 		if val != nil {
-			t.Errorf("TryRecv on empty chan: %s", valueToString(val));
+			t.Errorf("TryRecv on empty chan: %s", valueToString(val))
 		}
 
 		// TryRecv success
 		c <- 4;
 		val = cv.TryRecv();
 		if val == nil {
-			t.Errorf("TryRecv on ready chan got nil");
+			t.Errorf("TryRecv on ready chan got nil")
 		} else if i := val.(*IntValue).Get(); i != 4 {
-			t.Errorf("native send 4, TryRecv %d", i);
+			t.Errorf("native send 4, TryRecv %d", i)
 		}
 
 		// TrySend fail
@@ -886,16 +886,16 @@ func TestChan(t *testing.T) {
 		ok := cv.TrySend(NewValue(5));
 		i := <-c;
 		if ok {
-			t.Errorf("TrySend on full chan succeeded: value %d", i);
+			t.Errorf("TrySend on full chan succeeded: value %d", i)
 		}
 
 		// TrySend success
 		ok = cv.TrySend(NewValue(6));
 		if !ok {
-			t.Errorf("TrySend on empty chan failed");
+			t.Errorf("TrySend on empty chan failed")
 		} else {
 			if i = <-c; i != 6 {
-				t.Errorf("TrySend 6, recv %d", i);
+				t.Errorf("TrySend 6, recv %d", i)
 			}
 		}
 
@@ -903,19 +903,19 @@ func TestChan(t *testing.T) {
 		c <- 123;
 		cv.Close();
 		if cv.Closed() {
-			t.Errorf("closed too soon - 1");
+			t.Errorf("closed too soon - 1")
 		}
 		if i := cv.Recv().(*IntValue).Get(); i != 123 {
-			t.Errorf("send 123 then close; Recv %d", i);
+			t.Errorf("send 123 then close; Recv %d", i)
 		}
 		if cv.Closed() {
-			t.Errorf("closed too soon - 2");
+			t.Errorf("closed too soon - 2")
 		}
 		if i := cv.Recv().(*IntValue).Get(); i != 0 {
-			t.Errorf("after close Recv %d", i);
+			t.Errorf("after close Recv %d", i)
 		}
 		if !cv.Closed() {
-			t.Errorf("not closed");
+			t.Errorf("not closed")
 		}
 	}
 
@@ -924,20 +924,20 @@ func TestChan(t *testing.T) {
 	cv := MakeChan(Typeof(c).(*ChanType), 0);
 	c = cv.Interface().(chan int);
 	if cv.TrySend(NewValue(7)) {
-		t.Errorf("TrySend on sync chan succeeded");
+		t.Errorf("TrySend on sync chan succeeded")
 	}
 	if cv.TryRecv() != nil {
-		t.Errorf("TryRecv on sync chan succeeded");
+		t.Errorf("TryRecv on sync chan succeeded")
 	}
 
 	// len/cap
 	cv = MakeChan(Typeof(c).(*ChanType), 10);
 	c = cv.Interface().(chan int);
 	for i := 0; i < 3; i++ {
-		c <- i;
+		c <- i
 	}
 	if l, m := cv.Len(), cv.Cap(); l != len(c) || m != cap(c) {
-		t.Errorf("Len/Cap = %d/%d want %d/%d", l, m, len(c), cap(c));
+		t.Errorf("Len/Cap = %d/%d want %d/%d", l, m, len(c), cap(c))
 	}
 
 }
@@ -945,20 +945,20 @@ func TestChan(t *testing.T) {
 // Difficult test for function call because of
 // implicit padding between arguments.
 func dummy(b byte, c int, d byte) (i byte, j int, k byte) {
-	return b, c, d;
+	return b, c, d
 }
 
 func TestFunc(t *testing.T) {
 	ret := NewValue(dummy).(*FuncValue).Call([]Value{NewValue(byte(10)), NewValue(20), NewValue(byte(30))});
 	if len(ret) != 3 {
-		t.Fatalf("Call returned %d values, want 3", len(ret));
+		t.Fatalf("Call returned %d values, want 3", len(ret))
 	}
 
 	i := ret[0].(*Uint8Value).Get();
 	j := ret[1].(*IntValue).Get();
 	k := ret[2].(*Uint8Value).Get();
 	if i != 10 || j != 20 || k != 30 {
-		t.Errorf("Call returned %d, %d, %d; want 10, 20, 30", i, j, k);
+		t.Errorf("Call returned %d, %d, %d; want 10, 20, 30", i, j, k)
 	}
 }
 
@@ -973,13 +973,13 @@ func TestMethod(t *testing.T) {
 	p := Point{3, 4};
 	i := Typeof(p).Method(0).Func.Call([]Value{NewValue(p), NewValue(10)})[0].(*IntValue).Get();
 	if i != 250 {
-		t.Errorf("Type Method returned %d; want 250", i);
+		t.Errorf("Type Method returned %d; want 250", i)
 	}
 
 	// Curried method of value.
 	i = NewValue(p).Method(0).Call([]Value{NewValue(10)})[0].(*IntValue).Get();
 	if i != 250 {
-		t.Errorf("Value Method returned %d; want 250", i);
+		t.Errorf("Value Method returned %d; want 250", i)
 	}
 
 	// Curried method of interface value.
@@ -994,7 +994,7 @@ func TestMethod(t *testing.T) {
 	pv := NewValue(s).(*StructValue).Field(0);
 	i = pv.Method(0).Call([]Value{NewValue(10)})[0].(*IntValue).Get();
 	if i != 250 {
-		t.Errorf("Interface Method returned %d; want 250", i);
+		t.Errorf("Interface Method returned %d; want 250", i)
 	}
 }
 
@@ -1010,18 +1010,18 @@ func TestInterfaceSet(t *testing.T) {
 	sv := NewValue(&s).(*PtrValue).Elem().(*StructValue);
 	sv.Field(0).(*InterfaceValue).Set(NewValue(p));
 	if q := s.I.(*Point); q != p {
-		t.Errorf("i: have %p want %p", q, p);
+		t.Errorf("i: have %p want %p", q, p)
 	}
 
 	pv := sv.Field(1).(*InterfaceValue);
 	pv.Set(NewValue(p));
 	if q := s.P.(*Point); q != p {
-		t.Errorf("i: have %p want %p", q, p);
+		t.Errorf("i: have %p want %p", q, p)
 	}
 
 	i := pv.Method(0).Call([]Value{NewValue(10)})[0].(*IntValue).Get();
 	if i != 250 {
-		t.Errorf("Interface Method returned %d; want 250", i);
+		t.Errorf("Interface Method returned %d; want 250", i)
 	}
 }
 
@@ -1036,10 +1036,10 @@ func TestAnonymousFields(t *testing.T) {
 	var t1 T1;
 	type1 := Typeof(t1).(*StructType);
 	if field, ok = type1.FieldByName("int"); !ok {
-		t.Error("no field 'int'");
+		t.Error("no field 'int'")
 	}
 	if field.Index[0] != 1 {
-		t.Error("field index should be 1; is", field.Index);
+		t.Error("field index should be 1; is", field.Index)
 	}
 }
 
@@ -1123,13 +1123,13 @@ func TestFieldByIndex(t *testing.T) {
 		if f.Name != "" {
 			if test.index != nil {
 				if f.Name != test.name {
-					t.Errorf("%s.%s found; want %s", s.Name(), f.Name, test.name);
+					t.Errorf("%s.%s found; want %s", s.Name(), f.Name, test.name)
 				}
 			} else {
-				t.Errorf("%s.%s found", s.Name(), f.Name);
+				t.Errorf("%s.%s found", s.Name(), f.Name)
 			}
 		} else if len(test.index) > 0 {
-			t.Errorf("%s.%s not found", s.Name(), test.name);
+			t.Errorf("%s.%s not found", s.Name(), test.name)
 		}
 
 		if test.value != 0 {
@@ -1137,13 +1137,13 @@ func TestFieldByIndex(t *testing.T) {
 			if v != nil {
 				if x, ok := v.Interface().(int); ok {
 					if x != test.value {
-						t.Errorf("%s%v is %d; want %d", s.Name(), test.index, x, test.value);
+						t.Errorf("%s%v is %d; want %d", s.Name(), test.index, x, test.value)
 					}
 				} else {
-					t.Errorf("%s%v value not an int", s.Name(), test.index);
+					t.Errorf("%s%v value not an int", s.Name(), test.index)
 				}
 			} else {
-				t.Errorf("%s%v value not found", s.Name(), test.index);
+				t.Errorf("%s%v value not found", s.Name(), test.index)
 			}
 		}
 	}
@@ -1157,19 +1157,19 @@ func TestFieldByName(t *testing.T) {
 			if test.index != nil {
 				// Verify field depth and index.
 				if len(f.Index) != len(test.index) {
-					t.Errorf("%s.%s depth %d; want %d", s.Name(), test.name, len(f.Index), len(test.index));
+					t.Errorf("%s.%s depth %d; want %d", s.Name(), test.name, len(f.Index), len(test.index))
 				} else {
 					for i, x := range f.Index {
 						if x != test.index[i] {
-							t.Errorf("%s.%s.Index[%d] is %d; want %d", s.Name(), test.name, i, x, test.index[i]);
+							t.Errorf("%s.%s.Index[%d] is %d; want %d", s.Name(), test.name, i, x, test.index[i])
 						}
 					}
 				}
 			} else {
-				t.Errorf("%s.%s found", s.Name(), f.Name);
+				t.Errorf("%s.%s found", s.Name(), f.Name)
 			}
 		} else if len(test.index) > 0 {
-			t.Errorf("%s.%s not found", s.Name(), test.name);
+			t.Errorf("%s.%s not found", s.Name(), test.name)
 		}
 
 		if test.value != 0 {
@@ -1177,13 +1177,13 @@ func TestFieldByName(t *testing.T) {
 			if v != nil {
 				if x, ok := v.Interface().(int); ok {
 					if x != test.value {
-						t.Errorf("%s.%s is %d; want %d", s.Name(), test.name, x, test.value);
+						t.Errorf("%s.%s is %d; want %d", s.Name(), test.name, x, test.value)
 					}
 				} else {
-					t.Errorf("%s.%s value not an int", s.Name(), test.name);
+					t.Errorf("%s.%s value not an int", s.Name(), test.name)
 				}
 			} else {
-				t.Errorf("%s.%s value not found", s.Name(), test.name);
+				t.Errorf("%s.%s value not found", s.Name(), test.name)
 			}
 		}
 	}