std::unique_ptr<float[]> actual_values(new float[expected_values.size()]);
  EXPECT_EQ(sizeof(float) * expected_values.size(), TF_TensorByteSize(t));
  memcpy(actual_values.get(), TF_TensorData(t), TF_TensorByteSize(t));
  TF_DeleteTensor(t);

  for (int i = 0; i < expected_values.size(); i++) {
    EXPECT_EQ(expected_values[i], actual_values[i])
        << "Mismatch in expected values at (zero-based) index " << i;

                    checkMap(actualValue, expectedValue, checker)
                } else {
                    checker(actualValue, expectedValue)
                }
            } else if (checker instanceof List) {
                def subSpecs = checker as List
                checkModel(actualValue, expectedValue, subSpecs)
            } else {

	for k, expectedValue := range expectedKeys {
		keys := strings.Split(k, ".")
		if actualValue, ok, err := getJSONValue(generic, keys...); err != nil || !ok {
			t.Errorf("Unexpected error for %s: %v", k, err)
		} else if !reflect.DeepEqual(expectedValue, fmt.Sprintf("%v", actualValue)) {
			t.Errorf("Unexpected value for %v: expected %v, got %v", k, expectedValue, actualValue)
		}
	}

	for _, absentKey := range absentKeys {

            "getValue"
        );
        Object actualValue = invokeMethod(
            invokeMethod(throwable, "getActual"),
            "getValue"
        );

        if (isFileInfo(expectedValue) || isFileInfo(actualValue)) {
            return mapFileInfoComparisonFailure(throwable, expectedValue, actualValue);
        } else {

      TF_NewStatus(), TF_DeleteStatus);
  std::unique_ptr<TF_Tensor, decltype(&TF_DeleteTensor)> actual_value(
      TFE_TensorHandleResolve(handle, status.get()), TF_DeleteTensor);
  ASSERT_EQ(TF_GetCode(status.get()), TF_OK) << TF_Message(status.get());
  ASSERT_EQ(TF_TensorType(actual_value.get()),
            static_cast<TF_DataType>(DataTypeToEnum<value_type>().value));
  EXPECT_EQ(expected_value,

    @Override
    public <T> T getConventionValue(T actualValue, String propertyName, boolean isExplicitValue) {
        if (isExplicitValue) {
            return actualValue;
        }

        T returnValue = actualValue;
        if (_mappings.containsKey(propertyName)) {
            boolean useMapping = true;
            if (actualValue instanceof Collection && !((Collection<?>) actualValue).isEmpty()) {
                useMapping = false;

        } as Predicate
    }

    private static boolean testValue(expectedValue, actualValue) {
        if (expectedValue instanceof Closure) {
            expectedValue.call(actualValue)
        } else if (expectedValue instanceof Predicate) {
            expectedValue.apply(actualValue)
        } else {
            expectedValue == actualValue
        }
    }

        String expectedValue = invokeMethod(throwable, "getExpected", String.class);
        String actualValue = invokeMethod(throwable, "getActual", String.class);

        return TestFailure.fromTestAssertionFailure(throwable, expectedValue, actualValue);
    }

			}
			// All expected headers must be present; but there may be extras.
			for key, expectedValue := range tc.expectedHeaders {
				actualValue, found := ch.Headers[key]
				if found {
					if expectedValue != actualValue {
						t.Errorf("expected header value (%s), got (%s)", expectedValue, actualValue)
					}
				} else {
					t.Errorf("expected header (%s) not found", key)
				}
			}
		})
	}
}

        LineEndingSensitivity lineEndingSensitivity,
        @Nullable FileNormalizer fileNormalizer,
        PropertyValue value,
        InputFilePropertyType filePropertyType
    ) {
        FileCollectionInternal actualValue = FileParameterUtils.resolveInputFileValue(fileCollectionFactory, filePropertyType, value);
        FileNormalizer normalizer = FileParameterUtils.normalizerOrDefault(fileNormalizer);
        specs.add(new DefaultInputFilePropertySpec(