synthetic final field $title: java.lang.String
    inner (anonymous) class MainKt$ArticleScreenContent$2
    method <init>(p0: java.lang.String): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$2

        tracker.leaveDynamicCall(entryPoint2)
        tracker.leaveDynamicCall(entryPoint1)

        then:
        log == ["enter", entryPoint1, "enter", entryPoint2, "leave", entryPoint2, "leave", entryPoint1]
    }

    def "throws exception on mismatched calls"() {
        when:
        tracker.enterDynamicCall(new Object())
        tracker.leaveDynamicCall(new Object())

        then:

// run
package main

import (
	"fmt"
	"runtime/debug"
	"strings"
)

type Inner struct {
	Err int
}

func (i *Inner) NotExpectedInStackTrace() int {
	if i == nil {
		return 86
	}
	return 17 + i.Err
}

type Outer struct {
	Inner
}

func ExpectedInStackTrace() {
	var o *Outer
	println(o.NotExpectedInStackTrace())
}

func main() {
    defer func() {

func TestLookupPtrToStruct(t *testing.T) {
	type Elem struct {
		Key   string
		Value string
	}
	type Outer struct {
		Inner []Elem `json:"inner" patchStrategy:"merge" patchMergeKey:"key"`
	}
	outer := &Outer{}
	elemType, patchStrategies, patchMergeKey, err := LookupPatchMetadataForStruct(reflect.TypeOf(outer), "inner")
	if err != nil {
		t.Fatal(err)
	}
	if elemType != reflect.TypeOf([]Elem{}) {

            def a = it.askQuestion("enter value", "value")
            def b = it.askQuestion("enter another value", "value")
            [a, b]
        }

        then:
        1 * outputEventBroadcaster.onOutput(_ as UserInputRequestEvent)
        1 * outputEventBroadcaster.onOutput(_) >> { TextQuestionPromptEvent event ->
            assert event.question == "enter value"
        }

package main

func main() {
	f[int]()
}

func f[T1 any]() {
	var x Outer[T1, int]
	x.M()
}

type Outer[T1, T2 any] struct{ Inner[T2] }

type Inner[_ any] int

    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "Enter"
  op: "Enter"
  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "frame_name"
    value {
      s: "while_context"
    }
  }
  attr {

class StringInternerTest extends Specification {
    @Subject
    StringInterner stringInterner = new StringInterner()

    def "should return null when null is passed to intern method"() {
        expect:
        stringInterner.intern(null) == null
    }

    def "should return first instance when multiple strings with similar contents are interned"() {
        given:

func GetInterfaceNetStats(interf string) (procfs.NetDevLine, error) {
	proc, err := procfs.Self()
	if err != nil {
		return procfs.NetDevLine{}, err
	}
	netDev, err := proc.NetDev()
	if err != nil {
		return procfs.NetDevLine{}, err
	}
	ndl, ok := netDev[interf]
	if !ok {
		return procfs.NetDevLine{}, fmt.Errorf("%v interface not found", interf)
	}
	return ndl, nil

    synthetic final field $title: java.lang.String
    inner (anonymous) class MainKt$ArticleScreenContent$2
    method <init>(p0: java.lang.String): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$2