LLVM_DEBUG(llvm::dbgs() << "Expected kernel input feature == 2. Got: "
                            << kernel_input_feature_dim << ".\n");
    return failure();
  }

  const int64_t kernel_output_feature_dim =
      dimension_numbers.getKernelOutputFeatureDimension();
  if (kernel_output_feature_dim != 3) {
    LLVM_DEBUG(llvm::dbgs() << "Expected kernel output feature == 3. Got: "

	}
	// Verify that after syncing a complete job, the conditions are the same.
	if got, expected := len(actual.Status.Conditions), 1; got != expected {
		t.Fatalf("Unexpected job status conditions amount; expected %d, got %d", expected, got)
	}
}

func TestSyncJobDeleted(t *testing.T) {
	_, ctx := ktesting.NewTestContext(t)

// expected-warning @+1 {{Invalid number of arguments to non_max_suppression_padded_v2}}
func.func private @nms_padded_invalid_num_args(%arg0: tensor<100x4xf32>, %arg1: tensor<100xf32>, %arg2: tensor<i32>, %arg3: tensor<f32>) -> (tensor<1x10xi32>, tensor<i32>) attributes  {tf._implements = "non_max_suppression_padded_v2", tf._reference = "mlir"}

	}

	for k := range expectedMap {
		if v, ok := res.Header[k]; !ok {
			c.Errorf("Expected key %s missing from %v", k, res.Header)
		} else {
			expectedSet := set.CreateStringSet(expectedMap[k]...)
			gotSet := set.CreateStringSet(strings.Split(v[0], ", ")...)
			if !expectedSet.Equals(gotSet) {
				c.Errorf("Expected value %v, got %v", strings.Join(expectedMap[k], ", "), v)
			}
		}
	}
}

					t.Errorf("Expected cluster %s to have http protocol options but not found", tt.cluster.Name)
				}
				if ec.httpProtocolOptions.GetExplicitHttpConfig() == nil {
					t.Errorf("Expected cluster %s to have explicit http config but not found", tt.cluster.Name)
				}
				if ec.httpProtocolOptions.GetExplicitHttpConfig().GetHttp2ProtocolOptions() == nil {

		pods, err := spc.podsLister.Pods(set.Namespace).List(selector)
		if err != nil {
			t.Fatal(err)
		}

		sort.Sort(ascendingOrdinal(pods))

		// expected number of pod is 0,1,2,3
		if !reflect.DeepEqual(pods, originalPods[:4]) {
			t.Fatalf("Expected pods %v, got pods %v", originalPods[:4], pods)
		}

		// create new pods
		if _, err = ssc.UpdateStatefulSet(context.TODO(), set, pods); err != nil {

}

func expectHashError(t *testing.T, err error) {
	if err == nil {
		t.Fatalf("no error resulted from invalid hash")
	}
	if expected := "algorithm unimplemented"; !strings.Contains(err.Error(), expected) {
		t.Fatalf("error resulting from invalid hash didn't contain '%s', rather it was: %v", expected, err)
	}
}

func expectNameConstraintsError(t *testing.T, err error) {

		}
		if cl, expected := res.ContentLength, int64(3); cl != expected {
			t.Errorf("for %s expected res.ContentLength of %d; got %d", url, expected, cl)
		}
		if cl, expected := res.Header.Get("Content-Length"), "3"; cl != expected {
			t.Errorf("for %s expected Content-Length header of %q; got %q", url, expected, cl)
		}
		if tl, expected := len(res.TransferEncoding), 0; tl != expected {

			err := errs.ToAggregate()
			if err != nil {
				if e, a := test.expectedError, err.Error(); !strings.Contains(a, e) || e == "" {
					t.Errorf("expected to contain:\n  %s\ngot:\n  %s", e, a)
				}
			} else {
				if test.expectedError != "" {
					t.Errorf("unexpected no error, expected to contain:\n  %s", test.expectedError)
				}
			}
		})

	}
}

				err := errs[0]
				if len(v.createErr) == 0 {
					t.Errorf("unexpected error: %#v, none expected", err)
					return
				}
				if !strings.Contains(err.Error(), v.createErr) {
					t.Errorf("unexpected error: %v, expected: %s", err, v.createErr)
				}
			} else if len(v.createErr) != 0 {
				t.Errorf("no error, expected %v", v.createErr)
				return
			}

			oldSpec := v.cronJob.DeepCopy()