valid: false,
		},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			err := validateExtensionProviderTracingZipkin(c.config)
			valid := err == nil
			if valid != c.valid {
				t.Errorf("Expected valid=%v, got valid=%v for %v", c.valid, valid, c.config)
			}
		})
	}
}

func TestValidateExtensionProviderTracingLightstep(t *testing.T) {
	cases := []struct {
		name   string

       * This happens e.g. for unit tests. Below we just create a reasonable
       * layout.  We sort by dimension size, which makes the layout agree with
       * the "correct" TPU layout in surprisingly many cases.
       * Note that the corresponding InfeedEnqueue op will be generated
       * through another path, and might still generate an (incompatible)
       * layout using the TPU API. Running legalize_tf.cc on non-TPU nodes

      continue;

    // If an op doesn't implement any of the hardware interface we skip it.
    // This can happen in cases like Flex when we have non TFLite ops.
    auto device_name = GetDeviceName(&inst);

    if (device_name.has_value()) {
      // Add per device costs if present.
      auto per_device_cost = GetPerDeviceCosts(hardware_map, &inst);

		want := map[string]any{
			"level": cases[i].level,
			"msg":   cases[i].msg,
		}
		if k := cases[i].key; k != nil {
			want["key"] = *k
		}
		assert.Equal(t, want, parsedLog)
		i++
	}
}

func TestParseCniLog(t *testing.T) {
	wantT := &time.Time{}
	assert.NoError(t, wantT.UnmarshalText([]byte("2020-01-01T00:00:00.356374Z")))
	cases := []struct {
		name string
		in   string

      res_type.hasStaticShape()) {
    return false;
  }

  return true;
}

// In some cases, transposes may commute with elementwise operations. In order
// to make as many tranposes redudant as possible, we can "push" transposes
// back so that they fuse later on. These patterns handles 2 such cases in
// a conservative fashion; on-net it will never add to the number of transposes
// in the graph.

    return false;

  if (mlir::cast<IntegerAttr>(elements.front()).getInt() != 1 ||
      mlir::cast<IntegerAttr>(elements.back()).getInt() != 1)
    return false;

  Builder b(op->getContext());
  *x = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[1]).getInt());
  *y = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[2]).getInt());
  *z = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[3]).getInt());

}

func TestDetectLocalByBridgeInterface(t *testing.T) {
	cases := []struct {
		ifaceName               string
		expectedJumpIfOutput    []string
		expectedJumpIfNotOutput []string
	}{
		{
			ifaceName:               "eth0",
			expectedJumpIfOutput:    []string{"-i", "eth0"},
			expectedJumpIfNotOutput: []string{"!", "-i", "eth0"},
		},
	}
	for _, c := range cases {
		localDetector := NewDetectLocalByBridgeInterface(c.ifaceName)

		"invalid-version": {"", "", false, true},             // invalid version cannot be parsed
	}

	for k, v := range cases {
		t.Run(k, func(t *testing.T) {

			fileFetcher := func(url string, timeout time.Duration) (string, error) {
				key := strings.TrimSuffix(path.Base(url), ".txt")
				res, found := cases[key]
				if found {
					if v.FetcherErrorExpected {
						return "error", errors.New("expected error")
					}

		), false},
		{"empty configsUpdated for sidecar", sidecar, nil, true},
	}

	for k, name := range sidecarScopeKindNames {
		cases = append(cases, Case{ // valid name
			name:    fmt.Sprintf("%s config for sidecar", k.String()),
			proxy:   sidecar,
			configs: sets.New(model.ConfigKey{Kind: k, Name: name, Namespace: nsName}),
			want:    true,

      filter_i8_value_attr = mlir::cast<DenseIntElementsAttr>(
          cast<stablehlo::ConstantOp>(filter_op->getOperand(0).getDefiningOp())
              .getValue());
    }

    // Create Uniform Quantized constant for the filter.
    auto subtract_op =
        cast<stablehlo::SubtractOp>(*op.getResult().user_begin());
    auto other_conv_op = cast<stablehlo::ConvolutionOp>(