// This field is only available after ParseForm is called.
	// The HTTP client ignores Form and uses Body instead.
	Form url.Values

	// PostForm contains the parsed form data from PATCH, POST
	// or PUT body parameters.
	//
	// This field is only available after ParseForm is called.
	// The HTTP client ignores PostForm and uses Body instead.
	PostForm url.Values

        true              | false
        false             | true
        false             | false
    }

    def "task gets rerun after cancellation when buildcache = #buildCacheEnabled and exceptions ignored = #ignored"() {
        given:
        file('outputFile') << ''
        blockCode()
        buildFile << """
            apply plugin: 'java'

            @CacheableTask

        file('files/a/two.txt').createFile()
        file('files/b/ignore.txt').createFile()
        file('other/other-one.txt').createFile()
        file('other/a/other-ignore.txt').createFile()
        buildFile """
            def files = fileTree(dir: 'files').plus(fileTree(dir: 'other')).filter {
                println("checking \${it.name}")
                !it.name.contains('ignore')
            }
            task copy(type: Copy) {

	// have different names for GOOS=windows and GOOS=mac for example. On the
	// other hand if there's a NoGoError, the package might have source files
	// specifying "//go:build ignore" those packages should be skipped because
	// embeds from ignored files can't be used.
	// TODO(#42504): Find a better way to avoid errors from ImportDir. We'll
	// need to figure this out when we switch to PackagesAndErrors as per the
	// TODO above.

func TestIsErrIgnored(t *testing.T) {
	errIgnored := fmt.Errorf("ignored error")
	testCases := []struct {
		err     error
		ignored bool
	}{
		{
			err:     nil,
			ignored: false,
		},
		{
			err:     errIgnored,
			ignored: true,
		},
		{
			err:     errFaultyDisk,
			ignored: true,
		},
	}
	for i, testCase := range testCases {

		{Name: "Name", DBName: "company_name", BindNames: []string{"Base", "Name"}, DataType: schema.String, TagSettings: map[string]string{"EMBEDDED": "EMBEDDED", "EMBEDDEDPREFIX": "company_"}},
		{Name: "Ignored", BindNames: []string{"Base", "Ignored"}, TagSettings: map[string]string{"-": "-", "EMBEDDED": "EMBEDDED", "EMBEDDEDPREFIX": "company_"}},

    /**
     * Specifies that the value of a certain property should be ignored when normalizing properties files.  {@code propertyName} is matched case-sensitively with the property key.
     * This method can be called multiple times to declare additional properties to be ignored.
     * @param propertyName - the name of the property to ignore
     */
    void ignoreProperty(String propertyName);

// If a call fails (returns false), unification fails.
//
// In the unification context, structural equivalence of two types
// ignores the difference between a defined type and its underlying
// type if one type is a defined type and the other one is not.
// It also ignores the difference between an (external, unbound)
// type parameter and its core type.
// If two types are not structurally equivalent, they cannot be Go

                    phaseHasMoreProgress(startEvent);
                } else if (startEvent.getBuildOperationCategory() == BuildOperationCategory.CONFIGURE_PROJECT && currentPhase == Phase.Configuring) {
                    // Any configuring event received from nested or buildSrc builds before the root build starts configuring is ignored

        results.formattedSuccessRate == '0%'
    }

    def formatsSuccessRateWhenAllTestsAreIgnored() {
        results.addTest(test())
        results.addTest(test())
        results.ignored(test());
        results.ignored(test());

        expect:
        results.successRate == null
        results.formattedSuccessRate == '-'
    }

    def formatsDurationWhenNoTests() {
        expect: