p.As == obj.ARET || p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO
}

// lookForJCC returns the first real instruction starting from p, if that instruction is a conditional
// jump. Otherwise, nil is returned.
func lookForJCC(p *obj.Prog) *obj.Prog {
	// Skip any PCDATA, FUNCDATA or NOP instructions
	var q *obj.Prog

	} else {
		api.headObjectHandler(ctx, objectAPI, bucket, object, w, r)
	}
}

// Extract metadata relevant for an CopyObject operation based on conditional
// header values specified in X-Amz-Metadata-Directive.
func getCpObjMetadataFromHeader(ctx context.Context, r *http.Request, userMeta map[string]string) (map[string]string, error) {

      MockResponse(
        headers = headersOf("ETag", "v1"),
        body = "A",
      ),
    )
    executeSynchronously("/")
      .assertCode(200)
      .assertBody("A")

    // Attempt conditional cache validation and a DNS miss.
    client =
      client.newBuilder()
        .dns(FakeDns())
        .build()
    executeSynchronously("/").assertFailure(UnknownHostException::class.java)
  }

//  - the first occurrence of a variable defines that variable.  Subsequent
//    uses must match (be == to) the first use.
//  - v is defined to be the value matched.
//  - an additional conditional can be provided after the match pattern with "&&".
// on the generated side
//  - the type of the top-level expression is the same as the one on the left-hand side.

    Select values of 'x' if the corresponding value of 'condition' is true or
    the value of 'y' if false. There are valid condition input sizes:

    1. Either the same shape (in which case the select is elementwise), or
    2. condition must be Rank 1 and match over the first dimension.
  }];

  let arguments = (ins
    TFL_BoolTensor:$condition,

		if !reflect.DeepEqual(test.expect, rows) {
			t.Errorf("%d mismatch: %s", i, cmp.Diff(test.expect, rows))
		}
	}
}

func TestPrintPodwide(t *testing.T) {
	condition1 := "condition1"
	condition2 := "condition2"
	condition3 := "condition3"
	tests := []struct {
		pod    api.Pod
		expect []metav1.TableRow
	}{
		{
			// Test when the NodeName and PodIP are not none
			api.Pod{

}

func hasPodReadyCondition(conditions []api.PodCondition) bool {
	for _, condition := range conditions {
		if condition.Type == api.PodReady && condition.Status == api.ConditionTrue {
			return true
		}
	}
	return false
}

func hasJobCondition(conditions []batch.JobCondition, conditionType batch.JobConditionType) bool {
	for _, condition := range conditions {
		if condition.Type == conditionType {

		t.Errorf("Unexpected error updating podB")
	}

	// unconditional update
	// NOTE: The logic for unconditional updates doesn't make sense to me, and imho should be removed.
	// doUnconditionalUpdate := resourceVersion == 0 && e.UpdateStrategy.AllowUnconditionalUpdate()
	// ^^ That condition can *never be true due to the creation of root objects.
	//

          "description": "Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions",
          "type": "string"
        },
        "type": {
          "description": "Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions",
          "type": "string"
        }
      },

			},
			wantErrs: field.ErrorList{
				{Type: field.ErrorTypeInvalid, Field: "status.conditions"},
			},
		},
		"invalid removal of terminal condition Complete=True": {
			enableJobManagedBy: true,
			job: &batch.Job{
				ObjectMeta: validObjectMeta,
				Status: batch.JobStatus{
					Conditions: []batch.JobCondition{
						{
							Type:   batch.JobComplete,
							Status: api.ConditionTrue,