Exception level3 = new RuntimeException("Level 3 error");
        Exception level2 = new IllegalStateException("Level 2 error", level3);
        Exception level1 = new IOException("Level 1 error", level2);
        SsoLoginException exception = new SsoLoginException("Top level SSO error", level1);

        assertEquals("Top level SSO error", exception.getMessage());

        // Verify the exception chain

	// The real disk
	disk StorageAPI
	// Programmed errors: API call number => error to return
	errors map[int]error
	// The error to return when no error value is programmed
	defaultErr error
	// The current API call number
	callNR int
	// Data protection
	mu sync.Mutex
}

func newNaughtyDisk(d StorageAPI, errs map[int]error, defaultErr error) *naughtyDisk {
	return &naughtyDisk{disk: d, errors: errs, defaultErr: defaultErr}
}

    @Override
    public void error(CharSequence content) {
        logger.error(toString(content));
    }

    @Override
    public void error(CharSequence content, Throwable error) {
        logger.error(toString(content), error);
    }

    @Override
    public void error(Throwable error) {
        logger.error("", error);
    }

    @Override
    public boolean isDebugEnabled() {

        // Test with VirtualMachineError
        String url = "http://example.com/vm-error";
        String message = "VM error during crawling";
        InternalError error = new InternalError("JVM internal error");

        DataStoreCrawlingException exception = new DataStoreCrawlingException(url, message, error);

        assertEquals(url, exception.getUrl());

     * The error's stacktrace will be output when this error level is enabled.
     *
     * @param content
     * @param error
     */
    void error(CharSequence content, Throwable error);

    /**
     * Send an exception to the user in the <b>error</b> error level.<br>
     * The stack trace for this exception will be output when this error level is enabled.
     *

                Arguments.of(NbtException.ERR_NAM_SRVC, NbtException.SRV_ERR, "ERR_NAM_SRVC/Unknown error code: 2"),
                Arguments.of(NbtException.ERR_NAM_SRVC, NbtException.IMP_ERR, "ERR_NAM_SRVC/Unknown error code: 4"),
                Arguments.of(NbtException.ERR_NAM_SRVC, NbtException.RFS_ERR, "ERR_NAM_SRVC/Unknown error code: 5"),

	if err := DB.First(&profile2, "id = ?", profile.ID).Error; err != nil {
		t.Fatalf("failed to find profile, got error: %v", err)
	} else if profile2.MemberID != 100 {
		t.Fatalf("member id is not equal: expects: %v, got: %v", 100, profile2.MemberID)
	}

	if r := DB.Delete(&member); r.Error != nil || r.RowsAffected != 1 {
		t.Fatalf("Should delete member, got error: %v, affected: %v", r.Error, r.RowsAffected)
	}

	var result Member

	if err := DB.Save(&lang).Error; err != nil {
		t.Errorf("Failed to create, got error %v", err)
	}

	var result Language
	if err := DB.First(&result, "code = ?", lang.Code).Error; err != nil {
		t.Errorf("Failed to query lang, got error %v", err)
	} else {
		AssertEqual(t, result, lang)
	}

	lang.Name += "_new"
	if err := DB.Save(&lang).Error; err != nil {

		t.Fatalf("failed to create from map, got error %v", err)
	}

	if err := DB.Model(&User{}).Create(map[string]interface{}{"name": "create_from_map_1", "age": 18}).Error; err != nil {
		t.Fatalf("failed to create data from map, got error: %v", err)
	}

	var result1 User
	if err := DB.Where("name = ?", "create_from_map_1").First(&result1).Error; err != nil || result1.Age != 18 {

	}

	if tx.Error != nil {
		t.Errorf("Should not raise any error, but got %v", tx.Error)
	}

	AssertObjEqual(t, result, data, "Name", "Gender", "Age")

	if err := DB.Where(data).Assign(ScannerValuerStruct{Age: sql.NullInt64{Int64: 18, Valid: true}}).FirstOrCreate(&result).Error; err != nil {
		t.Errorf("Should not raise any error, but got %v", err)
	}

	if result.Age.Int64 != 18 {