// Arrange - Create URL with handler
        URL url = new URL(null, "smb://host/share", handler);

        // Act
        URLConnection conn = handler.openConnection(url);

        // Assert
        assertNotNull(conn);
        assertTrue(conn instanceof SmbFile);
    }

    @Test
    @DisplayName("openConnection throws NPE for null URL")
    void testOpenConnectionWithNullUrl() {
        // Act & Assert

                        return conn;
                    }
                }
            }

            conn = new SmbTransport(address, port, localAddr, localPort);
            CONNECTIONS.add(0, conn);
        }

        return conn;
    }

    class ServerData {
        byte flags;
        int flags2;
        int maxMpxCount;
        int maxBufferSize;

//	key: The key representing the SQL query, used for caching and preparing the statement.
//	isTransaction: Indicates whether this operation is part of a transaction, affecting cache strategy.
//	conn: A connection pool that provides database connections.
//	locker: A synchronization lock that is unlocked after initialization to avoid deadlocks.
//
// Returns:
//

	RollbackTo(tx *DB, name string) error
}

// TxBeginner tx beginner
type TxBeginner interface {
	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
}

// ConnPoolBeginner conn pool beginner
type ConnPoolBeginner interface {
	BeginTx(ctx context.Context, opts *sql.TxOptions) (ConnPool, error)
}

// TxCommitter tx committer
type TxCommitter interface {
	Commit() error
	Rollback() error

	if db.Error != nil {
		return db.Error
	}

	tx := db.getInstance()
	sqlDB, err := tx.DB()
	if err != nil {
		return
	}

	conn, err := sqlDB.Conn(tx.Statement.Context)
	if err != nil {
		return
	}

	defer conn.Close()
	tx.Statement.ConnPool = conn
	return fc(tx)
}

// Transaction start a transaction as a block, return error will rollback, otherwise to commit. Transaction executes an

    }

    @Test
    public void testOnConnectMethod() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        CurlRequest result = request.onConnect((req, conn) -> {
            conn.setConnectTimeout(5000);
        });

        assertSame(request, result); // Fluent API
    }

    @Test
    public void testParamMethod() {

		return nil
	}); err == nil {
		t.Errorf("should returns error when commit with closed conn, got error %v", err)
	}

	if err := DB.Session(&gorm.Session{PrepareStmt: true}).Transaction(func(tx *gorm.DB) error {
		return nil
	}); err == nil {
		t.Errorf("should returns error when commit with closed conn, got error %v", err)
	}
}

func TestTransactionWithHooks(t *testing.T) {

 * They don't specify whether a specific proxy server should be used or how to authenticate with that proxy server.

	TranslateError bool
	// PropagateUnscoped propagate Unscoped to every other nested statement
	PropagateUnscoped bool

	// ClauseBuilders clause builder
	ClauseBuilders map[string]clause.ClauseBuilder
	// ConnPool db conn pool
	ConnPool ConnPool
	// Dialector database dialector
	Dialector
	// Plugins registered plugins
	Plugins map[string]Plugin

	callbacks  *callbacks
	cacheStore *sync.Map
}

# under the License.

set maven.mainClass default org.apache.maven.cling.MavenCling

main is ${maven.mainClass} from plexus.core

set maven.conf default ${maven.home}/conf
set maven.installation.conf default ${maven.conf}

[plexus.core]
load       ${maven.conf}/logging
optionally ${maven.home}/lib/ext/redisson/*.jar
optionally ${maven.home}/lib/ext/hazelcast/*.jar
optionally ${user.home}/.m2/ext/*.jar