// is registered and fails otherwise.
func TestPostgreSQLRegistration(t *testing.T) {
	var found bool
	if slices.Contains(sql.Drivers(), "postgres") {
		found = true
	}
	if !found {
		t.Fatal("postgres driver not registered")
	}
}

func TestPsqlTableNameValidation(t *testing.T) {
	validTables := []string{"táblë", "table", "TableName", "\"Table name\"", "\"✅✅\"", "table$one", "\"táblë\""}

// is registered and fails otherwise.
func TestMySQLRegistration(t *testing.T) {
	var found bool
	if slices.Contains(sql.Drivers(), "mysql") {
		found = true
	}
	if !found {
		t.Fatal("mysql driver not registered")
	}

func testServicesCmdHandler(cmd cmdType, t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	adminTestBed, err := prepareAdminErasureTestBed(ctx)
	if err != nil {
		t.Fatal("Failed to initialize a single node Erasure backend for admin handler tests.", err)
	}
	defer adminTestBed.TearDown()

	// Initialize admin peers to make admin RPC calls. Note: In a

        DefaultProblem problem = new DefaultProblem(null, null, null, -1, -1, null);
        assertEquals(Severity.ERROR, problem.getSeverity());

        problem = new DefaultProblem(null, Severity.FATAL, null, -1, -1, null);
        assertEquals(Severity.FATAL, problem.getSeverity());

        problem = new DefaultProblem(null, Severity.ERROR, null, -1, -1, null);
        assertEquals(Severity.ERROR, problem.getSeverity());

        }
    }

    public boolean hasFatalErrors() {
        return severities.contains(ModelProblem.Severity.FATAL);
    }

    public boolean hasErrors() {
        return severities.contains(ModelProblem.Severity.ERROR) || severities.contains(ModelProblem.Severity.FATAL);
    }

    @Override
    public List<ModelProblem> getProblems() {
        return problems;
    }

                    SettingsProblem.Severity.FATAL,
                    "Non-parseable settings " + settingsSource.getLocation() + ": " + e.getMessage(),
                    e.getLineNumber(),
                    e.getColumnNumber(),
                    e);
            return new Settings();
        } catch (IOException e) {
            problems.add(
                    SettingsProblem.Severity.FATAL,

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

		if !testCase.expectErr {
			data, err := storage.ReadAll(t.Context(), testCase.volumeName, testCase.objectName)
			if err != nil {
				t.Fatal(err)
			}

			if !bytes.Equal(data, testCase.data) {
				t.Fatalf("case %v: expected %v, got %v", i+1, testCase.data, data)
			}

	log.Printf("%s\n", out.String())

	w.WriteHeader(http.StatusOK)
}

func main() {
	flag.Parse()
	http.HandleFunc("/", mainHandler)

	log.Printf("Listening on :%d\n", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))

	erasure, err := NewErasure(t.Context(), dataBlocks, parityBlocks, blockSize)
	if err != nil {
		t.Fatalf("failed to create ErasureStorage: %v", err)
	}
	// Prepare a slice of 5MiB with random data.
	data := make([]byte, 5*humanize.MiByte)
	length := int64(len(data))
	_, err = rand.Read(data)
	if err != nil {
		t.Fatal(err)
	}

	writers := make([]io.Writer, len(disks))
	for i, disk := range disks {

	// after model changed
	if DB.Statement.DryRun || DB.DryRun {
		t.Fatal("Failed expect DB.DryRun and DB.Statement.ToSQL to be false")
	}

	if DB.Statement.SQL.String() != "" {
		t.Fatal("Failed expect DB.Statement.SQL to be empty")
	}

	// first
	sql = DB.ToSQL(func(tx *gorm.DB) *gorm.DB {