}
        }

        class BridgeProvider<T> implements Provider<T> {
            final Binding<T> binding;

            BridgeProvider(Binding<T> binding) {
                this.binding = binding;
            }

            @Override
            public T get() {
                return compile(binding).get();
            }
        }

        @Override

                    }
                    binding.setOption(key, val);
                    key = null;
                }
                break;
            default:
                si = arr.length;
            }

            si++;
        } while (si < arr.length);

        if (binding == null || binding.endpoint == null) {
            throw new DcerpcException("Invalid binding URL: " + str);
        }

        this.binding = null;
    }

    /**
     * Constructs a DcerpcHandle with the specified CIFS context and binding
     *
     * @param tc
     *            the CIFS context for this handle
     * @param binding
     *            the DCE/RPC binding for this connection
     */
    public DcerpcHandle(final CIFSContext tc, final DcerpcBinding binding) {
        this.transportContext = tc;

            // When: Parsing the binding URL
            DcerpcBinding binding = DcerpcHandle.parseBinding(url);

            // Then: Should parse correctly
            assertNotNull(binding);
            assertEquals(expectedProto, binding.getProto());
            assertEquals(expectedServer, binding.getServer());
            assertEquals(expectedEndpoint, binding.getEndpoint());
        }

    }

    /**
     * Get channel binding hash
     *
     * @return binding hash bytes
     */
    public byte[] getBindingHash() {
        return bindingHash;
    }

    /**
     * Set channel binding hash
     *
     * @param bindingHash binding hash bytes
     */
    public void setBindingHash(byte[] bindingHash) {

    CONNECTING(1),       // Connection in progress
    AUTHENTICATING(2),   // Authentication in progress
    ESTABLISHED(3),      // Ready for use
    BINDING(4),         // Channel binding in progress
    ACTIVE(5),          // Actively transferring data
    FAILED(6),          // Connection failed
    CLOSING(7);         // Closing connection
    
    private final int value;
    

import javax.inject.Singleton;

import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import com.google.inject.AbstractModule;
import com.google.inject.Binding;
import com.google.inject.Injector;
import com.google.inject.TypeLiteral;
import org.apache.maven.api.model.Model;
import org.apache.maven.api.services.Source;
import org.apache.maven.api.spi.ModelParser;

    }

    @Test
    @DisplayName("Should handle session binding scenarios")
    void testSessionBindingScenarios() throws Exception {
        // Test both true and false session binding
        boolean[] bindingValues = { true, false };

        for (boolean binding : bindingValues) {
            // Given
            Smb2SessionSetupRequest req =

    }

    /**
     * Perform channel binding for a channel
     *
     * @param channel channel to bind
     * @throws IOException if binding fails
     */
    public void performChannelBinding(ChannelInfo channel) throws IOException {
        // MS-SMB2 3.2.4.1.6: Alternative Channel Creation
        // Channel binding requires SMB2_SESSION_FLAG_BINDING (0x01) in session setup

            // Then
            assertNotNull(bindWithNullBinding, "Constructor should handle null binding");
            Field bindingField = DcerpcBind.class.getDeclaredField("binding");
            bindingField.setAccessible(true);
            assertNull(bindingField.get(bindWithNullBinding), "Binding should be null");
        }
    }

    @Nested
    @DisplayName("Opnum Tests")
    class OpnumTests {