|| sourceSet.getName().equals(SourceSet.TEST_SOURCE_SET_NAME)
            )
            .map(sourceSet -> sourceSet.getOutput().getClassesDirs())
            .reduce(FileCollection::plus)
            .orElse(getProject().files())
            .filter(File::exists);
    }

 *
 * <p>This interface is now a legacy type. Use {@code java.util.function.Predicate} (or the
 * appropriate primitive specialization such as {@code IntPredicate}) instead whenever possible.
 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *

			need = 1 // to ensure we read at least one byte for every Read
			tokens = b
		}
	} else { // all tokens go towards payload
		need = int(math.Min(float64(b), float64(need)))
		tokens = need
	}
	// reduce tokens requested according to availability
	av := int(r.throttle.Tokens())
	if av < tokens && av > 0 {
		tokens = av
		need = int(math.Min(float64(tokens), float64(need)))
	}
	err = r.throttle.WaitN(r.ctx, tokens)

     */
    @InputFiles
    @SkipWhenEmpty
    public FileCollection getFiles() {
        return getSources().get()
            .stream()
            .map(sourceTree -> sourceTree.matching(filesFilter))
            .reduce(FileTree::plus)
            .orElse(projectLayout.files().getAsFileTree());
    }

    @TaskAction
    public void checkInvalidPermissions() throws IOException {
        if (Os.isFamily(Os.FAMILY_WINDOWS)) {

## Get Started with MinIO in Erasure Code

### 1. Prerequisites

Install MinIO - [MinIO Quickstart Guide](https://docs.min.io/community/minio-object-store/operations/deployments/baremetal-deploy-minio-on-redhat-linux.html)

### 2. Run MinIO Server with Erasure Code

Example: Start MinIO server in a 12 drives setup, using MinIO binary.

```sh
minio server /data{1...12}
```

      return DummyProxy.this;
    }

    @Override
    public String toString() {
      return "Dummy proxy for " + interfaceType;
    }

    // Since type variables aren't serializable, reduce the type down to raw type before
    // serialization.
        private Object writeReplace() {
      return new DummyHandler(TypeToken.of(interfaceType.getRawType()));
    }
  }

---> 100%
```

</div>

## WebSockets-Client { #websockets-client }

### In Produktion { #in-production }

In Ihrem Produktionssystem haben Sie wahrscheinlich ein Frontend, das mit einem modernen Framework wie React, Vue.js oder Angular erstellt wurde.

Und um über WebSockets mit Ihrem Backend zu kommunizieren, würden Sie wahrscheinlich die Werkzeuge Ihres Frontends verwenden.

connecting to servers with buggy HTTP/2 implementations.
These kinds of changes are unavoidable and
[permitted by the Go 1 compatibility rules](/doc/go1compat).
Even so, Go provides a mechanism called GODEBUG to
reduce the impact such changes have on Go developers
using newer toolchains to compile old code.

A GODEBUG setting is a `key=value` pair
that controls the execution of certain parts of a Go program.

    int RPC_PT_SHUTDOWN = 0x11;
    /**
     * Cancel packet type
     */
    int RPC_PT_CANCEL = 0x12;
    /**
     * Acknowledgment packet type
     */
    int RPC_PT_ACK = 0x13;
    /**
     * Reject packet type
     */
    int RPC_PT_REJECT = 0x14;
    /**
     * Connection-oriented cancel packet type
     */
    int RPC_PT_CO_CANCEL = 0x15;
    /**
     * Orphaned packet type
     */

        @Test
        @DisplayName("Should reject null data buffer in sign method")
        void testSignNullDataBuffer() {
            assertThrows(IllegalArgumentException.class, () -> digest.sign(null, 0, 100, request, response),
                    "Should throw IllegalArgumentException for null data buffer");
        }

        @Test
        @DisplayName("Should reject negative offset in sign method")