.setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test error message"))
                .build();

        LogEvent result = policy.rewrite(event);

        assertNotSame(event, result);
        assertEquals(Level.WARN, result.getLevel());
        assertEquals("test.logger.sublogger", result.getLoggerName());
        assertEquals("test error message", result.getMessage().getFormattedMessage());

	Used       uint64
	UsedInodes uint64
	FreeInodes uint64
	Major      uint32
	Minor      uint32
	NRRequests uint64
	FSType     string
	RootDisk   bool
	Healing    bool
	Scanning   bool
	Endpoint   string
	MountPath  string
	ID         string
	Rotational bool
	Metrics    DiskMetrics
	Error      string // carries the error over the network
}

// DiskMetrics has the information about XL Storage APIs

	}); err != nil {
		t.Errorf("failed to replace item content, got error: %v", err)
	}

	if count := tx.Model(&item).Association("Contents").Count(); count != 3 {
		t.Errorf("expected %d contents, got %d", 3, count)
	}

	var contents []ItemContent
	if err := tx.Find(&contents).Error; err != nil {
		t.Errorf("failed to find contents, got error: %v", err)
	}
	if len(contents) != 3 {

    }

    /** The DCERPC error code */
    private int error;
    /** The root cause exception */
    private Throwable rootCause;

    DcerpcException(final int error) {
        super(getMessageByDcerpcError(error));
        this.error = error;
    }

    /**
     * Constructs a DcerpcException with the specified message
     *
     * @param msg the error message
     */

	if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	if DB.Model(&User{}).Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Find(&User{}).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	var count1, count2 int64

		expectErr := (err != nil)

		if expectErr != testCase.expectErr {
			t.Fatalf("case %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}
		if err != errUnformattedDisk {
			t.Fatalf("case %v: error: expected: %v, got: %v", i+1, errUnformattedDisk, err)
		}
	}
}

func testStorageAPIStatInfoFile(t *testing.T, storage StorageAPI) {

	allPeerClients []*peerRESTClient // Includes nil client for self
}

// NotificationPeerErr returns error associated for a remote peer.
type NotificationPeerErr struct {
	Host xnet.Host // Remote host on which the rpc call was initiated
	Err  error     // Error returned by the remote peer for an rpc call
}

// A NotificationGroup is a collection of goroutines working on subtasks that are part of

	user := User{Name: "jinzhu", Account: Account{Number: "1"}}

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	if err := DB.Model(&user).Association("Languages").Replace(Account{Number: "2"}); err == nil {
		t.Error("expected association error to be not nil")
	}

        DataStoreException withIOException = new DataStoreException("IO Error", new java.io.IOException("File not found"));
        DataStoreException withNPE = new DataStoreException("NPE Error", new NullPointerException("Null value"));
        DataStoreException withCustom = new DataStoreException("Custom Error", new FessSystemException("System error"));

        assertTrue(withIOException.getCause() instanceof java.io.IOException);

            assertEquals(runtimeException, exception.getCause());
        });

        // Test with error
        Error error = new OutOfMemoryError("Out of memory");
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException(error);
            assertEquals(error, exception.getCause());
        });
    }

    @Test