Repository: moov-io/ach
Pull request #168 (2018-04-18 18:14:08)

# 164 Remove AddendaParam 
#164  Remove Param functionality 


Patch:
diff --git a/README.md b/README.md
index 58d1d2cb..0c61fa2a 100644
--- a/README.md
+++ b/README.md
@@ -50,14 +50,14 @@ if achFile.Validate(); err != nil {
 // Check if any Notifications Of Change exist in the file 
 if len(achFile.NotificationOfChange) > 0 {
 	for _, batch := range achFile.NotificationOfChange {
-		aNOC := batch.GetEntries()[0].Addendum[0].(*AddendaNOC)
-		println(aNOC.CorrectedData)
+		a98 := batch.GetEntries()[0].Addendum[0].(*Addenda98)
+		println(a98.CorrectedData)
 	} 
 } 
 // Check if any Return Entries exist in the file 
 if len(achFile.ReturnEntries) > 0 {
 	for _, batch := range achFile.ReturnEntries {
-		aReturn := batch.GetEntries()[0].Addendum[0].(*AddendaReturn)
+		aReturn := batch.GetEntries()[0].Addendum[0].(*Addenda99)
 		println(aReturn.ReturnCode)
 	} 
 }
@@ -134,8 +134,12 @@ entry.Category = ach.CategoryForward
 To add one or more optional addenda records for an entry
 
  ```go
-addenda := ach.NewAddenda(ach.AddendaParam{
-	PaymentRelatedInfo: "bonus pay for amazing work on #OSS"})
+addenda := NewAddenda05()
+addenda.PaymentRelatedInformation = "Bonus pay for amazing work on #OSS"
+```
+Add the addenda record to the detail entry 
+
+ ```go
 entry.AddAddenda(addenda)
 ```
 
@@ -159,7 +163,7 @@ And batches are added to files much the same way:
 file.AddBatch(batch)
 ```
 
-Now add a new batch for accepting payments on the web
+Now add a new batch for accepting payments on the WEB
 
 ```go
 func mockBatchWEBHeader() *BatchHeader {
@@ -190,8 +194,9 @@ entry2.IdentificationNumber = "#123456"
 entry.DiscretionaryData = "R"
 entry2.Category = ach.CategoryForward
 
-addenda2 := ach.NewAddenda(ach.AddendaParam{
-	PaymentRelatedInfo: "Monthly Membership Subscription"})
+
+addenda2 := NewAddenda05()
+addenda2.PaymentRelatedInformation = "Monthly Membership Subscription"
 ```
 
 Add the entry to the batch
diff --git a/addenda.go b/addenda.go
deleted file mode 100644
index 56afa50c..00000000
--- a/addenda.go
+++ /dev/null
@@ -1,166 +0,0 @@
-package ach
-
-import (
-	"fmt"
-	"strings"
-)
-
-// Addenda provides business transaction information in a machine
-// readable format. It is usually formatted according to ANSI, ASC, X12 Standard
-type Addenda struct {
-	// RecordType defines the type of record in the block. entryAddendaPos 7
-	recordType string
-	// TypeCode Addenda types code '05'
-	typeCode string
-	// PaymentRelatedInformation
-	PaymentRelatedInformation string
-	// SequenceNumber is consecutively assigned to each Addenda Record following
-	// an Entry Detail Record. The first addenda sequence number must always
-	// be a "1".
-	SequenceNumber int
-	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
-	// Detail or Corporate Entry Detail Record's trace number This number is
-	// the same as the last seven digits of the trace number of the related
-	// Entry Detail Record or Corporate Entry Detail Record.
-	EntryDetailSequenceNumber int
-	// validator is composed for data validation
-	validator
-	// converters is composed for ACH to GoLang Converters
-	converters
-}
-
-// AddendaParam is the minimal fields required to make a ach addenda
-type AddendaParam struct {
-	TypeCode           string `json:"type_code,omitempty"`
-	PaymentRelatedInfo string `json:"payment_related_info,omitempty"`
-	TraceNumber        string `json:"trace_number,omitempty"`
-	// Following Fields are used for Return addenda
-	ReturnCode    string `json:"return_code,omitempty"`
-	OriginalTrace string `json:"original_trace,omitempty"`
-	AddendaInfo   string `json:"addenda_info,omitempty"`
-	OriginalDFI   string `json:"original_dfi,omitempty"`
-	// Following fields are used for NOC(notification of change) addenda w/ return fields
-	ChangeCode    string `json:"change_code,omitempty"`
-	CorrectedData string `json:"corrected_data,omitempty"`
-}
-
-// NewAddenda returns a new Addenda with default values for none exported fields
-// TypeCode in AddendaParam for none ACK, ATX, CCD, CIE, CTX, DNE, ENR, PPD, TRX and WEB Entries
-func NewAddenda(params ...AddendaParam) (Addendumer, error) {
-	if (len(params)) > 0 {
-		// most common use case is 05 ACK, ATX, CCD, CIE, CTX, DNE, ENR, PPD, TRX and WEB Entries
-		if params[0].TypeCode == "" {
-			params[0].TypeCode = "05"
-		}
-		switch typeCode := params[0].TypeCode; typeCode {
-		case "05":
-			addenda := Addenda{
-				recordType:                "7",
-				typeCode:                  "05",
-				SequenceNumber:            1,
-				EntryDetailSequenceNumber: 1,
-			}
-			addenda.PaymentRelatedInformation = params[0].PaymentRelatedInfo
-			return &addenda, nil
-		case "98":
-			return NewAddendaNOC(params[0]), nil
-		case "99":
-			return NewAddendaReturn(params[0]), nil
-		default:
-			msg := fmt.Sprintf("Addenda Type Code %v is not supported", typeCode)
-			return nil, &FileError{FieldName: "TypeCode", Msg: msg}
-		}
-	}
-	// TODO think about renaming Addenda to something for its TypeCode NewAddenda05
-	addenda := Addenda{
-		recordType:                "7",
-		typeCode:                  "05",
-		SequenceNumber:            1,
-		EntryDetailSequenceNumber: 1,
-	}
-	return &addenda, nil
-
-}
-
-// Parse takes the input record string and parses the Addenda values
-func (addenda *Addenda) Parse(record string) {
-	// 1-1 Always "7"
-	addenda.recordType = "7"
-	// 2-3 Defines the specific explanation and format for the addenda information contained in the same record
-	addenda.typeCode = record[1:3]
-	// 4-83 Based on the information entered (04-83) 80 alphanumeric
-	addenda.PaymentRelatedInformation = strings.TrimSpace(record[3:83])
-	// 84-87 SequenceNumber is consecutively assigned to each Addenda Record following
-	// an Entry Detail Record
-	addenda.SequenceNumber = addenda.parseNumField(record[83:87])
-	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
-	addenda.EntryDetailSequenceNumber = addenda.parseNumField(record[87:94])
-}
-
-// String writes the Addenda struct to a 94 character string.
-func (addenda *Addenda) String() string {
-	return fmt.Sprintf("%v%v%v%v%v",
-		addenda.recordType,
-		addenda.typeCode,
-		addenda.PaymentRelatedInformationField(),
-		addenda.SequenceNumberField(),
-		addenda.EntryDetailSequenceNumberField())
-}
-
-// Validate performs NACHA format rule checks on the record and returns an error if not Validated
-// The first error encountered is returned and stops that parsing.
-func (addenda *Addenda) Validate() error {
-	if err := addenda.fieldInclusion(); err != nil {
-		return err
-	}
-	if addenda.recordType != "7" {
-		msg := fmt.Sprintf(msgRecordType, 7)
-		return &FieldError{FieldName: "recordType", Value: addenda.recordType, Msg: msg}
-	}
-	if err := addenda.isTypeCode(addenda.typeCode); err != nil {
-		return &FieldError{FieldName: "TypeCode", Value: addenda.typeCode, Msg: err.Error()}
-	}
-	if err := addenda.isAlphanumeric(addenda.PaymentRelatedInformation); err != nil {
-		return &FieldError{FieldName: "PaymentRelatedInformation", Value: addenda.PaymentRelatedInformation, Msg: err.Error()}
-	}
-
-	return nil
-}
-
-// fieldInclusion validate mandatory fields are not default values. If fields are
-// invalid the ACH transfer will be returned.
-func (addenda *Addenda) fieldInclusion() error {
-	if addenda.recordType == "" {
-		return &FieldError{FieldName: "recordType", Value: addenda.recordType, Msg: msgFieldInclusion}
-	}
-	if addenda.typeCode == "" {
-		return &FieldError{FieldName: "TypeCode", Value: addenda.typeCode, Msg: msgFieldInclusion}
-	}
-	if addenda.SequenceNumber == 0 {
-		return &FieldError{FieldName: "SequenceNumber", Value: addenda.SequenceNumberField(), Msg: msgFieldInclusion}
-	}
-	if addenda.EntryDetailSequenceNumber == 0 {
-		return &FieldError{FieldName: "EntryDetailSequenceNumber", Value: addenda.EntryDetailSequenceNumberField(), Msg: msgFieldInclusion}
-	}
-	return nil
-}
-
-// PaymentRelatedInformationField returns a zero padded PaymentRelatedInformation string
-func (addenda *Addenda) PaymentRelatedInformationField() string {
-	return addenda.alphaField(addenda.PaymentRelatedInformation, 80)
-}
-
-// SequenceNumberField returns a zero padded SequenceNumber string
-func (addenda *Addenda) SequenceNumberField() string {
-	return addenda.numericField(addenda.SequenceNumber, 4)
-}
-
-// EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
-func (addenda *Addenda) EntryDetailSequenceNumberField() string {
-	return addenda.numericField(addenda.EntryDetailSequenceNumber, 7)
-}
-
-// TypeCode Defines the specific explanation and format for the addenda information
-func (addenda *Addenda) TypeCode() string {
-	return addenda.typeCode
-}
diff --git a/addenda05.go b/addenda05.go
new file mode 100644
index 00000000..9ff3191d
--- /dev/null
+++ b/addenda05.go
@@ -0,0 +1,131 @@
+package ach
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Addenda05 is a Addendumer addenda which provides business transaction information for Addenda Type
+// Code 05 in a machine readable format. It is usually formatted according to ANSI, ASC, X12 Standard.
+// Future development to allow for use case specific 05 addenda records.
+
+type Addenda05 struct {
+	// RecordType defines the type of record in the block. entryAddenda05 Pos 7
+	recordType string
+	// TypeCode Addenda05 types code '05'
+	typeCode string
+	// PaymentRelatedInformation
+	PaymentRelatedInformation string
+	// SequenceNumber is consecutively assigned to each Addenda05 Record following
+	// an Entry Detail Record. The first addenda05 sequence number must always
+	// be a "1".
+	SequenceNumber int
+	// EntryDetailSequenceNumber contains the ascending sequence number section of the Entry
+	// Detail or Corporate Entry Detail Record's trace number This number is
+	// the same as the last seven digits of the trace number of the related
+	// Entry Detail Record or Corporate Entry Detail Record.
+	EntryDetailSequenceNumber int
+	// validator is composed for data validation
+	validator
+	// converters is composed for ACH to GoLang Converters
+	converters
+}
+
+// NewAddenda05 returns a new Addenda05 with default values for none exported fields
+
+func NewAddenda05() *Addenda05 {
+	addenda05 := new(Addenda05)
+	addenda05.recordType = "7"
+	addenda05.typeCode = "05"
+	return addenda05
+}
+
+// Parse takes the input record string and parses the Addenda05 values
+func (addenda05 *Addenda05) Parse(record string) {
+	// 1-1 Always "7"
+	addenda05.recordType = "7"
+	// 2-3 Always 05
+	addenda05.typeCode = record[1:3]
+	// 4-83 Based on the information entered (04-83) 80 alphanumeric
+	addenda05.PaymentRelatedInformation = strings.TrimSpace(record[3:83])
+	// 84-87 SequenceNumber is consecutively assigned to each Addenda05 Record following
+	// an Entry Detail Record
+	addenda05.SequenceNumber = addenda05.parseNumField(record[83:87])
+	// 88-94 Contains the last seven digits of the number entered in the Trace Number field in the corresponding Entry Detail Record
+	addenda05.EntryDetailSequenceNumber = addenda05.parseNumField(record[87:94])
+}
+
+// String writes the Addenda05 struct to a 94 character string.
+func (addenda05 *Addenda05) String() string {
+	return fmt.Sprintf("%v%v%v%v%v",
+		addenda05.recordType,
+		addenda05.typeCode,
+		addenda05.PaymentRelatedInformationField(),
+		addenda05.SequenceNumberField(),
+		addenda05.EntryDetailSequenceNumberField())
+}
+
+// SetPaymentRealtedInformation
+func (addenda05 *Addenda05) SetPaymentRelatedInformation(s string) *Addenda05 {
+	addenda05.PaymentRelatedInformation = s
+
+	return addenda05
+}
+
+// Validate performs NACHA format rule checks on the record and returns an error if not Validated
+// The first error encountered is returned and stops that parsing.
+func (addenda05 *Addenda05) Validate() error {
+	if err := addenda05.fieldInclusion(); err != nil {
+		return err
+	}
+	if addenda05.recordType != "7" {
+		msg := fmt.Sprintf(msgRecordType, 7)
+		return &FieldError{FieldName: "recordType", Value: addenda05.recordType, Msg: msg}
+	}
+	if err := addenda05.isTypeCode(addenda05.typeCode); err != nil {
+		return &FieldError{FieldName: "TypeCode", Value: addenda05.typeCode, Msg: err.Error()}
+	}
+	if err := addenda05.isAlphanumeric(addenda05.PaymentRelatedInformation); err != nil {
+		return &FieldError{FieldName: "PaymentRelatedInformation", Value: addenda05.PaymentRelatedInformation, Msg: err.Error()}
+	}
+
+	return nil
+}
+
+// fieldInclusion validate mandatory fields are not default values. If fields are
+// invalid the ACH transfer will be returned.
+func (addenda05 *Addenda05) fieldInclusion() error {
+	if addenda05.recordType == "" {
+		return &FieldError{FieldName: "recordType", Value: addenda05.recordType, Msg: msgFieldInclusion}
+	}
+	if addenda05.typeCode == "" {
+		return &FieldError{FieldName: "TypeCode", Value: addenda05.typeCode, Msg: msgFieldInclusion}
+	}
+	if addenda05.SequenceNumber == 0 {
+		return &FieldError{FieldName: "SequenceNumber", Value: addenda05.SequenceNumberField(), Msg: msgFieldInclusion}
+	}
+	if addenda05.EntryDetailSequenceNumber == 0 {
+		return &FieldError{FieldName: "EntryDetailSequenceNumber", Value: addenda05.EntryDetailSequenceNumberField(), Msg: msgFieldInclusion}
+	}
+	return nil
+}
+
+// PaymentRelatedInformationField returns a zero padded PaymentRelatedInformation string
+func (addenda05 *Addenda05) PaymentRelatedInformationField() string {
+	return addenda05.alphaField(addenda05.PaymentRelatedInformation, 80)
+}
+
+// SequenceNumberField returns a zero padded SequenceNumber string
+func (addenda05 *Addenda05) SequenceNumberField() string {
+	return addenda05.numericField(addenda05.SequenceNumber, 4)
+}
+
+// EntryDetailSequenceNumberField returns a zero padded EntryDetailSequenceNumber string
+func (addenda05 *Addenda05) EntryDetailSequenceNumberField() string {
+	return addenda05.numericField(addenda05.EntryDetailSequenceNumber, 7)
+}
+
+// TypeCode Defines the specific explanation and format for the addenda05 information
+func (addenda05 *Addenda05) TypeCode() string {
+	return addenda05.typeCode
+}
diff --git a/addendaNOC.go b/addenda98.go
similarity index 54%
rename from addendaNOC.go
rename to addenda98.go
index b6a8c988..3e732d74 100644
--- a/addendaNOC.go
+++ b/addenda98.go
@@ -5,9 +5,9 @@ import (
 	"strings"
 )
 
-// AddendaNOC is a Addendumer addenda record format for Notification OF Change(NOC)
+// Addenda98 is a Addendumer addenda record format for Notification OF Change(98)
 // The field contents for Notification of Change Entries must match the field contents of the original Entries
-type AddendaNOC struct {
+type Addenda98 struct {
 	// RecordType defines the type of record in the block. entryAddendaPos 7
 	recordType string
 	// TypeCode Addenda types code '98'
@@ -17,7 +17,7 @@ type AddendaNOC struct {
 	ChangeCode string
 	// OriginalTrace This field contains the Trace Number as originally included on the forward Entry or Prenotification.
 	// The RDFI must include the Original Entry Trace Number in the Addenda Record of an Entry being returned to an ODFI,
-	// in the Addenda Record of an NOC, within an Acknowledgment Entry, or with an RDFI request for a copy of an authorization.
+	// in the Addenda Record of an 98, within an Acknowledgment Entry, or with an RDFI request for a copy of an authorization.
 	OriginalTrace int
 	// OriginalDFI field contains the Receiving DFI Identification (addenda.RDFIIdentification) as originally included on the forward Entry or Prenotification that the RDFI is returning or correcting.
 	OriginalDFI int
@@ -35,10 +35,10 @@ type AddendaNOC struct {
 var (
 	changeCodeDict = map[string]*changeCode{}
 
-	// Error messages specific to AddendaNOC
-	msgAddendaNOCChangeCode    = "found is not a valid addenda Change Code"
-	msgAddendaNOCTypeCode      = "is not AddendaNOC type code of 98"
-	msgAddendaNOCCorrectedData = "must contain the corrected information corresponding to the Change Code"
+	// Error messages specific to Addenda98
+	msgAddenda98ChangeCode    = "found is not a valid addenda Change Code"
+	msgAddenda98TypeCode      = "is not Addenda98 type code of 98"
+	msgAddenda98CorrectedData = "must contain the corrected information corresponding to the Change Code"
 )
 
 func init() {
@@ -52,103 +52,96 @@ type changeCode struct {
 	Code, Reason, Description string
 }
 
-// NewAddendaNOC returns an reference to an instantiated AddendaNOC with default values
-func NewAddendaNOC(params ...AddendaParam) *AddendaNOC {
-	addendaNOC := &AddendaNOC{
+// NewAddenda98 returns an reference to an instantiated Addenda98 with default values
+func NewAddenda98() *Addenda98 {
+	addenda98 := &Addenda98{
 		recordType: "7",
 		typeCode:   "98",
 	}
-	if len(params) > 0 {
-		addendaNOC.ChangeCode = params[0].ChangeCode
-		addendaNOC.OriginalTrace = addendaNOC.parseNumField(params[0].OriginalTrace)
-		addendaNOC.OriginalDFI = addendaNOC.parseNumField(params[0].OriginalDFI)
-		addendaNOC.CorrectedData = params[0].CorrectedData
-		addendaNOC.TraceNumber = addendaNOC.parseNumField(params[0].TraceNumber)
-	}
-	return addendaNOC
+	return addenda98
 }
 
-// Parse takes the input record string and parses the AddendaNOC values
-func (addendaNOC *AddendaNOC) Parse(record string) {
+// Parse takes the input record string and parses the Addenda98 values
+func (addenda98 *Addenda98) Parse(record string) {
 	// 1-1 Always "7"
-	addendaNOC.recordType = "7"
+	addenda98.recordType = "7"
 	// 2-3 Always "98"
-	addendaNOC.typeCode = record[1:3]
+	addenda98.typeCode = record[1:3]
 	// 4-6
-	addendaNOC.ChangeCode = record[3:6]
+	addenda98.ChangeCode = record[3:6]
 	// 7-21
-	addendaNOC.OriginalTrace = addendaNOC.parseNumField(record[6:21])
+	addenda98.OriginalTrace = addenda98.parseNumField(record[6:21])
 	// 28-35
-	addendaNOC.OriginalDFI = addendaNOC.parseNumField(record[27:35])
+	addenda98.OriginalDFI = addenda98.parseNumField(record[27:35])
 	// 36-64
-	addendaNOC.CorrectedData = strings.TrimSpace(record[35:64])
+	addenda98.CorrectedData = strings.TrimSpace(record[35:64])
 	// 80-94
-	addendaNOC.TraceNumber = addendaNOC.parseNumField(record[79:94])
+	addenda98.TraceNumber = addenda98.parseNumField(record[79:94])
 }
 
-// String writes the AddendaNOC struct to a 94 character string
-func (addendaNOC *AddendaNOC) String() string {
+// String writes the Addenda98 struct to a 94 character string
+func (addenda98 *Addenda98) String() string {
 	return fmt.Sprintf("%v%v%v%v%v%v%v%v%v",
-		addendaNOC.recordType,
-		addendaNOC.TypeCode(),
-		addendaNOC.ChangeCode,
-		addendaNOC.OriginalTraceField(),
+		addenda98.recordType,
+		addenda98.TypeCode(),
+		addenda98.ChangeCode,
+		addenda98.OriginalTraceField(),
 		"      ", //6 char reserved field
-		addendaNOC.OriginalDFIField(),
-		addendaNOC.CorrectedDataField(),
+		addenda98.OriginalDFIField(),
+		addenda98.CorrectedDataField(),
 		"               ", // 15 char reserved field
-		addendaNOC.TraceNumberField(),
+		addenda98.TraceNumberField(),
 	)
 }
 
-// Validate verifies NACHA rules for AddendaNOC
-func (addendaNOC *AddendaNOC) Validate() error {
-	if addendaNOC.recordType != "7" {
+// Validate verifies NACHA rules for Addenda98
+func (addenda98 *Addenda98) Validate() error {
+	if addenda98.recordType != "7" {
 		msg := fmt.Sprintf(msgRecordType, 7)
-		return &FieldError{FieldName: "recordType", Value: addendaNOC.recordType, Msg: msg}
+		return &FieldError{FieldName: "recordType", Value: addenda98.recordType, Msg: msg}
 	}
 	// Type Code must be 98
-	if addendaNOC.typeCode != "98" {
-		return &FieldError{FieldName: "TypeCode", Value: addendaNOC.typeCode, Msg: msgAddendaTypeCode}
+	if addenda98.typeCode != "98" {
+		return &FieldError{FieldName: "TypeCode", Value: addenda98.typeCode, Msg: msgAddendaTypeCode}
 	}
 
-	// AddendaNOC requires a valid ChangeCode
-	_, ok := changeCodeDict[addendaNOC.ChangeCode]
+	// Addenda98 requires a valid ChangeCode
+	_, ok := changeCodeDict[addenda98.ChangeCode]
 	if !ok {
-		return &FieldError{FieldName: "ChangeCode", Value: addendaNOC.ChangeCode, Msg: msgAddendaNOCChangeCode}
+		return &FieldError{FieldName: "ChangeCode", Value: addenda98.ChangeCode, Msg: msgAddenda98ChangeCode}
 	}
 
-	// AddendaNOC Record must contain the corrected information corresponding to the Change Code used
-	if addendaNOC.CorrectedData == "" {
-		return &FieldError{FieldName: "CorrectedData", Value: addendaNOC.CorrectedData, Msg: msgAddendaNOCCorrectedData}
+	// Addenda98 Record must contain the corrected information corresponding to the Change Code used
+	if addenda98.CorrectedData == "" {
+		return &FieldError{FieldName: "CorrectedData", Value: addenda98.CorrectedData, Msg: msgAddenda98CorrectedData}
 	}
 
 	return nil
 }
 
 // TypeCode defines the format of the underlying addenda record
-func (addendaNOC *AddendaNOC) TypeCode() string {
-	return addendaNOC.typeCode
+func (addenda98 *Addenda98) TypeCode() string {
+	return addenda98.typeCode
 }
 
 // OriginalTraceField returns a zero padded OriginalTrace string
-func (addendaNOC *AddendaNOC) OriginalTraceField() string {
-	return addendaNOC.numericField(addendaNOC.OriginalTrace, 15)
+func (addenda98 *Addenda98) OriginalTraceField() string {
+	return addenda98.numericField(addenda98.OriginalTrace, 15)
 }
 
 // OriginalDFIField returns a zero padded OriginalDFI string
-func (addendaNOC *AddendaNOC) OriginalDFIField() string {
-	return addendaNOC.numericField(addendaNOC.OriginalDFI, 8)
+func (addenda98 *Addenda98) OriginalDFIField() string {
+	return addenda98.numericField(addenda98.OriginalDFI, 8)
 }
 
 //CorrectedDataField returns a space padded CorrectedData string
-func (addendaNOC *AddendaNOC) CorrectedDataField() string {
-	return addendaNOC.alphaField(addendaNOC.CorrectedData, 29)
+func (addenda98 *Addenda98) CorrectedDataField() string {
+	return addenda98.alphaField(addenda98.CorrectedData, 29)
 }
 
 // TraceNumberField returns a zero padded traceNumber string
-func (addendaNOC *AddendaNOC) TraceNumberField() string {
-	return addendaNOC.numericField(addendaNOC.TraceNumber, 15)
+func (addenda98 *Addenda98) TraceNumberField() string {
+	return addenda98.numericField(addenda98.TraceNumber, 15)
 }
 
 func makeChangeCodeDict() map[string]*changeCode {
diff --git a/addendaReturn.go b/addenda99.go
similarity index 74%
rename from addendaReturn.go
rename to addenda99.go
index bc09bbd8..5e825dc4 100644
--- a/addendaReturn.go
+++ b/addenda99.go
@@ -18,7 +18,7 @@ var (
 	returnCodeDict = map[string]*returnCode{}
 
 	// Error messages specific to Return Addenda
-	msgAddendaReturnReturnCode = "found is not a valid return code"
+	msgAddenda99ReturnCode = "found is not a valid return code"
 )
 
 func init() {
@@ -26,8 +26,8 @@ func init() {
 	returnCodeDict = makeReturnCodeDict()
 }
 
-// AddendaReturn utilized for Notification of Change Entry (COR) and Return types.
-type AddendaReturn struct {
+// Addenda99 utilized for Notification of Change Entry (COR) and Return types.
+type Addenda99 struct {
 	// RecordType defines the type of record in the block. entryAddendaPos 7
 	recordType string
 	// TypeCode Addenda types code '99'
@@ -37,7 +37,7 @@ type AddendaReturn struct {
 	ReturnCode string
 	// OriginalTrace This field contains the Trace Number as originally included on the forward Entry or Prenotification.
 	// The RDFI must include the Original Entry Trace Number in the Addenda Record of an Entry being returned to an ODFI,
-	// in the Addenda Record of an NOC, within an Acknowledgment Entry, or with an RDFI request for a copy of an authorization.
+	// in the Addenda Record of an 98, within an Acknowledgment Entry, or with an RDFI request for a copy of an authorization.
 	OriginalTrace int
 	// DateOfDeath The field date of death is to be supplied on Entries being returned for reason of death (return reason codes R14 and R15).
 	DateOfDeath time.Time
@@ -61,106 +61,99 @@ type returnCode struct {
 	Code, Reason, Description string
 }
 
-// NewAddendaReturn returns a new AddendaReturn with default values for none exported fields
-func NewAddendaReturn(params ...AddendaParam) *AddendaReturn {
-	addendaReturn := &AddendaReturn{
+// NewAddenda99 returns a new Addenda99 with default values for none exported fields
+func NewAddenda99() *Addenda99 {
+	Addenda99 := &Addenda99{
 		recordType: "7",
 		typeCode:   "99",
 	}
-	if len(params) > 0 {
-		addendaReturn.ReturnCode = params[0].ReturnCode
-		addendaReturn.OriginalTrace = addendaReturn.parseNumField(params[0].OriginalTrace)
-		addendaReturn.OriginalDFI = addendaReturn.parseNumField(params[0].OriginalDFI)
-		addendaReturn.AddendaInformation = params[0].AddendaInfo
-		addendaReturn.TraceNumber = addendaReturn.parseNumField(params[0].TraceNumber)
-	}
-	return addendaReturn
+	return Addenda99
 }
 
-// Parse takes the input record string and parses the AddendaReturn values
-func (addendaReturn *AddendaReturn) Parse(record string) {
+// Parse takes the input record string and parses the Addenda99 values
+func (Addenda99 *Addenda99) Parse(record string) {
 	// 1-1 Always "7"
-	addendaReturn.recordType = "7"
+	Addenda99.recordType = "7"
 	// 2-3 Defines the specific explanation and format for the addenda information contained in the same record
-	addendaReturn.typeCode = record[1:3]
+	Addenda99.typeCode = record[1:3]
 	// 4-6
-	addendaReturn.ReturnCode = record[3:6]
+	Addenda99.ReturnCode = record[3:6]
 	// 7-21
-	addendaReturn.OriginalTrace = addendaReturn.parseNumField(record[6:21])
+	Addenda99.OriginalTrace = Addenda99.parseNumField(record[6:21])
 	// 22-27, might be a date or blank
-	addendaReturn.DateOfDeath = addendaReturn.parseSimpleDate(record[21:27])
+	Addenda99.DateOfDeath = Addenda99.parseSimpleDate(record[21:27])
 	// 28-35
-	addendaReturn.OriginalDFI = addendaReturn.parseNumField(record[27:35])
+	Addenda99.OriginalDFI = Addenda99.parseNumField(record[27:35])
 	// 36-79
-	addendaReturn.AddendaInformation = strings.TrimSpace(record[35:79])
+	Addenda99.AddendaInformation = strings.TrimSpace(record[35:79])
 	// 80-94
-	addendaReturn.TraceNumber = addendaReturn.parseNumField(record[79:94])
+	Addenda99.TraceNumber = Addenda99.parseNumField(record[79:94])
 }
 
-// String writes the AddendaReturn struct to a 94 character string
-func (addendaReturn *AddendaReturn) String() string {
+// String writes the Addenda99 struct to a 94 character string
+func (Addenda99 *Addenda99) String() string {
 	return fmt.Sprintf("%v%v%v%v%v%v%v%v",
-		addendaReturn.recordType,
-		addendaReturn.TypeCode(),
-		addendaReturn.ReturnCode,
-		addendaReturn.OriginalTraceField(),
-		addendaReturn.DateOfDeathField(),
-		addendaReturn.OriginalDFIField(),
-		addendaReturn.AddendaInformationField(),
-		addendaReturn.TraceNumberField(),
+		Addenda99.recordType,
+		Addenda99.TypeCode(),
+		Addenda99.ReturnCode,
+		Addenda99.OriginalTraceField(),
+		Addenda99.DateOfDeathField(),
+		Addenda99.OriginalDFIField(),
+		Addenda99.AddendaInformationField(),
+		Addenda99.TraceNumberField(),
 	)
 }
 
-// Validate verifies NACHA rules for AddendaReturn
-func (addendaReturn *AddendaReturn) Validate() error {
+// Validate verifies NACHA rules for Addenda99
+func (Addenda99 *Addenda99) Validate() error {
 
-	if addendaReturn.recordType != "7" {
+	if Addenda99.recordType != "7" {
 		msg := fmt.Sprintf(msgRecordType, 7)
-		return &FieldError{FieldName: "recordType", Value: addendaReturn.recordType, Msg: msg}
+		return &FieldError{FieldName: "recordType", Value: Addenda99.recordType, Msg: msg}
 	}
 	// @TODO Type Code should be 99.
 
-	_, ok := returnCodeDict[addendaReturn.ReturnCode]
+	_, ok := returnCodeDict[Addenda99.ReturnCode]
 	if !ok {
 		// Return Addenda requires a valid ReturnCode
-		return &FieldError{FieldName: "ReturnCode", Value: addendaReturn.ReturnCode, Msg: msgAddendaReturnReturnCode}
+		return &FieldError{FieldName: "ReturnCode", Value: Addenda99.ReturnCode, Msg: msgAddenda99ReturnCode}
 	}
 	return nil
 }
 
 // TypeCode defines the format of the underlying addenda record
-func (addendaReturn *AddendaReturn) TypeCode() string {
-	return addendaReturn.typeCode
+func (Addenda99 *Addenda99) TypeCode() string {
+	return Addenda99.typeCode
 }
 
 // OriginalTraceField returns a zero padded OriginalTrace string
-func (addendaReturn *AddendaReturn) OriginalTraceField() string {
-	return addendaReturn.numericField(addendaReturn.OriginalTrace, 15)
+func (Addenda99 *Addenda99) OriginalTraceField() string {
+	return Addenda99.numericField(Addenda99.OriginalTrace, 15)
 }
 
 // DateOfDeathField returns a space padded DateOfDeath string
-func (addendaReturn *AddendaReturn) DateOfDeathField() string {
+func (Addenda99 *Addenda99) DateOfDeathField() string {
 	// Return space padded 6 characters if it is a zero value of DateOfDeath
-	if addendaReturn.DateOfDeath.IsZero() {
-		return addendaReturn.alphaField("", 6)
+	if Addenda99.DateOfDeath.IsZero() {
+		return Addenda99.alphaField("", 6)
 	}
 	// YYMMDD
-	return addendaReturn.formatSimpleDate(addendaReturn.DateOfDeath)
+	return Addenda99.formatSimpleDate(Addenda99.DateOfDeath)
 }
 
 // OriginalDFIField returns a zero padded OriginalDFI string
-func (addendaReturn *AddendaReturn) OriginalDFIField() string {
-	return addendaReturn.numericField(addendaReturn.OriginalDFI, 8)
+func (Addenda99 *Addenda99) OriginalDFIField() string {
+	return Addenda99.numericField(Addenda99.OriginalDFI, 8)
 }
 
 //AddendaInformationField returns a space padded AddendaInformation string
-func (addendaReturn *AddendaReturn) AddendaInformationField() string {
-	return addendaReturn.alphaField(addendaReturn.AddendaInformation, 44)
+func (Addenda99 *Addenda99) AddendaInformationField() string {
+	return Addenda99.alphaField(Addenda99.AddendaInformation, 44)
 }
 
 // TraceNumberField returns a zero padded traceNumber string
-func (addendaReturn *AddendaReturn) TraceNumberField() string {
-	return addendaReturn.numericField(addendaReturn.TraceNumber, 15)
+func (Addenda99 *Addenda99) TraceNumberField() string {
+	return Addenda99.numericField(Addenda99.TraceNumber, 15)
 }
 
 func makeReturnCodeDict() map[string]*returnCode {
diff --git a/batch.go b/batch.go
index 80c8d3aa..251d25bd 100644
--- a/batch.go
+++ b/batch.go
@@ -130,7 +130,7 @@ func (batch *batch) build() error {
 		addendaSeq := 1
 		for x := range entry.Addendum {
 			// sequences don't exist in NOC or Return addenda
-			if a, ok := batch.entries[i].Addendum[x].(*Addenda); ok {
+			if a, ok := batch.entries[i].Addendum[x].(*Addenda05); ok {
 				a.SequenceNumber = addendaSeq
 				a.EntryDetailSequenceNumber = batch.parseNumField(batch.entries[i].TraceNumberField()[8:])
 			}
@@ -325,7 +325,7 @@ func (batch *batch) isAddendaSequence() error {
 			// check if sequence is assending
 			for _, addenda := range entry.Addendum {
 				// sequences don't exist in NOC or Return addenda
-				if a, ok := addenda.(*Addenda); ok {
+				if a, ok := addenda.(*Addenda05); ok {
 
 					if a.SequenceNumber < lastSeq {
 						msg := fmt.Sprintf(msgBatchAscending, a.SequenceNumber, lastSeq)
diff --git a/batchCOR.go b/batchCOR.go
index b5ce9001..1646abf5 100644
--- a/batchCOR.go
+++ b/batchCOR.go
@@ -12,8 +12,8 @@ type BatchCOR struct {
 }
 
 var msgBatchCORAmount = "debit:%v credit:%v entry detail amount fields must be zero for SEC type COR"
-var msgBatchCORAddenda = "found and 1 AddendaNOC is required for SEC Type COR"
-var msgBatchCORAddendaType = "%T found where AddendaNOC is required for SEC type NOC"
+var msgBatchCORAddenda = "found and 1 Addenda98 is required for SEC Type COR"
+var msgBatchCORAddendaType = "%T found where Addenda98 is required for SEC type NOC"
 
 // NewBatchCOR returns a *BatchCOR
 func NewBatchCOR(bh *BatchHeader) *BatchCOR {
@@ -31,7 +31,7 @@ func (batch *BatchCOR) Validate() error {
 	}
 	// Add configuration based validation for this type.
 	// Web can have up to one addenda per entry record
-	if err := batch.isAddendaNOC(); err != nil {
+	if err := batch.isAddenda98(); err != nil {
 		return err
 	}
 
@@ -64,21 +64,21 @@ func (batch *BatchCOR) Create() error {
 	return nil
 }
 
-// isAddendaNOC verifies that a AddendaNoc exists for each EntryDetail and is Validated
-func (batch *BatchCOR) isAddendaNOC() error {
+// isAddenda98 verifies that a Addenda98 exists for each EntryDetail and is Validated
+func (batch *BatchCOR) isAddenda98() error {
 	for _, entry := range batch.entries {
 		// Addenda type must be equal to 1
 		if len(entry.Addendum) != 1 {
 			return &BatchError{BatchNumber: batch.header.BatchNumber, FieldName: "Addendum", Msg: msgBatchCORAddenda}
 		}
-		// Addenda type assertion must be AddendaNOC
-		aNOC, ok := entry.Addendum[0].(*AddendaNOC)
+		// Addenda type assertion must be Addenda98
+		addenda98, ok := entry.Addendum[0].(*Addenda98)
 		if !ok {
 			msg := fmt.Sprintf(msgBatchCORAddendaType, entry.Addendum[0])
 			return &BatchError{BatchNumber: batch.header.BatchNumber, FieldName: "Addendum", Msg: msg}
 		}
-		// AddendaNOC must be Validated
-		if err := aNOC.Validate(); err != nil {
+		// Addenda98 must be Validated
+		if err := addenda98.Validate(); err != nil {
 			// convert the field error in to a batch error for a consistent api
 			if e, ok := err.(*FieldError); ok {
 				return &BatchError{BatchNumber: batch.header.BatchNumber, FieldName: e.FieldName, Msg: e.Msg}
diff --git a/entryDetail.go b/entryDetail.go
index 97e2188d..77a354b1 100644
--- a/entryDetail.go
+++ b/entryDetail.go
@@ -206,16 +206,17 @@ func (ed *EntryDetail) AddAddenda(addenda Addendumer) []Addendumer {
 	ed.AddendaRecordIndicator = 1
 	// checks to make sure that we only have either or, not both
 	switch addenda.(type) {
-	case *AddendaReturn:
+	case *Addenda99:
 		ed.Category = CategoryReturn
 		ed.Addendum = nil
 		ed.Addendum = append(ed.Addendum, addenda)
 		return ed.Addendum
-	case *AddendaNOC:
+	case *Addenda98:
 		ed.Category = CategoryNOC
 		ed.Addendum = nil
 		ed.Addendum = append(ed.Addendum, addenda)
 		return ed.Addendum
+		// default is current *Addenda05
 	default:
 		ed.Category = CategoryForward
 		ed.Addendum = append(ed.Addendum, addenda)
diff --git a/file.go b/file.go
index 7d944aa8..5021e7a0 100644
--- a/file.go
+++ b/file.go
@@ -33,6 +33,7 @@ const (
 	web = "WEB"
 	ccd = "CCD"
 	cor = "COR"
+	tel = "TEL"
 )
 
 // Errors strings specific to parsing a Batch container
diff --git a/reader.go b/reader.go
index ca22e9fe..eda7129e 100644
--- a/reader.go
+++ b/reader.go
@@ -234,17 +234,29 @@ func (r *Reader) parseAddenda() error {
 	entry := r.currentBatch.GetEntries()[entryIndex]
 
 	if entry.AddendaRecordIndicator == 1 {
-		// Passing TypeCode type into NewAddenda creates a Addendumer of type copde type.
-		addenda, err := NewAddenda(AddendaParam{
-			TypeCode: r.line[1:3]})
-		if err != nil {
-			return r.error(err)
-		}
-		addenda.Parse(r.line)
-		if err := addenda.Validate(); err != nil {
-			return r.error(err)
+		switch r.line[1:3] {
+		case "05":
+			addenda05 := NewAddenda05()
+			addenda05.Parse(r.line)
+			if err := addenda05.Validate(); err != nil {
+				return r.error(err)
+			}
+			r.currentBatch.GetEntries()[entryIndex].AddAddenda(addenda05)
+		case "98":
+			addenda98 := NewAddenda98()
+			addenda98.Parse(r.line)
+			if err := addenda98.Validate(); err != nil {
+				return r.error(err)
+			}
+			r.currentBatch.GetEntries()[entryIndex].AddAddenda(addenda98)
+		case "99":
+			addenda99 := NewAddenda99()
+			addenda99.Parse(r.line)
+			if err := addenda99.Validate(); err != nil {
+				return r.error(err)
+			}
+			r.currentBatch.GetEntries()[entryIndex].AddAddenda(addenda99)
 		}
-		r.currentBatch.GetEntries()[entryIndex].AddAddenda(addenda)
 	} else {
 		msg := fmt.Sprintf(msgBatchAddendaIndicator)
 		return r.error(&FileError{FieldName: "AddendaRecordIndicator", Msg: msg})


Test patch:
diff --git a/addenda05_test.go b/addenda05_test.go
new file mode 100644
index 00000000..29d3b985
--- /dev/null
+++ b/addenda05_test.go
@@ -0,0 +1,149 @@
+// Copyright 2017 The ACH Authors
+// Use of this source code is governed by an Apache License
+// license that can be found in the LICENSE file.
+
+package ach
+
+import (
+	"strings"
+	"testing"
+)
+
+func mockAddenda05() *Addenda05 {
+	addenda05 := NewAddenda05()
+	addenda05.SequenceNumber = 1
+	addenda05.EntryDetailSequenceNumber = 0000001
+
+	return addenda05
+}
+
+func TestMockAddenda05(t *testing.T) {
+	addenda05 := mockAddenda05()
+	if err := addenda05.Validate(); err != nil {
+		t.Error("mockAddenda05 does not validate and will break other tests")
+	}
+	if addenda05.EntryDetailSequenceNumber != 0000001 {
+		t.Error("EntryDetailSequenceNumber dependent default value has changed")
+	}
+}
+
+func TestParseAddenda05(t *testing.T) {
+	addendaPPD := NewAddenda05()
+	var line = "705PPD                                        DIEGO MAY                            00010000001"
+	addendaPPD.Parse(line)
+
+	r := NewReader(strings.NewReader(line))
+
+	//Add a new BatchWEB
+	r.addCurrentBatch(NewBatchPPD(mockBatchPPDHeader()))
+
+	//Add a WEB EntryDetail
+	entryDetail := mockPPDEntryDetail()
+
+	//Add an addenda to the WEB EntryDetail
+	entryDetail.AddAddenda(addendaPPD)
+
+	// add the WEB entry detail to the batch
+	r.currentBatch.AddEntry(entryDetail)
+
+	record := r.currentBatch.GetEntries()[0].Addendum[0].(*Addenda05)
+
+	if record.recordType != "7" {
+		t.Errorf("RecordType Expected '7' got: %v", record.recordType)
+	}
+	if record.TypeCode() != "05" {
+		t.Errorf("TypeCode Expected 10 got: %v", record.TypeCode())
+	}
+	if record.PaymentRelatedInformationField() != "PPD                                        DIEGO MAY                            " {
+		t.Errorf("PaymentRelatedInformation Expected 'PPD                                        DIEGO MAY                            ' got: %v", record.PaymentRelatedInformationField())
+	}
+	if record.SequenceNumberField() != "0001" {
+		t.Errorf("SequenceNumber Expected '0001' got: %v", record.SequenceNumberField())
+	}
+	if record.EntryDetailSequenceNumberField() != "0000001" {
+		t.Errorf("EntryDetailSequenceNumber Expected '0000001' got: %v", record.EntryDetailSequenceNumberField())
+	}
+}
+
+// TestAddenda05 String validates that a known parsed file can be return to a string of the same value
+func TestAddenda05String(t *testing.T) {
+	addenda05 := NewAddenda05()
+	var line = "705WEB                                        DIEGO MAY                            00010000001"
+	addenda05.Parse(line)
+
+	if addenda05.String() != line {
+		t.Errorf("Strings do not match")
+	}
+}
+
+func TestValidateAddenda05RecordType(t *testing.T) {
+	addenda05 := mockAddenda05()
+	addenda05.recordType = "63"
+	if err := addenda05.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "recordType" {
+				t.Errorf("%T: %s", err, err)
+			}
+		}
+	}
+}
+
+func TestValidateAddenda05TypeCode(t *testing.T) {
+	addenda05 := mockAddenda05()
+	addenda05.typeCode = "23"
+	if err := addenda05.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "TypeCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		}
+	}
+}
+
+func TestAddenda05FieldInclusion(t *testing.T) {
+	addenda05 := mockAddenda05()
+	addenda05.EntryDetailSequenceNumber = 0
+	if err := addenda05.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "EntryDetailSequenceNumber" {
+				t.Errorf("%T: %s", err, err)
+			}
+		}
+	}
+}
+
+func TestAddenda05FieldInclusionRecordType(t *testing.T) {
+	addenda05 := mockAddenda05()
+	addenda05.recordType = ""
+	if err := addenda05.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.Msg != msgFieldInclusion {
+				t.Errorf("%T: %s", err, err)
+			}
+		}
+	}
+}
+
+func TestAddenda05PaymentRelatedInformationAlphaNumeric(t *testing.T) {
+	addenda05 := mockAddenda05()
+	addenda05.PaymentRelatedInformation = "®©"
+	if err := addenda05.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "PaymentRelatedInformation" {
+				t.Errorf("%T: %s", err, err)
+			}
+		}
+	}
+}
+
+func TestAddenda05TyeCodeNil(t *testing.T) {
+	addenda05 := mockAddenda05()
+	addenda05.typeCode = ""
+	if err := addenda05.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "TypeCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		}
+	}
+}
diff --git a/addenda98_test.go b/addenda98_test.go
new file mode 100644
index 00000000..cfa346aa
--- /dev/null
+++ b/addenda98_test.go
@@ -0,0 +1,155 @@
+package ach
+
+import (
+	"testing"
+)
+
+func mockAddenda98() *Addenda98 {
+	addenda98 := NewAddenda98()
+	addenda98.ChangeCode = "C01"
+	addenda98.OriginalTrace = 12345
+	addenda98.OriginalDFI = 9101298
+	addenda98.CorrectedData = "1918171614"
+	addenda98.TraceNumber = 91012980000088
+
+	return addenda98
+}
+
+func TestAddenda98Parse(t *testing.T) {
+	addenda98 := NewAddenda98()
+	line := "798C01099912340000015      091012981918171614                                  091012980000088"
+	addenda98.Parse(line)
+	// walk the Addenda98 struct
+	if addenda98.recordType != "7" {
+		t.Errorf("expected %v got %v", "7", addenda98.recordType)
+	}
+	if addenda98.typeCode != "98" {
+		t.Errorf("expected %v got %v", "98", addenda98.typeCode)
+	}
+	if addenda98.ChangeCode != "C01" {
+		t.Errorf("expected %v got %v", "C01", addenda98.ChangeCode)
+	}
+	if addenda98.OriginalTrace != 99912340000015 {
+		t.Errorf("expected %v got %v", 99912340000015, addenda98.OriginalTrace)
+	}
+	if addenda98.OriginalDFI != 9101298 {
+		t.Errorf("expected %v got %v", 9101298, addenda98.OriginalDFI)
+	}
+	if addenda98.CorrectedData != "1918171614" {
+		t.Errorf("expected %v got %v", "1918171614", addenda98.CorrectedData)
+	}
+	if addenda98.TraceNumber != 91012980000088 {
+		t.Errorf("expected %v got %v", 91012980000088, addenda98.TraceNumber)
+	}
+}
+
+func TestAddenda98String(t *testing.T) {
+	addenda98 := NewAddenda98()
+	line := "798C01099912340000015      091012981918171614                                  091012980000088"
+	addenda98.Parse(line)
+
+	if addenda98.String() != line {
+		t.Errorf("\n expected: %v\n got     : %v", line, addenda98.String())
+	}
+}
+
+func TestAddenda98ValidRecordType(t *testing.T) {
+	addenda98 := mockAddenda98()
+	addenda98.recordType = "63"
+	if err := addenda98.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "recordType" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestAddenda98ValidTypeCode(t *testing.T) {
+	addenda98 := mockAddenda98()
+	addenda98.typeCode = "05"
+	if err := addenda98.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "TypeCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestAddenda98ValidCorrectedData(t *testing.T) {
+	addenda98 := mockAddenda98()
+	addenda98.CorrectedData = ""
+	if err := addenda98.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "CorrectedData" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestAddenda98ValidateTrue(t *testing.T) {
+	addenda98 := mockAddenda98()
+	addenda98.ChangeCode = "C11"
+	if err := addenda98.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "ChangeCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+func TestAddenda98ValidateChangeCodeFalse(t *testing.T) {
+	addenda98 := mockAddenda98()
+	addenda98.ChangeCode = "C63"
+	if err := addenda98.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "ChangeCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestAddenda98OriginalTraceField(t *testing.T) {
+	addenda98 := mockAddenda98()
+	exp := "000000000012345"
+	if addenda98.OriginalTraceField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda98.OriginalTraceField())
+	}
+}
+
+func TestAddenda98OriginalDFIField(t *testing.T) {
+	addenda98 := mockAddenda98()
+	exp := "09101298"
+	if addenda98.OriginalDFIField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda98.OriginalDFIField())
+	}
+}
+
+func TestAddenda98CorrectedDataField(t *testing.T) {
+	addenda98 := mockAddenda98()
+	exp := "1918171614                   " // 29 char
+	if addenda98.CorrectedDataField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda98.CorrectedDataField())
+	}
+}
+
+func TestAddenda98TraceNumberField(t *testing.T) {
+	addenda98 := mockAddenda98()
+	exp := "091012980000088"
+	if addenda98.TraceNumberField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda98.TraceNumberField())
+	}
+}
diff --git a/addenda99_test.go b/addenda99_test.go
new file mode 100644
index 00000000..bf341ca4
--- /dev/null
+++ b/addenda99_test.go
@@ -0,0 +1,150 @@
+// Copyright 2017 The ACH Authors
+// Use of this source code is governed by an Apache License
+// license that can be found in the LICENSE file.
+
+package ach
+
+import (
+	"testing"
+	"time"
+)
+
+func mockAddenda99() *Addenda99 {
+	addenda99 := NewAddenda99()
+	addenda99.ReturnCode = "R07"
+	addenda99.OriginalTrace = 99912340000015
+	addenda99.AddendaInformation = "Authorization Revoked"
+	addenda99.OriginalDFI = 9101298
+
+	return addenda99
+}
+
+func TestAddenda99Parse(t *testing.T) {
+	addenda99 := NewAddenda99()
+	line := "799R07099912340000015      09101298Authorization revoked                       091012980000066"
+	addenda99.Parse(line)
+	// walk the Addenda99 struct
+	if addenda99.recordType != "7" {
+		t.Errorf("expected %v got %v", "7", addenda99.recordType)
+	}
+	if addenda99.typeCode != "99" {
+		t.Errorf("expected %v got %v", "99", addenda99.typeCode)
+	}
+	if addenda99.ReturnCode != "R07" {
+		t.Errorf("expected %v got %v", "R07", addenda99.ReturnCode)
+	}
+	if addenda99.OriginalTrace != 99912340000015 {
+		t.Errorf("expected: %v got: %v", 99912340000015, addenda99.OriginalTrace)
+	}
+	if addenda99.DateOfDeath.IsZero() != true {
+		t.Errorf("expected: %v got: %v", time.Time{}, addenda99.DateOfDeath)
+	}
+	if addenda99.OriginalDFI != 9101298 {
+		t.Errorf("expected: %v got: %v", 9101298, addenda99.OriginalDFI)
+	}
+	if addenda99.AddendaInformation != "Authorization revoked" {
+		t.Errorf("expected: %v got: %v", "Authorization revoked", addenda99.AddendaInformation)
+	}
+	if addenda99.TraceNumber != 91012980000066 {
+		t.Errorf("expected: %v got: %v", 91012980000066, addenda99.TraceNumber)
+	}
+}
+
+func TestAddenda99String(t *testing.T) {
+	addenda99 := NewAddenda99()
+	line := "799R07099912340000015      09101298Authorization revoked                       091012980000066"
+	addenda99.Parse(line)
+
+	if addenda99.String() != line {
+		t.Errorf("\n expected: %v\n got     : %v", line, addenda99.String())
+	}
+}
+
+// This is not an exported function but utilized for validation
+func TestAddenda99MakeReturnCodeDict(t *testing.T) {
+	codes := makeReturnCodeDict()
+	// check if known code is present
+	_, prs := codes["R01"]
+	if !prs {
+		t.Error("Return Code R01 was not found in the ReturnCodeDict")
+	}
+	// check if invalid code is present
+	_, prs = codes["ABC"]
+	if prs {
+		t.Error("Valid return for an invalid return code key")
+	}
+}
+
+func TestAddenda99ValidateTrue(t *testing.T) {
+	addenda99 := mockAddenda99()
+	addenda99.ReturnCode = "R13"
+	if err := addenda99.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "ReturnCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestAddenda99ValidateReturnCodeFalse(t *testing.T) {
+	addenda99 := mockAddenda99()
+	addenda99.ReturnCode = ""
+	if err := addenda99.Validate(); err != nil {
+		if e, ok := err.(*FieldError); ok {
+			if e.FieldName != "ReturnCode" {
+				t.Errorf("%T: %s", err, err)
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestAddenda99OriginalTraceField(t *testing.T) {
+	addenda99 := mockAddenda99()
+	addenda99.OriginalTrace = 12345
+	if addenda99.OriginalTraceField() != "000000000012345" {
+		t.Errorf("expected %v received %v", "000000000012345", addenda99.OriginalTraceField())
+	}
+}
+
+func TestAddenda99DateOfDeathField(t *testing.T) {
+	addenda99 := mockAddenda99()
+	// Check for all zeros
+	if addenda99.DateOfDeathField() != "      " {
+		t.Errorf("expected %v received %v", "      ", addenda99.DateOfDeathField())
+	}
+	// Year: 1978 Month: October Day: 23
+	addenda99.DateOfDeath = time.Date(1978, time.October, 23, 0, 0, 0, 0, time.UTC)
+	if addenda99.DateOfDeathField() != "781023" {
+		t.Errorf("expected %v received %v", "781023", addenda99.DateOfDeathField())
+	}
+}
+
+func TestAddenda99OriginalDFIField(t *testing.T) {
+	addenda99 := mockAddenda99()
+	exp := "09101298"
+	if addenda99.OriginalDFIField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda99.OriginalDFIField())
+	}
+}
+
+func TestAddenda99AddendaInformationField(t *testing.T) {
+	addenda99 := mockAddenda99()
+	exp := "Authorization Revoked                       "
+	if addenda99.AddendaInformationField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda99.AddendaInformationField())
+	}
+}
+
+func TestAddenda99TraceNumberField(t *testing.T) {
+	addenda99 := mockAddenda99()
+	addenda99.TraceNumber = 91012980000066
+	exp := "091012980000066"
+	if addenda99.TraceNumberField() != exp {
+		t.Errorf("expected %v received %v", exp, addenda99.TraceNumberField())
+	}
+}
diff --git a/addendaNOC_test.go b/addendaNOC_test.go
deleted file mode 100644
index 48ef5db7..00000000
--- a/addendaNOC_test.go
+++ /dev/null
@@ -1,194 +0,0 @@
-package ach
-
-import (
-	"strings"
-	"testing"
-)
-
-func mockAddendaNOC() *AddendaNOC {
-	aNOC := NewAddendaNOC()
-	aNOC.ChangeCode = "C01"
-	aNOC.OriginalTrace = 12345
-	aNOC.OriginalDFI = 9101298
-	aNOC.CorrectedData = "1918171614"
-	aNOC.TraceNumber = 91012980000088
-
-	return aNOC
-}
-
-func TestAddendaNOCParse(t *testing.T) {
-	aNOC := NewAddendaNOC()
-	line := "798C01099912340000015      091012981918171614                                  091012980000088"
-	aNOC.Parse(line)
-	// walk the AddendaNOC struct
-	if aNOC.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", aNOC.recordType)
-	}
-	if aNOC.typeCode != "98" {
-		t.Errorf("expected %v got %v", "98", aNOC.typeCode)
-	}
-	if aNOC.ChangeCode != "C01" {
-		t.Errorf("expected %v got %v", "C01", aNOC.ChangeCode)
-	}
-	if aNOC.OriginalTrace != 99912340000015 {
-		t.Errorf("expected %v got %v", 99912340000015, aNOC.OriginalTrace)
-	}
-	if aNOC.OriginalDFI != 9101298 {
-		t.Errorf("expected %v got %v", 9101298, aNOC.OriginalDFI)
-	}
-	if aNOC.CorrectedData != "1918171614" {
-		t.Errorf("expected %v got %v", "1918171614", aNOC.CorrectedData)
-	}
-	if aNOC.TraceNumber != 91012980000088 {
-		t.Errorf("expected %v got %v", 91012980000088, aNOC.TraceNumber)
-	}
-}
-
-func TestAddendaNOCString(t *testing.T) {
-	aNOC := NewAddendaNOC()
-	line := "798C01099912340000015      091012981918171614                                  091012980000088"
-	aNOC.Parse(line)
-
-	if aNOC.String() != line {
-		t.Errorf("\n expected: %v\n got     : %v", line, aNOC.String())
-	}
-}
-
-func TestAddendaNOCValidRecordType(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	aNOC.recordType = "63"
-	if err := aNOC.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "recordType" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-
-func TestAddendaNOCValidTypeCode(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	aNOC.typeCode = "05"
-	if err := aNOC.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "TypeCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-
-func TestAddendaNOCValidCorrectedData(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	aNOC.CorrectedData = ""
-	if err := aNOC.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "CorrectedData" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-
-func TestAddendaNOCValidateTrue(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	aNOC.ChangeCode = "C11"
-	if err := aNOC.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "ChangeCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-func TestAddendaNOCValidateChangeCodeFalse(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	aNOC.ChangeCode = "C63"
-	if err := aNOC.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "ChangeCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-
-func TestAddendaNOCOriginalTraceField(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	exp := "000000000012345"
-	if aNOC.OriginalTraceField() != exp {
-		t.Errorf("expected %v received %v", exp, aNOC.OriginalTraceField())
-	}
-}
-
-func TestAddendaNOCOriginalDFIField(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	exp := "09101298"
-	if aNOC.OriginalDFIField() != exp {
-		t.Errorf("expected %v received %v", exp, aNOC.OriginalDFIField())
-	}
-}
-
-func TestAddendaNOCCorrectedDataField(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	exp := "1918171614                   " // 29 char
-	if aNOC.CorrectedDataField() != exp {
-		t.Errorf("expected %v received %v", exp, aNOC.CorrectedDataField())
-	}
-}
-
-func TestAddendaNOCTraceNumberField(t *testing.T) {
-	aNOC := mockAddendaNOC()
-	exp := "091012980000088"
-	if aNOC.TraceNumberField() != exp {
-		t.Errorf("expected %v received %v", exp, aNOC.TraceNumberField())
-	}
-}
-
-func TestAddendaNOCNewAddendaParam(t *testing.T) {
-	aParam := AddendaParam{
-		TypeCode:      "98",
-		ChangeCode:    "C01",
-		OriginalTrace: "12345",
-		OriginalDFI:   "9101298",
-		CorrectedData: "1918171614",
-		TraceNumber:   "91012980000088",
-	}
-
-	a, err := NewAddenda(aParam)
-	if err != nil {
-		t.Errorf("AddendaNOC from NewAddenda: %v", err)
-	}
-	aNOC, ok := a.(*AddendaNOC)
-	if !ok {
-		t.Errorf("expecting *AddendaNOC received %T ", a)
-	}
-	if aNOC.TypeCode() != aParam.TypeCode {
-		t.Errorf("expected %v got %v", aParam.TypeCode, aNOC.TypeCode())
-	}
-	if aNOC.ChangeCode != aParam.ChangeCode {
-		t.Errorf("expected %v got %v", aParam.ChangeCode, aNOC.ChangeCode)
-	}
-	if !strings.Contains(aNOC.OriginalTraceField(), aParam.OriginalTrace) {
-		t.Errorf("expected %v got %v", aParam.OriginalTrace, aNOC.OriginalTrace)
-	}
-	if !strings.Contains(aNOC.OriginalDFIField(), aParam.OriginalDFI) {
-		t.Errorf("expected %v got %v", aParam.OriginalDFI, aNOC.OriginalDFI)
-	}
-	if aNOC.CorrectedData != aParam.CorrectedData {
-		t.Errorf("expected %v got %v", aParam.CorrectedData, aNOC.CorrectedData)
-	}
-	if !strings.Contains(aNOC.TraceNumberField(), aParam.TraceNumber) {
-		t.Errorf("expected %v got %v", aParam.TraceNumber, aNOC.TraceNumber)
-	}
-}
diff --git a/addendaReturn_test.go b/addendaReturn_test.go
deleted file mode 100644
index a9d14234..00000000
--- a/addendaReturn_test.go
+++ /dev/null
@@ -1,194 +0,0 @@
-// Copyright 2017 The ACH Authors
-// Use of this source code is governed by an Apache License
-// license that can be found in the LICENSE file.
-
-package ach
-
-import (
-	"strings"
-	"testing"
-	"time"
-)
-
-func mockAddendaReturn() *AddendaReturn {
-	addendaReturn := NewAddendaReturn()
-	addendaReturn.typeCode = "99"
-	addendaReturn.ReturnCode = "R07"
-	addendaReturn.OriginalTrace = 99912340000015
-	addendaReturn.AddendaInformation = "Authorization Revoked"
-	addendaReturn.OriginalDFI = 9101298
-
-	return addendaReturn
-}
-
-func TestMockAddendaReturn(t *testing.T) {
-	// TODO: build a mock addenda
-}
-
-func TestAddendaReturnParse(t *testing.T) {
-	addendaReturn := NewAddendaReturn()
-	line := "799R07099912340000015      09101298Authorization revoked                       091012980000066"
-	addendaReturn.Parse(line)
-	// walk the addendaReturn struct
-	if addendaReturn.recordType != "7" {
-		t.Errorf("expected %v got %v", "7", addendaReturn.recordType)
-	}
-	if addendaReturn.typeCode != "99" {
-		t.Errorf("expected %v got %v", "99", addendaReturn.typeCode)
-	}
-	if addendaReturn.ReturnCode != "R07" {
-		t.Errorf("expected %v got %v", "R07", addendaReturn.ReturnCode)
-	}
-	if addendaReturn.OriginalTrace != 99912340000015 {
-		t.Errorf("expected: %v got: %v", 99912340000015, addendaReturn.OriginalTrace)
-	}
-	if addendaReturn.DateOfDeath.IsZero() != true {
-		t.Errorf("expected: %v got: %v", time.Time{}, addendaReturn.DateOfDeath)
-	}
-	if addendaReturn.OriginalDFI != 9101298 {
-		t.Errorf("expected: %v got: %v", 9101298, addendaReturn.OriginalDFI)
-	}
-	if addendaReturn.AddendaInformation != "Authorization revoked" {
-		t.Errorf("expected: %v got: %v", "Authorization revoked", addendaReturn.AddendaInformation)
-	}
-	if addendaReturn.TraceNumber != 91012980000066 {
-		t.Errorf("expected: %v got: %v", 91012980000066, addendaReturn.TraceNumber)
-	}
-}
-
-func TestAddendaReturnString(t *testing.T) {
-	addendaReturn := NewAddendaReturn()
-	line := "799R07099912340000015      09101298Authorization revoked                       091012980000066"
-	addendaReturn.Parse(line)
-
-	if addendaReturn.String() != line {
-		t.Errorf("\n expected: %v\n got     : %v", line, addendaReturn.String())
-	}
-}
-
-// This is not an exported function but utilized for validation
-func TestAddendaReturnMakeReturnCodeDict(t *testing.T) {
-	codes := makeReturnCodeDict()
-	// check if known code is present
-	_, prs := codes["R01"]
-	if !prs {
-		t.Error("Return Code R01 was not found in the ReturnCodeDict")
-	}
-	// check if invalid code is present
-	_, prs = codes["ABC"]
-	if prs {
-		t.Error("Valid return for an invalid return code key")
-	}
-}
-
-func TestAddendaReturnValidateTrue(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	addendaReturn.ReturnCode = "R13"
-	if err := addendaReturn.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "ReturnCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-
-func TestAddendaReturnValidateReturnCodeFalse(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	addendaReturn.ReturnCode = ""
-	if err := addendaReturn.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "ReturnCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		} else {
-			t.Errorf("%T: %s", err, err)
-		}
-	}
-}
-
-func TestAddendaReturnOriginalTraceField(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	addendaReturn.OriginalTrace = 12345
-	if addendaReturn.OriginalTraceField() != "000000000012345" {
-		t.Errorf("expected %v received %v", "000000000012345", addendaReturn.OriginalTraceField())
-	}
-}
-
-func TestAddendaReturnDateOfDeathField(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	// Check for all zeros
-	if addendaReturn.DateOfDeathField() != "      " {
-		t.Errorf("expected %v received %v", "      ", addendaReturn.DateOfDeathField())
-	}
-	// Year: 1978 Month: October Day: 23
-	addendaReturn.DateOfDeath = time.Date(1978, time.October, 23, 0, 0, 0, 0, time.UTC)
-	if addendaReturn.DateOfDeathField() != "781023" {
-		t.Errorf("expected %v received %v", "781023", addendaReturn.DateOfDeathField())
-	}
-}
-
-func TestAddendaReturnOriginalDFIField(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	exp := "09101298"
-	if addendaReturn.OriginalDFIField() != exp {
-		t.Errorf("expected %v received %v", exp, addendaReturn.OriginalDFIField())
-	}
-}
-
-func TestAddendaReturnAddendaInformationField(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	exp := "Authorization Revoked                       "
-	if addendaReturn.AddendaInformationField() != exp {
-		t.Errorf("expected %v received %v", exp, addendaReturn.AddendaInformationField())
-	}
-}
-
-func TestAddendaReturnTraceNumberField(t *testing.T) {
-	addendaReturn := mockAddendaReturn()
-	addendaReturn.TraceNumber = 91012980000066
-	exp := "091012980000066"
-	if addendaReturn.TraceNumberField() != exp {
-		t.Errorf("expected %v received %v", exp, addendaReturn.TraceNumberField())
-	}
-}
-
-func TestAddendaReturnNewAddendaParam(t *testing.T) {
-	aParam := AddendaParam{
-		TypeCode:      "99",
-		ReturnCode:    "R07",
-		OriginalTrace: "99912340000015",
-		OriginalDFI:   "09101298",
-		AddendaInfo:   "Authorization Revoked",
-		TraceNumber:   "091012980000066",
-	}
-
-	a, err := NewAddenda(aParam)
-	if err != nil {
-		t.Errorf("addendaReturn from NewAddeda: %v", err)
-	}
-	addendaReturn, ok := a.(*AddendaReturn)
-	if !ok {
-		t.Errorf("expecting *AddendaReturn received %T ", a)
-	}
-	if addendaReturn.TypeCode() != aParam.TypeCode {
-		t.Errorf("expected %v got %v", aParam.TypeCode, addendaReturn.TypeCode())
-	}
-	if addendaReturn.ReturnCode != aParam.ReturnCode {
-		t.Errorf("expected %v got %v", aParam.ReturnCode, addendaReturn.ReturnCode)
-	}
-	if !strings.Contains(addendaReturn.OriginalTraceField(), aParam.OriginalTrace) {
-		t.Errorf("expected %v got %v", aParam.OriginalTrace, addendaReturn.OriginalTrace)
-	}
-	if !strings.Contains(addendaReturn.OriginalDFIField(), aParam.OriginalDFI) {
-		t.Errorf("expected %v got %v", aParam.OriginalDFI, addendaReturn.OriginalDFI)
-	}
-	if addendaReturn.AddendaInformation != aParam.AddendaInfo {
-		t.Errorf("expected %v got %v", aParam.AddendaInfo, addendaReturn.AddendaInformation)
-	}
-	if !strings.Contains(addendaReturn.TraceNumberField(), aParam.TraceNumber) {
-		t.Errorf("expected %v got %v", aParam.TraceNumber, addendaReturn.TraceNumber)
-	}
-}
diff --git a/addenda_internal_test.go b/addenda_internal_test.go
deleted file mode 100644
index 2daa8051..00000000
--- a/addenda_internal_test.go
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2017 The ACH Authors
-// Use of this source code is governed by an Apache License
-// license that can be found in the LICENSE file.
-
-package ach
-
-import (
-	"strings"
-	"testing"
-)
-
-func mockAddenda() *Addenda {
-	addenda := Addenda{
-		recordType:                "7",
-		typeCode:                  "05",
-		SequenceNumber:            1,
-		EntryDetailSequenceNumber: 1234567,
-	}
-	return &addenda
-}
-
-func TestMockAddenda(t *testing.T) {
-	addenda := mockAddenda()
-	if err := addenda.Validate(); err != nil {
-		t.Error("mockAddenda does not validate and will break other tests")
-	}
-	if addenda.EntryDetailSequenceNumber != 1234567 {
-		t.Error("EntryDetailSequenceNumber dependent default value has changed")
-	}
-}
-
-func TestParseAddenda(t *testing.T) {
-	var line = "705WEB                                        DIEGO MAY                            00010000001"
-
-	r := NewReader(strings.NewReader(line))
-	r.addCurrentBatch(NewBatchPPD(mockBatchPPDHeader()))
-	//r.currentBatch.GetHeader().StandardEntryClassCode = "PPD"
-	r.currentBatch.AddEntry(&EntryDetail{TransactionCode: 22, AddendaRecordIndicator: 1})
-	r.line = line
-	err := r.parseAddenda()
-	if err != nil {
-		t.Errorf("%T: %s", err, err)
-	}
-	record := r.currentBatch.GetEntries()[0].Addendum[0].(*Addenda)
-
-	if record.recordType != "7" {
-		t.Errorf("RecordType Expected '7' got: %v", record.recordType)
-	}
-	if record.TypeCode() != "05" {
-		t.Errorf("TypeCode Expected 10 got: %v", record.TypeCode())
-	}
-	if record.PaymentRelatedInformationField() != "WEB                                        DIEGO MAY                            " {
-		t.Errorf("PaymentRelatedInformation Expected 'WEB                                        DIEGO MAY                            ' got: %v", record.PaymentRelatedInformationField())
-	}
-	if record.SequenceNumberField() != "0001" {
-		t.Errorf("SequenceNumber Expected '0001' got: %v", record.SequenceNumberField())
-	}
-	if record.EntryDetailSequenceNumberField() != "0000001" {
-		t.Errorf("EntryDetailSequenceNumber Expected '0000001' got: %v", record.EntryDetailSequenceNumberField())
-	}
-}
-
-// TestAddendaString validats that a known parsed file can be return to a string of the same value
-func TestAddendaString(t *testing.T) {
-	var line = "705WEB                                        DIEGO MAY                            00010000001"
-	r := NewReader(strings.NewReader(line))
-	r.addCurrentBatch(NewBatchPPD(mockBatchPPDHeader()))
-	r.currentBatch.GetHeader().StandardEntryClassCode = "PPD"
-	r.currentBatch.AddEntry(&EntryDetail{AddendaRecordIndicator: 1})
-	r.line = line
-	err := r.parseAddenda()
-	if err != nil {
-		t.Errorf("%T: %s", err, err)
-	}
-	record := r.currentBatch.GetEntries()[0].Addendum[0]
-	if record.String() != line {
-		t.Errorf("Strings do not match")
-	}
-}
-
-func TestValidateAddendaRecordType(t *testing.T) {
-	addenda := mockAddenda()
-	addenda.recordType = "2"
-	if err := addenda.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "recordType" {
-				t.Errorf("%T: %s", err, err)
-			}
-		}
-	}
-}
-
-func TestValidateAddendaTypeCode(t *testing.T) {
-	addenda := mockAddenda()
-	addenda.typeCode = "23"
-	if err := addenda.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "TypeCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		}
-	}
-}
-
-func TestAddendaFieldInclusion(t *testing.T) {
-	addenda := mockAddenda()
-	addenda.EntryDetailSequenceNumber = 0
-	if err := addenda.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "EntryDetailSequenceNumber" {
-				t.Errorf("%T: %s", err, err)
-			}
-		}
-	}
-}
-
-func TestAddendaFieldInclusionRecordType(t *testing.T) {
-	addenda := mockAddenda()
-	addenda.recordType = ""
-	if err := addenda.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.Msg != msgFieldInclusion {
-				t.Errorf("%T: %s", err, err)
-			}
-		}
-	}
-}
-
-func TestAddendaPaymentRelatedInformationAlphaNumeric(t *testing.T) {
-	addenda := mockAddenda()
-	addenda.PaymentRelatedInformation = "®©"
-	if err := addenda.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "PaymentRelatedInformation" {
-				t.Errorf("%T: %s", err, err)
-			}
-		}
-	}
-}
-
-func TestAddendaTyeCodeNil(t *testing.T) {
-	addenda := mockAddenda()
-	addenda.typeCode = ""
-	if err := addenda.Validate(); err != nil {
-		if e, ok := err.(*FieldError); ok {
-			if e.FieldName != "TypeCode" {
-				t.Errorf("%T: %s", err, err)
-			}
-		}
-	}
-}
diff --git a/batchCCD_test.go b/batchCCD_test.go
index 07ee5138..b4806a26 100644
--- a/batchCCD_test.go
+++ b/batchCCD_test.go
@@ -31,7 +31,7 @@ func mockCCDEntryDetail() *EntryDetail {
 func mockBatchCCD() *BatchCCD {
 	mockBatch := NewBatchCCD(mockBatchCCDHeader())
 	mockBatch.AddEntry(mockCCDEntryDetail())
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	if err := mockBatch.Create(); err != nil {
 		panic(err)
 	}
@@ -52,7 +52,7 @@ func TestBatchCCDHeader(t *testing.T) {
 func TestBatchCCDAddendumCount(t *testing.T) {
 	mockBatch := mockBatchCCD()
 	// Adding a second addenda to the mock entry
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	if err := mockBatch.Validate(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "EntryAddendaCount" {
@@ -83,7 +83,7 @@ func TestBatchCCDReceivingCompanyName(t *testing.T) {
 // verify addenda type code is 05
 func TestBatchCCDAddendaTypeCode(t *testing.T) {
 	mockBatch := mockBatchCCD()
-	mockBatch.GetEntries()[0].Addendum[0].(*Addenda).typeCode = "07"
+	mockBatch.GetEntries()[0].Addendum[0].(*Addenda05).typeCode = "07"
 	if err := mockBatch.Validate(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "TypeCode" {
@@ -112,7 +112,7 @@ func TestBatchCCDSEC(t *testing.T) {
 
 func TestBatchCCDAddendaCount(t *testing.T) {
 	mockBatch := mockBatchCCD()
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	mockBatch.Create()
 	if err := mockBatch.Validate(); err != nil {
 		if e, ok := err.(*BatchError); ok {
diff --git a/batchCOR_test.go b/batchCOR_test.go
index 6754f5d8..8db3c563 100644
--- a/batchCOR_test.go
+++ b/batchCOR_test.go
@@ -33,7 +33,7 @@ func mockCOREntryDetail() *EntryDetail {
 func mockBatchCOR() *BatchCOR {
 	mockBatch := NewBatchCOR(mockBatchCORHeader())
 	mockBatch.AddEntry(mockCOREntryDetail())
-	mockBatch.GetEntries()[0].AddAddenda(mockAddendaNOC())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda98())
 	if err := mockBatch.Create(); err != nil {
 		panic(err)
 	}
@@ -67,7 +67,7 @@ func TestBatchCORSEC(t *testing.T) {
 func TestBatchCORAddendumCountTwo(t *testing.T) {
 	mockBatch := mockBatchCOR()
 	// Adding a second addenda to the mock entry
-	mockBatch.GetEntries()[0].AddAddenda(mockAddendaNOC())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda98())
 
 	if err := mockBatch.Create(); err != nil {
 		//	fmt.Printf("err: %v \n", err)
@@ -95,11 +95,11 @@ func TestBatchCORAddendaCountZero(t *testing.T) {
 	}
 }
 
-// check that Addendum is of type AddendaNOC
+// check that Addendum is of type Addenda98
 func TestBatchCORAddendaType(t *testing.T) {
 	mockBatch := NewBatchCOR(mockBatchCORHeader())
 	mockBatch.AddEntry(mockCOREntryDetail())
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	if err := mockBatch.Create(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "Addendum" {
@@ -113,7 +113,7 @@ func TestBatchCORAddendaType(t *testing.T) {
 
 func TestBatchCORAddendaTypeCode(t *testing.T) {
 	mockBatch := mockBatchCOR()
-	mockBatch.GetEntries()[0].Addendum[0].(*AddendaNOC).typeCode = "07"
+	mockBatch.GetEntries()[0].Addendum[0].(*Addenda98).typeCode = "07"
 	if err := mockBatch.Validate(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "TypeCode" {
diff --git a/batchPPD_test.go b/batchPPD_test.go
index c3ec5c1b..1e140bc2 100644
--- a/batchPPD_test.go
+++ b/batchPPD_test.go
@@ -108,7 +108,7 @@ func TestBatchPPDCreate(t *testing.T) {
 func TestBatchPPDTypeCode(t *testing.T) {
 	mockBatch := mockBatchPPD()
 	// change an addendum to an invalid type code
-	a := mockAddenda()
+	a := mockAddenda05()
 	a.typeCode = "63"
 	mockBatch.GetEntries()[0].AddAddenda(a)
 	mockBatch.Create()
@@ -154,8 +154,8 @@ func TestBatchODFIIDMismatch(t *testing.T) {
 func TestBatchBuild(t *testing.T) {
 	mockBatch := NewBatchPPD(mockBatchPPDHeader2())
 	entry := mockPPDEntry2()
-	a1, _ := NewAddenda()
-	entry.AddAddenda(a1)
+	addenda05 := NewAddenda05()
+	entry.AddAddenda(addenda05)
 	mockBatch.AddEntry(entry)
 	if err := mockBatch.Create(); err != nil {
 		t.Errorf("%T: %s", err, err)
diff --git a/batchTEL_test.go b/batchTEL_test.go
index fd6a9b5b..a1dbc2e3 100644
--- a/batchTEL_test.go
+++ b/batchTEL_test.go
@@ -64,7 +64,7 @@ func TestBatchTELCreate(t *testing.T) {
 func TestBatchTELAddendaCount(t *testing.T) {
 	mockBatch := mockBatchTEL()
 	// TEL can not have an addendum
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	mockBatch.Create()
 	if err := mockBatch.Validate(); err != nil {
 		if e, ok := err.(*BatchError); ok {
diff --git a/batchWEB_test.go b/batchWEB_test.go
index a5f53fe3..6a704c30 100644
--- a/batchWEB_test.go
+++ b/batchWEB_test.go
@@ -28,7 +28,7 @@ func mockWEBEntryDetail() *EntryDetail {
 func mockBatchWEB() *BatchWEB {
 	mockBatch := NewBatchWEB(mockBatchWEBHeader())
 	mockBatch.AddEntry(mockWEBEntryDetail())
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	if err := mockBatch.Create(); err != nil {
 		panic(err)
 	}
@@ -40,7 +40,7 @@ func mockBatchWEB() *BatchWEB {
 func TestBatchWebAddenda(t *testing.T) {
 	mockBatch := mockBatchWEB()
 	// mock batch already has one addenda. Creating two addenda should error
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	if err := mockBatch.Create(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "AddendaCount" {
@@ -71,7 +71,7 @@ func TestBatchWebIndividualNameRequired(t *testing.T) {
 // verify addenda type code is 05
 func TestBatchWEBAddendaTypeCode(t *testing.T) {
 	mockBatch := mockBatchWEB()
-	mockBatch.GetEntries()[0].Addendum[0].(*Addenda).typeCode = "07"
+	mockBatch.GetEntries()[0].Addendum[0].(*Addenda05).typeCode = "07"
 	if err := mockBatch.Validate(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "TypeCode" {
diff --git a/batch_test.go b/batch_test.go
index 0b7dbfdc..2837a28e 100644
--- a/batch_test.go
+++ b/batch_test.go
@@ -118,8 +118,8 @@ func TestBatchDNEMismatch(t *testing.T) {
 	mockBatch := mockBatch()
 	mockBatch.SetHeader(mockBatchHeader())
 	ed := mockBatch.GetEntries()[0]
-	ed.AddAddenda(mockAddenda())
-	ed.AddAddenda(mockAddenda())
+	ed.AddAddenda(mockAddenda05())
+	ed.AddAddenda(mockAddenda05())
 	mockBatch.build()
 
 	mockBatch.GetHeader().OriginatorStatusCode = 1
@@ -153,7 +153,7 @@ func TestBatchEntryCountEquality(t *testing.T) {
 	mockBatch := mockBatch()
 	mockBatch.SetHeader(mockBatchHeader())
 	e := mockEntryDetail()
-	a := mockAddenda()
+	a := mockAddenda05()
 	e.AddAddenda(a)
 	mockBatch.AddEntry(e)
 	if err := mockBatch.build(); err != nil {
@@ -174,7 +174,7 @@ func TestBatchEntryCountEquality(t *testing.T) {
 
 func TestBatchAddendaIndicator(t *testing.T) {
 	mockBatch := mockBatch()
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	mockBatch.GetEntries()[0].AddendaRecordIndicator = 0
 	mockBatch.GetControl().EntryAddendaCount = 2
 	if err := mockBatch.verify(); err != nil {
@@ -191,12 +191,12 @@ func TestBatchAddendaIndicator(t *testing.T) {
 func TestBatchIsAddendaSeqAscending(t *testing.T) {
 	mockBatch := mockBatch()
 	ed := mockBatch.GetEntries()[0]
-	ed.AddAddenda(mockAddenda())
-	ed.AddAddenda(mockAddenda())
+	ed.AddAddenda(mockAddenda05())
+	ed.AddAddenda(mockAddenda05())
 	mockBatch.build()
 
-	mockBatch.GetEntries()[0].Addendum[0].(*Addenda).SequenceNumber = 2
-	mockBatch.GetEntries()[0].Addendum[1].(*Addenda).SequenceNumber = 1
+	mockBatch.GetEntries()[0].Addendum[0].(*Addenda05).SequenceNumber = 2
+	mockBatch.GetEntries()[0].Addendum[1].(*Addenda05).SequenceNumber = 1
 	if err := mockBatch.verify(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "SequenceNumber" {
@@ -228,12 +228,12 @@ func TestBatchIsSequenceAscending(t *testing.T) {
 
 func TestBatchAddendaTraceNumber(t *testing.T) {
 	mockBatch := mockBatch()
-	mockBatch.GetEntries()[0].AddAddenda(mockAddenda())
+	mockBatch.GetEntries()[0].AddAddenda(mockAddenda05())
 	if err := mockBatch.build(); err != nil {
 		t.Errorf("%T: %s", err, err)
 	}
 
-	mockBatch.GetEntries()[0].Addendum[0].(*Addenda).EntryDetailSequenceNumber = 99
+	mockBatch.GetEntries()[0].Addendum[0].(*Addenda05).EntryDetailSequenceNumber = 99
 	if err := mockBatch.verify(); err != nil {
 		if e, ok := err.(*BatchError); ok {
 			if e.FieldName != "TraceNumber" {
@@ -261,7 +261,7 @@ func TestBatchCategory(t *testing.T) {
 	mockBatch := mockBatch()
 	// Add a Addenda Return to the mock batch
 	entry := mockEntryDetail()
-	entry.AddAddenda(mockAddendaReturn())
+	entry.AddAddenda(mockAddenda99())
 	mockBatch.AddEntry(entry)
 
 	if err := mockBatch.build(); err != nil {
@@ -269,7 +269,7 @@ func TestBatchCategory(t *testing.T) {
 	}
 
 	if mockBatch.Category() != CategoryReturn {
-		t.Errorf("AddendaReturn added to batch and category is %s", mockBatch.Category())
+		t.Errorf("Addenda99 added to batch and category is %s", mockBatch.Category())
 	}
 }
 
@@ -277,7 +277,7 @@ func TestBatchCategoryForwardReturn(t *testing.T) {
 	mockBatch := mockBatch()
 	// Add a Addenda Return to the mock batch
 	entry := mockEntryDetail()
-	entry.AddAddenda(mockAddendaReturn())
+	entry.AddAddenda(mockAddenda99())
 	entry.TraceNumber = entry.TraceNumber + 10
 	mockBatch.AddEntry(entry)
 	if err := mockBatch.build(); err != nil {
diff --git a/entryDetail_internal_test.go b/entryDetail_internal_test.go
index 72f94a46..46194a55 100644
--- a/entryDetail_internal_test.go
+++ b/entryDetail_internal_test.go
@@ -22,19 +22,6 @@ func mockEntryDetail() *EntryDetail {
 	return entry
 }
 
-func mockEntryDemandDebit() *EntryDetail {
-	entry := NewEntryDetail()
-	entry.TransactionCode = 27
-	entry.SetRDFI(102001017)
-	entry.DFIAccountNumber = "5343121"
-	entry.Amount = 17500
-	entry.IndividualName = "Robert Smith"
-	entry.SetTraceNumber(mockBatchHeader().ODFIIdentification, 1)
-	entry.IdentificationNumber = "ABC##jvkdjfuiwn"
-	entry.Category = CategoryForward
-	return entry
-}
-
 func TestMockEntryDetail(t *testing.T) {
 	entry := mockEntryDetail()
 	if err := entry.Validate(); err != nil {
@@ -303,28 +290,28 @@ func TestEDFieldInclusionTraceNumber(t *testing.T) {
 	}
 }
 
-func TestEDAddAddendaAddendaReturn(t *testing.T) {
+func TestEDAddAddendaAddenda99(t *testing.T) {
 	entry := mockEntryDetail()
-	entry.AddAddenda(mockAddendaReturn())
+	entry.AddAddenda(mockAddenda99())
 	if entry.Category != CategoryReturn {
-		t.Error("AddendaReturn added and isReturn is false")
+		t.Error("Addenda99 added and isReturn is false")
 	}
 	if entry.AddendaRecordIndicator != 1 {
-		t.Error("AddendaReturn added and record indicator is not 1")
+		t.Error("Addenda99 added and record indicator is not 1")
 	}
 
 }
 
-func TestEDAddAddendaAddendaReturnTwice(t *testing.T) {
+func TestEDAddAddendaAddenda99Twice(t *testing.T) {
 	entry := mockEntryDetail()
-	entry.AddAddenda(mockAddendaReturn())
-	entry.AddAddenda(mockAddendaReturn())
+	entry.AddAddenda(mockAddenda99())
+	entry.AddAddenda(mockAddenda99())
 	if entry.Category != CategoryReturn {
-		t.Error("AddendaReturn added and Category is not CategoryReturn")
+		t.Error("Addenda99 added and Category is not CategoryReturn")
 	}
 
 	if len(entry.Addendum) != 1 {
-		t.Error("AddendaReturn added and isReturn is false")
+		t.Error("Addenda99 added and isReturn is false")
 	}
 }
 
diff --git a/file_test.go b/file_test.go
index 83cd8200..bf4b5828 100644
--- a/file_test.go
+++ b/file_test.go
@@ -180,7 +180,7 @@ func TestFileReturnEntries(t *testing.T) {
 	// create or copy the entry to be returned record
 	entry := mockEntryDetail()
 	// Add the addenda return with appropriate ReturnCode and addenda information
-	entry.AddAddenda(mockAddendaReturn())
+	entry.AddAddenda(mockAddenda99())
 	// create or copy the previous batch header of the item being returned
 	batchHeader := mockBatchHeader()
 	// create or copy the batch to be returned
diff --git a/reader_test.go b/reader_test.go
index 40fa398c..8355a5c0 100644
--- a/reader_test.go
+++ b/reader_test.go
@@ -8,6 +8,8 @@ import (
 	"os"
 	"strings"
 	"testing"
+	"bytes"
+	"fmt"
 )
 
 func TestParseError(t *testing.T) {
@@ -246,11 +248,11 @@ func TestFileEntryDetail(t *testing.T) {
 	}
 }
 
-// TestFileAddenda validation error populates through the reader
-func TestFileAddenda(t *testing.T) {
+// TestFileAddenda05 validation error populates through the reader
+func TestFileAddenda05(t *testing.T) {
 	bh := mockBatchHeader()
 	ed := mockEntryDetail()
-	addenda := mockAddenda()
+	addenda := mockAddenda05()
 	addenda.SequenceNumber = 0
 	ed.AddAddenda(addenda)
 	line := bh.String() + "\n" + ed.String() + "\n" + ed.Addendum[0].String()
@@ -269,9 +271,58 @@ func TestFileAddenda(t *testing.T) {
 	}
 }
 
+func TestFileAddenda98(t *testing.T) {
+	bh := mockBatchHeader()
+	ed := mockEntryDetail()
+	addenda := mockAddenda98()
+
+	addenda.TraceNumber = 0000001
+	addenda.ChangeCode = "C10"
+	addenda.CorrectedData = "ACME One Corporation"
+	ed.AddAddenda(addenda)
+	line := bh.String() + "\n" + ed.String() + "\n" + ed.Addendum[0].String()
+	r := NewReader(strings.NewReader(line))
+	_, err := r.Read()
+	if err != nil {
+		if p, ok := err.(*ParseError); ok {
+			if e, ok := p.Err.(*FieldError); ok {
+				if e.Msg != msgFieldInclusion {
+					t.Errorf("%T: %s", e, e)
+				}
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+func TestFileAddenda99(t *testing.T) {
+	bh := mockBatchHeader()
+	ed := mockEntryDetail()
+	addenda := mockAddenda99()
+	addenda.TraceNumber = 0000001
+	addenda.ReturnCode = "R02"
+	ed.AddAddenda(addenda)
+	line := bh.String() + "\n" + ed.String() + "\n" + ed.Addendum[0].String()
+	r := NewReader(strings.NewReader(line))
+	_, err := r.Read()
+	if err != nil {
+		if p, ok := err.(*ParseError); ok {
+			if e, ok := p.Err.(*FieldError); ok {
+				if e.Msg != msgFieldInclusion {
+					t.Errorf("%T: %s", e, e)
+				}
+			}
+		} else {
+			t.Errorf("%T: %s", err, err)
+		}
+	}
+}
+
+
 // TestFileAddendaOutsideBatch validation error populates through the reader
 func TestFileAddendaOutsideBatch(t *testing.T) {
-	addenda := mockAddenda()
+	addenda := mockAddenda05()
 	r := NewReader(strings.NewReader(addenda.String()))
 	_, err := r.Read()
 	if err != nil {
@@ -291,7 +342,7 @@ func TestFileAddendaOutsideBatch(t *testing.T) {
 func TestFileAddendaNoIndicator(t *testing.T) {
 	bh := mockBatchHeader()
 	ed := mockEntryDetail()
-	addenda := mockAddenda()
+	addenda := mockAddenda05()
 	line := bh.String() + "\n" + ed.String() + "\n" + addenda.String()
 	r := NewReader(strings.NewReader(line))
 	_, err := r.Read()
@@ -387,10 +438,8 @@ func TestFileAddBatchValidation(t *testing.T) {
 	}
 }
 
-/**
 func TestFileHeaderExists(t *testing.T) {
 	file := mockFilePPD()
-	file.SetHeader(FileHeader{})
 	buf := new(bytes.Buffer)
 	w := NewWriter(buf)
 	w.Write(file)
@@ -412,7 +461,6 @@ func TestFileHeaderExists(t *testing.T) {
 		fmt.Println(f.Header.String())
 	}
 }
-**/
 
 // TestFileLongErr Batch Header Service Class is 000 which does not validate
 func TestFileLongErr(t *testing.T) {
@@ -430,7 +478,7 @@ func TestFileLongErr(t *testing.T) {
 
 func TestFileAddendaOutsideEntry(t *testing.T) {
 	bh := mockBatchHeader()
-	addenda := mockAddenda()
+	addenda := mockAddenda05()
 	line := bh.String() + "\n" + addenda.String()
 	r := NewReader(strings.NewReader(line))
 	_, err := r.Read()
diff --git a/recordParams_test.go b/record_test.go
similarity index 75%
rename from recordParams_test.go
rename to record_test.go
index adea6d07..08806a09 100644
--- a/recordParams_test.go
+++ b/record_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 )
 
-func TestFileParam(t *testing.T) {
+func TestFileRecord(t *testing.T) {
 	f := NewFile()
 	f.SetHeader(mockFileHeader())
 	if err := f.Header.Validate(); err != nil {
@@ -17,7 +17,7 @@ func TestFileParam(t *testing.T) {
 	}
 }
 
-func TestBatchParam(t *testing.T) {
+func TestBatchRecord(t *testing.T) {
 	companyName := "ACME Corporation"
 	batch, _ := NewBatch(mockBatchPPDHeader())
 
@@ -64,16 +64,18 @@ func TestEntryDetailReceivingCompany(t *testing.T) {
 	}
 }
 
-func TestAddendaParam(t *testing.T) {
-	addenda, _ := NewAddenda(AddendaParam{
-		PaymentRelatedInfo: "Currently string needs ASC X12 Interchange Control Structures",
-	})
-	if err := addenda.Validate(); err != nil {
+func TestAddendaRecord(t *testing.T) {
+	addenda05 := NewAddenda05()
+	addenda05.PaymentRelatedInformation = "Currently string needs ASC X12 Interchange Control Structures"
+	addenda05.SequenceNumber = 1
+	addenda05.EntryDetailSequenceNumber = 1234567
+
+	if err := addenda05.Validate(); err != nil {
 		t.Errorf("%T: %s", err, err)
 	}
 }
 
-func TestBuildFileParam(t *testing.T) {
+func TestBuildFile(t *testing.T) {
 	// To create a file
 	file := NewFile()
 	file.SetHeader(mockFileHeader())
@@ -82,13 +84,14 @@ func TestBuildFileParam(t *testing.T) {
 	batch, _ := NewBatch(mockBatchHeader())
 
 	// To create an entry
-	entry := mockEntryDemandDebit()
+	entry := mockPPDEntryDetail()
 
 	// To add one or more optional addenda records for an entry
+	addendaPPD := NewAddenda05()
+	addendaPPD.PaymentRelatedInformation = "Currently string needs ASC X12 Interchange Control Structures"
 
-	addenda, _ := NewAddenda(AddendaParam{
-		PaymentRelatedInfo: "bonus pay for amazing work on #OSS"})
-	entry.AddAddenda(addenda)
+	// Add the addenda record to the detail entry
+	entry.AddAddenda(addendaPPD)
 
 	// Entries are added to batches like so:
 
@@ -113,11 +116,11 @@ func TestBuildFileParam(t *testing.T) {
 
 	entry = mockWEBEntryDetail()
 
-	addenda, _ = NewAddenda(AddendaParam{
-		PaymentRelatedInfo: "Monthly Membership Subscription"})
+	addendaWEB := NewAddenda05()
+	addendaWEB.PaymentRelatedInformation = "Monthly Membership Subscription"
 
-	// add the entry to the batch
-	entry.AddAddenda(addenda)
+	// Add the addenda record to the detail entry
+	entry.AddAddenda(addendaWEB)
 
 	// add the second batch to the file
 
diff --git a/writer_test.go b/writer_test.go
index bb5d934d..b2e14fd7 100644
--- a/writer_test.go
+++ b/writer_test.go
@@ -9,7 +9,7 @@ import (
 func TestPPDWrite(t *testing.T) {
 	file := NewFile().SetHeader(mockFileHeader())
 	entry := mockEntryDetail()
-	entry.AddAddenda(mockAddenda())
+	entry.AddAddenda(mockAddenda05())
 	batch := NewBatchPPD(mockBatchPPDHeader())
 	batch.SetHeader(mockBatchHeader())
 	batch.AddEntry(entry)