ifd_builder_test.go: Fix test

v2/ifd_builder_test.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"reflect"
-	// "sort"
+	"sort"
 	"strings"
 	"testing"
 
@@ -1550,142 +1550,154 @@ func ExampleIfdBuilder_SetStandardWithName_updateGps() {
 	// Degrees<O=[N] D=(11) M=(22) S=(33)>
 }
 
-// TODO(dustin): There's some current discrepancy in-between the original and recovered that needs to be investigated.
+func TestIfdBuilder_NewIfdBuilderFromExistingChain_RealData(t *testing.T) {
+	testImageFilepath := getTestImageFilepath()
 
-// func TestIfdBuilder_NewIfdBuilderFromExistingChain_RealData(t *testing.T) {
+	rawExif, err := SearchFileAndExtractExif(testImageFilepath)
-// 	testImageFilepath := getTestImageFilepath()
+	log.PanicIf(err)
 
-// 	rawExif, err := SearchFileAndExtractExif(testImageFilepath)
+	// Decode from binary.
-// 	log.PanicIf(err)
 
-// 	// Decode from binary.
+	im := NewIfdMapping()
 
-// 	im := NewIfdMapping()
+	err = LoadStandardIfds(im)
+	log.PanicIf(err)
 
-// 	err = LoadStandardIfds(im)
+	ti := NewTagIndex()
-// 	log.PanicIf(err)
 
-// 	ti := NewTagIndex()
+	_, originalIndex, err := Collect(im, ti, rawExif)
+	log.PanicIf(err)
 
-// 	_, originalIndex, err := Collect(im, ti, rawExif)
+	originalThumbnailData, err := originalIndex.RootIfd.NextIfd.Thumbnail()
-// 	log.PanicIf(err)
+	log.PanicIf(err)
 
-// 	originalThumbnailData, err := originalIndex.RootIfd.NextIfd.Thumbnail()
+	originalTags := originalIndex.RootIfd.DumpTags()
-// 	log.PanicIf(err)
 
-// 	originalTags := originalIndex.RootIfd.DumpTags()
+	// Encode back to binary.
 
-// 	// Encode back to binary.
+	ibe := NewIfdByteEncoder()
 
-// 	ibe := NewIfdByteEncoder()
+	rootIb := NewIfdBuilderFromExistingChain(originalIndex.RootIfd)
 
-// 	rootIb := NewIfdBuilderFromExistingChain(originalIndex.RootIfd)
+	updatedExif, err := ibe.EncodeToExif(rootIb)
+	log.PanicIf(err)
 
-// 	updatedExif, err := ibe.EncodeToExif(rootIb)
+	// Parse again.
-// 	log.PanicIf(err)
 
-// 	// Parse again.
+	_, recoveredIndex, err := Collect(im, ti, updatedExif)
+	log.PanicIf(err)
 
-// 	_, recoveredIndex, err := Collect(im, ti, updatedExif)
+	recoveredTags := recoveredIndex.RootIfd.DumpTags()
-// 	log.PanicIf(err)
 
-// 	recoveredTags := recoveredIndex.RootIfd.DumpTags()
+	recoveredThumbnailData, err := recoveredIndex.RootIfd.NextIfd.Thumbnail()
+	log.PanicIf(err)
 
-// 	recoveredThumbnailData, err := recoveredIndex.RootIfd.NextIfd.Thumbnail()
+	// Check the thumbnail.
-// 	log.PanicIf(err)
 
-// 	// Check the thumbnail.
+	if bytes.Compare(recoveredThumbnailData, originalThumbnailData) != 0 {
+		t.Fatalf("recovered thumbnail does not match original")
+	}
 
-// 	if bytes.Compare(recoveredThumbnailData, originalThumbnailData) != 0 {
+	// Validate that all of the same IFDs were presented.
-// 		t.Fatalf("recovered thumbnail does not match original")
-// 	}
 
-// 	// Validate that all of the same IFDs were presented.
+	originalIfdTags := make([][2]interface{}, 0)
+	for _, ite := range originalTags {
+		if ite.ChildIfdPath() != "" {
+			originalIfdTags = append(originalIfdTags, [2]interface{}{ite.IfdPath(), ite.TagId()})
+		}
+	}
 
-// 	originalIfdTags := make([][2]interface{}, 0)
+	recoveredIfdTags := make([][2]interface{}, 0)
-// 	for _, ite := range originalTags {
+	for _, ite := range recoveredTags {
-// 		if ite.ChildIfdPath() != "" {
+		if ite.ChildIfdPath() != "" {
-// 			originalIfdTags = append(originalIfdTags, [2]interface{}{ite.IfdPath(), ite.TagId()})
+			recoveredIfdTags = append(recoveredIfdTags, [2]interface{}{ite.IfdPath(), ite.TagId()})
-// 		}
+		}
-// 	}
+	}
 
-// 	recoveredIfdTags := make([][2]interface{}, 0)
+	if reflect.DeepEqual(recoveredIfdTags, originalIfdTags) != true {
-// 	for _, ite := range recoveredTags {
+		fmt.Printf("Original IFD tags:\n\n")
-// 		if ite.ChildIfdPath() != "" {
-// 			recoveredIfdTags = append(recoveredIfdTags, [2]interface{}{ite.IfdPath(), ite.TagId()})
-// 		}
-// 	}
 
-// 	if reflect.DeepEqual(recoveredIfdTags, originalIfdTags) != true {
+		for i, x := range originalIfdTags {
-// 		fmt.Printf("Original IFD tags:\n\n")
+			fmt.Printf("  %02d %v\n", i, x)
+		}
 
-// 		for i, x := range originalIfdTags {
+		fmt.Printf("\nRecovered IFD tags:\n\n")
-// 			fmt.Printf("  %02d %v\n", i, x)
-// 		}
 
-// 		fmt.Printf("\nRecovered IFD tags:\n\n")
+		for i, x := range recoveredIfdTags {
+			fmt.Printf("  %02d %v\n", i, x)
+		}
 
-// 		for i, x := range recoveredIfdTags {
+		fmt.Printf("\n")
-// 			fmt.Printf("  %02d %v\n", i, x)
-// 		}
 
-// 		fmt.Printf("\n")
+		t.Fatalf("Recovered IFD tags are not correct.")
+	}
 
-// 		t.Fatalf("Recovered IFD tags are not correct.")
+	// Validate that all of the tags owned by the IFDs were presented. Note
-// 	}
+	// that the thumbnail tags are not kept but only produced on the fly, which
+	// is why we check it above.
 
-// 	// Validate that all of the tags owned by the IFDs were presented. Note
+	if len(recoveredTags) != len(originalTags) {
-// 	// that the thumbnail tags are not kept but only produced on the fly, which
+		t.Fatalf("Recovered tag-count does not match original.")
-// 	// is why we check it above.
+	}
 
-// 	if len(recoveredTags) != len(originalTags) {
+	originalTagPhrases := make([]string, 0)
-// 		t.Fatalf("Recovered tag-count does not match original.")
+	for _, ite := range originalTags {
-// 	}
+		phrase := ite.String()
 
-// 	originalTagPhrases := make([]string, 0)
+		// The value (the offset) of IFDs will almost never be the same after
-// 	for _, ite := range originalTags {
+		// reconstruction (by design).
-// 		valuePhrase, err := ite.Format()
+		if ite.ChildIfdName() == "" {
-// 		log.PanicIf(err)
+			valuePhrase, err := ite.FormatFirst()
+			log.PanicIf(err)
 
-// 		phrase := ite.String() + " " + valuePhrase
+			phrase += " " + valuePhrase
-// 		originalTagPhrases = append(originalTagPhrases, phrase)
+		}
-// 	}
 
-// 	sort.Strings(originalTagPhrases)
+		originalTagPhrases = append(originalTagPhrases, phrase)
+	}
 
-// 	recoveredTagPhrases := make([]string, 0)
+	sort.Strings(originalTagPhrases)
-// 	for _, ite := range recoveredTags {
-// 		valuePhrase, err := ite.Format()
-// 		log.PanicIf(err)
 
-// 		phrase := ite.String() + " " + valuePhrase
+	recoveredTagPhrases := make([]string, 0)
-// 		recoveredTagPhrases = append(recoveredTagPhrases, phrase)
+	for _, ite := range recoveredTags {
-// 	}
+		phrase := ite.String()
 
-// 	sort.Strings(recoveredTagPhrases)
+		// The value (the offset) of IFDs will almost never be the same after
+		// reconstruction (by design).
+		if ite.ChildIfdName() == "" {
+			valuePhrase, err := ite.FormatFirst()
+			log.PanicIf(err)
 
-// 	if reflect.DeepEqual(recoveredTagPhrases, originalTagPhrases) != true {
+			phrase += " " + valuePhrase
-// 		fmt.Printf("ORIGINAL:\n")
+		}
-// 		fmt.Printf("\n")
 
-// 		for _, tag := range originalTagPhrases {
+		recoveredTagPhrases = append(recoveredTagPhrases, phrase)
-// 			fmt.Printf("%s\n", tag)
+	}
-// 		}
 
-// 		fmt.Printf("\n")
+	sort.Strings(recoveredTagPhrases)
 
-// 		fmt.Printf("RECOVERED:\n")
+	if reflect.DeepEqual(recoveredTagPhrases, originalTagPhrases) != true {
-// 		fmt.Printf("\n")
+		fmt.Printf("ORIGINAL:\n")
+		fmt.Printf("\n")
 
-// 		for _, tag := range recoveredTagPhrases {
+		for _, tag := range originalTagPhrases {
-// 			fmt.Printf("%s\n", tag)
+			fmt.Printf("%s\n", tag)
-// 		}
+		}
 
-// 		fmt.Printf("\n")
+		fmt.Printf("\n")
 
-// 		t.Fatalf("Recovered tags do not equal original tags.")
+		fmt.Printf("RECOVERED:\n")
-// 	}
+		fmt.Printf("\n")
-// }
+
+		for _, tag := range recoveredTagPhrases {
+			fmt.Printf("%s\n", tag)
+		}
+
+		fmt.Printf("\n")
+
+		t.Fatalf("Recovered tags do not equal original tags.")
+	}
+}
 
 // func TestIfdBuilder_NewIfdBuilderFromExistingChain_RealData_WithUpdate(t *testing.T) {
 //	testImageFilepath := getTestImageFilepath()