* @return array of supported algorithm constants
     */
    int[] getSupportedAlgorithms();

    /**
     * Estimates the compression ratio for the given data and algorithm.
     * This can be used to decide whether compression is worthwhile.
     *
     * @param data the data to analyze
     * @param algorithm the compression algorithm
     * @return estimated compression ratio (0.0 to 1.0, where 0.5 means 50% size reduction)

    assertThat(networkA.edgeOrder()).isEqualTo(networkB.edgeOrder());

    assertThat(networkA).isEqualTo(networkB);
  }

  /**
   * In some cases our graph implementations return custom sets that define their own size() and
   * contains(). Verify that these sets are consistent with the elements of their iterator.
   */
  @CanIgnoreReturnValue
  static <T> Set<T> sanityCheckSet(Set<T> set) {

            // Verify that AllocInfo indirectly implements Decodable
            assertTrue(jcifs.Decodable.class.isAssignableFrom(AllocInfo.class));
        }

        @Test
        @DisplayName("Should define getCapacity method")
        void shouldDefineGetCapacityMethod() throws NoSuchMethodException {
            // Verify method exists with correct signature
            assertNotNull(AllocInfo.class.getMethod("getCapacity"));

    @BeforeEach
    void setUp() {
        testCache = new TestBufferCacheImpl(5, 1024); // 5 buffers of 1KB each
    }

    @Test
    @DisplayName("BufferCache interface should define correct method signatures")
    void testInterfaceContract() {
        // Given
        BufferCache cache = mockBufferCache;

        // When & Then - verify interface methods exist and can be called

import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.annotations.Nullable;

/**
 * Base interface for service requests in Maven. This interface defines the common contract
 * for all request types within the Maven service layer, providing access to session context
 * and request tracing capabilities.
 *
 * <p>Each request is associated with a {@link ProtoSession} that contains the configuration

        // Set up deferred buffer chain to avoid NPE
        mockDeferredNdrBuffer.deferred = mockDeferredNdrBuffer; // Self-reference to avoid NPE
        lenient().when(mockNdrBuffer.derive(anyInt())).thenReturn(mockDeferredNdrBuffer);
        lenient().when(mockDeferredNdrBuffer.derive(anyInt())).thenReturn(mockDeferredNdrBuffer);

        // Set up lenient stubs for common operations to avoid unnecessary stubbing exceptions

  docs-all-green:  # This job does nothing and is only used for the branch protection
    if: always()
    needs:
      - build-docs
    runs-on: ubuntu-latest
    steps:
      - name: Decide whether the needed jobs succeeded or failed
        uses: re-actors/alls-green@release/v1
        with:
          jobs: ${{ toJSON(needs) }}

	return Token{ScanToken: token, text: text}
}

func (l Token) String() string {
	return l.text
}

// A Macro represents the definition of a #defined macro.
type Macro struct {
	name   string   // The #define name.
	args   []string // Formal arguments.
	tokens []Token  // Body of macro.
}

// Tokenize turns a string into a list of Tokens; used to parse the -D flag and in tests.
func Tokenize(str string) []Token {

      - coverage-combine
    runs-on: ubuntu-latest
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - name: Decide whether the needed jobs succeeded or failed
        uses: re-actors/alls-green@release/v1
        with:

## Documentation Response description - OpenAPI { #documentation-response-description-openapi }

To define the description of the response, shown in the docs UI, read the docs for [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.