resultCh := make(chan itemOrErr[ObjectInfo])

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	if err := objectAPI.Walk(ctx, minioMetaBucket, batchJobReportsPrefix, resultCh, WalkOptions{}); err != nil {
		return err
	}

	for result := range resultCh {
		if result.Err != nil {
			return result.Err
		}
		ri := &batchJobInfo{}

	for _, nerr := range hostErrs {
		result := StartProfilingResult{NodeName: nerr.Host.String()}
		if nerr.Err != nil {
			result.Error = nerr.Err.Error()
		} else {
			result.Success = true
		}
		startProfilingResult = append(startProfilingResult, result)
	}

	// Create JSON result and send it to the client

	DB.Create(&namedUser)

	var result NamedUser
	DB.First(&result, "name1 = @name OR name2 = @name OR name3 = @name", sql.Named("name", "jinzhu2"))

	AssertEqual(t, result, namedUser)

	var result2 NamedUser
	DB.Where("name1 = @name OR name2 = @name OR name3 = @name", sql.Named("name", "jinzhu2")).First(&result2)

	AssertEqual(t, result2, namedUser)

	var result3 NamedUser

		lastCheckpoint = st.Object
	}
	workers := make([]chan ReplicateObjectInfo, resyncParallelRoutines)
	resultCh := make(chan TargetReplicationResyncStatus, 1)
	defer xioutil.SafeClose(resultCh)
	go func() {
		for r := range resultCh {
			s.incStats(r, opts)
			globalSiteResyncMetrics.updateMetric(r, opts.resyncID)
		}
	}()

	var wg sync.WaitGroup

	sort.Slice(result.Pets, func(i, j int) bool {
		return result.Pets[i].ID < result.Pets[j].ID
	})
	sort.Slice(result.Team, func(i, j int) bool {
		return result.Team[i].ID < result.Team[j].ID
	})
	sort.Slice(result.Friends, func(i, j int) bool {
		return result.Friends[i].ID < result.Friends[j].ID
	})
	sort.Slice(result2.Pets, func(i, j int) bool {
		return result2.Pets[i].ID < result2.Pets[j].ID

	}

	var result3 Product2
	if err := DB.First(&result3, "name = ?", "Nice2").Error; err != nil {
		t.Fatalf("Failed to query product, got error: %v", err)
	}

	DB.Model(&result3).Update("Price", 800)
	var result4 Product2
	DB.First(&result4, "name = ?", "Nice2")

	if result4.Price != 600 {
		t.Errorf("Admin product's price should not be changed, expects: %v, got %v", 600, result4.Price)
	}
}

		t.Errorf("Failed to commit transaction, got error %v\n", err)
	}

	if result := db.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 1 {
		t.Fatalf("Failed, got error: %v, rows affected: %v", result.Error, result.RowsAffected)
	}

	tx2 := db.Begin()
	if result := tx2.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 0 {

        }
        return new Result<>(result.hasErrors() || hasErrors(problems), result.get(), list);
    }

    public static <T> Result<T> addProblems(Result<T> result, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);
            }

	DB.Table("deleted_users").Create(&user)

	var result UserWithDelete
	if err := DB.Table("deleted_users").First(&result).Error; err != nil {
		t.Errorf("failed to find deleted user, got error %v", err)
	}

	AssertEqual(t, result, user)

	if err := DB.Table("deleted_users").Delete(&result).Error; err != nil {
		t.Errorf("failed to delete user, got error %v", err)
	}

	var result2 UserWithDelete

	for _, path := range []string{"mydns", "skydns"} {
		result := msgPath("service.staging.skydns.local.", path)
		if result != etcdPathSeparator+path+"/local/skydns/staging/service" {
			t.Errorf("Failure to get domain's path with prefix: %s", result)
		}
	}
}

func TestUnPath(t *testing.T) {
	result1 := msgUnPath("/skydns/local/cluster/staging/service/")
	if result1 != "service.staging.cluster.local." {