// Due to the implementation of the two services we know that both are now failed.  So the
    // following awaitHealthy call is just to get the exception.
    manager.startAsync();
    assertThat(manager.servicesByState().get(State.FAILED)).hasSize(2);
    IllegalStateException e =
        assertThrows(IllegalStateException.class, () -> manager.awaitHealthy());
    assertThat(e)

	"sync"
	"testing"
	"time"
)

func TestBatchCommit(t *testing.T) {
	defer func() {
		if err := tearDownQueueStore(); err != nil {
			t.Fatalf("Failed to tear down store; %v", err)
		}
	}()
	store, err := setUpQueueStore(queueDir, 100)
	if err != nil {
		t.Fatalf("Failed to create a queue store; %v", err)
	}

	var limit uint32 = 100

	batch := NewBatch[TestItem](BatchConfig[TestItem]{
		Limit:         limit,

	ReplicatedSize int64 `json:"replicatedSize"`
	// Total number of completed operations
	ReplicatedCount int64 `json:"replicatedCount"`
	// Failed captures replication errors in various time windows

	Failed madmin.TimedErrStats `json:"failed"`

	XferStats map[RMetricName]XferStats `json:"transferSummary"`
}

// SRMetricsSummary captures summary of replication counts across buckets on site

	},
	{ // 4. replication status for 3 targets, one of them failed
		name: "replication status for 3 targets - one failed",
		rs: ReplicationState{
			ReplicationStatusInternal: "arn1=COMPLETED;arn2=COMPLETED;arn3=FAILED;",
			Targets:                   map[string]replication.StatusType{"arn1": "COMPLETED", "arn2": "COMPLETED", "arn3": "FAILED"},
		},
		expStatus: replication.Failed,
	},
	{ // 5. replication status for replica version

		clause.Assignment{Column: clause.Column{Name: "age"}, Value: 25},
	).Create(ctx)
	if err != nil {
		t.Fatalf("Set Create failed: %v", err)
	}

	// Find the created user
	var user User
	if err := DB.Where("name = ?", "TestClauseAssociationSetCreateWithOpCreate").First(&user).Error; err != nil {
		t.Fatalf("failed to find created user: %v", err)
	}

	// Test Set + Update with Association OpCreate
	assocOp := clause.Association{

	if err != nil {
		t.Fatalf("failed to parse pointer user, got error %v", err)
	}

	if customize.Table != "customize" {
		t.Errorf("Failed to customize table with TableName method")
	}
}

func TestNestedModel(t *testing.T) {
	versionUser, err := schema.Parse(&VersionUser{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {
		t.Fatalf("failed to parse nested user, got error %v", err)
	}

	if ! run_test_erasure; then
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	echo "Testing in Distributed Erasure setup"
	if ! run_test_dist_erasure; then
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	echo "Testing in Erasure setup as sets"
	if ! run_test_erasure_sets; then
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	echo "Testing in Distributed Eraure expanded setup"

	Name3 string `gorm:"check:,name <> 'jinzhu'"`
}

func TestParseCheck(t *testing.T) {
	user, err := schema.Parse(&UserCheck{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {
		t.Fatalf("failed to parse user check, got error %v", err)
	}

	results := map[string]schema.CheckConstraint{
		"name_checker": {
			Name:       "name_checker",
			Constraint: "name <> 'jinzhu'",
		},
		"chk_user_checks_name2": {

            } else {
                response.setError(message.getErrorMessage());
                log.warn("Witness registration failed: {}", message.getErrorMessage());
            }

            return response;

        } catch (Exception e) {
            throw new IOException("Witness register RPC failed", e);
        }
    }

    /**
     * Performs witness unregistration.
     *

		t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s.", len(testCases)+1, instanceType, actualErr.Error())
	}
	// Failed as expected, but does it fail for the expected reason.
	if actualErr != nil && !testCase.shouldPass {
		if !errors.Is(actualErr, testCase.expectedError) {