diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml
new file mode 100644
index 00000000..80a86bf2
--- /dev/null
+++ b/.github/workflows/push.yml
@@ -0,0 +1,76 @@
+on:
+    push:
+
+name: push
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 1
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v2
+        with:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.29
+          args: --timeout=5m
+          working-directory: ./tests
+  test:
+    name: Test with Coverage
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Go
+        uses: actions/setup-go@v1
+        with:
+          go-version: '1.16.3'
+
+      - name: Get Build Tools
+        run: |
+          GO111MODULE=on go get github.com/ory/go-acc
+
+      - name: Add $GOPATH/bin to $PATH
+        run: |
+          echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"
+
+      - name: git checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 1
+
+      - name: Install dependencies
+        working-directory: ./tests
+        run: |
+          go mod download
+
+      - name: Run Unit tests
+        working-directory: ./tests
+        run: |
+          go-acc .
+
+  build:
+    name: Lint and build
+    runs-on: ubuntu-latest
+    steps:
+      - name: install go
+        uses: actions/setup-go@v2
+        with:
+          go-version: '1.16.3'
+
+      - name: git checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 1
+
+      - name: install lint
+        working-directory: ./tests
+        run: GO111MODULE=off go get golang.org/x/lint/golint
+
+      - name: run golint and go fmt
+        working-directory: ./tests
+        run: ./lint.sh
+
+      - name: go build
+        working-directory: ./tests
+        run: go build
diff --git a/tests/.gitignore b/tests/.gitignore
new file mode 100644
index 00000000..2b29f276
--- /dev/null
+++ b/tests/.gitignore
@@ -0,0 +1 @@
+tests
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 00000000..e552f1c7
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,13 @@
+# Tests
+These are the files used to test the sqlite database for inaccuracies
+
+They make assumptions, such as, all translations of the bible will have the same amount of chapters and verses in those chapters
+
+This assumption is not true, as chapters / verses are not in the original text, and each translation is free to decide how to split it up.
+
+For the purpose of these tests however, we assume they should all match t_kjv King James Version.
+
+If we use Crosswire https://crosswire.org/sword/modules/ModDisp.jsp?modType=Bibles as the source of the texts, we can meet these assumptions.
+
+## Usage
+These tests can be run via the include .github/workflows/ actions, or you can run ```go test``` on the command line
diff --git a/tests/generateTests.go b/tests/generateTests.go
new file mode 100644
index 00000000..a08339d5
--- /dev/null
+++ b/tests/generateTests.go
@@ -0,0 +1,129 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/divan/num2words"
+	"github.com/iancoleman/strcase"
+	_ "github.com/mattn/go-sqlite3"
+	"os"
+	"strings"
+)
+
+func rowQuery(query string, db *sql.DB) *sql.Row {
+	row := db.QueryRow(query)
+	return row
+}
+
+func rowsQuery(query string, db *sql.DB) (*sql.Rows, error) {
+	rows, err := db.Query(query)
+	return rows, err
+}
+
+func check(e error) {
+	if e != nil {
+		fmt.Println(e)
+	}
+}
+
+func mapIDToBook(db *sql.DB) map[int]string {
+	bookMap := make(map[int]string)
+	query := `SELECT b,n FROM key_english;`
+	rows, err := db.Query(query)
+	dbCheck(err)
+	keyEnglish := KeyEnglish{}
+	for rows.Next() {
+		err = rows.Scan(&keyEnglish.ID, &keyEnglish.Book)
+		check(err)
+		bookMap[keyEnglish.ID] = keyEnglish.Book
+	}
+	return bookMap
+}
+
+func dbCheck(e error) {
+	if e != nil {
+		if strings.Contains(e.Error(), "no such table:") {
+			fmt.Println(e)
+			fmt.Println("This usually means your database doesnt exist, or is corrupt")
+			os.Exit(1)
+		}
+	}
+}
+
+func returnSingleInt(query string) (int, error) {
+	var result int
+	db, err := sql.Open("sqlite3", "../bible-sqlite.db?cache=shared&mode=memory")
+	if err != nil {
+		return result, err
+	}
+	row := rowQuery(query, db)
+	err = row.Scan(&result)
+	if err != nil {
+		return result, err
+	}
+	db.Close()
+	return result, err
+}
+
+func longNames(book string) string {
+	book = strings.ReplaceAll(book, "1 ", "First")
+	book = strings.ReplaceAll(book, "2 ", "Second")
+	book = strings.ReplaceAll(book, "3 ", "Third")
+	book = strings.ReplaceAll(book, " of ", "Of")
+	return book
+}
+
+func generateTests(db *sql.DB) {
+	i := 1
+	booksInBible := 66
+	bookMap := mapIDToBook(db)
+	for i <= booksInBible {
+		bookName := longNames(bookMap[i])
+		query := fmt.Sprintf(`select count(distinct c) from t_kjv where b = %d;`, i)
+		chapters, err := returnSingleInt(query)
+		check(err)
+		test := fmt.Sprintf(`
+func Test%sChapterCount(t *testing.T) {
+        expectedCount := %d
+        query :=  `+`"`+"select `table` "+`from bible_version_key;"`+`
+        result := returnArray(t, query)
+        bookID := %d
+        for _, bibleVersion := range result {
+            query := fmt.Sprintf("select count(distinct c) from %%s where b = %%d;", bibleVersion, bookID)
+            actualCount, err := returnSingleInt(query)
+            assert.Nil(t, err)
+            msg := fmt.Sprintf("Should only be %%d chapters in %%s book in %%s translation", expectedCount, bookMap[bookID], bibleVersion)
+            assert.Equal(t, expectedCount, actualCount, msg)
+        }
+}`, bookName, chapters, i)
+		fmt.Println(test)
+		// Test amount of verses
+		currentChapter := 1
+		for currentChapter <= chapters {
+			prettyChapterName := num2words.Convert(currentChapter)
+			prettyChapterName = strings.ReplaceAll(prettyChapterName, " ", "")
+			prettyChapterName = strcase.ToCamel(prettyChapterName)
+			query := fmt.Sprintf(`select count(distinct v) from t_kjv where b = %d and c = %d;`, i, currentChapter)
+			expectedVerseCount, err := returnSingleInt(query)
+			check(err)
+			verseTest := fmt.Sprintf(`
+func Test%sChapter%sTotalVerseCount(t *testing.T) {
+        expectedCount := %d
+        query :=  `+`"`+"select `table` "+`from bible_version_key;"`+`
+        result := returnArray(t, query)
+        bookID := %d
+        chapterID := %d
+        for _, bibleVersion := range result {
+            query := fmt.Sprintf("select count(distinct v) from %%s where b = %%d and c = %%d;", bibleVersion, bookID, chapterID)
+            actualCount, err := returnSingleInt(query)
+            assert.Nil(t, err)
+            msg := fmt.Sprintf("Should only be %%d verses in chapter %%d of %%s book in %%s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+            assert.Equal(t, expectedCount, actualCount, msg)
+        }
+}`, bookName, prettyChapterName, expectedVerseCount, i, currentChapter)
+			fmt.Println(verseTest)
+			currentChapter++
+		}
+		i++
+	}
+}
diff --git a/tests/go.mod b/tests/go.mod
new file mode 100644
index 00000000..81288538
--- /dev/null
+++ b/tests/go.mod
@@ -0,0 +1,10 @@
+module github.com/jmainguy/bible_databases/tests
+
+go 1.16
+
+require (
+	github.com/divan/num2words v0.0.0-20170904212200-57dba452f942 // indirect
+	github.com/iancoleman/strcase v0.1.3 // indirect
+	github.com/mattn/go-sqlite3 v1.14.7 // indirect
+	github.com/stretchr/testify v1.7.0 // indirect
+)
diff --git a/tests/go.sum b/tests/go.sum
new file mode 100644
index 00000000..58809b68
--- /dev/null
+++ b/tests/go.sum
@@ -0,0 +1,16 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/divan/num2words v0.0.0-20170904212200-57dba452f942 h1:fJ8/Lid8fF4i7Bwl7vWKvG2KeZzr3yU4qG6h/DPdXLU=
+github.com/divan/num2words v0.0.0-20170904212200-57dba452f942/go.mod h1:K88GQWK1aAiPMo9q2LZwyKBfEGnge7kmVVTUcZ61HSc=
+github.com/iancoleman/strcase v0.1.3 h1:dJBk1m2/qjL1twPLf68JND55vvivMupZ4wIzE8CTdBw=
+github.com/iancoleman/strcase v0.1.3/go.mod h1:SK73tn/9oHe+/Y0h39VT4UCxmurVJkR5NA7kMEAOgSE=
+github.com/mattn/go-sqlite3 v1.14.7 h1:fxWBnXkxfM6sRiuH3bqJ4CfzZojMOLVc0UTsTglEghA=
+github.com/mattn/go-sqlite3 v1.14.7/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/tests/lint.sh b/tests/lint.sh
new file mode 100755
index 00000000..fb464ffb
--- /dev/null
+++ b/tests/lint.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+FormatCheck=$(gofmt -l *.go | wc -l)
+if [ $FormatCheck -gt 0 ]; then
+    gofmt -l *.go
+    echo "gofmt -w *.go your code please."
+    exit 1
+fi
+## Run golint
+golint -set_exit_status
+if [ $? -gt 0 ]; then
+    exit 1
+fi
diff --git a/tests/main.go b/tests/main.go
new file mode 100644
index 00000000..6608f9b9
--- /dev/null
+++ b/tests/main.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	_ "github.com/mattn/go-sqlite3"
+	"os"
+)
+
+func main() {
+	// Open sqlite3 database containing the bibles
+	db, err := sql.Open("sqlite3", "../bible-sqlite.db")
+	if err != nil {
+		fmt.Println("Had trouble opening database")
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	generateTests(db)
+}
diff --git a/tests/sqlite_test.go b/tests/sqlite_test.go
new file mode 100644
index 00000000..e9d4b9dc
--- /dev/null
+++ b/tests/sqlite_test.go
@@ -0,0 +1,18831 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	_ "github.com/mattn/go-sqlite3"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+var bookMap map[int]string
+
+func init() {
+	db, err := sql.Open("sqlite3", "../bible-sqlite.db?cache=shared&mode=memory")
+	check(err)
+	bookMap = mapIDToBook(db)
+}
+
+func prepareSqliteDB(t *testing.T) (db *sql.DB) {
+	db, err := sql.Open("sqlite3", "../bible-sqlite.db?cache=shared&mode=memory")
+	assert.Nil(t, err)
+	return db
+}
+
+type BibleVersionKey struct {
+	Table string
+}
+
+func returnArray(t *testing.T, query string) []string {
+	var result []string
+	db := prepareSqliteDB(t)
+	rows, err := rowsQuery(query, db)
+	assert.Nil(t, err)
+	bibleVersionKey := BibleVersionKey{}
+	for rows.Next() {
+		err = rows.Scan(&bibleVersionKey.Table)
+		assert.Nil(t, err)
+		result = append(result, bibleVersionKey.Table)
+	}
+	db.Close()
+	return result
+}
+
+func TestVerseCount(t *testing.T) {
+	expectedCount := 31102
+	query := `select "table" from bible_version_key`
+	result := returnArray(t, query)
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(*) from %s;", bibleVersion)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in %s translation", expectedCount, bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestBookCount(t *testing.T) {
+	expectedCount := 66
+	query := `select "table" from bible_version_key`
+	result := returnArray(t, query)
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select max(b) from %s;", bibleVersion)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d books in %s translation", expectedCount, bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+// Everything after this line was auto generated using the main program and appended to this file
+// go build
+// ./tests >> sqlite_test.go
+
+func TestGenesisChapterCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 67
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 55
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 57
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 43
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 44
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 45
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortySixTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 46
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 47
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 48
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFortyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 49
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGenesisChapterFiftyTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 1
+	chapterID := 50
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestExodusChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 2
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 59
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 57
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 55
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLeviticusChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 3
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 54
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 89
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 45
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 65
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 54
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 56
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNumbersChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 4
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 68
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDeuteronomyChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 5
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 63
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 45
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoshuaChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 6
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 57
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 48
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudgesChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 7
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRuthChapterCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRuthChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 8
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRuthChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 8
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRuthChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 8
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRuthChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 8
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 58
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstSamuelChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 9
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondSamuelChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 10
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 53
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 66
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstKingsChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 53
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 11
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondKingsChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 12
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 54
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 55
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 81
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstChroniclesChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 13
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondChroniclesChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 14
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 70
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzraChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 15
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 73
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNehemiahChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 16
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEstherChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 17
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJobChapterFortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 18
+	chapterID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterCount(t *testing.T) {
+	expectedCount := 150
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 43
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 44
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 45
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortySixTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 46
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 47
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 48
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFortyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 49
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 50
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 51
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 52
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 53
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 54
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 55
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftySixTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 56
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 57
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 58
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterFiftyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 59
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 60
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 61
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 62
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 63
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 64
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 65
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 66
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 67
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 68
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSixtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 69
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 70
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 71
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 72
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 73
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 74
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 75
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventySixTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 76
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 77
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 72
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 78
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterSeventyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 79
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 80
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 81
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 82
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 83
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 84
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 85
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightySixTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 86
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 87
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 88
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterEightyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 89
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 90
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 91
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 92
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 93
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 94
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 95
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetySixTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 96
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 97
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 98
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterNinetyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 99
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 100
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredoneTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 101
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwoTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 102
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthreeTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 103
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfourTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 104
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfiveTotalVerseCount(t *testing.T) {
+	expectedCount := 45
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 105
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredsixTotalVerseCount(t *testing.T) {
+	expectedCount := 48
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 106
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredsevenTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 107
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredeightTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 108
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundrednineTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 109
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 110
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredelevenTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 111
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 112
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 113
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 114
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 115
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredsixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 116
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredseventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 2
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 117
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredeighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 118
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundrednineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 176
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 119
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 120
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 121
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 122
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 123
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 124
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 125
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 126
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 127
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 128
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredtwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 129
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 130
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 131
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 132
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 133
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 134
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 135
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 136
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 137
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 138
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredthirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 139
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 140
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 141
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 142
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 143
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 144
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 145
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortySixTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 146
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 147
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 148
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfortyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 149
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPsalmsChapterOnehundredfiftyTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 19
+	chapterID := 150
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestProverbsChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 20
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEcclesiastesChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 21
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSongOfSolomonChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 22
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterCount(t *testing.T) {
+	expectedCount := 66
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 43
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 44
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 45
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortySixTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 46
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 47
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 48
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFortyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 49
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 50
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 51
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 52
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 53
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 54
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 55
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftySixTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 56
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 57
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 58
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterFiftyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 59
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtyTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 60
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 61
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 62
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 63
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 64
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 65
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestIsaiahChapterSixtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 23
+	chapterID := 66
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 43
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 44
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 45
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortySixTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 46
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 47
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 48
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFortyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 49
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFiftyTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 50
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFiftyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 64
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 51
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJeremiahChapterFiftyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 24
+	chapterID := 52
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLamentationsChapterCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLamentationsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 25
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLamentationsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 25
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLamentationsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 66
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 25
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLamentationsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 25
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLamentationsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 25
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterCount(t *testing.T) {
+	expectedCount := 48
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 63
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterTwentyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtySixTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterThirtyNineTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 43
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 44
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 45
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortySixTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 46
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 47
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEzekielChapterFortyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 26
+	chapterID := 48
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 45
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestDanielChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 27
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHoseaChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 28
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoelChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 29
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoelChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 29
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoelChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 29
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJoelChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 29
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestAmosChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 30
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestObadiahChapterCount(t *testing.T) {
+	expectedCount := 1
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 31
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestObadiahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 31
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJonahChapterCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 32
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJonahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 32
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJonahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 32
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJonahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 32
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJonahChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 32
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterCount(t *testing.T) {
+	expectedCount := 7
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMicahChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 33
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNahumChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 34
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNahumChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 34
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNahumChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 34
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestNahumChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 34
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHabakkukChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 35
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHabakkukChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 35
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHabakkukChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 35
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHabakkukChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 35
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZephaniahChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 36
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZephaniahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 36
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZephaniahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 36
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZephaniahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 36
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHaggaiChapterCount(t *testing.T) {
+	expectedCount := 2
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 37
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHaggaiChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 37
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHaggaiChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 37
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 9
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestZechariahChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 38
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMalachiChapterCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 39
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMalachiChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 39
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMalachiChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 39
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMalachiChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 39
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMalachiChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 39
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 48
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 58
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 46
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 75
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 66
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMatthewChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 40
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 45
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 56
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 72
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestMarkChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 41
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 80
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 49
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 56
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 62
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 54
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 59
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 48
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 71
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 56
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestLukeChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 53
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 42
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 51
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 54
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 71
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 53
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 59
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 57
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 50
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJohnChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 43
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 47
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 37
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 42
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 60
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 43
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 48
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 52
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 41
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 38
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 35
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 23
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyFourTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 24
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 25
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentySixTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 26
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentySevenTotalVerseCount(t *testing.T) {
+	expectedCount := 44
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 27
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestActsChapterTwentyEightTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 44
+	chapterID := 28
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 36
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRomansChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 45
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 34
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 58
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstCorinthiansChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 46
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondCorinthiansChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 47
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 31
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestGalatiansChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 48
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 32
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 33
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestEphesiansChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 49
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilippiansChapterCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 50
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilippiansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 50
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilippiansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 30
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 50
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilippiansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 50
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilippiansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 50
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestColossiansChapterCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 51
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestColossiansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 51
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestColossiansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 23
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 51
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestColossiansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 51
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestColossiansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 51
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstThessaloniansChapterCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 52
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstThessaloniansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 52
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstThessaloniansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 52
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstThessaloniansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 52
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstThessaloniansChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 52
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstThessaloniansChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 52
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondThessaloniansChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 53
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondThessaloniansChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 12
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 53
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondThessaloniansChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 53
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondThessaloniansChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 53
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterCount(t *testing.T) {
+	expectedCount := 6
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstTimothyChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 54
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondTimothyChapterCount(t *testing.T) {
+	expectedCount := 4
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 55
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondTimothyChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 55
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondTimothyChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 55
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondTimothyChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 55
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondTimothyChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 55
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestTitusChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 56
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestTitusChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 56
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestTitusChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 56
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestTitusChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 56
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilemonChapterCount(t *testing.T) {
+	expectedCount := 1
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 57
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestPhilemonChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 57
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 16
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 28
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 39
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 40
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestHebrewsChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 58
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJamesChapterCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 59
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJamesChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 59
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJamesChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 26
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 59
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJamesChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 59
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJamesChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 59
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJamesChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 59
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstPeterChapterCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 60
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstPeterChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 60
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstPeterChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 60
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstPeterChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 60
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstPeterChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 60
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstPeterChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 60
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondPeterChapterCount(t *testing.T) {
+	expectedCount := 3
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 61
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondPeterChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 61
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondPeterChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 61
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondPeterChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 61
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstJohnChapterCount(t *testing.T) {
+	expectedCount := 5
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 62
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstJohnChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 10
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 62
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstJohnChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 62
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstJohnChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 62
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstJohnChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 62
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestFirstJohnChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 62
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondJohnChapterCount(t *testing.T) {
+	expectedCount := 1
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 63
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestSecondJohnChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 63
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestThirdJohnChapterCount(t *testing.T) {
+	expectedCount := 1
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 64
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestThirdJohnChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 64
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudeChapterCount(t *testing.T) {
+	expectedCount := 1
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 65
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestJudeChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 25
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 65
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct c) from %s where b = %d;", bibleVersion, bookID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d chapters in %s book in %s translation", expectedCount, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterOneTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 1
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 29
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 2
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterThreeTotalVerseCount(t *testing.T) {
+	expectedCount := 22
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 3
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterFourTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 4
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterFiveTotalVerseCount(t *testing.T) {
+	expectedCount := 14
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 5
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterSixTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 6
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterSevenTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 7
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterEightTotalVerseCount(t *testing.T) {
+	expectedCount := 13
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 8
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterNineTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 9
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterTenTotalVerseCount(t *testing.T) {
+	expectedCount := 11
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 10
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterElevenTotalVerseCount(t *testing.T) {
+	expectedCount := 19
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 11
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterTwelveTotalVerseCount(t *testing.T) {
+	expectedCount := 17
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 12
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterThirteenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 13
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterFourteenTotalVerseCount(t *testing.T) {
+	expectedCount := 20
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 14
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterFifteenTotalVerseCount(t *testing.T) {
+	expectedCount := 8
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 15
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterSixteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 16
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterSeventeenTotalVerseCount(t *testing.T) {
+	expectedCount := 18
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 17
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterEighteenTotalVerseCount(t *testing.T) {
+	expectedCount := 24
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 18
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterNineteenTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 19
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterTwentyTotalVerseCount(t *testing.T) {
+	expectedCount := 15
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 20
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterTwentyOneTotalVerseCount(t *testing.T) {
+	expectedCount := 27
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 21
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
+
+func TestRevelationChapterTwentyTwoTotalVerseCount(t *testing.T) {
+	expectedCount := 21
+	query := "select `table` from bible_version_key;"
+	result := returnArray(t, query)
+	bookID := 66
+	chapterID := 22
+	for _, bibleVersion := range result {
+		query := fmt.Sprintf("select count(distinct v) from %s where b = %d and c = %d;", bibleVersion, bookID, chapterID)
+		actualCount, err := returnSingleInt(query)
+		assert.Nil(t, err)
+		msg := fmt.Sprintf("Should only be %d verses in chapter %d of %s book in %s translation", expectedCount, chapterID, bookMap[bookID], bibleVersion)
+		assert.Equal(t, expectedCount, actualCount, msg)
+	}
+}
diff --git a/tests/structs.go b/tests/structs.go
new file mode 100644
index 00000000..46f6b0d3
--- /dev/null
+++ b/tests/structs.go
@@ -0,0 +1,7 @@
+package main
+
+// KeyEnglish : Limited structure of scrollmapper key_english table
+type KeyEnglish struct {
+	ID   int
+	Book string
+}