b = (5 + 6i) == C1
	if !b {
		println("const bool 1", b)
		panic("fail")
	}

	b = (5 + 6i) != C1
	if b {
		println("const bool 2", b)
		panic("fail")
	}

	b = C1 == (5 + 6i)
	if !b {
		println("const bool 3", b)
		panic("fail")
	}

	b = C1 != (5 + 6i)
	if b {
		println("const bool 4", b)
		panic("fail")
	}

	// vars passed through parameters
	booltest(5+6i, true)

		println("ideal-1", n1, d1, n1/d1, n1%d1)
		panic("fail")
	}
	if n2/d1 != q2 || n2%d1 != r2 {
		println("ideal-2", n2, d1, n2/d1, n2%d1)
		panic("fail")
	}
	if n1/d2 != q3 || n1%d2 != r3 {
		println("ideal-3", n1, d2, n1/d2, n1%d2)
		panic("fail")
	}
	if n2/d2 != q4 || n2%d2 != r4 {
		println("ideal-4", n2, d2, n2/d2, n2%d2)
		panic("fail")
	}

	/* int */
	var in1 int = +5
	var in2 int = -5

		sc       *v1.SecurityContext
		uid      *int64
		username string
		fail     bool
	}{
		{
			desc:     "Pass if SecurityContext is not set",
			sc:       nil,
			username: rootUser,
			fail:     false,
		},
		{
			desc: "Pass if RunAsNonRoot is not set",
			sc: &v1.SecurityContext{
				RunAsNonRoot: nil,
			},
			username: rootUser,
			fail:     false,
		},
		{

}
// end::dependencies[]

// tag::fail-on-version-conflict[]
configurations.all {
    resolutionStrategy {
        failOnVersionConflict()
    }
}
// end::fail-on-version-conflict[]

// tag::fail-on-dynamic[]
configurations.all {
    resolutionStrategy {
        failOnDynamicVersions()
    }
}
// end::fail-on-dynamic[]

// tag::fail-on-changing[]
configurations.all {

		panic("fail")
	}
	if b[1] != 2 {
		println("b[1]", b[1])
		panic("fail")
	}
	if b[2] != 3 {
		println("b[2]", b[2])
		panic("fail")
	}
	if b[3] != 0 {
		println("b[3]", b[3])
		panic("fail")
	}
	if b[4] != 0 {
		println("b[4]", b[4])
		panic("fail")
	}

	if c[0] != 1 {
		println("c[0]", c[0])
		panic("fail")
	}

	if d[0] != 1 {
		println("d[0]", d[0])
		panic("fail")
	}

		panic("fail")
	}
	if s != 15 {
		println("wrong sum ranging over makearray", s)
		panic("fail")
	}
}

func testarray1() {
	s := 0
	nmake = 0
	for i := range makearray() {
		s += i
	}
	if nmake != 1 {
		println("range called makearray", nmake, "times")
		panic("fail")
	}
	if s != 10 {
		println("wrong sum ranging over makearray", s)
		panic("fail")
	}
}

      MathPreconditions.checkPositive("int", 0);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    try {
      MathPreconditions.checkPositive("int", Integer.MIN_VALUE);
      fail();
    } catch (IllegalArgumentException expected) {
    }

			println("key array range", k, v, a[k])
			panic("fail")
		}
		i++
	}
	if i != size {
		println("key array size", i)
		panic("fail")
	}

	i = 0
	for k := range p {
		v := p[k]
		if v != f(k) {
			println("key pointer range", k, v, p[k])
			panic("fail")
		}
		i++
	}
	if i != size {
		println("key pointer size", i)
		panic("fail")
	}

	i = 0
	for k := range m {
		v := m[k]

! stdout ^ok
stdout FAIL

# Test that calling f.Fatal in a fuzz target causes a non-zero exit status.
! go test fatal_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that successful test exits cleanly.
go test success_fuzz_test.go
stdout ^ok
! stdout FAIL

# Test that successful fuzzing exits cleanly.
go test -fuzz=Fuzz -fuzztime=1x success_fuzz_test.go
stdout ok
! stdout FAIL

	s = ia[0].(string)
	if s != "xxx" {
		println(0, s)
		panic("fail")
	}
	i32 = int32(ia[1].(int))
	if i32 != 12345 {
		println(1, i32)
		panic("fail")
	}
	b = ia[2].(bool)
	if b != true {
		println(2, b)
		panic("fail")
	}

	s = ia[3].(string)
	if s != "now is" {
		println(3, s)
		panic("fail")
	}
	b = ia[4].(bool)
	if b != false {
		println(4, b)