"testProject" : "largeAndroidBuild",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    }, {
      "testProject" : "nowInAndroidBuild",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    }, {
      "testProject" : "santaTrackerAndroidBuild",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {

### Creating commits and writing commit messages

The commit messages that accompany your code changes are an important piece of documentation. Please follow these guidelines when creating commits:

* [Write good commit messages.](https://cbea.ms/git-commit/#seven-rules)

	user := User{Name: "transaction"}
	if err := tx.Save(&user).Error; err != nil {
		t.Fatalf("No error should raise")
	}

	if err := tx.Commit().Error; err != nil {
		t.Fatalf("Commit should not raise error")
	}

	if err := tx.Rollback().Error; err == nil {
		t.Fatalf("Rollback after commit should raise error")
	}
}

func TestTransactionWithSavePoint(t *testing.T) {
	tx := DB.Begin()

private val performanceRegressionTestCoverages = listOf(
    PerformanceTestCoverage(1, PerformanceTestType.per_commit, Os.LINUX, numberOfBuckets = 40, oldUuid = "PerformanceTestTestLinux"),
    PerformanceTestCoverage(6, PerformanceTestType.per_commit, Os.WINDOWS, numberOfBuckets = 10, failsStage = false),
    PerformanceTestCoverage(7, PerformanceTestType.per_commit, Os.MACOS, numberOfBuckets = 5, failsStage = false)
)

enum class FlakyTestStrategy {
    INCLUDE, EXCLUDE, ONLY
}


object BuildParams {
    const val BUILD_BRANCH = "BUILD_BRANCH"
    const val BUILD_COMMIT_ID = "BUILD_COMMIT_ID"
    const val BUILD_COMMIT_DISTRIBUTION = "buildCommitDistribution"
    const val BUILD_CONFIGURATION_ID = "BUILD_TYPE_ID"
    const val BUILD_FINAL_RELEASE = "finalRelease"
    const val BUILD_ID = "BUILD_ID"

	}

	if err != nil {
		tx.AddError(err)
	}

	return tx
}

// Commit commits the changes in a transaction
func (db *DB) Commit() *DB {
	if committer, ok := db.Statement.ConnPool.(TxCommitter); ok && committer != nil && !reflect.ValueOf(committer).IsNil() {
		db.AddError(committer.Commit())
	} else {
		db.AddError(ErrInvalidTransaction)
	}
	return db
}

                    }
                } else {
                    itemList.add(item);
                }
            }
            if (updater != null) {
                final StemmerOverrideItem item = updater.commit();
                if (item != null) {
                    itemList.add(item);
                }
            }
            stemmerOverrideItemList = itemList;
        } catch (final IOException e) {

                    }
                } else {
                    itemList.add(item);
                }
            }
            if (updater != null) {
                final CharMappingItem item = updater.commit();
                if (item != null) {
                    itemList.add(item);
                }
            }
            mappingItemList = itemList;
        } catch (final IOException e) {

    val fileOperator = FileOperator(file!!.channel)
    fileOperator.write(FILE_HEADER_SIZE + upstreamSize, metadataBuffer, metadata.size.toLong())
  }

  @Throws(IOException::class)
  fun commit(upstreamSize: Long) {
    // Write metadata to the end of the file.
    writeMetadata(upstreamSize)
    file!!.channel.force(false)

    // Once everything else is in place we can swap the dirty header for a clean one.

                    deleteDocuments();
                }
            }
        }
        return true;
    }

    @Override
    public void commit() {
        try {
            if (logger.isDebugEnabled()) {
                logger.debug("Shutting down thread executor.");
            }
            executor.shutdown();