package main

var out int
var zero int

func main() {
	wantPanic("test1", func() {
		out = 1 / zero
	})
	wantPanic("test2", func() {
		_ = 1 / zero
	})
	wantPanic("test3", func() {
		v := 0
		_ = 1 / v
	})
	wantPanic("test4", func() { divby(0) })
}

func wantPanic(test string, fn func()) {
	defer func() {
		if e := recover(); e == nil {
			panic(test + ": expected panic")

import (
	"testing"

	"issue.56370/filter"
)

func Test1(t *testing.T) {
	t.Parallel()

	_ = filter.New()
}

func Test2(t *testing.T) {
	t.Parallel()

	_ = filter.New()
}

func Test3(t *testing.T) {
	t.Parallel()

	_ = filter.New()
}

func Test4(t *testing.T) {
	t.Parallel()

	_ = filter.New()

	if a != b {
		panic("broken equality: a != b")
	}

	m[a] = 1
	m[b] = 2
	if len(m) == 2 {
		panic("broken hash: len(m) == 2")
	}
	if m[a] != 2 {
		panic("m[a] != 2")
	}
}

func test3() {
	var a, b USmall
	copy((*[12]byte)(unsafe.Pointer(&a))[:], "hello world!")
	a.A, a.B = 1, 2
	b.A, b.B = 1, 2
	if a != b {
		panic("broken equality: a != b")
	}
}

func test4() {
	var a, b V

type tst1 map[string]bool

func (r tst1) Hi() string { return "Hi!" }

func Test2() Foo { return make(tst2, 0) }

type tst2 []string

func (r tst2) Hi() string { return "Hi!" }

func Test3() Foo { return make(tst3) }

type tst3 chan string

	changeNproc(4)
	go send(ca[0])
	go send(ca[1])
	go send(ca[2])
	go send(ca[3])

	changeNproc(1)
	go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc)
}

// select send to direct recv
func test3(c int) {
	ca := mkchan(c, 4)

	changeNproc(4)
	go recv(ca[0])
	go recv(ca[1])
	go recv(ca[2])
	go recv(ca[3])

	changeNproc(1)
	go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3])
}

        m1.pom.expectGetMissing()
        def m2 = mavenHttpRepo.module("test", "test2", "1.2")
        m2.pom.expectGetUnauthorized()
        def m3 = mavenHttpRepo.module("test", "test3", "1.2").publish()
        m3.pom.expectGet()

        fails("show")

        then:
        failure.assertHasDescription("Execution failed for task ':show'.")

	val T
}

//go:noinline
func (l *privateVal[T]) check(want T) {
	if l.val != want {
		panic("hi")
	}
}

type Outer struct {
	val privateVal[string]
}

func Test3() {
	var o Outer
	o.val.check("")
	_ = IVal[string](&o.val)

        assertThat(count, is(2));
        assertThat(names, is("ba"));
        assertThat(DisposableUtil.disposables.size(), is(0));
    }

    /**
     * @throws Exception
     */
    @Test
    public void test3() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));
        DisposableUtil.add(new TestDisposable2());
        DisposableUtil.add(new TestDisposable("b"));

func (f foo6) F() { return }
func (f foo7) F() { return }
func (f foo8) F() { return }
func (f foo9) F() { return }

func Test1(s string) I  { return foo1(s) }
func Test2(s string) I  { return foo2(s) }
func Test3(s string) I  { return foo3(s) }
func Test4(s string) I  { return foo4(s) }
func Test5(s []byte) I  { return foo5(s) }
func Test6(s []rune) I  { return foo6(s) }
func Test7(s []uint8) I { return foo7(s) }

specific language governing permissions and limitations
under the License.
-->

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.apache.maven.its.mng4053</groupId>
  <artifactId>test3</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>Maven Integration Test :: MNG-4053</name>
  <description>