Upgrade spdx-tools to v0.4.0 am: 75f88b4895

Original change: https://android-review.googlesource.com/c/platform/external/spdx-tools/+/2401868

Change-Id: Ic8874ba0a8ce9c14050c2de8f652de86415dacbe
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

1 files changed, 314 insertions, 0 deletions

diff --git a/spdx/common/identifier_test.go b/spdx/common/identifier_test.go
new file mode 100644
index 0000000..8df2ea3
--- /dev/null
+++ b/spdx/common/identifier_test.go
@@ -0,0 +1,314 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func Test_DocElementIDEncoding(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    DocElementID
+		expected string
+		err      bool
+	}{
+		{
+			name: "ElementRefID",
+			value: DocElementID{
+				ElementRefID: "some-id",
+			},
+			expected: "SPDXRef-some-id",
+		},
+		{
+			name: "DocumentRefID:ElementRefID",
+			value: DocElementID{
+				DocumentRefID: "a-doc",
+				ElementRefID:  "some-id",
+			},
+			expected: "DocumentRef-a-doc:SPDXRef-some-id",
+		},
+		{
+			name: "DocumentRefID no ElementRefID",
+			value: DocElementID{
+				DocumentRefID: "a-doc",
+			},
+			err: true,
+		},
+		{
+			name: "SpecialID",
+			value: DocElementID{
+				SpecialID: "special-id",
+			},
+			expected: "special-id",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result, err := json.Marshal(test.value)
+			switch {
+			case !test.err && err != nil:
+				t.Fatalf("unexpected error: %v", err)
+			case test.err && err == nil:
+				t.Fatalf("expected error but got none")
+			case test.err:
+				return
+			}
+			s := string(result)
+			if !strings.HasPrefix(s, `"`) || !strings.HasSuffix(s, `"`) {
+				t.Fatalf("string was not returned: %s", s)
+			}
+			s = strings.Trim(s, `"`)
+			if test.expected != s {
+				t.Fatalf("%s != %s", test.expected, s)
+			}
+		})
+	}
+}
+
+func Test_DocElementIDDecoding(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    string
+		expected DocElementID
+		err      bool
+	}{
+		{
+			name:  "ElementRefID",
+			value: "SPDXRef-some-id",
+			expected: DocElementID{
+				ElementRefID: "some-id",
+			},
+		},
+		{
+			name:  "DocumentRefID:ElementRefID",
+			value: "DocumentRef-a-doc:SPDXRef-some-id",
+			expected: DocElementID{
+				DocumentRefID: "a-doc",
+				ElementRefID:  "some-id",
+			},
+		},
+		{
+			name:  "DocumentRefID no ElementRefID",
+			value: "DocumentRef-a-doc",
+			expected: DocElementID{
+				DocumentRefID: "a-doc",
+			},
+		},
+		{
+			name:  "DocumentRefID invalid ElementRefID",
+			value: "DocumentRef-a-doc:invalid",
+			err:   true,
+		},
+		{
+			name:  "invalid format",
+			value: "some-id-without-spdxref",
+			err:   true,
+		},
+		{
+			name:  "SpecialID NONE",
+			value: "NONE",
+			expected: DocElementID{
+				SpecialID: "NONE",
+			},
+		},
+		{
+			name:  "SpecialID NOASSERTION",
+			value: "NOASSERTION",
+			expected: DocElementID{
+				SpecialID: "NOASSERTION",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			out := DocElementID{}
+			s := fmt.Sprintf(`"%s"`, test.value)
+			err := json.Unmarshal([]byte(s), &out)
+			switch {
+			case !test.err && err != nil:
+				t.Fatalf("unexpected error: %v", err)
+			case test.err && err == nil:
+				t.Fatalf("expected error but got none")
+			case test.err:
+				return
+			}
+			if !reflect.DeepEqual(test.expected, out) {
+				t.Fatalf("unexpected value: %v != %v", test.expected, out)
+			}
+		})
+	}
+}
+
+func Test_ElementIDEncoding(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    ElementID
+		expected string
+		err      bool
+	}{
+		{
+			name:     "appends spdxref",
+			value:    ElementID("some-id"),
+			expected: "SPDXRef-some-id",
+		},
+		{
+			name:     "appends spdxref",
+			value:    ElementID("SPDXRef-some-id"),
+			expected: "SPDXRef-some-id",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result, err := json.Marshal(test.value)
+			switch {
+			case !test.err && err != nil:
+				t.Fatalf("unexpected error: %v", err)
+			case test.err && err == nil:
+				t.Fatalf("expected error but got none")
+			case test.err:
+				return
+			}
+			s := string(result)
+			if !strings.HasPrefix(s, `"`) || !strings.HasSuffix(s, `"`) {
+				t.Fatalf("string was not returned: %s", s)
+			}
+			s = strings.Trim(s, `"`)
+			if test.expected != s {
+				t.Fatalf("%s != %s", test.expected, s)
+			}
+		})
+	}
+}
+
+func Test_ElementIDDecoding(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    string
+		expected ElementID
+		err      bool
+	}{
+		{
+			name:     "valid id",
+			value:    "SPDXRef-some-id",
+			expected: ElementID("some-id"),
+		},
+		{
+			name:  "invalid format",
+			value: "some-id-without-spdxref",
+			err:   true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var out ElementID
+			s := fmt.Sprintf(`"%s"`, test.value)
+			err := json.Unmarshal([]byte(s), &out)
+			switch {
+			case !test.err && err != nil:
+				t.Fatalf("unexpected error: %v", err)
+			case test.err && err == nil:
+				t.Fatalf("expected error but got none")
+			case test.err:
+				return
+			}
+			if !reflect.DeepEqual(test.expected, out) {
+				t.Fatalf("unexpected value: %v != %v", test.expected, out)
+			}
+		})
+	}
+}
+
+func Test_ElementIDStructEncoding(t *testing.T) {
+	type typ struct {
+		Id ElementID `json:"id"`
+	}
+	tests := []struct {
+		name     string
+		value    typ
+		expected string
+		err      bool
+	}{
+		{
+			name: "appends spdxref",
+			value: typ{
+				Id: ElementID("some-id"),
+			},
+			expected: `{"id":"SPDXRef-some-id"}`,
+		},
+		{
+			name: "appends spdxref",
+			value: typ{
+				Id: ElementID("SPDXRef-some-id"),
+			},
+			expected: `{"id":"SPDXRef-some-id"}`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result, err := json.Marshal(test.value)
+			switch {
+			case !test.err && err != nil:
+				t.Fatalf("unexpected error: %v", err)
+			case test.err && err == nil:
+				t.Fatalf("expected error but got none")
+			case test.err:
+				return
+			}
+			s := string(result)
+			if test.expected != s {
+				t.Fatalf("%s != %s", test.expected, s)
+			}
+		})
+	}
+}
+
+func Test_ElementIDStructDecoding(t *testing.T) {
+	type typ struct {
+		Id ElementID `json:"id"`
+	}
+	tests := []struct {
+		name     string
+		value    string
+		expected typ
+		err      bool
+	}{
+		{
+			name: "valid id",
+			expected: typ{
+				Id: ElementID("some-id"),
+			},
+			value: `{"id":"SPDXRef-some-id"}`,
+		},
+		{
+			name:  "invalid format",
+			value: `{"id":"some-id"}`,
+			err:   true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			out := typ{}
+			err := json.Unmarshal([]byte(test.value), &out)
+			switch {
+			case !test.err && err != nil:
+				t.Fatalf("unexpected error: %v", err)
+			case test.err && err == nil:
+				t.Fatalf("expected error but got none")
+			case test.err:
+				return
+			}
+			if !reflect.DeepEqual(test.expected, out) {
+				t.Fatalf("unexpected value: %v != %v", test.expected, out)
+			}
+		})
+	}
+}