// class.
  static void TearDownTestCase() {}

  // Returns true iff the current test has a fatal failure.
  static bool HasFatalFailure();

  // Returns true iff the current test has a non-fatal failure.
  static bool HasNonfatalFailure();

  // Returns true iff the current test has a (either fatal or
  // non-fatal) failure.
  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }

				frameworkruntime.WithLogger(logger),
			)
			if err != nil {
				t.Fatal(err)
			}

			informerFactory.Start(ctx.Done())
			informerFactory.WaitForCacheSync(ctx.Done())

			nodeInfos, err := snapshot.NodeInfos().List()
			if err != nil {
				t.Fatal(err)
			}
			sort.Slice(nodeInfos, func(i, j int) bool {

		nsConfig, err := namespace.New(t, namespace.Config{
			Prefix: "badgateway",
			Inject: false,
			Labels: map[string]string{
				constants.DataplaneModeLabel: "ambient",
			},
		})
		if err != nil {
			t.Fatal(err)
		}
		istioctl.NewOrFail(t, t, istioctl.Config{}).InvokeOrFail(t, []string{
			"waypoint",
			"apply",
			"--namespace",
			nsConfig.Name(),
			"--revision",
			"foo",
		})

func (c *common) Errorf(format string, args ...any) {
	c.checkFuzzFn("Errorf")
	c.log(fmt.Sprintf(format, args...))
	c.Fail()
}

// Fatal is equivalent to Log followed by FailNow.
func (c *common) Fatal(args ...any) {
	c.checkFuzzFn("Fatal")
	c.log(fmt.Sprintln(args...))
	c.FailNow()
}

// Fatalf is equivalent to Logf followed by FailNow.

		oldestProtocol := oldestService.Ports[0].Protocol
		if oldestProtocol != protocol.HTTP && isHTTPListener(listeners[0]) {
			t.Fatal("expected TCP listener, found HTTP")
		} else if oldestProtocol == protocol.HTTP && !isHTTPListener(listeners[0]) {
			t.Fatal("expected HTTP listener, found TCP")
		}

		// Validate that listener conflict preserves the listener of oldest service.

	if got == nil {
		return nil
	}
	s, err := protomarshal.Marshal(got)
	if err != nil {
		t.Fatal(err)
	}
	meta := clusterServicesMetadata{}
	if err := json.Unmarshal(s, &meta); err != nil {
		t.Fatal(err)
	}
	res := []string{}
	for _, m := range meta.Services {
		res = append(res, m.Host)
	}
	return res
}

func TestQueryScanToArray(t *testing.T) {
	err := DB.Create(&User{Name: "testname1", Age: 10}).Error
	if err != nil {
		t.Fatal(err)
	}

	users := [2]*User{{Name: "1"}, {Name: "2"}}
	err = DB.Model(&User{}).Where("name = ?", "testname1").Find(&users).Error
	if err != nil {
		t.Fatal(err)
	}
	if users[0] == nil || users[0].Name != "testname1" {
		t.Error("users[0] not covered")
	}
	if users[1] != nil {

				}

			default:
				panic(fmt.Sprintf("internal error: modload missing case for pattern %s", m.Pattern()))
			}
		}
	}

	initialRS, err := loadModFile(ctx, &opts)
	if err != nil {
		base.Fatal(err)
	}

	ld := loadFromRoots(ctx, loaderParams{
		PackageOpts:  opts,
		requirements: initialRS,

		allPatternIsRoot: allPatternIsRoot,

		listRoots: func(rs *Requirements) (roots []string) {

					t.Fatalf("failed to attach: %v", err)
				}
			}

			// retrieve attached status
			stats, err := csiAttacher.VolumesAreAttached(specs, types.NodeName(nodeName))
			if err != nil {
				t.Fatal(err)
			}
			if len(tc.attachedSpecs) != len(stats) {
				t.Errorf("expecting %d attachment status, got %d", len(tc.attachedSpecs), len(stats))
			}

			// compare attachment status for each spec

	}

	var n int
	for n < chacha8outlen {
		if IntN(2) == 0 {
			out, err := p.MarshalBinary()
			if err != nil {
				t.Fatal(err)
			}
			if IntN(2) == 0 {
				p = NewChaCha8([32]byte{})
			}
			if err := p.UnmarshalBinary(out); err != nil {
				t.Fatal(err)
			}
		}
		buf := make([]byte, IntN(100))
		if n+len(buf) > chacha8outlen {
			buf = buf[:chacha8outlen-n]
		}
		n += len(buf)