extern int sum1(int a, int b) asm("_sum1");
            extern int sum2(int a, int b) asm("_sum2");
            #endif

            int main () {
                printf("foo%dfoo%d", sum1(1, 0), sum2(1, 1));
                fflush(stdout);
                return 0;
            }

            """),
            sourceFile("asm", "foo1/sum.s", getAsmSource("sum1")),

	}
	if x := sum2(); x != 2*0 {
		println("sum 0", x)
		panic("fail")
	}
	if x := sum2(10); x != 2*10 {
		println("sum 10", x)
		panic("fail")
	}
	if x := sum2(1, 8); x != 2*9 {
		println("sum 9", x)
		panic("fail")
	}
	if x := sum3(1, 2, 3); x != 3*6 {
		println("sum 6", x)
		panic("fail")
	}
	if x := sum3(); x != 3*0 {
		println("sum 0", x)
		panic("fail")
	}
	if x := sum3(10); x != 3*10 {

	h1 := new(Hash)
	h1.WriteString("testing")
	sum1 := h1.Sum64()

	h1.Reset()
	h1.WriteString("testing")
	sum2 := h1.Sum64()

	if sum1 != sum2 {
		t.Errorf("different sum after resetting: %#x != %#x", sum1, sum2)
	}

	h2 := new(Hash)
	h2.SetSeed(h1.Seed())
	h2.WriteString("testing")
	sum3 := h2.Sum64()

	if sum1 != sum3 {
		t.Errorf("different sum on the same seed: %#x != %#x", sum1, sum3)
	}
}

	sum2 := 0
	cnt := 0
	for i := 0; i < 2; i++ {
		for {
			node := toMyNode(LFStackPop(stacks[i]))
			if node == nil {
				break
			}
			cnt++
			sum2 += node.data
			node.Next = 0
		}
	}
	if cnt != K {
		t.Fatalf("Wrong number of nodes %d/%d", cnt, K)
	}
	if sum2 != sum {
		t.Fatalf("Wrong sum %d/%d", sum2, sum)
	}

				t.Fatalf("UnmarshalBinary: %v", err)
			}
			h2.Write(buf[split:])
			h3.Write(buf[split:])
			sum2 := h2.Sum(nil)
			sum3 := h3.Sum(nil)
			if !bytes.Equal(sum2, sum) {
				t.Fatalf("Sum after MarshalBinary = %x, want %x", sum2, sum)
			}
			if !bytes.Equal(sum3, sum) {
				t.Fatalf("Sum after UnmarshalBinary = %x, want %x", sum3, sum)
			}
		})
	}

=== RUN   TestOutputWithSubtest
=== RUN   TestOutputWithSubtest/sub_test
=== RUN   TestOutputWithSubtest/sub_test/sub2
=== RUN   TestOutputWithSubtest/sub_test2
=== RUN   TestOutputWithSubtest/sub_test2/sub2
--- FAIL: TestOutputWithSubtest (0.00s)
    foo_test.go:6: output before sub tests
    foo_test.go:10: output from root test
    foo_test.go:15: output from root test
    --- PASS: TestOutputWithSubtest/sub_test (0.00s)

            // Ensure consistent asm name mapping on all platforms
            #if !defined(_MSC_VER)
            extern int sumx(int a, int b) asm("_sumx");
            #endif

            int DLL_FUNC sum(int a, int b) {
                return sumx(a, b);
            }
"""),
            new SourceFile("asm", "sum.s", getAsmSource())
        ]
    }

    protected def getAsmSource() {
        if (toolChain.isVisualCpp()) {

package main

import (
	"fmt"
)

func Sum[T interface{ int | float64 }](vec []T) T {
	var sum T
	for _, elt := range vec {
		sum = sum + elt
	}
	return sum
}

func Abs(f float64) float64 {
	if f < 0.0 {
		return -f
	}
	return f
}

func main() {
	vec1 := []int{3, 4}
	vec2 := []float64{5.8, 9.6}
	got := Sum[int](vec1)
	want := vec1[0] + vec1[1]
	if got != want {

Harshavardhana <******@****.***> 1716888464 -0700

{"Action":"output","Test":"TestOutputWithSubtest/sub_test2/sub2","Output":"        --- PASS: TestOutputWithSubtest/sub_test2/sub2 (0.00s)\n"}
{"Action":"output","Test":"TestOutputWithSubtest/sub_test2/sub2","Output":"            foo_test.go:26: output from sub2 test\n"}
{"Action":"output","Test":"TestOutputWithSubtest","Output":"    foo_test.go:32: output after sub test\n"}
{"Action":"pass","Test":"TestOutputWithSubtest/sub_test2/sub2"}