)

func BeginTransaction(db *gorm.DB) {
	if !db.Config.SkipDefaultTransaction && db.Error == nil {
		if tx := db.Begin(); tx.Error == nil {
			db.Statement.ConnPool = tx.Statement.ConnPool
			db.InstanceSet("gorm:started_transaction", true)
		} else if tx.Error == gorm.ErrInvalidTransaction {
			tx.Error = nil
		} else {
			db.Error = tx.Error
		}
	}
}

func CommitOrRollbackTransaction(db *gorm.DB) {

* New kubeadm flag `--ignore-preflight-errors` that enables to decrease severity of each individual error to warning. ([#56072](https://github.com/kubernetes/kubernetes/pull/56072), [@kad](https://github.com/kad))
    * Old flag `--skip-preflight-checks` is marked as deprecated and acts as `--ignore-preflight-errors=all`

func (z decomError) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "Err"
	o = append(o, 0x81, 0xa3, 0x45, 0x72, 0x72)
	o = msgp.AppendString(o, z.Err)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *decomError) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32

import java.io.IOException;

/**
 * Exception thrown when an error occurs during NDR encoding or decoding operations.
 */
public class NdrException extends IOException {

    /**
     * Error message for null reference pointers.
     */
    public static final String NO_NULL_REF = "ref pointer cannot be null";

    /**
     * Error message for invalid array conformance.
     */

    boolean errorNotThrown = false;
    try {
      SerializableTester.reserializeAndAssert(orig);
      errorNotThrown = true;
    } catch (AssertionFailedError error) {
      // expected
      assertContains("must be Object#equals to", error.getMessage());
    }
    assertFalse(errorNotThrown);
  }

  public void testClassWhichIsAlwaysEqualButHasDifferentHashcodes() {

 */
@GwtCompatible
@NullUnmarked
final class UncheckedThrowingFuture<V> extends AbstractFuture<V> {

  public static <V> ListenableFuture<V> throwingError(Error error) {
    UncheckedThrowingFuture<V> future = new UncheckedThrowingFuture<V>();
    future.complete(checkNotNull(error));
    return future;
  }

  public static <V> ListenableFuture<V> throwingRuntimeException(RuntimeException e) {

package http

import (
	"context"
	"net"
	"time"
)

// LookupHost is a function to make custom lookupHost for optional cached DNS requests
type LookupHost func(ctx context.Context, host string) (addrs []string, err error)

// DialContextWithLookupHost is a helper function which returns `net.DialContext` function.
// It randomly fetches an IP via custom LookupHost function and dials it by the given dial

				return oi.ETag != "wrong-etag-12345"
			},
		}

		_, err := obj.NewMultipartUpload(ctx, bucket, object, opts)
		if !isErrReadQuorum(err) {
			t.Logf("Got error (as expected): %v", err)
			t.Logf("But expected read quorum error, not object-not-found error")
		}
	})

	t.Run("if-match with correct ETag and read quorum failure", func(t *testing.T) {
		// Test Case 3: if-match with CORRECT ETag but read quorum failure

     * @throws IOException if an I/O error occurs
     */
    public PacDataInputStream(final InputStream in) throws IOException {
        this.dis = new DataInputStream(in);
        this.size = in.available();
    }

    /**
     * Aligns the stream position to the specified boundary.
     * @param mask the alignment mask (typically 2, 4, or 8)
     * @throws IOException if an I/O error occurs
     */

	}
	for i, urs := range unparsableRangeSpecs {
		rs, err := parseRequestRangeSpec(urs)
		if err == nil {
			t.Errorf("Case %d: Did not get an expected error - got %v", i, rs)
		}
		if isErrInvalidRange(err) {
			t.Errorf("Case %d: Got invalid range error instead of a parse error", i)
		}
		if rs != nil {
			t.Errorf("Case %d: Got non-nil rs though err != nil: %v", i, rs)
		}
	}

	invalidRangeSpecs := []string{