}

    /**
     * Gets the successful HTTP codes.
     *
     * @return the successful HTTP codes
     */
    public int[] getSuccessfulHttpCodes() {
        return successfulHttpCodes;
    }

    /**
     * Sets the successful HTTP codes.
     *
     * @param successfulHttpCodes the successful HTTP codes to set
     */

        faultCodes.add(DcerpcError.DCERPC_FAULT_PROTO_ERROR);

        // Verify all 9 codes are unique
        assertEquals(9, faultCodes.size(), "All fault codes should be unique");
    }

    @Test
    @DisplayName("Should verify fault code value ranges and patterns")
    void testFaultCodeValueRanges() {
        // Standard fault codes (0x00000000 - 0x0000FFFF range)

      tagClass = tagClass,
      tag = tag,
      codec = codec,
    )
  }

  /** Returns an adapter that returns a list of values of this type. */
  fun asSequenceOf(
    name: String = "SEQUENCE OF",
    tagClass: Int = DerHeader.TAG_CLASS_UNIVERSAL,
    tag: Long = 16L,
  ): BasicDerAdapter<List<T>> {
    val codec =
      object : BasicDerAdapter.Codec<List<T>> {
        override fun encode(

# Status Codes

You can import the `status` module from `fastapi`:

```python
from fastapi import status
```

`status` is provided directly by Starlette.

It contains a group of named constants (variables) with integer status codes.

For example:

* 200: `status.HTTP_200_OK`
* 403: `status.HTTP_403_FORBIDDEN`
* etc.

Sebastián Ramírez <******@****.***> 1731896744 +0100

        }
    }

    @Test
    @DisplayName("Should have status codes array")
    void testStatusCodesArray() {
        // When
        int[] codes = NtStatus.NT_STATUS_CODES;

        // Then
        assertNotNull(codes);
        assertTrue(codes.length > 0);
        // First code should be success
        assertEquals(NtStatus.NT_STATUS_SUCCESS, codes[0]);
    }

    @Test

  }

  /**
   * Assigns to {@code hashCode} a "bucket" in the range {@code [0, buckets)}, in a uniform manner
   * that minimizes the need for remapping as {@code buckets} grows. That is, {@code
   * consistentHash(h, n)} equals:
   *
   * <ul>
   *   <li>{@code n - 1}, with approximate probability {@code 1/n}
   *   <li>{@code consistentHash(h, n - 1)}, otherwise (probability {@code 1 - 1/n})
   * </ul>
   *

      RandomHasherAction.pickAtRandom(random).performAction(random, hashers);
    }
    HashCode[] codes = new HashCode[hashers.size()];
    for (int i = 0; i < hashers.size(); i++) {
      codes[i] = hashers.get(i).hash();
    }
    for (int i = 1; i < codes.length; i++) {
      assertEquals(codes[i - 1], codes[i]);
    }
  }

  public void testPutStringWithLowSurrogate() {

  val tagClass: Int,
  /** The tag this adapter expects, or -1 to match any tag. */
  val tag: Long,
  /** Encode and decode the value once tags are handled. */
  private val codec: Codec<T>,
  /** True if the default value should be used if this value is absent during decoding. */
  val isOptional: Boolean = false,
  /** The value to return if this value is absent. Undefined unless this is optional. */

                int dialect = version.getDialect();
                assertTrue(dialect > 0, "Dialect code should be positive for " + version);
                assertTrue(dialectCodes.add(dialect), "Dialect code should be unique for " + version);
            }
        }

        // Should have 5 unique dialect codes for SMB2+ versions
        assertEquals(5, dialectCodes.size());
    }