1// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later 2package parser2v2 3 4import ( 5 "testing" 6 7 "github.com/spdx/tools-golang/spdx/common" 8 "github.com/spdx/tools-golang/spdx/v2_2" 9) 10 11// ===== Parser snippet section state change tests ===== 12func TestParser2_2SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { 13 // create the first snippet 14 sid1 := common.ElementID("s1") 15 parser := tvParser2_2{ 16 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 17 st: psSnippet2_2, 18 pkg: &v2_2.Package{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*v2_2.File{}}, 19 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 20 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: sid1}, 21 } 22 s1 := parser.snippet 23 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 24 parser.pkg.Files = append(parser.pkg.Files, parser.file) 25 parser.file.Snippets[sid1] = parser.snippet 26 27 // the File's Snippets should have this one only 28 if len(parser.file.Snippets) != 1 { 29 t.Errorf("Expected len(Snippets) to be 1, got %d", len(parser.file.Snippets)) 30 } 31 if parser.file.Snippets["s1"] != s1 { 32 t.Errorf("Expected snippet %v in Snippets[s1], got %v", s1, parser.file.Snippets["s1"]) 33 } 34 if parser.file.Snippets["s1"].SnippetSPDXIdentifier != sid1 { 35 t.Errorf("expected snippet ID %s in Snippets[s1], got %s", sid1, parser.file.Snippets["s1"].SnippetSPDXIdentifier) 36 } 37 38 // now add a new snippet 39 err := parser.parsePair2_2("SnippetSPDXID", "SPDXRef-s2") 40 if err != nil { 41 t.Errorf("got error when calling parsePair2_2: %v", err) 42 } 43 // state should be correct 44 if parser.st != psSnippet2_2 { 45 t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) 46 } 47 // and a snippet should be created 48 if parser.snippet == nil { 49 t.Fatalf("parser didn't create new snippet") 50 } 51 // and the snippet ID should be as expected 52 if parser.snippet.SnippetSPDXIdentifier != "s2" { 53 t.Errorf("expected snippet ID %s, got %s", "s2", parser.snippet.SnippetSPDXIdentifier) 54 } 55 // and the File's Snippets should be of size 2 and have these two 56 if len(parser.file.Snippets) != 2 { 57 t.Errorf("Expected len(Snippets) to be 2, got %d", len(parser.file.Snippets)) 58 } 59 if parser.file.Snippets["s1"] != s1 { 60 t.Errorf("Expected snippet %v in Snippets[s1], got %v", s1, parser.file.Snippets["s1"]) 61 } 62 if parser.file.Snippets["s1"].SnippetSPDXIdentifier != sid1 { 63 t.Errorf("expected snippet ID %s in Snippets[s1], got %s", sid1, parser.file.Snippets["s1"].SnippetSPDXIdentifier) 64 } 65 if parser.file.Snippets["s2"] != parser.snippet { 66 t.Errorf("Expected snippet %v in Snippets[s2], got %v", parser.snippet, parser.file.Snippets["s2"]) 67 } 68 if parser.file.Snippets["s2"].SnippetSPDXIdentifier != "s2" { 69 t.Errorf("expected snippet ID %s in Snippets[s2], got %s", "s2", parser.file.Snippets["s2"].SnippetSPDXIdentifier) 70 } 71} 72 73func TestParser2_2SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { 74 parser := tvParser2_2{ 75 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 76 st: psSnippet2_2, 77 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 78 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 79 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 80 } 81 p1 := parser.pkg 82 f1 := parser.file 83 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 84 parser.pkg.Files = append(parser.pkg.Files, parser.file) 85 parser.file.Snippets["s1"] = parser.snippet 86 87 // now add a new package 88 p2Name := "package2" 89 err := parser.parsePair2_2("PackageName", p2Name) 90 if err != nil { 91 t.Errorf("got error when calling parsePair2_2: %v", err) 92 } 93 // state should go back to Package 94 if parser.st != psPackage2_2 { 95 t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) 96 } 97 // and a package should be created 98 if parser.pkg == nil { 99 t.Fatalf("parser didn't create new pkg") 100 } 101 // and the package name should be as expected 102 if parser.pkg.PackageName != p2Name { 103 t.Errorf("expected package name %s, got %s", p2Name, parser.pkg.PackageName) 104 } 105 // and the package should default to true for FilesAnalyzed 106 if parser.pkg.FilesAnalyzed != true { 107 t.Errorf("expected FilesAnalyzed to default to true, got false") 108 } 109 if parser.pkg.IsFilesAnalyzedTagPresent != false { 110 t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") 111 } 112 // and the Document's Packages should still be of size 1 b/c no SPDX 113 // identifier has been seen yet 114 if len(parser.doc.Packages) != 1 { 115 t.Errorf("Expected len(Packages) to be 1, got %d", len(parser.doc.Packages)) 116 } 117 if parser.doc.Packages[0] != p1 { 118 t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages[0]) 119 } 120 if parser.doc.Packages[0].PackageName != "package1" { 121 t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages[0].PackageName) 122 } 123 // and the first Package's Files should be of size 1 and have f1 only 124 if len(parser.doc.Packages[0].Files) != 1 { 125 t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages[0].Files)) 126 } 127 if parser.doc.Packages[0].Files[0] != f1 { 128 t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages[0].Files[0]) 129 } 130 if parser.doc.Packages[0].Files[0].FileName != "f1.txt" { 131 t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages[0].Files[0].FileName) 132 } 133 // and the new Package should have no files 134 if len(parser.pkg.Files) != 0 { 135 t.Errorf("Expected no files in Packages[1].Files, got %d", len(parser.pkg.Files)) 136 } 137 // and the current file should be nil 138 if parser.file != nil { 139 t.Errorf("Expected nil for parser.file, got %v", parser.file) 140 } 141 // and the current snippet should be nil 142 if parser.snippet != nil { 143 t.Errorf("Expected nil for parser.snippet, got %v", parser.snippet) 144 } 145} 146 147func TestParser2_2SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) { 148 f1Name := "f1.txt" 149 parser := tvParser2_2{ 150 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 151 st: psSnippet2_2, 152 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 153 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 154 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 155 } 156 p1 := parser.pkg 157 f1 := parser.file 158 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 159 parser.pkg.Files = append(parser.pkg.Files, parser.file) 160 parser.file.Snippets["s1"] = parser.snippet 161 162 f2Name := "f2.txt" 163 err := parser.parsePair2_2("FileName", f2Name) 164 if err != nil { 165 t.Errorf("got error when calling parsePair2_2: %v", err) 166 } 167 // state should be correct 168 if parser.st != psFile2_2 { 169 t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) 170 } 171 // and current package should remain what it was 172 if parser.pkg != p1 { 173 t.Fatalf("expected package to remain %v, got %v", p1, parser.pkg) 174 } 175 // and a file should be created 176 if parser.file == nil { 177 t.Fatalf("parser didn't create new file") 178 } 179 // and the file name should be as expected 180 if parser.file.FileName != f2Name { 181 t.Errorf("expected file name %s, got %s", f2Name, parser.file.FileName) 182 } 183 // and the Package's Files should still be of size 1 since we haven't seen 184 // an SPDX identifier yet for this new file 185 if len(parser.pkg.Files) != 1 { 186 t.Errorf("Expected len(Files) to be 1, got %d", len(parser.pkg.Files)) 187 } 188 if parser.pkg.Files[0] != f1 { 189 t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files[0]) 190 } 191 if parser.pkg.Files[0].FileName != f1Name { 192 t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files[0].FileName) 193 } 194 // and the current snippet should be nil 195 if parser.snippet != nil { 196 t.Errorf("Expected nil for parser.snippet, got %v", parser.snippet) 197 } 198} 199 200func TestParser2_2SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { 201 parser := tvParser2_2{ 202 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 203 st: psSnippet2_2, 204 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 205 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 206 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 207 } 208 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 209 parser.pkg.Files = append(parser.pkg.Files, parser.file) 210 parser.file.Snippets["s1"] = parser.snippet 211 212 err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic") 213 if err != nil { 214 t.Errorf("got error when calling parsePair2_2: %v", err) 215 } 216 if parser.st != psOtherLicense2_2 { 217 t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) 218 } 219} 220 221func TestParser2_2SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) { 222 parser := tvParser2_2{ 223 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 224 st: psSnippet2_2, 225 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 226 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 227 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 228 } 229 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 230 parser.pkg.Files = append(parser.pkg.Files, parser.file) 231 parser.file.Snippets["s1"] = parser.snippet 232 233 err := parser.parsePair2_2("Reviewer", "Person: John Doe") 234 if err != nil { 235 t.Errorf("got error when calling parsePair2_2: %v", err) 236 } 237 if parser.st != psReview2_2 { 238 t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) 239 } 240} 241 242func TestParser2_2SnippetStaysAfterParsingRelationshipTags(t *testing.T) { 243 parser := tvParser2_2{ 244 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 245 st: psSnippet2_2, 246 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 247 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 248 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 249 } 250 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 251 parser.pkg.Files = append(parser.pkg.Files, parser.file) 252 parser.file.Snippets["s1"] = parser.snippet 253 254 err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") 255 if err != nil { 256 t.Errorf("got error when calling parsePair2_2: %v", err) 257 } 258 // state should remain unchanged 259 if parser.st != psSnippet2_2 { 260 t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) 261 } 262 // and the relationship should be in the Document's Relationships 263 if len(parser.doc.Relationships) != 1 { 264 t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships)) 265 } 266 deID := parser.doc.Relationships[0].RefA 267 if deID.DocumentRefID != "" || deID.ElementRefID != "blah" { 268 t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) 269 } 270 271 err = parser.parsePair2_2("RelationshipComment", "blah") 272 if err != nil { 273 t.Errorf("got error when calling parsePair2_2: %v", err) 274 } 275 // state should still remain unchanged 276 if parser.st != psSnippet2_2 { 277 t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) 278 } 279} 280 281func TestParser2_2SnippetStaysAfterParsingAnnotationTags(t *testing.T) { 282 parser := tvParser2_2{ 283 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 284 st: psSnippet2_2, 285 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 286 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 287 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 288 } 289 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 290 parser.pkg.Files = append(parser.pkg.Files, parser.file) 291 parser.file.Snippets["s1"] = parser.snippet 292 293 err := parser.parsePair2_2("Annotator", "Person: John Doe ()") 294 if err != nil { 295 t.Errorf("got error when calling parsePair2_2: %v", err) 296 } 297 if parser.st != psSnippet2_2 { 298 t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) 299 } 300 301 err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") 302 if err != nil { 303 t.Errorf("got error when calling parsePair2_2: %v", err) 304 } 305 if parser.st != psSnippet2_2 { 306 t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) 307 } 308 309 err = parser.parsePair2_2("AnnotationType", "REVIEW") 310 if err != nil { 311 t.Errorf("got error when calling parsePair2_2: %v", err) 312 } 313 if parser.st != psSnippet2_2 { 314 t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) 315 } 316 317 err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") 318 if err != nil { 319 t.Errorf("got error when calling parsePair2_2: %v", err) 320 } 321 if parser.st != psSnippet2_2 { 322 t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) 323 } 324 325 err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file") 326 if err != nil { 327 t.Errorf("got error when calling parsePair2_2: %v", err) 328 } 329 if parser.st != psSnippet2_2 { 330 t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) 331 } 332 333 // and the annotation should be in the Document's Annotations 334 if len(parser.doc.Annotations) != 1 { 335 t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations)) 336 } 337 if parser.doc.Annotations[0].Annotator.Annotator != "John Doe ()" { 338 t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator) 339 } 340} 341 342// ===== Snippet data section tests ===== 343func TestParser2_2CanParseSnippetTags(t *testing.T) { 344 parser := tvParser2_2{ 345 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 346 st: psSnippet2_2, 347 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 348 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 349 snippet: &v2_2.Snippet{}, 350 } 351 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 352 parser.pkg.Files = append(parser.pkg.Files, parser.file) 353 354 // Snippet SPDX Identifier 355 err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") 356 if err != nil { 357 t.Errorf("expected nil error, got %v", err) 358 } 359 if parser.snippet.SnippetSPDXIdentifier != "s1" { 360 t.Errorf("got %v for SnippetSPDXIdentifier", parser.snippet.SnippetSPDXIdentifier) 361 } 362 363 // Snippet from File SPDX Identifier 364 err = parser.parsePairFromSnippet2_2("SnippetFromFileSPDXID", "SPDXRef-f1") 365 if err != nil { 366 t.Errorf("expected nil error, got %v", err) 367 } 368 wantDeID := common.DocElementID{DocumentRefID: "", ElementRefID: common.ElementID("f1")} 369 if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID.ElementRefID { 370 t.Errorf("got %v for SnippetFromFileSPDXIdentifier", parser.snippet.SnippetFromFileSPDXIdentifier) 371 } 372 373 // Snippet Byte Range 374 err = parser.parsePairFromSnippet2_2("SnippetByteRange", "20:320") 375 if err != nil { 376 t.Errorf("expected nil error, got %v", err) 377 } 378 if parser.snippet.Ranges[0].StartPointer.Offset != 20 { 379 t.Errorf("got %v for SnippetByteRangeStart", parser.snippet.Ranges[0].StartPointer.Offset) 380 } 381 if parser.snippet.Ranges[0].EndPointer.Offset != 320 { 382 t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.Ranges[0].EndPointer.Offset) 383 } 384 385 // Snippet Line Range 386 err = parser.parsePairFromSnippet2_2("SnippetLineRange", "5:12") 387 if err != nil { 388 t.Errorf("expected nil error, got %v", err) 389 } 390 if parser.snippet.Ranges[1].StartPointer.LineNumber != 5 { 391 t.Errorf("got %v for SnippetLineRangeStart", parser.snippet.Ranges[1].StartPointer.LineNumber) 392 } 393 if parser.snippet.Ranges[1].EndPointer.LineNumber != 12 { 394 t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.Ranges[1].EndPointer.LineNumber) 395 } 396 397 // Snippet Concluded License 398 err = parser.parsePairFromSnippet2_2("SnippetLicenseConcluded", "BSD-3-Clause") 399 if err != nil { 400 t.Errorf("expected nil error, got %v", err) 401 } 402 if parser.snippet.SnippetLicenseConcluded != "BSD-3-Clause" { 403 t.Errorf("got %v for SnippetLicenseConcluded", parser.snippet.SnippetLicenseConcluded) 404 } 405 406 // License Information in Snippet 407 lics := []string{ 408 "Apache-2.0", 409 "GPL-2.0-or-later", 410 "CC0-1.0", 411 } 412 for _, lic := range lics { 413 err = parser.parsePairFromSnippet2_2("LicenseInfoInSnippet", lic) 414 if err != nil { 415 t.Errorf("expected nil error, got %v", err) 416 } 417 } 418 for _, licWant := range lics { 419 flagFound := false 420 for _, licCheck := range parser.snippet.LicenseInfoInSnippet { 421 if licWant == licCheck { 422 flagFound = true 423 } 424 } 425 if flagFound == false { 426 t.Errorf("didn't find %s in LicenseInfoInSnippet", licWant) 427 } 428 } 429 if len(lics) != len(parser.snippet.LicenseInfoInSnippet) { 430 t.Errorf("expected %d licenses in LicenseInfoInSnippet, got %d", len(lics), 431 len(parser.snippet.LicenseInfoInSnippet)) 432 } 433 434 // Snippet Comments on License 435 err = parser.parsePairFromSnippet2_2("SnippetLicenseComments", "this is a comment about the licenses") 436 if err != nil { 437 t.Errorf("expected nil error, got %v", err) 438 } 439 if parser.snippet.SnippetLicenseComments != "this is a comment about the licenses" { 440 t.Errorf("got %v for SnippetLicenseComments", parser.snippet.SnippetLicenseComments) 441 } 442 443 // Snippet Copyright Text 444 err = parser.parsePairFromSnippet2_2("SnippetCopyrightText", "copyright (c) John Doe and friends") 445 if err != nil { 446 t.Errorf("expected nil error, got %v", err) 447 } 448 if parser.snippet.SnippetCopyrightText != "copyright (c) John Doe and friends" { 449 t.Errorf("got %v for SnippetCopyrightText", parser.snippet.SnippetCopyrightText) 450 } 451 452 // Snippet Comment 453 err = parser.parsePairFromSnippet2_2("SnippetComment", "this is a comment about the snippet") 454 if err != nil { 455 t.Errorf("expected nil error, got %v", err) 456 } 457 if parser.snippet.SnippetComment != "this is a comment about the snippet" { 458 t.Errorf("got %v for SnippetComment", parser.snippet.SnippetComment) 459 } 460 461 // Snippet Name 462 err = parser.parsePairFromSnippet2_2("SnippetName", "from some other package called abc") 463 if err != nil { 464 t.Errorf("expected nil error, got %v", err) 465 } 466 if parser.snippet.SnippetName != "from some other package called abc" { 467 t.Errorf("got %v for SnippetName", parser.snippet.SnippetName) 468 } 469 470 // Snippet Attribution Texts 471 attrs := []string{ 472 "Include this notice in all advertising materials", 473 "This is a \nmulti-line string", 474 } 475 for _, attr := range attrs { 476 err = parser.parsePairFromSnippet2_2("SnippetAttributionText", attr) 477 if err != nil { 478 t.Errorf("expected nil error, got %v", err) 479 } 480 } 481 for _, attrWant := range attrs { 482 flagFound := false 483 for _, attrCheck := range parser.snippet.SnippetAttributionTexts { 484 if attrWant == attrCheck { 485 flagFound = true 486 } 487 } 488 if flagFound == false { 489 t.Errorf("didn't find %s in SnippetAttributionText", attrWant) 490 } 491 } 492 if len(attrs) != len(parser.snippet.SnippetAttributionTexts) { 493 t.Errorf("expected %d attribution texts in SnippetAttributionTexts, got %d", len(attrs), 494 len(parser.snippet.SnippetAttributionTexts)) 495 } 496 497} 498 499func TestParser2_2SnippetUnknownTagFails(t *testing.T) { 500 parser := tvParser2_2{ 501 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 502 st: psSnippet2_2, 503 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 504 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 505 snippet: &v2_2.Snippet{SnippetSPDXIdentifier: "s1"}, 506 } 507 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 508 parser.pkg.Files = append(parser.pkg.Files, parser.file) 509 510 err := parser.parsePairFromSnippet2_2("blah", "something") 511 if err == nil { 512 t.Errorf("expected error from parsing unknown tag") 513 } 514} 515 516func TestParser2_2FailsForInvalidSnippetSPDXID(t *testing.T) { 517 parser := tvParser2_2{ 518 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 519 st: psSnippet2_2, 520 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 521 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 522 snippet: &v2_2.Snippet{}, 523 } 524 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 525 parser.pkg.Files = append(parser.pkg.Files, parser.file) 526 527 // invalid Snippet SPDX Identifier 528 err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "whoops") 529 if err == nil { 530 t.Errorf("expected non-nil error, got nil") 531 } 532} 533 534func TestParser2_2FailsForInvalidSnippetFromFileSPDXID(t *testing.T) { 535 parser := tvParser2_2{ 536 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 537 st: psSnippet2_2, 538 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 539 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 540 snippet: &v2_2.Snippet{}, 541 } 542 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 543 parser.pkg.Files = append(parser.pkg.Files, parser.file) 544 545 // start with Snippet SPDX Identifier 546 err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") 547 if err != nil { 548 t.Errorf("expected nil error, got %v", err) 549 } 550 // invalid From File identifier 551 err = parser.parsePairFromSnippet2_2("SnippetFromFileSPDXID", "whoops") 552 if err == nil { 553 t.Errorf("expected non-nil error, got nil") 554 } 555} 556 557func TestParser2_2FailsForInvalidSnippetByteValues(t *testing.T) { 558 parser := tvParser2_2{ 559 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 560 st: psSnippet2_2, 561 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 562 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 563 snippet: &v2_2.Snippet{}, 564 } 565 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 566 parser.pkg.Files = append(parser.pkg.Files, parser.file) 567 568 // start with Snippet SPDX Identifier 569 err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") 570 if err != nil { 571 t.Errorf("expected nil error, got %v", err) 572 } 573 // invalid byte formats and values 574 err = parser.parsePairFromSnippet2_2("SnippetByteRange", "200 210") 575 if err == nil { 576 t.Errorf("expected non-nil error, got nil") 577 } 578 err = parser.parsePairFromSnippet2_2("SnippetByteRange", "a:210") 579 if err == nil { 580 t.Errorf("expected non-nil error, got nil") 581 } 582 err = parser.parsePairFromSnippet2_2("SnippetByteRange", "200:a") 583 if err == nil { 584 t.Errorf("expected non-nil error, got nil") 585 } 586} 587 588func TestParser2_2FailsForInvalidSnippetLineValues(t *testing.T) { 589 parser := tvParser2_2{ 590 doc: &v2_2.Document{Packages: []*v2_2.Package{}}, 591 st: psSnippet2_2, 592 pkg: &v2_2.Package{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*v2_2.File{}}, 593 file: &v2_2.File{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[common.ElementID]*v2_2.Snippet{}}, 594 snippet: &v2_2.Snippet{}, 595 } 596 parser.doc.Packages = append(parser.doc.Packages, parser.pkg) 597 parser.pkg.Files = append(parser.pkg.Files, parser.file) 598 599 // start with Snippet SPDX Identifier 600 err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") 601 if err != nil { 602 t.Errorf("expected nil error, got %v", err) 603 } 604 // invalid byte formats and values 605 err = parser.parsePairFromSnippet2_2("SnippetLineRange", "200 210") 606 if err == nil { 607 t.Errorf("expected non-nil error, got nil") 608 } 609 err = parser.parsePairFromSnippet2_2("SnippetLineRange", "a:210") 610 if err == nil { 611 t.Errorf("expected non-nil error, got nil") 612 } 613 err = parser.parsePairFromSnippet2_2("SnippetLineRange", "200:a") 614 if err == nil { 615 t.Errorf("expected non-nil error, got nil") 616 } 617} 618 619func TestParser2_2FilesWithoutSpdxIdThrowErrorWithSnippets(t *testing.T) { 620 // Invalid file with snippet 621 // Last unpackaged file before the snippet starts 622 // Last file of a package and New package starts 623 fileName := "f2.txt" 624 sid1 := common.ElementID("s1") 625 parser2 := tvParser2_2{ 626 doc: &v2_2.Document{}, 627 st: psCreationInfo2_2, 628 file: &v2_2.File{FileName: fileName}, 629 } 630 err := parser2.parsePair2_2("SnippetSPDXID", string(sid1)) 631 if err == nil { 632 t.Errorf("file without SPDX Identifier getting accepted") 633 } 634 635} 636