Add tvloader and tests for 2.2

Signed-off-by: Steve Winslow <steve@swinslow.net>

22 files changed, 5355 insertions, 0 deletions

diff --git a/tvloader/parser2v2/parse_annotation.go b/tvloader/parser2v2/parse_annotation.go
new file mode 100644
index 0000000..8cd5b76
--- /dev/null
+++ b/tvloader/parser2v2/parse_annotation.go
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+)
+
+func (parser *tvParser2_2) parsePairForAnnotation2_2(tag string, value string) error {
+	if parser.ann == nil {
+		return fmt.Errorf("no annotation struct created in parser ann pointer")
+	}
+
+	switch tag {
+	case "Annotator":
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		if subkey == "Person" || subkey == "Organization" || subkey == "Tool" {
+			parser.ann.AnnotatorType = subkey
+			parser.ann.Annotator = subvalue
+			return nil
+		}
+		return fmt.Errorf("unrecognized Annotator type %v", subkey)
+	case "AnnotationDate":
+		parser.ann.AnnotationDate = value
+	case "AnnotationType":
+		parser.ann.AnnotationType = value
+	case "SPDXREF":
+		deID, err := extractDocElementID(value)
+		if err != nil {
+			return err
+		}
+		parser.ann.AnnotationSPDXIdentifier = deID
+	case "AnnotationComment":
+		parser.ann.AnnotationComment = value
+	default:
+		return fmt.Errorf("received unknown tag %v in Annotation section", tag)
+	}
+
+	return nil
+}
diff --git a/tvloader/parser2v2/parse_annotation_test.go b/tvloader/parser2v2/parse_annotation_test.go
new file mode 100644
index 0000000..7a12adf
--- /dev/null
+++ b/tvloader/parser2v2/parse_annotation_test.go
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Annotation section tests =====
+func TestParser2_2FailsIfAnnotationNotSet(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePairForAnnotation2_2("Annotator", "Person: John Doe (jdoe@example.com)")
+	if err == nil {
+		t.Errorf("expected error when calling parsePairFromAnnotation2_2 without setting ann pointer")
+	}
+}
+
+func TestParser2_2FailsIfAnnotationTagUnknown(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	// start with valid annotator
+	err := parser.parsePair2_2("Annotator", "Person: John Doe (jdoe@example.com)")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// parse invalid tag, using parsePairForAnnotation2_2(
+	err = parser.parsePairForAnnotation2_2("blah", "oops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfAnnotationFieldsWithoutAnnotation(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("AnnotationDate", "2018-09-15T17:25:00Z")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2 for AnnotationDate without Annotator first")
+	}
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2 for AnnotationType without Annotator first")
+	}
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2 for SPDXREF without Annotator first")
+	}
+	err = parser.parsePair2_2("AnnotationComment", "comment whatever")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2 for AnnotationComment without Annotator first")
+	}
+}
+
+func TestParser2_2CanParseAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// Annotator without email address
+	err := parser.parsePair2_2("Annotator", "Person: John Doe")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.ann.Annotator != "John Doe" {
+		t.Errorf("got %v for Annotator, expected John Doe", parser.ann.Annotator)
+	}
+	if parser.ann.AnnotatorType != "Person" {
+		t.Errorf("got %v for AnnotatorType, expected Person", parser.ann.AnnotatorType)
+	}
+
+	// Annotation Date
+	dt := "2018-09-15T17:32:00Z"
+	err = parser.parsePair2_2("AnnotationDate", dt)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.ann.AnnotationDate != dt {
+		t.Errorf("got %v for AnnotationDate, expected %v", parser.ann.AnnotationDate, dt)
+	}
+
+	// Annotation type
+	aType := "REVIEW"
+	err = parser.parsePair2_2("AnnotationType", aType)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.ann.AnnotationType != aType {
+		t.Errorf("got %v for AnnotationType, expected %v", parser.ann.AnnotationType, aType)
+	}
+
+	// SPDX Identifier Reference
+	ref := "SPDXRef-30"
+	err = parser.parsePair2_2("SPDXREF", ref)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	deID := parser.ann.AnnotationSPDXIdentifier
+	if deID.DocumentRefID != "" || deID.ElementRefID != "30" {
+		t.Errorf("got %v for SPDXREF, expected %v", parser.ann.AnnotationSPDXIdentifier, "30")
+	}
+
+	// Annotation Comment
+	cmt := "this is a comment"
+	err = parser.parsePair2_2("AnnotationComment", cmt)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.ann.AnnotationComment != cmt {
+		t.Errorf("got %v for AnnotationComment, expected %v", parser.ann.AnnotationComment, cmt)
+	}
+}
+
+func TestParser2_2FailsIfAnnotatorInvalid(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("Annotator", "John Doe (jdoe@example.com)")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfAnnotatorTypeInvalid(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("Annotator", "Human: John Doe (jdoe@example.com)")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfAnnotationRefInvalid(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	// start with valid annotator
+	err := parser.parsePair2_2("Annotator", "Person: John Doe (jdoe@example.com)")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePair2_2("SPDXREF", "blah:other")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
diff --git a/tvloader/parser2v2/parse_creation_info.go b/tvloader/parser2v2/parse_creation_info.go
new file mode 100644
index 0000000..9c84404
--- /dev/null
+++ b/tvloader/parser2v2/parse_creation_info.go
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+func (parser *tvParser2_2) parsePairFromCreationInfo2_2(tag string, value string) error {
+	// fail if not in Creation Info parser state
+	if parser.st != psCreationInfo2_2 {
+		return fmt.Errorf("Got invalid state %v in parsePairFromCreationInfo2_2", parser.st)
+	}
+
+	// create an SPDX Creation Info data struct if we don't have one already
+	if parser.doc.CreationInfo == nil {
+		parser.doc.CreationInfo = &spdx.CreationInfo2_2{}
+	}
+
+	ci := parser.doc.CreationInfo
+	switch tag {
+	case "SPDXVersion":
+		ci.SPDXVersion = value
+	case "DataLicense":
+		ci.DataLicense = value
+	case "SPDXID":
+		ci.SPDXIdentifier = spdx.ElementID(value)
+	case "DocumentName":
+		ci.DocumentName = value
+	case "DocumentNamespace":
+		ci.DocumentNamespace = value
+	case "ExternalDocumentRef":
+		ci.ExternalDocumentReferences = append(ci.ExternalDocumentReferences, value)
+	case "LicenseListVersion":
+		ci.LicenseListVersion = value
+	case "Creator":
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		switch subkey {
+		case "Person":
+			ci.CreatorPersons = append(ci.CreatorPersons, subvalue)
+		case "Organization":
+			ci.CreatorOrganizations = append(ci.CreatorOrganizations, subvalue)
+		case "Tool":
+			ci.CreatorTools = append(ci.CreatorTools, subvalue)
+		default:
+			return fmt.Errorf("unrecognized Creator type %v", subkey)
+		}
+	case "Created":
+		ci.Created = value
+	case "CreatorComment":
+		ci.CreatorComment = value
+	case "DocumentComment":
+		ci.DocumentComment = value
+
+	// tag for going on to package section
+	case "PackageName":
+		parser.st = psPackage2_2
+		parser.pkg = &spdx.Package2_2{
+			FilesAnalyzed:             true,
+			IsFilesAnalyzedTagPresent: false,
+		}
+		return parser.parsePairFromPackage2_2(tag, value)
+	// tag for going on to _unpackaged_ file section
+	case "FileName":
+		// leave pkg as nil, so that packages will be placed in UnpackagedFiles
+		parser.st = psFile2_2
+		parser.pkg = nil
+		return parser.parsePairFromFile2_2(tag, value)
+	// tag for going on to other license section
+	case "LicenseID":
+		parser.st = psOtherLicense2_2
+		return parser.parsePairFromOtherLicense2_2(tag, value)
+	// tag for going on to review section (DEPRECATED)
+	case "Reviewer":
+		parser.st = psReview2_2
+		return parser.parsePairFromReview2_2(tag, value)
+	// for relationship tags, pass along but don't change state
+	case "Relationship":
+		parser.rln = &spdx.Relationship2_2{}
+		parser.doc.Relationships = append(parser.doc.Relationships, parser.rln)
+		return parser.parsePairForRelationship2_2(tag, value)
+	case "RelationshipComment":
+		return parser.parsePairForRelationship2_2(tag, value)
+	// for annotation tags, pass along but don't change state
+	case "Annotator":
+		parser.ann = &spdx.Annotation2_2{}
+		parser.doc.Annotations = append(parser.doc.Annotations, parser.ann)
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationDate":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationType":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "SPDXREF":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationComment":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	default:
+		return fmt.Errorf("received unknown tag %v in CreationInfo section", tag)
+	}
+
+	return nil
+}
diff --git a/tvloader/parser2v2/parse_creation_info_test.go b/tvloader/parser2v2/parse_creation_info_test.go
new file mode 100644
index 0000000..0be6110
--- /dev/null
+++ b/tvloader/parser2v2/parse_creation_info_test.go
@@ -0,0 +1,431 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Parser creation info state change tests =====
+func TestParser2_2CIMovesToPackageAfterParsingPackageNameTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	pkgName := "testPkg"
+	err := parser.parsePair2_2("PackageName", pkgName)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psPackage2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2)
+	}
+	// and a package should be created
+	if parser.pkg == nil {
+		t.Fatalf("parser didn't create new package")
+	}
+	// and the package name should be as expected
+	if parser.pkg.PackageName != pkgName {
+		t.Errorf("expected package name %s, got %s", pkgName, parser.pkg.PackageName)
+	}
+	// and the package should default to true for FilesAnalyzed
+	if parser.pkg.FilesAnalyzed != true {
+		t.Errorf("expected FilesAnalyzed to default to true, got false")
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != false {
+		t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true")
+	}
+	// and the package should NOT be in the SPDX Document's map of packages,
+	// because it doesn't have an SPDX identifier yet
+	if len(parser.doc.Packages) != 0 {
+		t.Errorf("expected 0 packages, got %d", len(parser.doc.Packages))
+	}
+}
+
+func TestParser2_2CIMovesToFileAfterParsingFileNameTagWithNoPackages(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("FileName", "testFile")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psFile2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
+	}
+	// and current package should be nil, meaning Files are placed in the
+	// UnpackagedFiles map instead of in a Package
+	if parser.pkg != nil {
+		t.Fatalf("expected pkg to be nil, got non-nil pkg")
+	}
+}
+
+func TestParser2_2CIMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2)
+	}
+}
+
+func TestParser2_2CIMovesToReviewAfterParsingReviewerTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("Reviewer", "Person: John Doe")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2)
+	}
+}
+
+func TestParser2_2CIStaysAfterParsingRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+
+	err = parser.parsePair2_2("RelationshipComment", "blah")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+}
+
+func TestParser2_2CIStaysAfterParsingAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this spdx file")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+}
+
+func TestParser2_2FailsParsingCreationInfoWithInvalidState(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psPackage2_2,
+	}
+	err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+// ===== Creation Info section tests =====
+func TestParser2_2HasCreationInfoAfterCallToParseFirstTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2")
+	if err != nil {
+		t.Errorf("got error when calling parsePairFromCreationInfo2_2: %v", err)
+	}
+	if parser.doc.CreationInfo == nil {
+		t.Errorf("doc.CreationInfo is still nil after parsing first pair")
+	}
+}
+
+func TestParser2_2CanParseCreationInfoTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// SPDX Version
+	err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.SPDXVersion != "SPDX-2.2" {
+		t.Errorf("got %v for SPDXVersion", parser.doc.CreationInfo.SPDXVersion)
+	}
+
+	// Data License
+	err = parser.parsePairFromCreationInfo2_2("DataLicense", "CC0-1.0")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.DataLicense != "CC0-1.0" {
+		t.Errorf("got %v for DataLicense", parser.doc.CreationInfo.DataLicense)
+	}
+
+	// SPDX Identifier
+	err = parser.parsePairFromCreationInfo2_2("SPDXID", "SPDXRef-DOCUMENT")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.SPDXIdentifier != "SPDXRef-DOCUMENT" {
+		t.Errorf("got %v for SPDXIdentifier", parser.doc.CreationInfo.SPDXIdentifier)
+	}
+
+	// Document Name
+	err = parser.parsePairFromCreationInfo2_2("DocumentName", "xyz-2.1.5")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.DocumentName != "xyz-2.1.5" {
+		t.Errorf("got %v for DocumentName", parser.doc.CreationInfo.DocumentName)
+	}
+
+	// Document Namespace
+	err = parser.parsePairFromCreationInfo2_2("DocumentNamespace", "http://example.com/xyz-2.1.5.spdx")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.DocumentNamespace != "http://example.com/xyz-2.1.5.spdx" {
+		t.Errorf("got %v for DocumentNamespace", parser.doc.CreationInfo.DocumentNamespace)
+	}
+
+	// External Document Reference
+	refs := []string{
+		"DocumentRef-spdx-tool-1.2 http://spdx.org/spdxdocs/spdx-tools-v1.2-3F2504E0-4F89-41D3-9A0C-0305E82C3301 SHA1: d6a770ba38583ed4bb4525bd96e50461655d2759",
+		"DocumentRef-xyz-2.1.2 http://example.com/xyz-2.1.2 SHA1: d6a770ba38583ed4bb4525bd96e50461655d2760",
+	}
+	err = parser.parsePairFromCreationInfo2_2("ExternalDocumentRef", refs[0])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromCreationInfo2_2("ExternalDocumentRef", refs[1])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if len(parser.doc.CreationInfo.ExternalDocumentReferences) != 2 ||
+		parser.doc.CreationInfo.ExternalDocumentReferences[0] != refs[0] ||
+		parser.doc.CreationInfo.ExternalDocumentReferences[1] != refs[1] {
+		t.Errorf("got %v for ExternalDocumentReferences", parser.doc.CreationInfo.ExternalDocumentReferences)
+	}
+
+	// License List Version
+	err = parser.parsePairFromCreationInfo2_2("LicenseListVersion", "2.2")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.LicenseListVersion != "2.2" {
+		t.Errorf("got %v for LicenseListVersion", parser.doc.CreationInfo.LicenseListVersion)
+	}
+
+	// Creators: Persons
+	refPersons := []string{
+		"Person: Person A",
+		"Person: Person B",
+	}
+	err = parser.parsePairFromCreationInfo2_2("Creator", refPersons[0])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromCreationInfo2_2("Creator", refPersons[1])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if len(parser.doc.CreationInfo.CreatorPersons) != 2 ||
+		parser.doc.CreationInfo.CreatorPersons[0] != "Person A" ||
+		parser.doc.CreationInfo.CreatorPersons[1] != "Person B" {
+		t.Errorf("got %v for CreatorPersons", parser.doc.CreationInfo.CreatorPersons)
+	}
+
+	// Creators: Organizations
+	refOrgs := []string{
+		"Organization: Organization A",
+		"Organization: Organization B",
+	}
+	err = parser.parsePairFromCreationInfo2_2("Creator", refOrgs[0])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromCreationInfo2_2("Creator", refOrgs[1])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if len(parser.doc.CreationInfo.CreatorOrganizations) != 2 ||
+		parser.doc.CreationInfo.CreatorOrganizations[0] != "Organization A" ||
+		parser.doc.CreationInfo.CreatorOrganizations[1] != "Organization B" {
+		t.Errorf("got %v for CreatorOrganizations", parser.doc.CreationInfo.CreatorOrganizations)
+	}
+
+	// Creators: Tools
+	refTools := []string{
+		"Tool: Tool A",
+		"Tool: Tool B",
+	}
+	err = parser.parsePairFromCreationInfo2_2("Creator", refTools[0])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromCreationInfo2_2("Creator", refTools[1])
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if len(parser.doc.CreationInfo.CreatorTools) != 2 ||
+		parser.doc.CreationInfo.CreatorTools[0] != "Tool A" ||
+		parser.doc.CreationInfo.CreatorTools[1] != "Tool B" {
+		t.Errorf("got %v for CreatorTools", parser.doc.CreationInfo.CreatorTools)
+	}
+
+	// Created date
+	err = parser.parsePairFromCreationInfo2_2("Created", "2018-09-10T11:46:00Z")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.Created != "2018-09-10T11:46:00Z" {
+		t.Errorf("got %v for Created", parser.doc.CreationInfo.Created)
+	}
+
+	// Creator Comment
+	err = parser.parsePairFromCreationInfo2_2("CreatorComment", "Blah whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.CreatorComment != "Blah whatever" {
+		t.Errorf("got %v for CreatorComment", parser.doc.CreationInfo.CreatorComment)
+	}
+
+	// Document Comment
+	err = parser.parsePairFromCreationInfo2_2("DocumentComment", "Blah whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.doc.CreationInfo.DocumentComment != "Blah whatever" {
+		t.Errorf("got %v for DocumentComment", parser.doc.CreationInfo.DocumentComment)
+	}
+
+}
+
+func TestParser2_2InvalidCreatorTagsFail(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePairFromCreationInfo2_2("Creator", "blah: somebody")
+	if err == nil {
+		t.Errorf("expected error from parsing invalid Creator format, got nil")
+	}
+
+	err = parser.parsePairFromCreationInfo2_2("Creator", "Tool with no colons")
+	if err == nil {
+		t.Errorf("expected error from parsing invalid Creator format, got nil")
+	}
+}
+
+func TestParser2_2CreatorTagWithMultipleColonsPasses(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePairFromCreationInfo2_2("Creator", "Tool: tool1:2:3")
+	if err != nil {
+		t.Errorf("unexpected error from parsing valid Creator format")
+	}
+}
+
+func TestParser2_2CIUnknownTagFails(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePairFromCreationInfo2_2("blah", "something")
+	if err == nil {
+		t.Errorf("expected error from parsing unknown tag")
+	}
+}
+
+func TestParser2_2CICreatesRelationship(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.rln == nil {
+		t.Fatalf("parser didn't create and point to Relationship struct")
+	}
+	if parser.rln != parser.doc.Relationships[0] {
+		t.Errorf("pointer to new Relationship doesn't match idx 0 for doc.Relationships[]")
+	}
+}
+
+func TestParser2_2CICreatesAnnotation(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.ann == nil {
+		t.Fatalf("parser didn't create and point to Annotation struct")
+	}
+	if parser.ann != parser.doc.Annotations[0] {
+		t.Errorf("pointer to new Annotation doesn't match idx 0 for doc.Annotations[]")
+	}
+}
diff --git a/tvloader/parser2v2/parse_file.go b/tvloader/parser2v2/parse_file.go
new file mode 100644
index 0000000..c0e3c92
--- /dev/null
+++ b/tvloader/parser2v2/parse_file.go
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+func (parser *tvParser2_2) parsePairFromFile2_2(tag string, value string) error {
+	// expire fileAOP for anything other than an AOPHomePage or AOPURI
+	// (we'll actually handle the HomePage and URI further below)
+	if tag != "ArtifactOfProjectHomePage" && tag != "ArtifactOfProjectURI" {
+		parser.fileAOP = nil
+	}
+
+	switch tag {
+	// tag for creating new file section
+	case "FileName":
+		parser.file = &spdx.File2_2{}
+		parser.file.FileName = value
+	// tag for creating new package section and going back to parsing Package
+	case "PackageName":
+		parser.st = psPackage2_2
+		parser.file = nil
+		return parser.parsePairFromPackage2_2(tag, value)
+	// tag for going on to snippet section
+	case "SnippetSPDXID":
+		parser.st = psSnippet2_2
+		return parser.parsePairFromSnippet2_2(tag, value)
+	// tag for going on to other license section
+	case "LicenseID":
+		parser.st = psOtherLicense2_2
+		return parser.parsePairFromOtherLicense2_2(tag, value)
+	// tags for file data
+	case "SPDXID":
+		eID, err := extractElementID(value)
+		if err != nil {
+			return err
+		}
+		parser.file.FileSPDXIdentifier = eID
+		if parser.pkg == nil {
+			if parser.doc.UnpackagedFiles == nil {
+				parser.doc.UnpackagedFiles = map[spdx.ElementID]*spdx.File2_2{}
+			}
+			parser.doc.UnpackagedFiles[eID] = parser.file
+		} else {
+			if parser.pkg.Files == nil {
+				parser.pkg.Files = map[spdx.ElementID]*spdx.File2_2{}
+			}
+			parser.pkg.Files[eID] = parser.file
+		}
+	case "FileType":
+		parser.file.FileType = append(parser.file.FileType, value)
+	case "FileChecksum":
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		switch subkey {
+		case "SHA1":
+			parser.file.FileChecksumSHA1 = subvalue
+		case "SHA256":
+			parser.file.FileChecksumSHA256 = subvalue
+		case "MD5":
+			parser.file.FileChecksumMD5 = subvalue
+		default:
+			return fmt.Errorf("got unknown checksum type %s", subkey)
+		}
+	case "LicenseConcluded":
+		parser.file.LicenseConcluded = value
+	case "LicenseInfoInFile":
+		parser.file.LicenseInfoInFile = append(parser.file.LicenseInfoInFile, value)
+	case "LicenseComments":
+		parser.file.LicenseComments = value
+	case "FileCopyrightText":
+		parser.file.FileCopyrightText = value
+	case "ArtifactOfProjectName":
+		parser.fileAOP = &spdx.ArtifactOfProject2_2{}
+		parser.file.ArtifactOfProjects = append(parser.file.ArtifactOfProjects, parser.fileAOP)
+		parser.fileAOP.Name = value
+	case "ArtifactOfProjectHomePage":
+		if parser.fileAOP == nil {
+			return fmt.Errorf("no current ArtifactOfProject found")
+		}
+		parser.fileAOP.HomePage = value
+	case "ArtifactOfProjectURI":
+		if parser.fileAOP == nil {
+			return fmt.Errorf("no current ArtifactOfProject found")
+		}
+		parser.fileAOP.URI = value
+	case "FileComment":
+		parser.file.FileComment = value
+	case "FileNotice":
+		parser.file.FileNotice = value
+	case "FileContributor":
+		parser.file.FileContributor = append(parser.file.FileContributor, value)
+	case "FileDependency":
+		parser.file.FileDependencies = append(parser.file.FileDependencies, value)
+	case "FileAttributionText":
+		parser.file.FileAttributionTexts = append(parser.file.FileAttributionTexts, value)
+	// for relationship tags, pass along but don't change state
+	case "Relationship":
+		parser.rln = &spdx.Relationship2_2{}
+		parser.doc.Relationships = append(parser.doc.Relationships, parser.rln)
+		return parser.parsePairForRelationship2_2(tag, value)
+	case "RelationshipComment":
+		return parser.parsePairForRelationship2_2(tag, value)
+	// for annotation tags, pass along but don't change state
+	case "Annotator":
+		parser.ann = &spdx.Annotation2_2{}
+		parser.doc.Annotations = append(parser.doc.Annotations, parser.ann)
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationDate":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationType":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "SPDXREF":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationComment":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	// tag for going on to review section (DEPRECATED)
+	case "Reviewer":
+		parser.st = psReview2_2
+		return parser.parsePairFromReview2_2(tag, value)
+	default:
+		return fmt.Errorf("received unknown tag %v in File section", tag)
+	}
+
+	return nil
+}
diff --git a/tvloader/parser2v2/parse_file_test.go b/tvloader/parser2v2/parse_file_test.go
new file mode 100644
index 0000000..ffa7662
--- /dev/null
+++ b/tvloader/parser2v2/parse_file_test.go
@@ -0,0 +1,913 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Parser file section state change tests =====
+func TestParser2_2FileStartsNewFileAfterParsingFileNameTag(t *testing.T) {
+	// create the first file
+	fileOldName := "f1.txt"
+
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: fileOldName, FileSPDXIdentifier: "f1"},
+	}
+	fileOld := parser.file
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = fileOld
+	// the Package's Files should have this one only
+	if len(parser.pkg.Files) != 1 {
+		t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files))
+	}
+	if parser.pkg.Files["f1"] != fileOld {
+		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"])
+	}
+	if parser.pkg.Files["f1"].FileName != fileOldName {
+		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName)
+	}
+
+	// now add a new file
+	fileName := "f2.txt"
+	err := parser.parsePair2_2("FileName", fileName)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psFile2_2 {
+		t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st)
+	}
+	// and a file should be created
+	if parser.file == nil {
+		t.Fatalf("parser didn't create new file")
+	}
+	// and the file name should be as expected
+	if parser.file.FileName != fileName {
+		t.Errorf("expected file name %s, got %s", fileName, parser.file.FileName)
+	}
+	// and the Package's Files should still be of size 1 and not have this new
+	// one yet, since it hasn't seen an SPDX identifier
+	if len(parser.pkg.Files) != 1 {
+		t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files))
+	}
+	if parser.pkg.Files["f1"] != fileOld {
+		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"])
+	}
+	if parser.pkg.Files["f1"].FileName != fileOldName {
+		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName)
+	}
+
+	// now parse an SPDX identifier tag
+	err = parser.parsePair2_2("SPDXID", "SPDXRef-f2ID")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// and the Package's Files should now be of size 2 and have this new one
+	if len(parser.pkg.Files) != 2 {
+		t.Fatalf("expected 2 files, got %d", len(parser.pkg.Files))
+	}
+	if parser.pkg.Files["f1"] != fileOld {
+		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"])
+	}
+	if parser.pkg.Files["f1"].FileName != fileOldName {
+		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName)
+	}
+	if parser.pkg.Files["f2ID"] != parser.file {
+		t.Errorf("expected file %v in Files[f2ID], got %v", parser.file, parser.pkg.Files["f2ID"])
+	}
+	if parser.pkg.Files["f2ID"].FileName != fileName {
+		t.Errorf("expected file name %s in Files[f2ID], got %s", fileName, parser.pkg.Files["f2ID"].FileName)
+	}
+}
+
+func TestParser2_2FileAddsToPackageOrUnpackagedFiles(t *testing.T) {
+	// start with no packages
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// add a file and SPDX identifier
+	fileName := "f2.txt"
+	err := parser.parsePair2_2("FileName", fileName)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	err = parser.parsePair2_2("SPDXID", "SPDXRef-f2ID")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	fileOld := parser.file
+	// should have been added to UnpackagedFiles
+	if len(parser.doc.UnpackagedFiles) != 1 {
+		t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles))
+	}
+	if parser.doc.UnpackagedFiles["f2ID"] != fileOld {
+		t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"])
+	}
+	// now create a package and a new file
+	err = parser.parsePair2_2("PackageName", "package1")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	err = parser.parsePair2_2("SPDXID", "SPDXRef-pkg1")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	err = parser.parsePair2_2("FileName", "f3.txt")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	err = parser.parsePair2_2("SPDXID", "SPDXRef-f3ID")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// UnpackagedFiles should still be size 1 and have old file only
+	if len(parser.doc.UnpackagedFiles) != 1 {
+		t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles))
+	}
+	if parser.doc.UnpackagedFiles["f2ID"] != fileOld {
+		t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"])
+	}
+	// and new package should have gotten the new file
+	if len(parser.pkg.Files) != 1 {
+		t.Fatalf("expected 1 file in Files, got %d", len(parser.pkg.Files))
+	}
+	if parser.pkg.Files["f3ID"] != parser.file {
+		t.Errorf("expected file %v in Files[f3ID], got %v", parser.file, parser.pkg.Files["f3ID"])
+	}
+}
+
+func TestParser2_2FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
+	// create the first file and package
+	p1Name := "package1"
+	f1Name := "f1.txt"
+
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: f1Name, FileSPDXIdentifier: "f1"},
+	}
+	p1 := parser.pkg
+	f1 := parser.file
+	parser.doc.Packages["package1"] = p1
+	parser.pkg.Files["f1"] = f1
+
+	// now add a new package
+	p2Name := "package2"
+	err := parser.parsePair2_2("PackageName", p2Name)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should go back to Package
+	if parser.st != psPackage2_2 {
+		t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st)
+	}
+	// and a package should be created
+	if parser.pkg == nil {
+		t.Fatalf("parser didn't create new pkg")
+	}
+	// and the package name should be as expected
+	if parser.pkg.PackageName != p2Name {
+		t.Errorf("expected package name %s, got %s", p2Name, parser.pkg.PackageName)
+	}
+	// and the package should default to true for FilesAnalyzed
+	if parser.pkg.FilesAnalyzed != true {
+		t.Errorf("expected FilesAnalyzed to default to true, got false")
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != false {
+		t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true")
+	}
+	// and the new Package should have no files
+	if len(parser.pkg.Files) != 0 {
+		t.Errorf("Expected no files in pkg.Files, got %d", len(parser.pkg.Files))
+	}
+	// and the Document's Packages should still be of size 1 and not have this
+	// new one, because no SPDX identifier has been seen yet
+	if len(parser.doc.Packages) != 1 {
+		t.Fatalf("expected 1 package, got %d", len(parser.doc.Packages))
+	}
+	if parser.doc.Packages["package1"] != p1 {
+		t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"])
+	}
+	if parser.doc.Packages["package1"].PackageName != p1Name {
+		t.Errorf("expected package name %s in Packages[package1], got %s", p1Name, parser.doc.Packages["package1"].PackageName)
+	}
+	// and the first Package's Files should be of size 1 and have f1 only
+	if len(parser.doc.Packages["package1"].Files) != 1 {
+		t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files))
+	}
+	if parser.doc.Packages["package1"].Files["f1"] != f1 {
+		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"])
+	}
+	if parser.doc.Packages["package1"].Files["f1"].FileName != f1Name {
+		t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.doc.Packages["package1"].Files["f1"].FileName)
+	}
+	// and the current file should be nil
+	if parser.file != nil {
+		t.Errorf("Expected nil for parser.file, got %v", parser.file)
+	}
+}
+
+func TestParser2_2FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	fileCurrent := parser.file
+
+	err := parser.parsePair2_2("SnippetSPDXID", "SPDXRef-Test1")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psSnippet2_2 {
+		t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st)
+	}
+	// and current file should remain what it was
+	if parser.file != fileCurrent {
+		t.Fatalf("expected file to remain %v, got %v", fileCurrent, parser.file)
+	}
+}
+
+func TestParser2_2FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f2"] = parser.file
+
+	err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+}
+
+func TestParser2_2FileMovesToReviewAfterParsingReviewerTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePair2_2("Reviewer", "Person: John Doe")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+}
+
+func TestParser2_2FileStaysAfterParsingRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should remain unchanged
+	if parser.st != psFile2_2 {
+		t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st)
+	}
+
+	err = parser.parsePair2_2("RelationshipComment", "blah")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should still remain unchanged
+	if parser.st != psFile2_2 {
+		t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st)
+	}
+}
+
+func TestParser2_2FileStaysAfterParsingAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psFile2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psFile2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psFile2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
+	}
+
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psFile2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psFile2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
+	}
+}
+
+// ===== File data section tests =====
+func TestParser2_2CanParseFileTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+
+	// File Name
+	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.FileName != "f1.txt" {
+		t.Errorf("got %v for FileName", parser.file.FileName)
+	}
+	// should not yet be added to the Packages file list, because we haven't
+	// seen an SPDX identifier yet
+	if len(parser.pkg.Files) != 0 {
+		t.Errorf("expected 0 files, got %d", len(parser.pkg.Files))
+	}
+
+	// File SPDX Identifier
+	err = parser.parsePairFromFile2_2("SPDXID", "SPDXRef-f1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.FileSPDXIdentifier != "f1" {
+		t.Errorf("got %v for FileSPDXIdentifier", parser.file.FileSPDXIdentifier)
+	}
+	// should now be added to the Packages file list
+	if len(parser.pkg.Files) != 1 {
+		t.Errorf("expected 1 file, got %d", len(parser.pkg.Files))
+	}
+	if parser.pkg.Files["f1"] != parser.file {
+		t.Errorf("expected Files[f1] to be %v, got %v", parser.file, parser.pkg.Files["f1"])
+	}
+
+	// File Type
+	fileTypes := []string{
+		"TEXT",
+		"DOCUMENTATION",
+	}
+	for _, ty := range fileTypes {
+		err = parser.parsePairFromFile2_2("FileType", ty)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, typeWant := range fileTypes {
+		flagFound := false
+		for _, typeCheck := range parser.file.FileType {
+			if typeWant == typeCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in FileType", typeWant)
+		}
+	}
+	if len(fileTypes) != len(parser.file.FileType) {
+		t.Errorf("expected %d types in FileType, got %d", len(fileTypes),
+			len(parser.file.FileType))
+	}
+
+	// File Checksums
+	codeSha1 := "85ed0817af83a24ad8da68c2b5094de69833983c"
+	sumSha1 := "SHA1: 85ed0817af83a24ad8da68c2b5094de69833983c"
+	codeSha256 := "11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd"
+	sumSha256 := "SHA256: 11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd"
+	codeMd5 := "624c1abb3664f4b35547e7c73864ad24"
+	sumMd5 := "MD5: 624c1abb3664f4b35547e7c73864ad24"
+	err = parser.parsePairFromFile2_2("FileChecksum", sumSha1)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromFile2_2("FileChecksum", sumSha256)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromFile2_2("FileChecksum", sumMd5)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.FileChecksumSHA1 != codeSha1 {
+		t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha1, parser.file.FileChecksumSHA1)
+	}
+	if parser.file.FileChecksumSHA256 != codeSha256 {
+		t.Errorf("expected %s for FileChecksumSHA256, got %s", codeSha256, parser.file.FileChecksumSHA256)
+	}
+	if parser.file.FileChecksumMD5 != codeMd5 {
+		t.Errorf("expected %s for FileChecksumMD5, got %s", codeMd5, parser.file.FileChecksumMD5)
+	}
+
+	// Concluded License
+	err = parser.parsePairFromFile2_2("LicenseConcluded", "Apache-2.0 OR GPL-2.0-or-later")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.LicenseConcluded != "Apache-2.0 OR GPL-2.0-or-later" {
+		t.Errorf("got %v for LicenseConcluded", parser.file.LicenseConcluded)
+	}
+
+	// License Information in File
+	lics := []string{
+		"Apache-2.0",
+		"GPL-2.0-or-later",
+		"CC0-1.0",
+	}
+	for _, lic := range lics {
+		err = parser.parsePairFromFile2_2("LicenseInfoInFile", lic)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, licWant := range lics {
+		flagFound := false
+		for _, licCheck := range parser.file.LicenseInfoInFile {
+			if licWant == licCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in LicenseInfoInFile", licWant)
+		}
+	}
+	if len(lics) != len(parser.file.LicenseInfoInFile) {
+		t.Errorf("expected %d licenses in LicenseInfoInFile, got %d", len(lics),
+			len(parser.file.LicenseInfoInFile))
+	}
+
+	// Comments on License
+	err = parser.parsePairFromFile2_2("LicenseComments", "this is a comment")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.LicenseComments != "this is a comment" {
+		t.Errorf("got %v for LicenseComments", parser.file.LicenseComments)
+	}
+
+	// Copyright Text
+	err = parser.parsePairFromFile2_2("FileCopyrightText", "copyright (c) me")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.FileCopyrightText != "copyright (c) me" {
+		t.Errorf("got %v for FileCopyrightText", parser.file.FileCopyrightText)
+	}
+
+	// Artifact of Projects: Name, HomePage and URI
+	// Artifact set 1
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "http://example.com/1/")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "http://example.com/1/uri.whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// Artifact set 2 -- just name
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project2")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// Artifact set 3 -- just name and home page
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project3")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "http://example.com/3/")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// Artifact set 4 -- just name and URI
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project4")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "http://example.com/4/uri.whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+
+	if len(parser.file.ArtifactOfProjects) != 4 {
+		t.Fatalf("expected len %d, got %d", 4, len(parser.file.ArtifactOfProjects))
+	}
+
+	aop := parser.file.ArtifactOfProjects[0]
+	if aop.Name != "project1" {
+		t.Errorf("expected %v, got %v", "project1", aop.Name)
+	}
+	if aop.HomePage != "http://example.com/1/" {
+		t.Errorf("expected %v, got %v", "http://example.com/1/", aop.HomePage)
+	}
+	if aop.URI != "http://example.com/1/uri.whatever" {
+		t.Errorf("expected %v, got %v", "http://example.com/1/uri.whatever", aop.URI)
+	}
+
+	aop = parser.file.ArtifactOfProjects[1]
+	if aop.Name != "project2" {
+		t.Errorf("expected %v, got %v", "project2", aop.Name)
+	}
+	if aop.HomePage != "" {
+		t.Errorf("expected %v, got %v", "", aop.HomePage)
+	}
+	if aop.URI != "" {
+		t.Errorf("expected %v, got %v", "", aop.URI)
+	}
+
+	aop = parser.file.ArtifactOfProjects[2]
+	if aop.Name != "project3" {
+		t.Errorf("expected %v, got %v", "project3", aop.Name)
+	}
+	if aop.HomePage != "http://example.com/3/" {
+		t.Errorf("expected %v, got %v", "http://example.com/3/", aop.HomePage)
+	}
+	if aop.URI != "" {
+		t.Errorf("expected %v, got %v", "", aop.URI)
+	}
+
+	aop = parser.file.ArtifactOfProjects[3]
+	if aop.Name != "project4" {
+		t.Errorf("expected %v, got %v", "project4", aop.Name)
+	}
+	if aop.HomePage != "" {
+		t.Errorf("expected %v, got %v", "", aop.HomePage)
+	}
+	if aop.URI != "http://example.com/4/uri.whatever" {
+		t.Errorf("expected %v, got %v", "http://example.com/4/uri.whatever", aop.URI)
+	}
+
+	// File Comment
+	err = parser.parsePairFromFile2_2("FileComment", "this is a comment")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.FileComment != "this is a comment" {
+		t.Errorf("got %v for FileComment", parser.file.FileComment)
+	}
+
+	// File Notice
+	err = parser.parsePairFromFile2_2("FileNotice", "this is a Notice")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.file.FileNotice != "this is a Notice" {
+		t.Errorf("got %v for FileNotice", parser.file.FileNotice)
+	}
+
+	// File Contributor
+	contribs := []string{
+		"John Doe jdoe@example.com",
+		"EvilCorp",
+	}
+	for _, contrib := range contribs {
+		err = parser.parsePairFromFile2_2("FileContributor", contrib)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, contribWant := range contribs {
+		flagFound := false
+		for _, contribCheck := range parser.file.FileContributor {
+			if contribWant == contribCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in FileContributor", contribWant)
+		}
+	}
+	if len(contribs) != len(parser.file.FileContributor) {
+		t.Errorf("expected %d contribenses in FileContributor, got %d", len(contribs),
+			len(parser.file.FileContributor))
+	}
+
+	// File Dependencies
+	deps := []string{
+		"f-1.txt",
+		"g.txt",
+	}
+	for _, dep := range deps {
+		err = parser.parsePairFromFile2_2("FileDependency", dep)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, depWant := range deps {
+		flagFound := false
+		for _, depCheck := range parser.file.FileDependencies {
+			if depWant == depCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in FileDependency", depWant)
+		}
+	}
+	if len(deps) != len(parser.file.FileDependencies) {
+		t.Errorf("expected %d depenses in FileDependency, got %d", len(deps),
+			len(parser.file.FileDependencies))
+	}
+
+	// File Attribution Texts
+	attrs := []string{
+		"Include this notice in all advertising materials",
+		"This is a \nmulti-line string",
+	}
+	for _, attr := range attrs {
+		err = parser.parsePairFromFile2_2("FileAttributionText", attr)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, attrWant := range attrs {
+		flagFound := false
+		for _, attrCheck := range parser.file.FileAttributionTexts {
+			if attrWant == attrCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in FileAttributionText", attrWant)
+		}
+	}
+	if len(attrs) != len(parser.file.FileAttributionTexts) {
+		t.Errorf("expected %d attribution texts in FileAttributionTexts, got %d", len(attrs),
+			len(parser.file.FileAttributionTexts))
+	}
+
+}
+
+func TestParser2_2FileCreatesRelationshipInDocument(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.rln == nil {
+		t.Fatalf("parser didn't create and point to Relationship struct")
+	}
+	if parser.rln != parser.doc.Relationships[0] {
+		t.Errorf("pointer to new Relationship doesn't match idx 0 for doc.Relationships[]")
+	}
+}
+
+func TestParser2_2FileCreatesAnnotationInDocument(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.ann == nil {
+		t.Fatalf("parser didn't create and point to Annotation struct")
+	}
+	if parser.ann != parser.doc.Annotations[0] {
+		t.Errorf("pointer to new Annotation doesn't match idx 0 for doc.Annotations[]")
+	}
+}
+
+func TestParser2_2FileUnknownTagFails(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePairFromFile2_2("blah", "something")
+	if err == nil {
+		t.Errorf("expected error from parsing unknown tag")
+	}
+}
+
+func TestFileAOPPointerChangesAfterTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psFile2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePairFromFile2_2("ArtifactOfProjectName", "project1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.fileAOP == nil {
+		t.Errorf("expected non-nil AOP pointer, got nil")
+	}
+	curPtr := parser.fileAOP
+
+	// now, a home page; pointer should stay
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "http://example.com/1/")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.fileAOP != curPtr {
+		t.Errorf("expected no change in AOP pointer, was %v, got %v", curPtr, parser.fileAOP)
+	}
+
+	// a URI; pointer should stay
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "http://example.com/1/uri.whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.fileAOP != curPtr {
+		t.Errorf("expected no change in AOP pointer, was %v, got %v", curPtr, parser.fileAOP)
+	}
+
+	// now, another artifact name; pointer should change but be non-nil
+	// now, a home page; pointer should stay
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project2")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.fileAOP == curPtr {
+		t.Errorf("expected change in AOP pointer, got no change")
+	}
+
+	// finally, an unrelated tag; pointer should go away
+	err = parser.parsePairFromFile2_2("FileComment", "whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.fileAOP != nil {
+		t.Errorf("expected nil AOP pointer, got %v", parser.fileAOP)
+	}
+}
+
+func TestParser2_2FailsIfInvalidSPDXIDInFileSection(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+
+	// start with File Name
+	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid SPDX Identifier
+	err = parser.parsePairFromFile2_2("SPDXID", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfInvalidChecksumFormatInFileSection(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+
+	// start with File Name
+	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid format for checksum line, missing colon
+	err = parser.parsePairFromFile2_2("FileChecksum", "SHA1 85ed0817af83a24ad8da68c2b5094de69833983c")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+
+	// start with File Name
+	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// unknown checksum type
+	err = parser.parsePairFromFile2_2("FileChecksum", "Special: 85ed0817af83a24ad8da68c2b5094de69833983c")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+
+	// start with File Name
+	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// artifact home page appears before artifact name
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "https://example.com")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfArtifactURIBeforeArtifactName(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+
+	// start with File Name
+	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// artifact home page appears before artifact name
+	err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "https://example.com")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
diff --git a/tvloader/parser2v2/parse_other_license.go b/tvloader/parser2v2/parse_other_license.go
new file mode 100644
index 0000000..371f834
--- /dev/null
+++ b/tvloader/parser2v2/parse_other_license.go
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+func (parser *tvParser2_2) parsePairFromOtherLicense2_2(tag string, value string) error {
+	switch tag {
+	// tag for creating new other license section
+	case "LicenseID":
+		parser.otherLic = &spdx.OtherLicense2_2{}
+		parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+		parser.otherLic.LicenseIdentifier = value
+	case "ExtractedText":
+		parser.otherLic.ExtractedText = value
+	case "LicenseName":
+		parser.otherLic.LicenseName = value
+	case "LicenseCrossReference":
+		parser.otherLic.LicenseCrossReferences = append(parser.otherLic.LicenseCrossReferences, value)
+	case "LicenseComment":
+		parser.otherLic.LicenseComment = value
+	// for relationship tags, pass along but don't change state
+	case "Relationship":
+		parser.rln = &spdx.Relationship2_2{}
+		parser.doc.Relationships = append(parser.doc.Relationships, parser.rln)
+		return parser.parsePairForRelationship2_2(tag, value)
+	case "RelationshipComment":
+		return parser.parsePairForRelationship2_2(tag, value)
+	// for annotation tags, pass along but don't change state
+	case "Annotator":
+		parser.ann = &spdx.Annotation2_2{}
+		parser.doc.Annotations = append(parser.doc.Annotations, parser.ann)
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationDate":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationType":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "SPDXREF":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationComment":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	// tag for going on to review section (DEPRECATED)
+	case "Reviewer":
+		parser.st = psReview2_2
+		return parser.parsePairFromReview2_2(tag, value)
+	default:
+		return fmt.Errorf("received unknown tag %v in OtherLicense section", tag)
+	}
+
+	return nil
+}
diff --git a/tvloader/parser2v2/parse_other_license_test.go b/tvloader/parser2v2/parse_other_license_test.go
new file mode 100644
index 0000000..ebf4170
--- /dev/null
+++ b/tvloader/parser2v2/parse_other_license_test.go
@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Parser other license section state change tests =====
+func TestParser2_2OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
+	// create the first other license
+	olid1 := "LicenseRef-Lic11"
+	olname1 := "License 11"
+
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: olid1,
+			LicenseName:       olname1,
+		},
+	}
+	olic1 := parser.otherLic
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	// the Document's OtherLicenses should have this one only
+	if parser.doc.OtherLicenses[0] != olic1 {
+		t.Errorf("Expected other license %v in OtherLicenses[0], got %v", olic1, parser.doc.OtherLicenses[0])
+	}
+	if parser.doc.OtherLicenses[0].LicenseName != olname1 {
+		t.Errorf("expected other license name %s in OtherLicenses[0], got %s", olname1, parser.doc.OtherLicenses[0].LicenseName)
+	}
+
+	// now add a new other license
+	olid2 := "LicenseRef-22"
+	olname2 := "License 22"
+	err := parser.parsePair2_2("LicenseID", olid2)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+	// and an other license should be created
+	if parser.otherLic == nil {
+		t.Fatalf("parser didn't create new other license")
+	}
+	// also parse the new license's name
+	err = parser.parsePair2_2("LicenseName", olname2)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should still be correct
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+	// and the other license name should be as expected
+	if parser.otherLic.LicenseName != olname2 {
+		t.Errorf("expected other license name %s, got %s", olname2, parser.otherLic.LicenseName)
+	}
+	// and the Document's Other Licenses should be of size 2 and have these two
+	if len(parser.doc.OtherLicenses) != 2 {
+		t.Fatalf("Expected OtherLicenses to have len 2, got %d", len(parser.doc.OtherLicenses))
+	}
+	if parser.doc.OtherLicenses[0] != olic1 {
+		t.Errorf("Expected other license %v in OtherLicenses[0], got %v", olic1, parser.doc.OtherLicenses[0])
+	}
+	if parser.doc.OtherLicenses[0].LicenseIdentifier != olid1 {
+		t.Errorf("expected other license ID %s in OtherLicenses[0], got %s", olid1, parser.doc.OtherLicenses[0].LicenseIdentifier)
+	}
+	if parser.doc.OtherLicenses[0].LicenseName != olname1 {
+		t.Errorf("expected other license name %s in OtherLicenses[0], got %s", olname1, parser.doc.OtherLicenses[0].LicenseName)
+	}
+	if parser.doc.OtherLicenses[1] != parser.otherLic {
+		t.Errorf("Expected other license %v in OtherLicenses[1], got %v", parser.otherLic, parser.doc.OtherLicenses[1])
+	}
+	if parser.doc.OtherLicenses[1].LicenseIdentifier != olid2 {
+		t.Errorf("expected other license ID %s in OtherLicenses[1], got %s", olid2, parser.doc.OtherLicenses[1].LicenseIdentifier)
+	}
+	if parser.doc.OtherLicenses[1].LicenseName != olname2 {
+		t.Errorf("expected other license name %s in OtherLicenses[1], got %s", olname2, parser.doc.OtherLicenses[1].LicenseName)
+	}
+}
+
+func TestParser2_2OLMovesToReviewAfterParsingReviewerTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	err := parser.parsePair2_2("Reviewer", "Person: John Doe")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+}
+
+func TestParser2_2OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-whatever",
+			LicenseName:       "the whatever license",
+		},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should remain unchanged
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+	// and the relationship should be in the Document's Relationships
+	if len(parser.doc.Relationships) != 1 {
+		t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships))
+	}
+	deID := parser.doc.Relationships[0].RefA
+	if deID.DocumentRefID != "" || deID.ElementRefID != "blah" {
+		t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA)
+	}
+
+	err = parser.parsePair2_2("RelationshipComment", "blah")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should still remain unchanged
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+}
+
+func TestParser2_2OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-whatever",
+			LicenseName:       "the whatever license",
+		},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2)
+	}
+
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2)
+	}
+
+	// and the annotation should be in the Document's Annotations
+	if len(parser.doc.Annotations) != 1 {
+		t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations))
+	}
+	if parser.doc.Annotations[0].Annotator != "John Doe ()" {
+		t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator)
+	}
+}
+
+func TestParser2_2OLFailsAfterParsingOtherSectionTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	// can't go back to old sections
+	err := parser.parsePair2_2("SPDXVersion", "SPDX-2.2")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+	err = parser.parsePair2_2("PackageName", "whatever")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+	err = parser.parsePair2_2("FileName", "whatever")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+}
+
+// ===== Other License data section tests =====
+func TestParser2_2CanParseOtherLicenseTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	// License Identifier
+	err := parser.parsePairFromOtherLicense2_2("LicenseID", "LicenseRef-Lic11")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.otherLic.LicenseIdentifier != "LicenseRef-Lic11" {
+		t.Errorf("got %v for LicenseID", parser.otherLic.LicenseIdentifier)
+	}
+
+	// Extracted Text
+	err = parser.parsePairFromOtherLicense2_2("ExtractedText", "You are permitted to do anything with the software, hooray!")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.otherLic.ExtractedText != "You are permitted to do anything with the software, hooray!" {
+		t.Errorf("got %v for ExtractedText", parser.otherLic.ExtractedText)
+	}
+
+	// License Name
+	err = parser.parsePairFromOtherLicense2_2("LicenseName", "License 11")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.otherLic.LicenseName != "License 11" {
+		t.Errorf("got %v for LicenseName", parser.otherLic.LicenseName)
+	}
+
+	// License Cross Reference
+	crossRefs := []string{
+		"https://example.com/1",
+		"https://example.com/2",
+		"https://example.com/3",
+	}
+	for _, cr := range crossRefs {
+		err = parser.parsePairFromOtherLicense2_2("LicenseCrossReference", cr)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, refWant := range crossRefs {
+		flagFound := false
+		for _, refCheck := range parser.otherLic.LicenseCrossReferences {
+			if refWant == refCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in LicenseCrossReferences", refWant)
+		}
+	}
+	if len(crossRefs) != len(parser.otherLic.LicenseCrossReferences) {
+		t.Errorf("expected %d types in LicenseCrossReferences, got %d", len(crossRefs),
+			len(parser.otherLic.LicenseCrossReferences))
+	}
+
+	// License Comment
+	err = parser.parsePairFromOtherLicense2_2("LicenseComment", "this is a comment")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.otherLic.LicenseComment != "this is a comment" {
+		t.Errorf("got %v for LicenseComment", parser.otherLic.LicenseComment)
+	}
+}
+
+func TestParser2_2OLUnknownTagFails(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psOtherLicense2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+
+	err := parser.parsePairFromOtherLicense2_2("blah", "something")
+	if err == nil {
+		t.Errorf("expected error from parsing unknown tag")
+	}
+}
diff --git a/tvloader/parser2v2/parse_package.go b/tvloader/parser2v2/parse_package.go
new file mode 100644
index 0000000..ddc9cb0
--- /dev/null
+++ b/tvloader/parser2v2/parse_package.go
@@ -0,0 +1,217 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+func (parser *tvParser2_2) parsePairFromPackage2_2(tag string, value string) error {
+	// expire pkgExtRef for anything other than a comment
+	// (we'll actually handle the comment further below)
+	if tag != "ExternalRefComment" {
+		parser.pkgExtRef = nil
+	}
+
+	switch tag {
+	case "PackageName":
+		// if package already has a name, create and go on to a new package
+		if parser.pkg == nil || parser.pkg.PackageName != "" {
+			parser.pkg = &spdx.Package2_2{
+				FilesAnalyzed:             true,
+				IsFilesAnalyzedTagPresent: false,
+			}
+		}
+		parser.pkg.PackageName = value
+	// tag for going on to file section
+	case "FileName":
+		parser.st = psFile2_2
+		return parser.parsePairFromFile2_2(tag, value)
+	// tag for going on to other license section
+	case "LicenseID":
+		parser.st = psOtherLicense2_2
+		return parser.parsePairFromOtherLicense2_2(tag, value)
+	case "SPDXID":
+		eID, err := extractElementID(value)
+		if err != nil {
+			return err
+		}
+		parser.pkg.PackageSPDXIdentifier = eID
+		if parser.doc.Packages == nil {
+			parser.doc.Packages = map[spdx.ElementID]*spdx.Package2_2{}
+		}
+		parser.doc.Packages[eID] = parser.pkg
+	case "PackageVersion":
+		parser.pkg.PackageVersion = value
+	case "PackageFileName":
+		parser.pkg.PackageFileName = value
+	case "PackageSupplier":
+		if value == "NOASSERTION" {
+			parser.pkg.PackageSupplierNOASSERTION = true
+			break
+		}
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		switch subkey {
+		case "Person":
+			parser.pkg.PackageSupplierPerson = subvalue
+		case "Organization":
+			parser.pkg.PackageSupplierOrganization = subvalue
+		default:
+			return fmt.Errorf("unrecognized PackageSupplier type %v", subkey)
+		}
+	case "PackageOriginator":
+		if value == "NOASSERTION" {
+			parser.pkg.PackageOriginatorNOASSERTION = true
+			break
+		}
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		switch subkey {
+		case "Person":
+			parser.pkg.PackageOriginatorPerson = subvalue
+		case "Organization":
+			parser.pkg.PackageOriginatorOrganization = subvalue
+		default:
+			return fmt.Errorf("unrecognized PackageOriginator type %v", subkey)
+		}
+	case "PackageDownloadLocation":
+		parser.pkg.PackageDownloadLocation = value
+	case "FilesAnalyzed":
+		parser.pkg.IsFilesAnalyzedTagPresent = true
+		if value == "false" {
+			parser.pkg.FilesAnalyzed = false
+		} else if value == "true" {
+			parser.pkg.FilesAnalyzed = true
+		}
+	case "PackageVerificationCode":
+		code, excludesFileName := extractCodeAndExcludes(value)
+		parser.pkg.PackageVerificationCode = code
+		parser.pkg.PackageVerificationCodeExcludedFile = excludesFileName
+	case "PackageChecksum":
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		switch subkey {
+		case "SHA1":
+			parser.pkg.PackageChecksumSHA1 = subvalue
+		case "SHA256":
+			parser.pkg.PackageChecksumSHA256 = subvalue
+		case "MD5":
+			parser.pkg.PackageChecksumMD5 = subvalue
+		default:
+			return fmt.Errorf("got unknown checksum type %s", subkey)
+		}
+	case "PackageHomePage":
+		parser.pkg.PackageHomePage = value
+	case "PackageSourceInfo":
+		parser.pkg.PackageSourceInfo = value
+	case "PackageLicenseConcluded":
+		parser.pkg.PackageLicenseConcluded = value
+	case "PackageLicenseInfoFromFiles":
+		parser.pkg.PackageLicenseInfoFromFiles = append(parser.pkg.PackageLicenseInfoFromFiles, value)
+	case "PackageLicenseDeclared":
+		parser.pkg.PackageLicenseDeclared = value
+	case "PackageLicenseComments":
+		parser.pkg.PackageLicenseComments = value
+	case "PackageCopyrightText":
+		parser.pkg.PackageCopyrightText = value
+	case "PackageSummary":
+		parser.pkg.PackageSummary = value
+	case "PackageDescription":
+		parser.pkg.PackageDescription = value
+	case "PackageComment":
+		parser.pkg.PackageComment = value
+	case "PackageAttributionText":
+		parser.pkg.PackageAttributionTexts = append(parser.pkg.PackageAttributionTexts, value)
+	case "ExternalRef":
+		parser.pkgExtRef = &spdx.PackageExternalReference2_2{}
+		parser.pkg.PackageExternalReferences = append(parser.pkg.PackageExternalReferences, parser.pkgExtRef)
+		category, refType, locator, err := extractPackageExternalReference(value)
+		if err != nil {
+			return err
+		}
+		parser.pkgExtRef.Category = category
+		parser.pkgExtRef.RefType = refType
+		parser.pkgExtRef.Locator = locator
+	case "ExternalRefComment":
+		if parser.pkgExtRef == nil {
+			return fmt.Errorf("no current ExternalRef found")
+		}
+		parser.pkgExtRef.ExternalRefComment = value
+		// now, expire pkgExtRef anyway because it can have at most one comment
+		parser.pkgExtRef = nil
+	// for relationship tags, pass along but don't change state
+	case "Relationship":
+		parser.rln = &spdx.Relationship2_2{}
+		parser.doc.Relationships = append(parser.doc.Relationships, parser.rln)
+		return parser.parsePairForRelationship2_2(tag, value)
+	case "RelationshipComment":
+		return parser.parsePairForRelationship2_2(tag, value)
+	// for annotation tags, pass along but don't change state
+	case "Annotator":
+		parser.ann = &spdx.Annotation2_2{}
+		parser.doc.Annotations = append(parser.doc.Annotations, parser.ann)
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationDate":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationType":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "SPDXREF":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationComment":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	// tag for going on to review section (DEPRECATED)
+	case "Reviewer":
+		parser.st = psReview2_2
+		return parser.parsePairFromReview2_2(tag, value)
+	default:
+		return fmt.Errorf("received unknown tag %v in Package section", tag)
+	}
+
+	return nil
+}
+
+// ===== Helper functions =====
+
+func extractCodeAndExcludes(value string) (string, string) {
+	// FIXME this should probably be done using regular expressions instead
+	// split by paren + word "excludes:"
+	sp := strings.SplitN(value, "(excludes:", 2)
+	if len(sp) < 2 {
+		// not found; return the whole string as just the code
+		return value, ""
+	}
+
+	// if we're here, code is in first part and excludes filename is in
+	// second part, with trailing paren
+	code := strings.TrimSpace(sp[0])
+	parsedSp := strings.SplitN(sp[1], ")", 2)
+	fileName := strings.TrimSpace(parsedSp[0])
+	return code, fileName
+}
+
+func extractPackageExternalReference(value string) (string, string, string, error) {
+	sp := strings.Split(value, " ")
+	// remove any that are just whitespace
+	keepSp := []string{}
+	for _, s := range sp {
+		ss := strings.TrimSpace(s)
+		if ss != "" {
+			keepSp = append(keepSp, ss)
+		}
+	}
+	// now, should have 3 items and should be able to map them
+	if len(keepSp) != 3 {
+		return "", "", "", fmt.Errorf("expected 3 elements, got %d", len(keepSp))
+	}
+	return keepSp[0], keepSp[1], keepSp[2], nil
+}
diff --git a/tvloader/parser2v2/parse_package_test.go b/tvloader/parser2v2/parse_package_test.go
new file mode 100644
index 0000000..6f40170
--- /dev/null
+++ b/tvloader/parser2v2/parse_package_test.go
@@ -0,0 +1,1097 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Parser package section state change tests =====
+func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
+	// create the first package
+	pkgOldName := "p1"
+
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: pkgOldName, PackageSPDXIdentifier: "p1"},
+	}
+	pkgOld := parser.pkg
+	parser.doc.Packages["p1"] = pkgOld
+	// the Document's Packages should have this one only
+	if parser.doc.Packages["p1"] != pkgOld {
+		t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages["p1"])
+	}
+	if len(parser.doc.Packages) != 1 {
+		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
+	}
+
+	// now add a new package
+	pkgName := "p2"
+	err := parser.parsePair2_2("PackageName", pkgName)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psPackage2_2 {
+		t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st)
+	}
+	// and a package should be created
+	if parser.pkg == nil {
+		t.Fatalf("parser didn't create new package")
+	}
+	// and it should not be pkgOld
+	if parser.pkg == pkgOld {
+		t.Errorf("expected new package, got pkgOld")
+	}
+	// and the package name should be as expected
+	if parser.pkg.PackageName != pkgName {
+		t.Errorf("expected package name %s, got %s", pkgName, parser.pkg.PackageName)
+	}
+	// and the package should default to true for FilesAnalyzed
+	if parser.pkg.FilesAnalyzed != true {
+		t.Errorf("expected FilesAnalyzed to default to true, got false")
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != false {
+		t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true")
+	}
+	// and the Document's Packages should still be of size 1 and have pkgOld only
+	if parser.doc.Packages["p1"] != pkgOld {
+		t.Errorf("Expected package %v, got %v", pkgOld, parser.doc.Packages["p1"])
+	}
+	if len(parser.doc.Packages) != 1 {
+		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
+	}
+}
+
+func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpackaged(t *testing.T) {
+	// pkg is nil, so that Files appearing before the first PackageName tag
+	// are added to UnpackagedFiles instead of Packages
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psFile2_2,
+		pkg: nil,
+	}
+	// the Document's Packages should be empty
+	if len(parser.doc.Packages) != 0 {
+		t.Errorf("Expected zero packages, got %d", len(parser.doc.Packages))
+	}
+
+	// now add a new package
+	pkgName := "p2"
+	err := parser.parsePair2_2("PackageName", pkgName)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psPackage2_2 {
+		t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st)
+	}
+	// and a package should be created
+	if parser.pkg == nil {
+		t.Fatalf("parser didn't create new package")
+	}
+	// and the package name should be as expected
+	if parser.pkg.PackageName != pkgName {
+		t.Errorf("expected package name %s, got %s", pkgName, parser.pkg.PackageName)
+	}
+	// and the package should default to true for FilesAnalyzed
+	if parser.pkg.FilesAnalyzed != true {
+		t.Errorf("expected FilesAnalyzed to default to true, got false")
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != false {
+		t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true")
+	}
+	// and the Document's Packages should be of size 0, because the prior was
+	// unpackaged files and this one won't be added until an SPDXID is seen
+	if len(parser.doc.Packages) != 0 {
+		t.Errorf("Expected %v packages in doc, got %v", 0, len(parser.doc.Packages))
+	}
+}
+
+func TestParser2_2PackageMovesToFileAfterParsingFileNameTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+	pkgCurrent := parser.pkg
+
+	err := parser.parsePair2_2("FileName", "testFile")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psFile2_2 {
+		t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st)
+	}
+	// and current package should remain what it was
+	if parser.pkg != pkgCurrent {
+		t.Fatalf("expected package to remain %v, got %v", pkgCurrent, parser.pkg)
+	}
+}
+
+func TestParser2_2PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+}
+
+func TestParser2_2PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePair2_2("Reviewer", "Person: John Doe")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+}
+
+func TestParser2_2PackageStaysAfterParsingRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should remain unchanged
+	if parser.st != psPackage2_2 {
+		t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st)
+	}
+
+	err = parser.parsePair2_2("RelationshipComment", "blah")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should still remain unchanged
+	if parser.st != psPackage2_2 {
+		t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st)
+	}
+}
+
+func TestParser2_2PackageStaysAfterParsingAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psPackage2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psPackage2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psPackage2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2)
+	}
+
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psPackage2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this package")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psPackage2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2)
+	}
+}
+
+// ===== Package data section tests =====
+func TestParser2_2CanParsePackageTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// should not yet be in Packages map, b/c no SPDX identifier
+	if len(parser.doc.Packages) != 0 {
+		t.Errorf("expected 0 packages, got %d", len(parser.doc.Packages))
+	}
+
+	// Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageName != "p1" {
+		t.Errorf("got %v for PackageName", parser.pkg.PackageName)
+	}
+	// still should not yet be in Packages map, b/c no SPDX identifier
+	if len(parser.doc.Packages) != 0 {
+		t.Errorf("expected 0 packages, got %d", len(parser.doc.Packages))
+	}
+
+	// Package SPDX Identifier
+	err = parser.parsePairFromPackage2_2("SPDXID", "SPDXRef-p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// "SPDXRef-" prefix should be removed from the item
+	if parser.pkg.PackageSPDXIdentifier != "p1" {
+		t.Errorf("got %v for PackageSPDXIdentifier", parser.pkg.PackageSPDXIdentifier)
+	}
+	// and it should now be added to the Packages map
+	if len(parser.doc.Packages) != 1 {
+		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
+	}
+	if parser.doc.Packages["p1"] != parser.pkg {
+		t.Errorf("expected to point to parser.pkg, got %v", parser.doc.Packages["p1"])
+	}
+
+	// Package Version
+	err = parser.parsePairFromPackage2_2("PackageVersion", "2.1.1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageVersion != "2.1.1" {
+		t.Errorf("got %v for PackageVersion", parser.pkg.PackageVersion)
+	}
+
+	// Package File Name
+	err = parser.parsePairFromPackage2_2("PackageFileName", "p1-2.1.1.tar.gz")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageFileName != "p1-2.1.1.tar.gz" {
+		t.Errorf("got %v for PackageFileName", parser.pkg.PackageFileName)
+	}
+
+	// Package Supplier
+	// SKIP -- separate tests for subvalues below
+
+	// Package Originator
+	// SKIP -- separate tests for subvalues below
+
+	// Package Download Location
+	err = parser.parsePairFromPackage2_2("PackageDownloadLocation", "https://example.com/whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageDownloadLocation != "https://example.com/whatever" {
+		t.Errorf("got %v for PackageDownloadLocation", parser.pkg.PackageDownloadLocation)
+	}
+
+	// Files Analyzed
+	err = parser.parsePairFromPackage2_2("FilesAnalyzed", "false")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.FilesAnalyzed != false {
+		t.Errorf("got %v for FilesAnalyzed", parser.pkg.FilesAnalyzed)
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != true {
+		t.Errorf("got %v for IsFilesAnalyzedTagPresent", parser.pkg.IsFilesAnalyzedTagPresent)
+	}
+
+	// Package Verification Code
+	// SKIP -- separate tests for "excludes", or not, below
+
+	// Package Checksums
+	codeSha1 := "85ed0817af83a24ad8da68c2b5094de69833983c"
+	sumSha1 := "SHA1: 85ed0817af83a24ad8da68c2b5094de69833983c"
+	codeSha256 := "11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd"
+	sumSha256 := "SHA256: 11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd"
+	codeMd5 := "624c1abb3664f4b35547e7c73864ad24"
+	sumMd5 := "MD5: 624c1abb3664f4b35547e7c73864ad24"
+	err = parser.parsePairFromPackage2_2("PackageChecksum", sumSha1)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromPackage2_2("PackageChecksum", sumSha256)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromPackage2_2("PackageChecksum", sumMd5)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageChecksumSHA1 != codeSha1 {
+		t.Errorf("expected %s for PackageChecksumSHA1, got %s", codeSha1, parser.pkg.PackageChecksumSHA1)
+	}
+	if parser.pkg.PackageChecksumSHA256 != codeSha256 {
+		t.Errorf("expected %s for PackageChecksumSHA256, got %s", codeSha256, parser.pkg.PackageChecksumSHA256)
+	}
+	if parser.pkg.PackageChecksumMD5 != codeMd5 {
+		t.Errorf("expected %s for PackageChecksumMD5, got %s", codeMd5, parser.pkg.PackageChecksumMD5)
+	}
+
+	// Package Home Page
+	err = parser.parsePairFromPackage2_2("PackageHomePage", "https://example.com/whatever2")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageHomePage != "https://example.com/whatever2" {
+		t.Errorf("got %v for PackageHomePage", parser.pkg.PackageHomePage)
+	}
+
+	// Package Source Info
+	err = parser.parsePairFromPackage2_2("PackageSourceInfo", "random comment")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageSourceInfo != "random comment" {
+		t.Errorf("got %v for PackageSourceInfo", parser.pkg.PackageSourceInfo)
+	}
+
+	// Package License Concluded
+	err = parser.parsePairFromPackage2_2("PackageLicenseConcluded", "Apache-2.0 OR GPL-2.0-or-later")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageLicenseConcluded != "Apache-2.0 OR GPL-2.0-or-later" {
+		t.Errorf("got %v for PackageLicenseConcluded", parser.pkg.PackageLicenseConcluded)
+	}
+
+	// All Licenses Info From Files
+	lics := []string{
+		"Apache-2.0",
+		"GPL-2.0-or-later",
+		"CC0-1.0",
+	}
+	for _, lic := range lics {
+		err = parser.parsePairFromPackage2_2("PackageLicenseInfoFromFiles", lic)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, licWant := range lics {
+		flagFound := false
+		for _, licCheck := range parser.pkg.PackageLicenseInfoFromFiles {
+			if licWant == licCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in PackageLicenseInfoFromFiles", licWant)
+		}
+	}
+	if len(lics) != len(parser.pkg.PackageLicenseInfoFromFiles) {
+		t.Errorf("expected %d licenses in PackageLicenseInfoFromFiles, got %d", len(lics),
+			len(parser.pkg.PackageLicenseInfoFromFiles))
+	}
+
+	// Package License Declared
+	err = parser.parsePairFromPackage2_2("PackageLicenseDeclared", "Apache-2.0 OR GPL-2.0-or-later")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageLicenseDeclared != "Apache-2.0 OR GPL-2.0-or-later" {
+		t.Errorf("got %v for PackageLicenseDeclared", parser.pkg.PackageLicenseDeclared)
+	}
+
+	// Package License Comments
+	err = parser.parsePairFromPackage2_2("PackageLicenseComments", "this is a license comment")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageLicenseComments != "this is a license comment" {
+		t.Errorf("got %v for PackageLicenseComments", parser.pkg.PackageLicenseComments)
+	}
+
+	// Package Copyright Text
+	err = parser.parsePairFromPackage2_2("PackageCopyrightText", "Copyright (c) me myself and i")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageCopyrightText != "Copyright (c) me myself and i" {
+		t.Errorf("got %v for PackageCopyrightText", parser.pkg.PackageCopyrightText)
+	}
+
+	// Package Summary
+	err = parser.parsePairFromPackage2_2("PackageSummary", "i wrote this package")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageSummary != "i wrote this package" {
+		t.Errorf("got %v for PackageSummary", parser.pkg.PackageSummary)
+	}
+
+	// Package Description
+	err = parser.parsePairFromPackage2_2("PackageDescription", "i wrote this package a lot")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageDescription != "i wrote this package a lot" {
+		t.Errorf("got %v for PackageDescription", parser.pkg.PackageDescription)
+	}
+
+	// Package Comment
+	err = parser.parsePairFromPackage2_2("PackageComment", "i scanned this package")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageComment != "i scanned this package" {
+		t.Errorf("got %v for PackageComment", parser.pkg.PackageComment)
+	}
+
+	// Package Attribution Text
+	attrs := []string{
+		"Include this notice in all advertising materials",
+		"This is a \nmulti-line string",
+	}
+	for _, attr := range attrs {
+		err = parser.parsePairFromPackage2_2("PackageAttributionText", attr)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, attrWant := range attrs {
+		flagFound := false
+		for _, attrCheck := range parser.pkg.PackageAttributionTexts {
+			if attrWant == attrCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in PackageAttributionText", attrWant)
+		}
+	}
+	if len(attrs) != len(parser.pkg.PackageAttributionTexts) {
+		t.Errorf("expected %d attribution texts in PackageAttributionTexts, got %d", len(attrs),
+			len(parser.pkg.PackageAttributionTexts))
+	}
+
+	// Package External References and Comments
+	ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
+	ref1Category := "SECURITY"
+	ref1Type := "cpe23Type"
+	ref1Locator := "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
+	ref1Comment := "this is comment #1"
+	ref2 := "OTHER LocationRef-acmeforge acmecorp/acmenator/4.1.3alpha"
+	ref2Category := "OTHER"
+	ref2Type := "LocationRef-acmeforge"
+	ref2Locator := "acmecorp/acmenator/4.1.3alpha"
+	ref2Comment := "this is comment #2"
+	err = parser.parsePairFromPackage2_2("ExternalRef", ref1)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if len(parser.pkg.PackageExternalReferences) != 1 {
+		t.Errorf("expected 1 external reference, got %d", len(parser.pkg.PackageExternalReferences))
+	}
+	if parser.pkgExtRef == nil {
+		t.Errorf("expected non-nil pkgExtRef, got nil")
+	}
+	if parser.pkg.PackageExternalReferences[0] == nil {
+		t.Errorf("expected non-nil PackageExternalReferences[0], got nil")
+	}
+	if parser.pkgExtRef != parser.pkg.PackageExternalReferences[0] {
+		t.Errorf("expected pkgExtRef to match PackageExternalReferences[0], got no match")
+	}
+	err = parser.parsePairFromPackage2_2("ExternalRefComment", ref1Comment)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	err = parser.parsePairFromPackage2_2("ExternalRef", ref2)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if len(parser.pkg.PackageExternalReferences) != 2 {
+		t.Errorf("expected 2 external references, got %d", len(parser.pkg.PackageExternalReferences))
+	}
+	if parser.pkgExtRef == nil {
+		t.Errorf("expected non-nil pkgExtRef, got nil")
+	}
+	if parser.pkg.PackageExternalReferences[1] == nil {
+		t.Errorf("expected non-nil PackageExternalReferences[1], got nil")
+	}
+	if parser.pkgExtRef != parser.pkg.PackageExternalReferences[1] {
+		t.Errorf("expected pkgExtRef to match PackageExternalReferences[1], got no match")
+	}
+	err = parser.parsePairFromPackage2_2("ExternalRefComment", ref2Comment)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// finally, check these values
+	gotRef1 := parser.pkg.PackageExternalReferences[0]
+	if gotRef1.Category != ref1Category {
+		t.Errorf("expected ref1 category to be %s, got %s", gotRef1.Category, ref1Category)
+	}
+	if gotRef1.RefType != ref1Type {
+		t.Errorf("expected ref1 type to be %s, got %s", gotRef1.RefType, ref1Type)
+	}
+	if gotRef1.Locator != ref1Locator {
+		t.Errorf("expected ref1 locator to be %s, got %s", gotRef1.Locator, ref1Locator)
+	}
+	if gotRef1.ExternalRefComment != ref1Comment {
+		t.Errorf("expected ref1 comment to be %s, got %s", gotRef1.ExternalRefComment, ref1Comment)
+	}
+	gotRef2 := parser.pkg.PackageExternalReferences[1]
+	if gotRef2.Category != ref2Category {
+		t.Errorf("expected ref2 category to be %s, got %s", gotRef2.Category, ref2Category)
+	}
+	if gotRef2.RefType != ref2Type {
+		t.Errorf("expected ref2 type to be %s, got %s", gotRef2.RefType, ref2Type)
+	}
+	if gotRef2.Locator != ref2Locator {
+		t.Errorf("expected ref2 locator to be %s, got %s", gotRef2.Locator, ref2Locator)
+	}
+	if gotRef2.ExternalRefComment != ref2Comment {
+		t.Errorf("expected ref2 comment to be %s, got %s", gotRef2.ExternalRefComment, ref2Comment)
+	}
+
+}
+
+func TestParser2_2CanParsePackageSupplierPersonTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Supplier: Person
+	err := parser.parsePairFromPackage2_2("PackageSupplier", "Person: John Doe")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageSupplierPerson != "John Doe" {
+		t.Errorf("got %v for PackageSupplierPerson", parser.pkg.PackageSupplierPerson)
+	}
+}
+
+func TestParser2_2CanParsePackageSupplierOrganizationTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Supplier: Organization
+	err := parser.parsePairFromPackage2_2("PackageSupplier", "Organization: John Doe, Inc.")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageSupplierOrganization != "John Doe, Inc." {
+		t.Errorf("got %v for PackageSupplierOrganization", parser.pkg.PackageSupplierOrganization)
+	}
+}
+
+func TestParser2_2CanParsePackageSupplierNOASSERTIONTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Supplier: NOASSERTION
+	err := parser.parsePairFromPackage2_2("PackageSupplier", "NOASSERTION")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageSupplierNOASSERTION != true {
+		t.Errorf("got false for PackageSupplierNOASSERTION")
+	}
+}
+
+func TestParser2_2CanParsePackageOriginatorPersonTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Originator: Person
+	err := parser.parsePairFromPackage2_2("PackageOriginator", "Person: John Doe")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageOriginatorPerson != "John Doe" {
+		t.Errorf("got %v for PackageOriginatorPerson", parser.pkg.PackageOriginatorPerson)
+	}
+}
+
+func TestParser2_2CanParsePackageOriginatorOrganizationTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Originator: Organization
+	err := parser.parsePairFromPackage2_2("PackageOriginator", "Organization: John Doe, Inc.")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageOriginatorOrganization != "John Doe, Inc." {
+		t.Errorf("got %v for PackageOriginatorOrganization", parser.pkg.PackageOriginatorOrganization)
+	}
+}
+
+func TestParser2_2CanParsePackageOriginatorNOASSERTIONTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Originator: NOASSERTION
+	err := parser.parsePairFromPackage2_2("PackageOriginator", "NOASSERTION")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageOriginatorNOASSERTION != true {
+		t.Errorf("got false for PackageOriginatorNOASSERTION")
+	}
+}
+
+func TestParser2_2CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Verification Code with excludes parenthetical
+	code := "d6a770ba38583ed4bb4525bd96e50461655d2758"
+	fileName := "./package.spdx"
+	fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)"
+	err := parser.parsePairFromPackage2_2("PackageVerificationCode", fullCodeValue)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageVerificationCode != code {
+		t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode)
+	}
+	if parser.pkg.PackageVerificationCodeExcludedFile != fileName {
+		t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile)
+	}
+
+}
+
+func TestParser2_2CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	// Package Verification Code without excludes parenthetical
+	code := "d6a770ba38583ed4bb4525bd96e50461655d2758"
+	err := parser.parsePairFromPackage2_2("PackageVerificationCode", code)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.PackageVerificationCode != code {
+		t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode)
+	}
+	if parser.pkg.PackageVerificationCodeExcludedFile != "" {
+		t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile)
+	}
+
+}
+
+func TestParser2_2PackageExternalRefPointerChangesAfterTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
+	err := parser.parsePairFromPackage2_2("ExternalRef", ref1)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkgExtRef == nil {
+		t.Errorf("expected non-nil external reference pointer, got nil")
+	}
+
+	// now, a comment; pointer should go away
+	err = parser.parsePairFromPackage2_2("ExternalRefComment", "whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkgExtRef != nil {
+		t.Errorf("expected nil external reference pointer, got non-nil")
+	}
+
+	ref2 := "Other LocationRef-something https://example.com/whatever"
+	err = parser.parsePairFromPackage2_2("ExternalRef", ref2)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkgExtRef == nil {
+		t.Errorf("expected non-nil external reference pointer, got nil")
+	}
+
+	// and some other random tag makes the pointer go away too
+	err = parser.parsePairFromPackage2_2("PackageSummary", "whatever")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkgExtRef != nil {
+		t.Errorf("expected nil external reference pointer, got non-nil")
+	}
+}
+
+func TestParser2_2PackageCreatesRelationshipInDocument(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.rln == nil {
+		t.Fatalf("parser didn't create and point to Relationship struct")
+	}
+	if parser.rln != parser.doc.Relationships[0] {
+		t.Errorf("pointer to new Relationship doesn't match idx 0 for doc.Relationships[]")
+	}
+}
+
+func TestParser2_2PackageCreatesAnnotationInDocument(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.ann == nil {
+		t.Fatalf("parser didn't create and point to Annotation struct")
+	}
+	if parser.ann != parser.doc.Annotations[0] {
+		t.Errorf("pointer to new Annotation doesn't match idx 0 for doc.Annotations[]")
+	}
+}
+
+func TestParser2_2PackageUnknownTagFails(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
+	}
+	parser.doc.Packages["p1"] = parser.pkg
+
+	err := parser.parsePairFromPackage2_2("blah", "something")
+	if err == nil {
+		t.Errorf("expected error from parsing unknown tag")
+	}
+}
+
+func TestParser2_2FailsIfInvalidSPDXIDInPackageSection(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid ID format
+	err = parser.parsePairFromPackage2_2("SPDXID", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfInvalidPackageSupplierFormat(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid supplier format
+	err = parser.parsePairFromPackage2_2("PackageSupplier", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfUnknownPackageSupplierType(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid supplier type
+	err = parser.parsePairFromPackage2_2("PackageSupplier", "whoops: John Doe")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfInvalidPackageOriginatorFormat(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid originator format
+	err = parser.parsePairFromPackage2_2("PackageOriginator", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfUnknownPackageOriginatorType(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid originator type
+	err = parser.parsePairFromPackage2_2("PackageOriginator", "whoops: John Doe")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2SetsFilesAnalyzedTagsCorrectly(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// set tag
+	err = parser.parsePairFromPackage2_2("FilesAnalyzed", "true")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.pkg.FilesAnalyzed != true {
+		t.Errorf("expected %v, got %v", true, parser.pkg.FilesAnalyzed)
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != true {
+		t.Errorf("expected %v, got %v", true, parser.pkg.IsFilesAnalyzedTagPresent)
+	}
+}
+
+func TestParser2_2FailsIfInvalidPackageChecksumFormat(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid checksum format
+	err = parser.parsePairFromPackage2_2("PackageChecksum", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfInvalidPackageChecksumType(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid checksum type
+	err = parser.parsePairFromPackage2_2("PackageChecksum", "whoops: blah")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfInvalidExternalRefFormat(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid external ref format
+	err = parser.parsePairFromPackage2_2("ExternalRef", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfExternalRefCommentBeforeExternalRef(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psPackage2_2,
+		pkg: &spdx.Package2_2{},
+	}
+
+	// start with Package Name
+	err := parser.parsePairFromPackage2_2("PackageName", "p1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// external ref comment before external ref
+	err = parser.parsePairFromPackage2_2("ExternalRefComment", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+// ===== Helper function tests =====
+
+func TestCanCheckAndExtractExcludesFilenameAndCode(t *testing.T) {
+	code := "d6a770ba38583ed4bb4525bd96e50461655d2758"
+	fileName := "./package.spdx"
+	fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)"
+
+	gotCode, gotFileName := extractCodeAndExcludes(fullCodeValue)
+	if gotCode != code {
+		t.Errorf("got %v for gotCode", gotCode)
+	}
+	if gotFileName != fileName {
+		t.Errorf("got %v for gotFileName", gotFileName)
+	}
+}
+
+func TestCanExtractPackageExternalReference(t *testing.T) {
+	ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
+	category := "SECURITY"
+	refType := "cpe23Type"
+	location := "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
+
+	gotCategory, gotRefType, gotLocation, err := extractPackageExternalReference(ref1)
+	if err != nil {
+		t.Errorf("got non-nil error: %v", err)
+	}
+	if gotCategory != category {
+		t.Errorf("expected category %s, got %s", category, gotCategory)
+	}
+	if gotRefType != refType {
+		t.Errorf("expected refType %s, got %s", refType, gotRefType)
+	}
+	if gotLocation != location {
+		t.Errorf("expected location %s, got %s", location, gotLocation)
+	}
+}
+
+func TestCanExtractPackageExternalReferenceWithExtraWhitespace(t *testing.T) {
+	ref1 := "  SECURITY    \t cpe23Type   cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:* \t "
+	category := "SECURITY"
+	refType := "cpe23Type"
+	location := "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
+
+	gotCategory, gotRefType, gotLocation, err := extractPackageExternalReference(ref1)
+	if err != nil {
+		t.Errorf("got non-nil error: %v", err)
+	}
+	if gotCategory != category {
+		t.Errorf("expected category %s, got %s", category, gotCategory)
+	}
+	if gotRefType != refType {
+		t.Errorf("expected refType %s, got %s", refType, gotRefType)
+	}
+	if gotLocation != location {
+		t.Errorf("expected location %s, got %s", location, gotLocation)
+	}
+}
+
+func TestFailsPackageExternalRefWithInvalidFormat(t *testing.T) {
+	_, _, _, err := extractPackageExternalReference("whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
diff --git a/tvloader/parser2v2/parse_relationship.go b/tvloader/parser2v2/parse_relationship.go
new file mode 100644
index 0000000..28e5b72
--- /dev/null
+++ b/tvloader/parser2v2/parse_relationship.go
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (parser *tvParser2_2) parsePairForRelationship2_2(tag string, value string) error {
+	if parser.rln == nil {
+		return fmt.Errorf("no relationship struct created in parser rln pointer")
+	}
+
+	if tag == "Relationship" {
+		// parse the value to see if it's a valid relationship format
+		sp := strings.SplitN(value, " ", -1)
+
+		// filter out any purely-whitespace items
+		var rp []string
+		for _, v := range sp {
+			v = strings.TrimSpace(v)
+			if v != "" {
+				rp = append(rp, v)
+			}
+		}
+
+		if len(rp) != 3 {
+			return fmt.Errorf("invalid relationship format for %s", value)
+		}
+
+		aID, err := extractDocElementID(strings.TrimSpace(rp[0]))
+		if err != nil {
+			return err
+		}
+		parser.rln.RefA = aID
+		parser.rln.Relationship = strings.TrimSpace(rp[1])
+		bID, err := extractDocElementID(strings.TrimSpace(rp[2]))
+		if err != nil {
+			return err
+		}
+		parser.rln.RefB = bID
+		return nil
+	}
+
+	if tag == "RelationshipComment" {
+		parser.rln.RelationshipComment = value
+		return nil
+	}
+
+	return fmt.Errorf("received unknown tag %v in Relationship section", tag)
+}
diff --git a/tvloader/parser2v2/parse_relationship_test.go b/tvloader/parser2v2/parse_relationship_test.go
new file mode 100644
index 0000000..1312cc5
--- /dev/null
+++ b/tvloader/parser2v2/parse_relationship_test.go
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Relationship section tests =====
+func TestParser2_2FailsIfRelationshipNotSet(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePairForRelationship2_2("Relationship", "SPDXRef-A CONTAINS SPDXRef-B")
+	if err == nil {
+		t.Errorf("expected error when calling parsePairFromRelationship2_2 without setting rln pointer")
+	}
+}
+
+func TestParser2_2FailsIfRelationshipCommentWithoutRelationship(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+	err := parser.parsePair2_2("RelationshipComment", "comment whatever")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2 for RelationshipComment without Relationship first")
+	}
+}
+
+func TestParser2_2CanParseRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// Relationship
+	err := parser.parsePair2_2("Relationship", "SPDXRef-something CONTAINS DocumentRef-otherdoc:SPDXRef-something-else")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rln.RefA.DocumentRefID != "" || parser.rln.RefA.ElementRefID != "something" {
+		t.Errorf("got %v for first part of Relationship, expected something", parser.rln.RefA)
+	}
+	if parser.rln.RefB.DocumentRefID != "otherdoc" || parser.rln.RefB.ElementRefID != "something-else" {
+		t.Errorf("got %v for second part of Relationship, expected otherdoc:something-else", parser.rln.RefB)
+	}
+	if parser.rln.Relationship != "CONTAINS" {
+		t.Errorf("got %v for Relationship type, expected CONTAINS", parser.rln.Relationship)
+	}
+
+	// Relationship Comment
+	cmt := "this is a comment"
+	err = parser.parsePair2_2("RelationshipComment", cmt)
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rln.RelationshipComment != cmt {
+		t.Errorf("got %v for RelationshipComment, expected %v", parser.rln.RelationshipComment, cmt)
+	}
+}
+
+func TestParser2_2InvalidRelationshipTagsNoValueFail(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// no items
+	parser.rln = nil
+	err := parser.parsePair2_2("Relationship", "")
+	if err == nil {
+		t.Errorf("expected error for empty items in relationship, got nil")
+	}
+}
+
+func TestParser2_2InvalidRelationshipTagsOneValueFail(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// one item
+	parser.rln = nil
+	err := parser.parsePair2_2("Relationship", "DESCRIBES")
+	if err == nil {
+		t.Errorf("expected error for only one item in relationship, got nil")
+	}
+}
+
+func TestParser2_2InvalidRelationshipTagsTwoValuesFail(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// two items
+	parser.rln = nil
+	err := parser.parsePair2_2("Relationship", "SPDXRef-DOCUMENT DESCRIBES")
+	if err == nil {
+		t.Errorf("expected error for only two items in relationship, got nil")
+	}
+}
+
+func TestParser2_2InvalidRelationshipTagsThreeValuesSucceed(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// three items but with interspersed additional whitespace
+	parser.rln = nil
+	err := parser.parsePair2_2("Relationship", "  SPDXRef-DOCUMENT \t   DESCRIBES  SPDXRef-something-else    ")
+	if err != nil {
+		t.Errorf("expected pass for three items in relationship w/ extra whitespace, got: %v", err)
+	}
+}
+
+func TestParser2_2InvalidRelationshipTagsFourValuesFail(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// four items
+	parser.rln = nil
+	err := parser.parsePair2_2("Relationship", "SPDXRef-a DESCRIBES SPDXRef-b SPDXRef-c")
+	if err == nil {
+		t.Errorf("expected error for more than three items in relationship, got nil")
+	}
+}
+
+func TestParser2_2InvalidRelationshipTagsInvalidRefIDs(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// four items
+	parser.rln = nil
+	err := parser.parsePair2_2("Relationship", "SPDXRef-a DESCRIBES b")
+	if err == nil {
+		t.Errorf("expected error for missing SPDXRef- prefix, got nil")
+	}
+
+	parser.rln = nil
+	err = parser.parsePair2_2("Relationship", "a DESCRIBES SPDXRef-b")
+	if err == nil {
+		t.Errorf("expected error for missing SPDXRef- prefix, got nil")
+	}
+}
+
+func TestParser2_2FailsToParseUnknownTagInRelationshipSection(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{},
+		st:  psCreationInfo2_2,
+	}
+
+	// Relationship
+	err := parser.parsePair2_2("Relationship", "SPDXRef-something CONTAINS DocumentRef-otherdoc:SPDXRef-something-else")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid tag
+	err = parser.parsePairForRelationship2_2("blah", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
diff --git a/tvloader/parser2v2/parse_review.go b/tvloader/parser2v2/parse_review.go
new file mode 100644
index 0000000..065d889
--- /dev/null
+++ b/tvloader/parser2v2/parse_review.go
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+func (parser *tvParser2_2) parsePairFromReview2_2(tag string, value string) error {
+	switch tag {
+	// tag for creating new review section
+	case "Reviewer":
+		parser.rev = &spdx.Review2_2{}
+		parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+		subkey, subvalue, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		switch subkey {
+		case "Person":
+			parser.rev.Reviewer = subvalue
+			parser.rev.ReviewerType = "Person"
+		case "Organization":
+			parser.rev.Reviewer = subvalue
+			parser.rev.ReviewerType = "Organization"
+		case "Tool":
+			parser.rev.Reviewer = subvalue
+			parser.rev.ReviewerType = "Tool"
+		default:
+			return fmt.Errorf("unrecognized Reviewer type %v", subkey)
+		}
+	case "ReviewDate":
+		parser.rev.ReviewDate = value
+	case "ReviewComment":
+		parser.rev.ReviewComment = value
+	// for relationship tags, pass along but don't change state
+	case "Relationship":
+		parser.rln = &spdx.Relationship2_2{}
+		parser.doc.Relationships = append(parser.doc.Relationships, parser.rln)
+		return parser.parsePairForRelationship2_2(tag, value)
+	case "RelationshipComment":
+		return parser.parsePairForRelationship2_2(tag, value)
+	// for annotation tags, pass along but don't change state
+	case "Annotator":
+		parser.ann = &spdx.Annotation2_2{}
+		parser.doc.Annotations = append(parser.doc.Annotations, parser.ann)
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationDate":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationType":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "SPDXREF":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationComment":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	default:
+		return fmt.Errorf("received unknown tag %v in Review section", tag)
+	}
+
+	return nil
+}
diff --git a/tvloader/parser2v2/parse_review_test.go b/tvloader/parser2v2/parse_review_test.go
new file mode 100644
index 0000000..f482184
--- /dev/null
+++ b/tvloader/parser2v2/parse_review_test.go
@@ -0,0 +1,414 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Parser review section state change tests =====
+func TestParser2_2ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) {
+	// create the first review
+	rev1 := "John Doe"
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{
+			Reviewer:     rev1,
+			ReviewerType: "Person",
+		},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+	r1 := parser.rev
+
+	// the Document's Reviews should have this one only
+	if len(parser.doc.Reviews) != 1 {
+		t.Errorf("Expected only one review, got %d", len(parser.doc.Reviews))
+	}
+	if parser.doc.Reviews[0] != r1 {
+		t.Errorf("Expected review %v in Reviews[0], got %v", r1, parser.doc.Reviews[0])
+	}
+	if parser.doc.Reviews[0].Reviewer != rev1 {
+		t.Errorf("expected review name %s in Reviews[0], got %s", rev1, parser.doc.Reviews[0].Reviewer)
+	}
+
+	// now add a new review
+	rev2 := "Steve"
+	rp2 := "Person: Steve"
+	err := parser.parsePair2_2("Reviewer", rp2)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+	// and a review should be created
+	if parser.rev == nil {
+		t.Fatalf("parser didn't create new review")
+	}
+	// and the reviewer's name should be as expected
+	if parser.rev.Reviewer != rev2 {
+		t.Errorf("expected reviewer name %s, got %s", rev2, parser.rev.Reviewer)
+	}
+	// and the Document's reviews should be of size 2 and have these two
+	if len(parser.doc.Reviews) != 2 {
+		t.Fatalf("Expected Reviews to have len 2, got %d", len(parser.doc.Reviews))
+	}
+	if parser.doc.Reviews[0] != r1 {
+		t.Errorf("Expected review %v in Reviews[0], got %v", r1, parser.doc.Reviews[0])
+	}
+	if parser.doc.Reviews[0].Reviewer != rev1 {
+		t.Errorf("expected reviewer name %s in Reviews[0], got %s", rev1, parser.doc.Reviews[0].Reviewer)
+	}
+	if parser.doc.Reviews[1] != parser.rev {
+		t.Errorf("Expected review %v in Reviews[1], got %v", parser.rev, parser.doc.Reviews[1])
+	}
+	if parser.doc.Reviews[1].Reviewer != rev2 {
+		t.Errorf("expected reviewer name %s in Reviews[1], got %s", rev2, parser.doc.Reviews[1].Reviewer)
+	}
+
+}
+
+func TestParser2_2ReviewStaysAfterParsingRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{
+			Reviewer:     "Jane Doe",
+			ReviewerType: "Person",
+		},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should remain unchanged
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+	// and the relationship should be in the Document's Relationships
+	if len(parser.doc.Relationships) != 1 {
+		t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships))
+	}
+	deID := parser.doc.Relationships[0].RefA
+	if deID.DocumentRefID != "" || deID.ElementRefID != "blah" {
+		t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA)
+	}
+
+	err = parser.parsePair2_2("RelationshipComment", "blah")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should still remain unchanged
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+}
+
+func TestParser2_2ReviewStaysAfterParsingAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{
+			Reviewer:     "Jane Doe",
+			ReviewerType: "Person",
+		},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2)
+	}
+
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2)
+	}
+
+	// and the annotation should be in the Document's Annotations
+	if len(parser.doc.Annotations) != 1 {
+		t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations))
+	}
+	if parser.doc.Annotations[0].Annotator != "John Doe ()" {
+		t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator)
+	}
+}
+
+func TestParser2_2ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	// can't go back to old sections
+	err := parser.parsePair2_2("SPDXVersion", "SPDX-2.2")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+	err = parser.parsePair2_2("PackageName", "whatever")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+	err = parser.parsePair2_2("FileName", "whatever")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+	err = parser.parsePair2_2("LicenseID", "LicenseRef-Lic22")
+	if err == nil {
+		t.Errorf("expected error when calling parsePair2_2, got nil")
+	}
+}
+
+// ===== Review data section tests =====
+func TestParser2_2CanParseReviewTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	// Reviewer (DEPRECATED)
+	// handled in subsequent subtests
+
+	// Review Date (DEPRECATED)
+	err := parser.parsePairFromReview2_2("ReviewDate", "2018-09-23T08:30:00Z")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rev.ReviewDate != "2018-09-23T08:30:00Z" {
+		t.Errorf("got %v for ReviewDate", parser.rev.ReviewDate)
+	}
+
+	// Review Comment (DEPRECATED)
+	err = parser.parsePairFromReview2_2("ReviewComment", "this is a comment")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rev.ReviewComment != "this is a comment" {
+		t.Errorf("got %v for ReviewComment", parser.rev.ReviewComment)
+	}
+}
+
+func TestParser2_2CanParseReviewerPersonTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	// Reviewer: Person
+	err := parser.parsePairFromReview2_2("Reviewer", "Person: John Doe")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rev.Reviewer != "John Doe" {
+		t.Errorf("got %v for Reviewer", parser.rev.Reviewer)
+	}
+	if parser.rev.ReviewerType != "Person" {
+		t.Errorf("got %v for ReviewerType", parser.rev.ReviewerType)
+	}
+}
+
+func TestParser2_2CanParseReviewerOrganizationTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	// Reviewer: Organization
+	err := parser.parsePairFromReview2_2("Reviewer", "Organization: John Doe, Inc.")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rev.Reviewer != "John Doe, Inc." {
+		t.Errorf("got %v for Reviewer", parser.rev.Reviewer)
+	}
+	if parser.rev.ReviewerType != "Organization" {
+		t.Errorf("got %v for ReviewerType", parser.rev.ReviewerType)
+	}
+}
+
+func TestParser2_2CanParseReviewerToolTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	// Reviewer: Tool
+	err := parser.parsePairFromReview2_2("Reviewer", "Tool: scannertool - 1.2.12")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.rev.Reviewer != "scannertool - 1.2.12" {
+		t.Errorf("got %v for Reviewer", parser.rev.Reviewer)
+	}
+	if parser.rev.ReviewerType != "Tool" {
+		t.Errorf("got %v for ReviewerType", parser.rev.ReviewerType)
+	}
+}
+
+func TestParser2_2FailsIfReviewerInvalidFormat(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psReview2_2,
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	err := parser.parsePairFromReview2_2("Reviewer", "oops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsIfReviewerUnknownType(t *testing.T) {
+	parser := tvParser2_2{
+		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:  psReview2_2,
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	err := parser.parsePairFromReview2_2("Reviewer", "whoops: John Doe")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2ReviewUnknownTagFails(t *testing.T) {
+	parser := tvParser2_2{
+		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:   psReview2_2,
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
+		otherLic: &spdx.OtherLicense2_2{
+			LicenseIdentifier: "LicenseRef-Lic11",
+			LicenseName:       "License 11",
+		},
+		rev: &spdx.Review2_2{},
+	}
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
+	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
+
+	err := parser.parsePairFromReview2_2("blah", "something")
+	if err == nil {
+		t.Errorf("expected error from parsing unknown tag")
+	}
+}
diff --git a/tvloader/parser2v2/parse_snippet.go b/tvloader/parser2v2/parse_snippet.go
new file mode 100644
index 0000000..0d9dc3f
--- /dev/null
+++ b/tvloader/parser2v2/parse_snippet.go
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+func (parser *tvParser2_2) parsePairFromSnippet2_2(tag string, value string) error {
+	switch tag {
+	// tag for creating new snippet section
+	case "SnippetSPDXID":
+		parser.snippet = &spdx.Snippet2_2{}
+		eID, err := extractElementID(value)
+		if err != nil {
+			return err
+		}
+		// FIXME: how should we handle where not associated with current file?
+		if parser.file != nil {
+			if parser.file.Snippets == nil {
+				parser.file.Snippets = map[spdx.ElementID]*spdx.Snippet2_2{}
+			}
+			parser.file.Snippets[eID] = parser.snippet
+		}
+		parser.snippet.SnippetSPDXIdentifier = eID
+	// tag for creating new file section and going back to parsing File
+	case "FileName":
+		parser.st = psFile2_2
+		parser.snippet = nil
+		return parser.parsePairFromFile2_2(tag, value)
+	// tag for creating new package section and going back to parsing Package
+	case "PackageName":
+		parser.st = psPackage2_2
+		parser.file = nil
+		parser.snippet = nil
+		return parser.parsePairFromPackage2_2(tag, value)
+	// tag for going on to other license section
+	case "LicenseID":
+		parser.st = psOtherLicense2_2
+		return parser.parsePairFromOtherLicense2_2(tag, value)
+	// tags for snippet data
+	case "SnippetFromFileSPDXID":
+		deID, err := extractDocElementID(value)
+		if err != nil {
+			return err
+		}
+		parser.snippet.SnippetFromFileSPDXIdentifier = deID
+	case "SnippetByteRange":
+		byteStart, byteEnd, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		bIntStart, err := strconv.Atoi(byteStart)
+		if err != nil {
+			return err
+		}
+		bIntEnd, err := strconv.Atoi(byteEnd)
+		if err != nil {
+			return err
+		}
+		parser.snippet.SnippetByteRangeStart = bIntStart
+		parser.snippet.SnippetByteRangeEnd = bIntEnd
+	case "SnippetLineRange":
+		lineStart, lineEnd, err := extractSubs(value)
+		if err != nil {
+			return err
+		}
+		lInttStart, err := strconv.Atoi(lineStart)
+		if err != nil {
+			return err
+		}
+		lInttEnd, err := strconv.Atoi(lineEnd)
+		if err != nil {
+			return err
+		}
+		parser.snippet.SnippetLineRangeStart = lInttStart
+		parser.snippet.SnippetLineRangeEnd = lInttEnd
+	case "SnippetLicenseConcluded":
+		parser.snippet.SnippetLicenseConcluded = value
+	case "LicenseInfoInSnippet":
+		parser.snippet.LicenseInfoInSnippet = append(parser.snippet.LicenseInfoInSnippet, value)
+	case "SnippetLicenseComments":
+		parser.snippet.SnippetLicenseComments = value
+	case "SnippetCopyrightText":
+		parser.snippet.SnippetCopyrightText = value
+	case "SnippetComment":
+		parser.snippet.SnippetComment = value
+	case "SnippetName":
+		parser.snippet.SnippetName = value
+	case "SnippetAttributionText":
+		parser.snippet.SnippetAttributionTexts = append(parser.snippet.SnippetAttributionTexts, value)
+	// for relationship tags, pass along but don't change state
+	case "Relationship":
+		parser.rln = &spdx.Relationship2_2{}
+		parser.doc.Relationships = append(parser.doc.Relationships, parser.rln)
+		return parser.parsePairForRelationship2_2(tag, value)
+	case "RelationshipComment":
+		return parser.parsePairForRelationship2_2(tag, value)
+	// for annotation tags, pass along but don't change state
+	case "Annotator":
+		parser.ann = &spdx.Annotation2_2{}
+		parser.doc.Annotations = append(parser.doc.Annotations, parser.ann)
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationDate":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationType":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "SPDXREF":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	case "AnnotationComment":
+		return parser.parsePairForAnnotation2_2(tag, value)
+	// tag for going on to review section (DEPRECATED)
+	case "Reviewer":
+		parser.st = psReview2_2
+		return parser.parsePairFromReview2_2(tag, value)
+	default:
+		return fmt.Errorf("received unknown tag %v in Snippet section", tag)
+	}
+
+	return nil
+}
diff --git a/tvloader/parser2v2/parse_snippet_test.go b/tvloader/parser2v2/parse_snippet_test.go
new file mode 100644
index 0000000..987fe2a
--- /dev/null
+++ b/tvloader/parser2v2/parse_snippet_test.go
@@ -0,0 +1,616 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Parser snippet section state change tests =====
+func TestParser2_2SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) {
+	// create the first snippet
+	sid1 := spdx.ElementID("s1")
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: sid1},
+	}
+	s1 := parser.snippet
+	parser.doc.Packages["test"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets[sid1] = parser.snippet
+
+	// the File's Snippets should have this one only
+	if len(parser.file.Snippets) != 1 {
+		t.Errorf("Expected len(Snippets) to be 1, got %d", len(parser.file.Snippets))
+	}
+	if parser.file.Snippets["s1"] != s1 {
+		t.Errorf("Expected snippet %v in Snippets[s1], got %v", s1, parser.file.Snippets["s1"])
+	}
+	if parser.file.Snippets["s1"].SnippetSPDXIdentifier != sid1 {
+		t.Errorf("expected snippet ID %s in Snippets[s1], got %s", sid1, parser.file.Snippets["s1"].SnippetSPDXIdentifier)
+	}
+
+	// now add a new snippet
+	err := parser.parsePair2_2("SnippetSPDXID", "SPDXRef-s2")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psSnippet2_2 {
+		t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st)
+	}
+	// and a snippet should be created
+	if parser.snippet == nil {
+		t.Fatalf("parser didn't create new snippet")
+	}
+	// and the snippet ID should be as expected
+	if parser.snippet.SnippetSPDXIdentifier != "s2" {
+		t.Errorf("expected snippet ID %s, got %s", "s2", parser.snippet.SnippetSPDXIdentifier)
+	}
+	// and the File's Snippets should be of size 2 and have these two
+	if len(parser.file.Snippets) != 2 {
+		t.Errorf("Expected len(Snippets) to be 2, got %d", len(parser.file.Snippets))
+	}
+	if parser.file.Snippets["s1"] != s1 {
+		t.Errorf("Expected snippet %v in Snippets[s1], got %v", s1, parser.file.Snippets["s1"])
+	}
+	if parser.file.Snippets["s1"].SnippetSPDXIdentifier != sid1 {
+		t.Errorf("expected snippet ID %s in Snippets[s1], got %s", sid1, parser.file.Snippets["s1"].SnippetSPDXIdentifier)
+	}
+	if parser.file.Snippets["s2"] != parser.snippet {
+		t.Errorf("Expected snippet %v in Snippets[s2], got %v", parser.snippet, parser.file.Snippets["s2"])
+	}
+	if parser.file.Snippets["s2"].SnippetSPDXIdentifier != "s2" {
+		t.Errorf("expected snippet ID %s in Snippets[s2], got %s", "s2", parser.file.Snippets["s2"].SnippetSPDXIdentifier)
+	}
+}
+
+func TestParser2_2SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	p1 := parser.pkg
+	f1 := parser.file
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets["s1"] = parser.snippet
+
+	// now add a new package
+	p2Name := "package2"
+	err := parser.parsePair2_2("PackageName", p2Name)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should go back to Package
+	if parser.st != psPackage2_2 {
+		t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st)
+	}
+	// and a package should be created
+	if parser.pkg == nil {
+		t.Fatalf("parser didn't create new pkg")
+	}
+	// and the package name should be as expected
+	if parser.pkg.PackageName != p2Name {
+		t.Errorf("expected package name %s, got %s", p2Name, parser.pkg.PackageName)
+	}
+	// and the package should default to true for FilesAnalyzed
+	if parser.pkg.FilesAnalyzed != true {
+		t.Errorf("expected FilesAnalyzed to default to true, got false")
+	}
+	if parser.pkg.IsFilesAnalyzedTagPresent != false {
+		t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true")
+	}
+	// and the Document's Packages should still be of size 1 b/c no SPDX
+	// identifier has been seen yet
+	if len(parser.doc.Packages) != 1 {
+		t.Errorf("Expected len(Packages) to be 1, got %d", len(parser.doc.Packages))
+	}
+	if parser.doc.Packages["package1"] != p1 {
+		t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"])
+	}
+	if parser.doc.Packages["package1"].PackageName != "package1" {
+		t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages["package1"].PackageName)
+	}
+	// and the first Package's Files should be of size 1 and have f1 only
+	if len(parser.doc.Packages["package1"].Files) != 1 {
+		t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files))
+	}
+	if parser.doc.Packages["package1"].Files["f1"] != f1 {
+		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"])
+	}
+	if parser.doc.Packages["package1"].Files["f1"].FileName != "f1.txt" {
+		t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages["package1"].Files["f1"].FileName)
+	}
+	// and the new Package should have no files
+	if len(parser.pkg.Files) != 0 {
+		t.Errorf("Expected no files in Packages[1].Files, got %d", len(parser.pkg.Files))
+	}
+	// and the current file should be nil
+	if parser.file != nil {
+		t.Errorf("Expected nil for parser.file, got %v", parser.file)
+	}
+	// and the current snippet should be nil
+	if parser.snippet != nil {
+		t.Errorf("Expected nil for parser.snippet, got %v", parser.snippet)
+	}
+}
+
+func TestParser2_2SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) {
+	f1Name := "f1.txt"
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	p1 := parser.pkg
+	f1 := parser.file
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets["s1"] = parser.snippet
+
+	f2Name := "f2.txt"
+	err := parser.parsePair2_2("FileName", f2Name)
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should be correct
+	if parser.st != psFile2_2 {
+		t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st)
+	}
+	// and current package should remain what it was
+	if parser.pkg != p1 {
+		t.Fatalf("expected package to remain %v, got %v", p1, parser.pkg)
+	}
+	// and a file should be created
+	if parser.file == nil {
+		t.Fatalf("parser didn't create new file")
+	}
+	// and the file name should be as expected
+	if parser.file.FileName != f2Name {
+		t.Errorf("expected file name %s, got %s", f2Name, parser.file.FileName)
+	}
+	// and the Package's Files should still be of size 1 since we haven't seen
+	// an SPDX identifier yet for this new file
+	if len(parser.pkg.Files) != 1 {
+		t.Errorf("Expected len(Files) to be 1, got %d", len(parser.pkg.Files))
+	}
+	if parser.pkg.Files["f1"] != f1 {
+		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files["f1"])
+	}
+	if parser.pkg.Files["f1"].FileName != f1Name {
+		t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files["f1"].FileName)
+	}
+	// and the current snippet should be nil
+	if parser.snippet != nil {
+		t.Errorf("Expected nil for parser.snippet, got %v", parser.snippet)
+	}
+}
+
+func TestParser2_2SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets["s1"] = parser.snippet
+
+	err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psOtherLicense2_2 {
+		t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st)
+	}
+}
+
+func TestParser2_2SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets["s1"] = parser.snippet
+
+	err := parser.parsePair2_2("Reviewer", "Person: John Doe")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psReview2_2 {
+		t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st)
+	}
+}
+
+func TestParser2_2SnippetStaysAfterParsingRelationshipTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets["s1"] = parser.snippet
+
+	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should remain unchanged
+	if parser.st != psSnippet2_2 {
+		t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st)
+	}
+	// and the relationship should be in the Document's Relationships
+	if len(parser.doc.Relationships) != 1 {
+		t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships))
+	}
+	deID := parser.doc.Relationships[0].RefA
+	if deID.DocumentRefID != "" || deID.ElementRefID != "blah" {
+		t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA)
+	}
+
+	err = parser.parsePair2_2("RelationshipComment", "blah")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	// state should still remain unchanged
+	if parser.st != psSnippet2_2 {
+		t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st)
+	}
+}
+
+func TestParser2_2SnippetStaysAfterParsingAnnotationTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+	parser.file.Snippets["s1"] = parser.snippet
+
+	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psSnippet2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psSnippet2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationType", "REVIEW")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psSnippet2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2)
+	}
+
+	err = parser.parsePair2_2("SPDXREF", "SPDXRef-45")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psSnippet2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2)
+	}
+
+	err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psSnippet2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2)
+	}
+
+	// and the annotation should be in the Document's Annotations
+	if len(parser.doc.Annotations) != 1 {
+		t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations))
+	}
+	if parser.doc.Annotations[0].Annotator != "John Doe ()" {
+		t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator)
+	}
+}
+
+// ===== Snippet data section tests =====
+func TestParser2_2CanParseSnippetTags(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	// Snippet SPDX Identifier
+	err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetSPDXIdentifier != "s1" {
+		t.Errorf("got %v for SnippetSPDXIdentifier", parser.snippet.SnippetSPDXIdentifier)
+	}
+
+	// Snippet from File SPDX Identifier
+	err = parser.parsePairFromSnippet2_2("SnippetFromFileSPDXID", "SPDXRef-f1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	wantDeID := spdx.DocElementID{DocumentRefID: "", ElementRefID: spdx.ElementID("f1")}
+	if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID {
+		t.Errorf("got %v for SnippetFromFileSPDXIdentifier", parser.snippet.SnippetFromFileSPDXIdentifier)
+	}
+
+	// Snippet Byte Range
+	err = parser.parsePairFromSnippet2_2("SnippetByteRange", "20:320")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetByteRangeStart != 20 {
+		t.Errorf("got %v for SnippetByteRangeStart", parser.snippet.SnippetByteRangeStart)
+	}
+	if parser.snippet.SnippetByteRangeEnd != 320 {
+		t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.SnippetByteRangeEnd)
+	}
+
+	// Snippet Line Range
+	err = parser.parsePairFromSnippet2_2("SnippetLineRange", "5:12")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetLineRangeStart != 5 {
+		t.Errorf("got %v for SnippetLineRangeStart", parser.snippet.SnippetLineRangeStart)
+	}
+	if parser.snippet.SnippetLineRangeEnd != 12 {
+		t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.SnippetLineRangeEnd)
+	}
+
+	// Snippet Concluded License
+	err = parser.parsePairFromSnippet2_2("SnippetLicenseConcluded", "BSD-3-Clause")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetLicenseConcluded != "BSD-3-Clause" {
+		t.Errorf("got %v for SnippetLicenseConcluded", parser.snippet.SnippetLicenseConcluded)
+	}
+
+	// License Information in Snippet
+	lics := []string{
+		"Apache-2.0",
+		"GPL-2.0-or-later",
+		"CC0-1.0",
+	}
+	for _, lic := range lics {
+		err = parser.parsePairFromSnippet2_2("LicenseInfoInSnippet", lic)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, licWant := range lics {
+		flagFound := false
+		for _, licCheck := range parser.snippet.LicenseInfoInSnippet {
+			if licWant == licCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in LicenseInfoInSnippet", licWant)
+		}
+	}
+	if len(lics) != len(parser.snippet.LicenseInfoInSnippet) {
+		t.Errorf("expected %d licenses in LicenseInfoInSnippet, got %d", len(lics),
+			len(parser.snippet.LicenseInfoInSnippet))
+	}
+
+	// Snippet Comments on License
+	err = parser.parsePairFromSnippet2_2("SnippetLicenseComments", "this is a comment about the licenses")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetLicenseComments != "this is a comment about the licenses" {
+		t.Errorf("got %v for SnippetLicenseComments", parser.snippet.SnippetLicenseComments)
+	}
+
+	// Snippet Copyright Text
+	err = parser.parsePairFromSnippet2_2("SnippetCopyrightText", "copyright (c) John Doe and friends")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetCopyrightText != "copyright (c) John Doe and friends" {
+		t.Errorf("got %v for SnippetCopyrightText", parser.snippet.SnippetCopyrightText)
+	}
+
+	// Snippet Comment
+	err = parser.parsePairFromSnippet2_2("SnippetComment", "this is a comment about the snippet")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetComment != "this is a comment about the snippet" {
+		t.Errorf("got %v for SnippetComment", parser.snippet.SnippetComment)
+	}
+
+	// Snippet Name
+	err = parser.parsePairFromSnippet2_2("SnippetName", "from some other package called abc")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	if parser.snippet.SnippetName != "from some other package called abc" {
+		t.Errorf("got %v for SnippetName", parser.snippet.SnippetName)
+	}
+
+	// Snippet Attribution Texts
+	attrs := []string{
+		"Include this notice in all advertising materials",
+		"This is a \nmulti-line string",
+	}
+	for _, attr := range attrs {
+		err = parser.parsePairFromSnippet2_2("SnippetAttributionText", attr)
+		if err != nil {
+			t.Errorf("expected nil error, got %v", err)
+		}
+	}
+	for _, attrWant := range attrs {
+		flagFound := false
+		for _, attrCheck := range parser.snippet.SnippetAttributionTexts {
+			if attrWant == attrCheck {
+				flagFound = true
+			}
+		}
+		if flagFound == false {
+			t.Errorf("didn't find %s in SnippetAttributionText", attrWant)
+		}
+	}
+	if len(attrs) != len(parser.snippet.SnippetAttributionTexts) {
+		t.Errorf("expected %d attribution texts in SnippetAttributionTexts, got %d", len(attrs),
+			len(parser.snippet.SnippetAttributionTexts))
+	}
+
+}
+
+func TestParser2_2SnippetUnknownTagFails(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	err := parser.parsePairFromSnippet2_2("blah", "something")
+	if err == nil {
+		t.Errorf("expected error from parsing unknown tag")
+	}
+}
+
+func TestParser2_2FailsForInvalidSnippetSPDXID(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	// invalid Snippet SPDX Identifier
+	err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsForInvalidSnippetFromFileSPDXID(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	// start with Snippet SPDX Identifier
+	err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid From File identifier
+	err = parser.parsePairFromSnippet2_2("SnippetFromFileSPDXID", "whoops")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsForInvalidSnippetByteValues(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	// start with Snippet SPDX Identifier
+	err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid byte formats and values
+	err = parser.parsePairFromSnippet2_2("SnippetByteRange", "200 210")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+	err = parser.parsePairFromSnippet2_2("SnippetByteRange", "a:210")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+	err = parser.parsePairFromSnippet2_2("SnippetByteRange", "200:a")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
+
+func TestParser2_2FailsForInvalidSnippetLineValues(t *testing.T) {
+	parser := tvParser2_2{
+		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		st:      psSnippet2_2,
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
+		snippet: &spdx.Snippet2_2{},
+	}
+	parser.doc.Packages["package1"] = parser.pkg
+	parser.pkg.Files["f1"] = parser.file
+
+	// start with Snippet SPDX Identifier
+	err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1")
+	if err != nil {
+		t.Errorf("expected nil error, got %v", err)
+	}
+	// invalid byte formats and values
+	err = parser.parsePairFromSnippet2_2("SnippetLineRange", "200 210")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+	err = parser.parsePairFromSnippet2_2("SnippetLineRange", "a:210")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+	err = parser.parsePairFromSnippet2_2("SnippetLineRange", "200:a")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
diff --git a/tvloader/parser2v2/parser.go b/tvloader/parser2v2/parser.go
new file mode 100644
index 0000000..e89bab1
--- /dev/null
+++ b/tvloader/parser2v2/parser.go
@@ -0,0 +1,64 @@
+// Package parser2v2 contains functions to read, load and parse
+// SPDX tag-value files, version 2.2.
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"fmt"
+
+	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/tvloader/reader"
+)
+
+// ParseTagValues takes a list of (tag, value) pairs, parses it and returns
+// a pointer to a parsed SPDX Document.
+func ParseTagValues(tvs []reader.TagValuePair) (*spdx.Document2_2, error) {
+	parser := tvParser2_2{}
+	for _, tv := range tvs {
+		err := parser.parsePair2_2(tv.Tag, tv.Value)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return parser.doc, nil
+}
+
+func (parser *tvParser2_2) parsePair2_2(tag string, value string) error {
+	switch parser.st {
+	case psStart2_2:
+		return parser.parsePairFromStart2_2(tag, value)
+	case psCreationInfo2_2:
+		return parser.parsePairFromCreationInfo2_2(tag, value)
+	case psPackage2_2:
+		return parser.parsePairFromPackage2_2(tag, value)
+	case psFile2_2:
+		return parser.parsePairFromFile2_2(tag, value)
+	case psSnippet2_2:
+		return parser.parsePairFromSnippet2_2(tag, value)
+	case psOtherLicense2_2:
+		return parser.parsePairFromOtherLicense2_2(tag, value)
+	case psReview2_2:
+		return parser.parsePairFromReview2_2(tag, value)
+	default:
+		return fmt.Errorf("Parser state %v not recognized when parsing (%s, %s)", parser.st, tag, value)
+	}
+}
+
+func (parser *tvParser2_2) parsePairFromStart2_2(tag string, value string) error {
+	// fail if not in Start parser state
+	if parser.st != psStart2_2 {
+		return fmt.Errorf("Got invalid state %v in parsePairFromStart2_2", parser.st)
+	}
+
+	// create an SPDX Document data struct if we don't have one already
+	if parser.doc == nil {
+		parser.doc = &spdx.Document2_2{}
+	}
+
+	// move to Creation Info parser state
+	parser.st = psCreationInfo2_2
+
+	// and ask Creation Info subfunc to parse
+	return parser.parsePairFromCreationInfo2_2(tag, value)
+}
diff --git a/tvloader/parser2v2/parser_test.go b/tvloader/parser2v2/parser_test.go
new file mode 100644
index 0000000..a2de032
--- /dev/null
+++ b/tvloader/parser2v2/parser_test.go
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/tvloader/reader"
+)
+
+// ===== Parser exported entry point tests =====
+func TestParser2_2CanParseTagValues(t *testing.T) {
+	var tvPairs []reader.TagValuePair
+
+	// create some pairs
+	tvPair1 := reader.TagValuePair{Tag: "SPDXVersion", Value: "SPDX-2.2"}
+	tvPairs = append(tvPairs, tvPair1)
+	tvPair2 := reader.TagValuePair{Tag: "DataLicense", Value: "CC0-1.0"}
+	tvPairs = append(tvPairs, tvPair2)
+	tvPair3 := reader.TagValuePair{Tag: "SPDXID", Value: "SPDXRef-DOCUMENT"}
+	tvPairs = append(tvPairs, tvPair3)
+
+	// now parse them
+	doc, err := ParseTagValues(tvPairs)
+	if err != nil {
+		t.Errorf("got error when calling ParseTagValues: %v", err)
+	}
+	if doc.CreationInfo.SPDXVersion != "SPDX-2.2" {
+		t.Errorf("expected SPDXVersion to be SPDX-2.2, got %v", doc.CreationInfo.SPDXVersion)
+	}
+	if doc.CreationInfo.DataLicense != "CC0-1.0" {
+		t.Errorf("expected DataLicense to be CC0-1.0, got %v", doc.CreationInfo.DataLicense)
+	}
+	if doc.CreationInfo.SPDXIdentifier != "SPDXRef-DOCUMENT" {
+		t.Errorf("expected SPDXIdentifier to be SPDXRef-DOCUMENT, got %v", doc.CreationInfo.SPDXIdentifier)
+	}
+
+}
+
+// ===== Parser initialization tests =====
+func TestParser2_2InitCreatesResetStatus(t *testing.T) {
+	parser := tvParser2_2{}
+	if parser.st != psStart2_2 {
+		t.Errorf("parser did not begin in start state")
+	}
+	if parser.doc != nil {
+		t.Errorf("parser did not begin with nil document")
+	}
+}
+
+func TestParser2_2HasDocumentAfterCallToParseFirstTag(t *testing.T) {
+	parser := tvParser2_2{}
+	err := parser.parsePair2_2("SPDXVersion", "SPDX-2.2")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.doc == nil {
+		t.Errorf("doc is still nil after parsing first pair")
+	}
+}
+
+// ===== Parser start state change tests =====
+func TestParser2_2StartMovesToCreationInfoStateAfterParsingFirstTag(t *testing.T) {
+	parser := tvParser2_2{}
+	err := parser.parsePair2_2("SPDXVersion", "b")
+	if err != nil {
+		t.Errorf("got error when calling parsePair2_2: %v", err)
+	}
+	if parser.st != psCreationInfo2_2 {
+		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
+	}
+}
+
+func TestParser2_2StartFailsToParseIfInInvalidState(t *testing.T) {
+	parser := tvParser2_2{st: psReview2_2}
+	err := parser.parsePairFromStart2_2("SPDXVersion", "SPDX-2.2")
+	if err == nil {
+		t.Errorf("expected non-nil error, got nil")
+	}
+}
diff --git a/tvloader/parser2v2/types.go b/tvloader/parser2v2/types.go
new file mode 100644
index 0000000..6039a1c
--- /dev/null
+++ b/tvloader/parser2v2/types.go
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"github.com/spdx/tools-golang/spdx"
+)
+
+type tvParser2_2 struct {
+	// document into which data is being parsed
+	doc *spdx.Document2_2
+
+	// current parser state
+	st tvParserState2_2
+
+	// current SPDX item being filled in, if any
+	pkg       *spdx.Package2_2
+	pkgExtRef *spdx.PackageExternalReference2_2
+	file      *spdx.File2_2
+	fileAOP   *spdx.ArtifactOfProject2_2
+	snippet   *spdx.Snippet2_2
+	otherLic  *spdx.OtherLicense2_2
+	rln       *spdx.Relationship2_2
+	ann       *spdx.Annotation2_2
+	rev       *spdx.Review2_2
+	// don't need creation info pointer b/c only one,
+	// and we can get to it via doc.CreationInfo
+}
+
+// parser state (SPDX document version 2.2)
+type tvParserState2_2 int
+
+const (
+	// at beginning of document
+	psStart2_2 tvParserState2_2 = iota
+
+	// in document creation info section
+	psCreationInfo2_2
+
+	// in package data section
+	psPackage2_2
+
+	// in file data section (including "unpackaged" files)
+	psFile2_2
+
+	// in snippet data section (including "unpackaged" files)
+	psSnippet2_2
+
+	// in other license section
+	psOtherLicense2_2
+
+	// in review section
+	psReview2_2
+)
diff --git a/tvloader/parser2v2/util.go b/tvloader/parser2v2/util.go
new file mode 100644
index 0000000..691fe4e
--- /dev/null
+++ b/tvloader/parser2v2/util.go
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+package parser2v2
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// used to extract key / value from embedded substrings
+// returns subkey, subvalue, nil if no error, or "", "", error otherwise
+func extractSubs(value string) (string, string, error) {
+	// parse the value to see if it's a valid subvalue format
+	sp := strings.SplitN(value, ":", 2)
+	if len(sp) == 1 {
+		return "", "", fmt.Errorf("invalid subvalue format for %s (no colon found)", value)
+	}
+
+	subkey := strings.TrimSpace(sp[0])
+	subvalue := strings.TrimSpace(sp[1])
+
+	return subkey, subvalue, nil
+}
+
+// used to extract DocumentRef and SPDXRef values from an SPDX Identifier
+// which can point either to this document or to a different one
+func extractDocElementID(value string) (spdx.DocElementID, error) {
+	docRefID := ""
+	idStr := value
+
+	// check prefix to see if it's a DocumentRef ID
+	if strings.HasPrefix(idStr, "DocumentRef-") {
+		// extract the part that comes between "DocumentRef-" and ":"
+		strs := strings.Split(idStr, ":")
+		// should be exactly two, part before and part after
+		if len(strs) < 2 {
+			return spdx.DocElementID{}, fmt.Errorf("no colon found although DocumentRef- prefix present")
+		}
+		if len(strs) > 2 {
+			return spdx.DocElementID{}, fmt.Errorf("more than one colon found")
+		}
+
+		// trim the prefix and confirm non-empty
+		docRefID = strings.TrimPrefix(strs[0], "DocumentRef-")
+		if docRefID == "" {
+			return spdx.DocElementID{}, fmt.Errorf("document identifier has nothing after prefix")
+		}
+		// and use remainder for element ID parsing
+		idStr = strs[1]
+	}
+
+	// check prefix to confirm it's got the right prefix for element IDs
+	if !strings.HasPrefix(idStr, "SPDXRef-") {
+		return spdx.DocElementID{}, fmt.Errorf("missing SPDXRef- prefix for element identifier")
+	}
+
+	// make sure no colons are present
+	if strings.Contains(idStr, ":") {
+		// we know this means there was no DocumentRef- prefix, because
+		// we would have handled multiple colons above if it was
+		return spdx.DocElementID{}, fmt.Errorf("invalid colon in element identifier")
+	}
+
+	// trim the prefix and confirm non-empty
+	eltRefID := strings.TrimPrefix(idStr, "SPDXRef-")
+	if eltRefID == "" {
+		return spdx.DocElementID{}, fmt.Errorf("element identifier has nothing after prefix")
+	}
+
+	// we're good
+	return spdx.DocElementID{DocumentRefID: docRefID, ElementRefID: spdx.ElementID(eltRefID)}, nil
+}
+
+// used to extract SPDXRef values only from an SPDX Identifier which can point
+// to this document only. Use extractDocElementID for parsing IDs that can
+// refer either to this document or a different one.
+func extractElementID(value string) (spdx.ElementID, error) {
+	// check prefix to confirm it's got the right prefix for element IDs
+	if !strings.HasPrefix(value, "SPDXRef-") {
+		return spdx.ElementID(""), fmt.Errorf("missing SPDXRef- prefix for element identifier")
+	}
+
+	// make sure no colons are present
+	if strings.Contains(value, ":") {
+		return spdx.ElementID(""), fmt.Errorf("invalid colon in element identifier")
+	}
+
+	// trim the prefix and confirm non-empty
+	eltRefID := strings.TrimPrefix(value, "SPDXRef-")
+	if eltRefID == "" {
+		return spdx.ElementID(""), fmt.Errorf("element identifier has nothing after prefix")
+	}
+
+	// we're good
+	return spdx.ElementID(eltRefID), nil
+}
diff --git a/tvloader/parser2v2/util_test.go b/tvloader/parser2v2/util_test.go
new file mode 100644
index 0000000..9f63364
--- /dev/null
+++ b/tvloader/parser2v2/util_test.go
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+package parser2v2
+
+import (
+	"testing"
+
+	"github.com/spdx/tools-golang/spdx"
+)
+
+// ===== Helper function tests =====
+
+func TestCanExtractSubvalues(t *testing.T) {
+	subkey, subvalue, err := extractSubs("SHA1: abc123")
+	if err != nil {
+		t.Errorf("got error when calling extractSubs: %v", err)
+	}
+	if subkey != "SHA1" {
+		t.Errorf("got %v for subkey", subkey)
+	}
+	if subvalue != "abc123" {
+		t.Errorf("got %v for subvalue", subvalue)
+	}
+}
+
+func TestReturnsErrorForInvalidSubvalueFormat(t *testing.T) {
+	_, _, err := extractSubs("blah")
+	if err == nil {
+		t.Errorf("expected error when calling extractSubs for invalid format (0 colons), got nil")
+	}
+}
+
+func TestCanExtractDocumentAndElementRefsFromID(t *testing.T) {
+	// test with valid ID in this document
+	helperForExtractDocElementID(t, "SPDXRef-file1", false, "", "file1")
+	// test with valid ID in another document
+	helperForExtractDocElementID(t, "DocumentRef-doc2:SPDXRef-file2", false, "doc2", "file2")
+	// test with invalid ID in this document
+	helperForExtractDocElementID(t, "a:SPDXRef-file1", true, "", "")
+	helperForExtractDocElementID(t, "file1", true, "", "")
+	helperForExtractDocElementID(t, "SPDXRef-", true, "", "")
+	helperForExtractDocElementID(t, "SPDXRef-file1:", true, "", "")
+	// test with invalid ID in another document
+	helperForExtractDocElementID(t, "DocumentRef-doc2", true, "", "")
+	helperForExtractDocElementID(t, "DocumentRef-doc2:", true, "", "")
+	helperForExtractDocElementID(t, "DocumentRef-doc2:SPDXRef-", true, "", "")
+	helperForExtractDocElementID(t, "DocumentRef-doc2:a", true, "", "")
+	helperForExtractDocElementID(t, "DocumentRef-:", true, "", "")
+	helperForExtractDocElementID(t, "DocumentRef-:SPDXRef-file1", true, "", "")
+	// test with invalid formats
+	helperForExtractDocElementID(t, "DocumentRef-doc2:SPDXRef-file1:file2", true, "", "")
+}
+
+func helperForExtractDocElementID(t *testing.T, tst string, wantErr bool, wantDoc string, wantElt string) {
+	deID, err := extractDocElementID(tst)
+	if err != nil && wantErr == false {
+		t.Errorf("testing %v: expected nil error, got %v", tst, err)
+	}
+	if err == nil && wantErr == true {
+		t.Errorf("testing %v: expected non-nil error, got nil", tst)
+	}
+	if deID.DocumentRefID != wantDoc {
+		if wantDoc == "" {
+			t.Errorf("testing %v: want empty string for DocumentRefID, got %v", tst, deID.DocumentRefID)
+		} else {
+			t.Errorf("testing %v: want %v for DocumentRefID, got %v", tst, wantDoc, deID.DocumentRefID)
+		}
+	}
+	if deID.ElementRefID != spdx.ElementID(wantElt) {
+		if wantElt == "" {
+			t.Errorf("testing %v: want emptyString for ElementRefID, got %v", tst, deID.ElementRefID)
+		} else {
+			t.Errorf("testing %v: want %v for ElementRefID, got %v", tst, wantElt, deID.ElementRefID)
+		}
+	}
+}
+
+func TestCanExtractElementRefsOnlyFromID(t *testing.T) {
+	// test with valid ID in this document
+	helperForExtractElementID(t, "SPDXRef-file1", false, "file1")
+	// test with valid ID in another document
+	helperForExtractElementID(t, "DocumentRef-doc2:SPDXRef-file2", true, "")
+	// test with invalid ID in this document
+	helperForExtractElementID(t, "a:SPDXRef-file1", true, "")
+	helperForExtractElementID(t, "file1", true, "")
+	helperForExtractElementID(t, "SPDXRef-", true, "")
+	helperForExtractElementID(t, "SPDXRef-file1:", true, "")
+	// test with invalid ID in another document
+	helperForExtractElementID(t, "DocumentRef-doc2", true, "")
+	helperForExtractElementID(t, "DocumentRef-doc2:", true, "")
+	helperForExtractElementID(t, "DocumentRef-doc2:SPDXRef-", true, "")
+	helperForExtractElementID(t, "DocumentRef-doc2:a", true, "")
+	helperForExtractElementID(t, "DocumentRef-:", true, "")
+	helperForExtractElementID(t, "DocumentRef-:SPDXRef-file1", true, "")
+}
+
+func helperForExtractElementID(t *testing.T, tst string, wantErr bool, wantElt string) {
+	eID, err := extractElementID(tst)
+	if err != nil && wantErr == false {
+		t.Errorf("testing %v: expected nil error, got %v", tst, err)
+	}
+	if err == nil && wantErr == true {
+		t.Errorf("testing %v: expected non-nil error, got nil", tst)
+	}
+	if eID != spdx.ElementID(wantElt) {
+		if wantElt == "" {
+			t.Errorf("testing %v: want emptyString for ElementRefID, got %v", tst, eID)
+		} else {
+			t.Errorf("testing %v: want %v for ElementRefID, got %v", tst, wantElt, eID)
+		}
+	}
+}
diff --git a/tvloader/tvloader.go b/tvloader/tvloader.go
index d24c174..4ad95b1 100644
--- a/tvloader/tvloader.go
+++ b/tvloader/tvloader.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/spdx/tools-golang/spdx"
 	"github.com/spdx/tools-golang/tvloader/parser2v1"
+	"github.com/spdx/tools-golang/tvloader/parser2v2"
 	"github.com/spdx/tools-golang/tvloader/reader"
 )
 
@@ -26,3 +27,19 @@ func Load2_1(content io.Reader) (*spdx.Document2_1, error) {
 
 	return doc, nil
 }
+
+// Load2_2 takes an io.Reader and returns a fully-parsed SPDX Document
+// (version 2.2) if parseable, or error if any error is encountered.
+func Load2_2(content io.Reader) (*spdx.Document2_2, error) {
+	tvPairs, err := reader.ReadTagValues(content)
+	if err != nil {
+		return nil, err
+	}
+
+	doc, err := parser2v2.ParseTagValues(tvPairs)
+	if err != nil {
+		return nil, err
+	}
+
+	return doc, nil
+}