private val renameFaults: MutableSet<Path> = LinkedHashSet()

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      writeFaults.add(file)
    } else {
      writeFaults.remove(file)
    }
  }

  fun setFaultyDelete(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      deleteFaults.add(file)
    } else {
      deleteFaults.remove(file)
    }
  }

var errDriveIsRoot = StorageErr("drive is part of root drive, will not be used")

// errFaultyRemoteDisk - remote disk is faulty.
var errFaultyRemoteDisk = StorageErr("remote drive is faulty")

// errFaultyDisk - disk is faulty.
var errFaultyDisk = StorageErr("drive is faulty")

// errDiskAccessDenied - we don't have write permissions on disk.
var errDiskAccessDenied = StorageErr("drive access denied")

# window size, and how much to save for an application buffer.
net.ipv4.tcp_adv_win_scale=1

# disable RFC2861 behavior
net.ipv4.tcp_slow_start_after_idle = 0

# Fix faulty network setups
net.ipv4.tcp_mtu_probing=1
net.ipv4.tcp_base_mss=1280

# Disable ipv6
net.ipv6.conf.all.disable_ipv6=1
net.ipv6.conf.default.disable_ipv6=1
net.ipv6.conf.lo.disable_ipv6=1

[bootloader]

        // 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)
        assertTrue(DcerpcError.DCERPC_FAULT_OTHER >= 0 && DcerpcError.DCERPC_FAULT_OTHER <= 0x0000FFFF,

// but this fault is also not guaranteed.
func New[T any](a *Arena) *T {
	return runtime_arena_arena_New(a.a, reflectlite.TypeOf((*T)(nil))).(*T)
}

// MakeSlice creates a new []T with the provided capacity and length. The []T must
// not be used after the arena is freed. Accessing the underlying storage of the
// slice after free may result in a fault, but this fault is also not guaranteed.

         * Called when a request starts.
         *
         * @param client the fault-tolerant client
         * @param request the request data
         */
        void onRequestStart(FaultTolerantClient client, RequestData request);

        /**
         * Called before each request attempt.
         *
         * @param client the fault-tolerant client
         * @param request the request data

        // Create a properly formatted fault message
        NdrBuffer buf = new NdrBuffer(new byte[1024], 0);

        // Manually encode a fault header
        buf.enc_ndr_small(5); // RPC version
        buf.enc_ndr_small(0); // minor version
        buf.enc_ndr_small(3); // ptype = 3 (Fault)
        buf.enc_ndr_small(0); // flags

     */
    int DCERPC_FAULT_NDR = 0x000006F7;
    /**
     * Invalid tag fault code
     */
    int DCERPC_FAULT_INVALID_TAG = 0x1C000006;
    /**
     * Context mismatch fault code
     */
    int DCERPC_FAULT_CONTEXT_MISMATCH = 0x1C00001A;
    /**
     * Operation range error fault code
     */
    int DCERPC_FAULT_OP_RNG_ERROR = 0x1C010002;
    /**
     * Unknown interface fault code
     */

package jcifs.smb1.dcerpc;

/**
 * DCE/RPC error codes and fault constants for SMB1 compatibility
 */
public interface DcerpcError {

    /**
     * Generic fault code for other errors
     */
    int DCERPC_FAULT_OTHER = 0x00000001;
    /**
     * Access denied fault code
     */
    int DCERPC_FAULT_ACCESS_DENIED = 0x00000005;
    /**
     * Cannot perform operation fault code
     */

        }

        if (this.ptype == 2 || this.ptype == 3) { /* Response or Fault */
            this.alloc_hint = buf.dec_ndr_long();
            buf.dec_ndr_short(); /* context id */
            buf.dec_ndr_short(); /* cancel count */
        }
        if (this.ptype == 3 || this.ptype == 13) { /* Fault */
            this.result = buf.dec_ndr_long();
        } else { /* Bind_ack or Response */