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 {

    @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(

            probedSystemProperties.each {
                def actualValue = actualProperties[it.systemPropertyKey]
                // write conditionally to simulate wrong number of outputs
                if (actualValue != null) {
                    output.println(MetadataProbe.MARKER_PREFIX + actualValue)
                }
            }
            Mock(ExecResult)
        }

                PropertyValue value,
                InputFilePropertyType filePropertyType
            ) {
                FileCollection actualValue = FileParameterUtils.resolveInputFileValue(fileCollectionFactory, filePropertyType, value);
                context.add(actualValue);
            }
        });
    }

    private static class TaskInputUnionFileCollection extends CompositeFileCollection implements Describable {