Gradle introduced additional task and artifact transform validation warnings in the Gradle 7.x series.
Those warnings are now errors in Gradle 8.0 and will fail the build.

Warnings that became errors:

- An input file collection that can't be resolved.
- An input or output file or directory that cannot be read.

//   EXPECT_TRUE  verifies that a Boolean condition is true.
//   EXPECT_FALSE verifies that a Boolean condition is false.
//
// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
// that they will also abort the current function on failure.  People
// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
// writing data-driven tests often find themselves using ADD_FAILURE
// and EXPECT_* more.

                        byConflictResolution("between versions 1.1 and 1.0")
                    }
                }
                module('org:core:1.1')
            }
        }
    }

    def "shouldn't fail if target alignment version doesn't exist"() {
        repository {
            path 'xml -> core'
            path 'json -> core'
            path 'json:1.1 -> core:1.1'
        }

        given:

    /**
     * Associates {@code key} with {@code value} in the built map. Duplicate keys, according to the
     * comparator (which might be the keys' natural order), are not allowed, and will cause {@link
     * #build} to fail.
     */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      ensureCapacity(size + 1);
      checkEntryNotNull(key, value);
      keys[size] = key;

		if err := DB.Create(&AutoIncrementStruct{}).Error; err != nil {
			t.Fatalf("create auto_increment_struct fail, err: %v", err)
		}
	}

	rows := make([]*AutoIncrementStruct, 0, ROWS)
	if err := DB.Order("id ASC").Find(&rows).Error; err != nil {
		t.Fatalf("find auto_increment_struct fail, err: %v", err)
	}

	ids := make([]int64, 0, len(rows))
	for _, row := range rows {
		ids = append(ids, row.ID)

          "in":...

	}
	_, err = r.Seek(0, 0)
	if err == nil {
		t.Fatal("Seek on pipe should fail")
	}
	if perr, ok := err.(*PathError); !ok || perr.Err != syscall.ESPIPE {
		t.Errorf("Seek returned error %v, want &PathError{Err: syscall.ESPIPE}", err)
	}
	_, err = w.Seek(0, 0)
	if err == nil {
		t.Fatal("Seek on pipe should fail")
	}
	if perr, ok := err.(*PathError); !ok || perr.Err != syscall.ESPIPE {

    public void testValidationErrorUponNonUniqueDependencyKey()
        throws Exception
    {
        try
        {
            buildPom( "unique-dependency-key/deps" );
            fail( "Non-unique dependency keys did not cause validation error" );
        }
        catch ( ProjectBuildingException e )
        {
            // expected
        }
    }

    @Test

POD_MANIFEST_PATH=${POD_MANIFEST_PATH:-"/var/run/kubernetes/static-pods"}
KUBELET_FLAGS=${KUBELET_FLAGS:-""}
KUBELET_IMAGE=${KUBELET_IMAGE:-""}
# many dev environments run with swap on, so we don't fail in this env
FAIL_SWAP_ON=${FAIL_SWAP_ON:-"false"}
# Name of the dns addon, eg: "kube-dns" or "coredns"
DNS_ADDON=${DNS_ADDON:-"coredns"}
CLUSTER_CIDR=${CLUSTER_CIDR:-10.1.0.0/16}

	// The lookup to generate a new client will fail when it tries to query a driver with an unknown name
	csiUnmounter.csiClientGetter.csiClient = nil
	// Note that registerFakePlugin above will create a driver with a name of "test-driver"
	csiUnmounter.csiClientGetter.driverName = "unknown-driver"

	err = csiUnmounter.TearDownAt(dir)
	if err == nil {
		t.Errorf("test should fail, but no error occurred")