feat(demo): add result verification to go/token and go/types demos

Added comprehensive result verification and assertions to ensure correctness:

go/token demo:
- Verify Pos values and IsValid() results
- Check token string representations
- Validate keyword detection (IsKeyword())
- Assert operator precedence relationships
- Verify file and position operations

go/types demo:
- Validate basic type kinds
- Check object names and types (Var, Const, Func, TypeName)
- Verify package path and name
- Assert interface method counts and names
- Check struct field counts, names, and types
- Validate signature params and results
- Verify tuple, array, slice, pointer, map, and chan properties

All demos now fail fast with panic() if results don't match expected values,
providing better test coverage than just printing output.

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: luoliwoshang <51194195+luoliwoshang@users.noreply.github.com>

_demo/go/gotoken/main.go

@@ -22,10 +22,26 @@ func testPos() {
 	pos1 := token.Pos(100)
 	pos2 := token.Pos(200)
 	
+	if pos1 != 100 {
+		panic(fmt.Sprintf("Expected pos1 to be 100, got %d", pos1))
+	}
+	if pos2 != 200 {
+		panic(fmt.Sprintf("Expected pos2 to be 200, got %d", pos2))
+	}
 	fmt.Printf("Pos1: %d, Pos2: %d\n", pos1, pos2)
+	
+	if !pos1.IsValid() {
+		panic("Expected pos1.IsValid() to be true")
+	}
 	fmt.Printf("Pos1.IsValid(): %v\n", pos1.IsValid())
 	
 	noPos := token.NoPos
+	if noPos != 0 {
+		panic(fmt.Sprintf("Expected NoPos to be 0, got %d", noPos))
+	}
+	if noPos.IsValid() {
+		panic("Expected NoPos.IsValid() to be false")
+	}
 	fmt.Printf("NoPos: %d, IsValid: %v\n", noPos, noPos.IsValid())
 	
 	fmt.Println("SUCCESS: Pos operations work correctly\n")
@@ -34,6 +50,23 @@ func testPos() {
 func testToken() {
 	fmt.Println("\n=== Test Token Types ===")
 	
+	expectedStrings := map[token.Token]string{
+		token.ADD:    "+",
+		token.SUB:    "-",
+		token.MUL:    "*",
+		token.QUO:    "/",
+		token.LPAREN: "(",
+		token.RPAREN: ")",
+		token.EQL:    "==",
+		token.NEQ:    "!=",
+	}
+	
+	for tok, expected := range expectedStrings {
+		if tok.String() != expected {
+			panic(fmt.Sprintf("Expected %v.String() to be %q, got %q", tok, expected, tok.String()))
+		}
+	}
+	
 	tokens := []token.Token{
 		token.ILLEGAL,
 		token.EOF,
@@ -132,15 +165,38 @@ func testTokenKeywords() {
 	}
 	
 	for _, kw := range keywords {
+		if !kw.IsKeyword() {
+			panic(fmt.Sprintf("Expected %s to be a keyword", kw))
+		}
 		fmt.Printf("Keyword: %s, IsKeyword: %v\n", kw, kw.IsKeyword())
 	}
 	
+	if token.ADD.IsKeyword() {
+		panic("Expected ADD operator to not be a keyword")
+	}
+	if token.IDENT.IsKeyword() {
+		panic("Expected IDENT token to not be a keyword")
+	}
+	
 	fmt.Println("SUCCESS: Keyword checks work correctly\n")
 }
 
 func testTokenPrecedence() {
 	fmt.Println("\n=== Test Token Precedence ===")
 	
+	if token.MUL.Precedence() <= token.ADD.Precedence() {
+		panic("Expected MUL to have higher precedence than ADD")
+	}
+	if token.LAND.Precedence() <= token.LOR.Precedence() {
+		panic("Expected LAND to have higher precedence than LOR")
+	}
+	if token.MUL.Precedence() != token.QUO.Precedence() {
+		panic("Expected MUL and QUO to have same precedence")
+	}
+	if token.ADD.Precedence() != token.SUB.Precedence() {
+		panic("Expected ADD and SUB to have same precedence")
+	}
+	
 	operators := []token.Token{
 		token.ADD,
 		token.SUB,
@@ -190,10 +246,21 @@ func testFile() {
 	fset := token.NewFileSet()
 	file := fset.AddFile("test.go", -1, 1000)
 	
+	if file.Name() != "test.go" {
+		panic(fmt.Sprintf("Expected file name to be 'test.go', got %q", file.Name()))
+	}
+	if file.Size() != 1000 {
+		panic(fmt.Sprintf("Expected file size to be 1000, got %d", file.Size()))
+	}
+	
 	file.AddLine(0)
 	file.AddLine(50)
 	file.AddLine(100)
 	
+	if file.LineCount() != 3 {
+		panic(fmt.Sprintf("Expected line count to be 3, got %d", file.LineCount()))
+	}
+	
 	fmt.Printf("File name: %s\n", file.Name())
 	fmt.Printf("File base: %d\n", file.Base())
 	fmt.Printf("File size: %d\n", file.Size())
@@ -203,9 +270,15 @@ func testFile() {
 	fmt.Printf("Pos at offset 50: %d\n", pos)
 	
 	offset := file.Offset(pos)
+	if offset != 50 {
+		panic(fmt.Sprintf("Expected offset to be 50, got %d", offset))
+	}
 	fmt.Printf("Offset of pos: %d\n", offset)
 	
 	line := file.Line(pos)
+	if line != 2 {
+		panic(fmt.Sprintf("Expected line to be 2, got %d", line))
+	}
 	fmt.Printf("Line number at pos: %d\n", line)
 	
 	lineStart := file.LineStart(2)
@@ -227,12 +300,28 @@ func testPosition() {
 		Column:   10,
 	}
 	
+	if !pos.IsValid() {
+		panic("Expected valid position to be valid")
+	}
+	if pos.Filename != "test.go" {
+		panic(fmt.Sprintf("Expected filename to be 'test.go', got %q", pos.Filename))
+	}
+	if pos.Line != 5 {
+		panic(fmt.Sprintf("Expected line to be 5, got %d", pos.Line))
+	}
+	if pos.Column != 10 {
+		panic(fmt.Sprintf("Expected column to be 10, got %d", pos.Column))
+	}
+	
 	fmt.Printf("Position: %s\n", pos.String())
 	fmt.Printf("Filename: %s, Line: %d, Column: %d, Offset: %d\n", 
 		pos.Filename, pos.Line, pos.Column, pos.Offset)
 	fmt.Printf("IsValid: %v\n", pos.IsValid())
 	
 	invalidPos := token.Position{}
+	if invalidPos.IsValid() {
+		panic("Expected empty position to be invalid")
+	}
 	fmt.Printf("Invalid position IsValid: %v\n", invalidPos.IsValid())
 	
 	fmt.Println("SUCCESS: Position operations work correctly\n")

_demo/go/gotypes/main.go

@@ -33,15 +33,27 @@ func testBasicTypes() {
 
 	intType := types.Typ[types.Int]
 	fmt.Printf("Int type: %v, Kind: %v\n", intType, intType.Kind())
+	if intType.Kind() != types.Int {
+		panic(fmt.Sprintf("Int type kind mismatch: expected %v, got %v", types.Int, intType.Kind()))
+	}
 
 	stringType := types.Typ[types.String]
 	fmt.Printf("String type: %v, Kind: %v\n", stringType, stringType.Kind())
+	if stringType.Kind() != types.String {
+		panic(fmt.Sprintf("String type kind mismatch: expected %v, got %v", types.String, stringType.Kind()))
+	}
 
 	boolType := types.Typ[types.Bool]
 	fmt.Printf("Bool type: %v, Kind: %v\n", boolType, boolType.Kind())
+	if boolType.Kind() != types.Bool {
+		panic(fmt.Sprintf("Bool type kind mismatch: expected %v, got %v", types.Bool, boolType.Kind()))
+	}
 
 	float64Type := types.Typ[types.Float64]
 	fmt.Printf("Float64 type: %v, Kind: %v\n", float64Type, float64Type.Kind())
+	if float64Type.Kind() != types.Float64 {
+		panic(fmt.Sprintf("Float64 type kind mismatch: expected %v, got %v", types.Float64, float64Type.Kind()))
+	}
 
 	fmt.Println("SUCCESS: Basic types work correctly\n")
 }
@@ -51,16 +63,34 @@ func testObjects() {
 
 	varObj := types.NewVar(token.NoPos, nil, "x", types.Typ[types.Int])
 	fmt.Printf("Var: Name=%s, Type=%v\n", varObj.Name(), varObj.Type())
+	if varObj.Name() != "x" {
+		panic(fmt.Sprintf("Var name mismatch: expected x, got %s", varObj.Name()))
+	}
+	if varObj.Type() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Var type mismatch: expected int, got %v", varObj.Type()))
+	}
 
 	constObj := types.NewConst(token.NoPos, nil, "pi", types.Typ[types.Float64], nil)
 	fmt.Printf("Const: Name=%s, Type=%v\n", constObj.Name(), constObj.Type())
+	if constObj.Name() != "pi" {
+		panic(fmt.Sprintf("Const name mismatch: expected pi, got %s", constObj.Name()))
+	}
+	if constObj.Type() != types.Typ[types.Float64] {
+		panic(fmt.Sprintf("Const type mismatch: expected float64, got %v", constObj.Type()))
+	}
 
 	sig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
 	funcObj := types.NewFunc(token.NoPos, nil, "foo", sig)
 	fmt.Printf("Func: Name=%s, Type=%v\n", funcObj.Name(), funcObj.Type())
+	if funcObj.Name() != "foo" {
+		panic(fmt.Sprintf("Func name mismatch: expected foo, got %s", funcObj.Name()))
+	}
 
 	typeObj := types.NewTypeName(token.NoPos, nil, "MyInt", types.Typ[types.Int])
 	fmt.Printf("TypeName: Name=%s, Type=%v\n", typeObj.Name(), typeObj.Type())
+	if typeObj.Name() != "MyInt" {
+		panic(fmt.Sprintf("TypeName name mismatch: expected MyInt, got %s", typeObj.Name()))
+	}
 
 	var obj types.Object = varObj
 	if obj.Name() != "x" {
@@ -100,6 +130,12 @@ func testPackage() {
 
 	pkg := types.NewPackage("example.com/test", "test")
 	fmt.Printf("Package: Path=%s, Name=%s\n", pkg.Path(), pkg.Name())
+	if pkg.Path() != "example.com/test" {
+		panic(fmt.Sprintf("Package path mismatch: expected example.com/test, got %s", pkg.Path()))
+	}
+	if pkg.Name() != "test" {
+		panic(fmt.Sprintf("Package name mismatch: expected test, got %s", pkg.Name()))
+	}
 
 	scope := pkg.Scope()
 	if scope == nil {
@@ -146,9 +182,15 @@ func testInterface() {
 	iface.Complete()
 
 	fmt.Printf("Interface with %d methods\n", iface.NumMethods())
+	if iface.NumMethods() != 2 {
+		panic(fmt.Sprintf("Interface method count mismatch: expected 2, got %d", iface.NumMethods()))
+	}
 
 	method := iface.Method(0)
 	fmt.Printf("Method 0: %s\n", method.Name())
+	if method.Name() != "End" && method.Name() != "Pos" {
+		panic(fmt.Sprintf("Unexpected method name: %s", method.Name()))
+	}
 
 	fmt.Println("SUCCESS: Interface operations work correctly\n")
 }
@@ -163,9 +205,18 @@ func testStruct() {
 
 	structType := types.NewStruct(fields, nil)
 	fmt.Printf("Struct with %d fields\n", structType.NumFields())
+	if structType.NumFields() != 2 {
+		panic(fmt.Sprintf("Struct field count mismatch: expected 2, got %d", structType.NumFields()))
+	}
 
 	field0 := structType.Field(0)
 	fmt.Printf("Field 0: Name=%s, Type=%v\n", field0.Name(), field0.Type())
+	if field0.Name() != "X" {
+		panic(fmt.Sprintf("Field 0 name mismatch: expected X, got %s", field0.Name()))
+	}
+	if field0.Type() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Field 0 type mismatch: expected int, got %v", field0.Type()))
+	}
 
 	fmt.Println("SUCCESS: Struct operations work correctly\n")
 }
@@ -185,9 +236,21 @@ func testSignature() {
 	sig := types.NewSignatureType(nil, nil, nil, params, results, false)
 
 	fmt.Printf("Signature: %d params, %d results\n", sig.Params().Len(), sig.Results().Len())
+	if sig.Params().Len() != 2 {
+		panic(fmt.Sprintf("Signature param count mismatch: expected 2, got %d", sig.Params().Len()))
+	}
+	if sig.Results().Len() != 1 {
+		panic(fmt.Sprintf("Signature result count mismatch: expected 1, got %d", sig.Results().Len()))
+	}
 
 	param0 := sig.Params().At(0)
 	fmt.Printf("Param 0: Name=%s, Type=%v\n", param0.Name(), param0.Type())
+	if param0.Name() != "x" {
+		panic(fmt.Sprintf("Param 0 name mismatch: expected x, got %s", param0.Name()))
+	}
+	if param0.Type() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Param 0 type mismatch: expected int, got %v", param0.Type()))
+	}
 
 	fmt.Println("SUCCESS: Signature operations work correctly\n")
 }
@@ -201,9 +264,18 @@ func testTuple() {
 	)
 
 	fmt.Printf("Tuple length: %d\n", tuple.Len())
+	if tuple.Len() != 2 {
+		panic(fmt.Sprintf("Tuple length mismatch: expected 2, got %d", tuple.Len()))
+	}
 
 	var0 := tuple.At(0)
 	fmt.Printf("Element 0: Name=%s, Type=%v\n", var0.Name(), var0.Type())
+	if var0.Name() != "a" {
+		panic(fmt.Sprintf("Tuple element 0 name mismatch: expected a, got %s", var0.Name()))
+	}
+	if var0.Type() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Tuple element 0 type mismatch: expected int, got %v", var0.Type()))
+	}
 
 	fmt.Println("SUCCESS: Tuple operations work correctly\n")
 }
@@ -213,6 +285,12 @@ func testArray() {
 
 	arrayType := types.NewArray(types.Typ[types.Int], 10)
 	fmt.Printf("Array type: %v, Elem: %v, Len: %d\n", arrayType, arrayType.Elem(), arrayType.Len())
+	if arrayType.Len() != 10 {
+		panic(fmt.Sprintf("Array length mismatch: expected 10, got %d", arrayType.Len()))
+	}
+	if arrayType.Elem() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Array element type mismatch: expected int, got %v", arrayType.Elem()))
+	}
 
 	fmt.Println("SUCCESS: Array operations work correctly\n")
 }
@@ -222,6 +300,9 @@ func testSlice() {
 
 	sliceType := types.NewSlice(types.Typ[types.String])
 	fmt.Printf("Slice type: %v, Elem: %v\n", sliceType, sliceType.Elem())
+	if sliceType.Elem() != types.Typ[types.String] {
+		panic(fmt.Sprintf("Slice element type mismatch: expected string, got %v", sliceType.Elem()))
+	}
 
 	fmt.Println("SUCCESS: Slice operations work correctly\n")
 }
@@ -231,6 +312,9 @@ func testPointer() {
 
 	ptrType := types.NewPointer(types.Typ[types.Int])
 	fmt.Printf("Pointer type: %v, Elem: %v\n", ptrType, ptrType.Elem())
+	if ptrType.Elem() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Pointer element type mismatch: expected int, got %v", ptrType.Elem()))
+	}
 
 	fmt.Println("SUCCESS: Pointer operations work correctly\n")
 }
@@ -240,6 +324,12 @@ func testMap() {
 
 	mapType := types.NewMap(types.Typ[types.String], types.Typ[types.Int])
 	fmt.Printf("Map type: %v, Key: %v, Elem: %v\n", mapType, mapType.Key(), mapType.Elem())
+	if mapType.Key() != types.Typ[types.String] {
+		panic(fmt.Sprintf("Map key type mismatch: expected string, got %v", mapType.Key()))
+	}
+	if mapType.Elem() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Map element type mismatch: expected int, got %v", mapType.Elem()))
+	}
 
 	fmt.Println("SUCCESS: Map operations work correctly\n")
 }
@@ -249,12 +339,24 @@ func testChan() {
 
 	chanType := types.NewChan(types.SendRecv, types.Typ[types.Int])
 	fmt.Printf("Chan type: %v, Dir: %v, Elem: %v\n", chanType, chanType.Dir(), chanType.Elem())
+	if chanType.Dir() != types.SendRecv {
+		panic(fmt.Sprintf("Chan direction mismatch: expected SendRecv, got %v", chanType.Dir()))
+	}
+	if chanType.Elem() != types.Typ[types.Int] {
+		panic(fmt.Sprintf("Chan element type mismatch: expected int, got %v", chanType.Elem()))
+	}
 
 	sendChan := types.NewChan(types.SendOnly, types.Typ[types.String])
 	fmt.Printf("SendOnly chan: %v, Dir: %v\n", sendChan, sendChan.Dir())
+	if sendChan.Dir() != types.SendOnly {
+		panic(fmt.Sprintf("SendOnly chan direction mismatch: expected SendOnly, got %v", sendChan.Dir()))
+	}
 
 	recvChan := types.NewChan(types.RecvOnly, types.Typ[types.Bool])
 	fmt.Printf("RecvOnly chan: %v, Dir: %v\n", recvChan, recvChan.Dir())
+	if recvChan.Dir() != types.RecvOnly {
+		panic(fmt.Sprintf("RecvOnly chan direction mismatch: expected RecvOnly, got %v", recvChan.Dir()))
+	}
 
 	fmt.Println("SUCCESS: Chan operations work correctly\n")
 }