func TestHost32(t *testing.T) { if !Host32(i32).Equals(Host32(i32)) { t.Error("Host32 fail: Equality") } if r, _ := Host32(i32).Test(b16); r { t.Error("Host32 fail: shouldn't match") } if r, l := Host32(i32).Test(l32); !r || l != 4 { t.Error("Host32 fail: should match") } if r, l := Host32(i32).Test(b32); !r || l != 4 { t.Error("Host32 fail: should match") } if r, l := Host32(i32).TestR(l32); !r || l != 4 { t.Error("Host32 fail: should match reverse") } if r, l := Host32(i32).TestR(b32); !r || l != 4 { t.Error("Host32 fail: should match reverse") } saver := persist.NewLoadSaver(nil) Host32(i32).Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loadHost32(loader) if !p.Equals(Host32(i32)) { t.Errorf("expecting %d, got %s", i32, p) } }
func TestIgnoreCase(t *testing.T) { apple := []byte("AppLe") apple2 := []byte("apple") if !IgnoreCase(apple).Equals(IgnoreCase(apple2)) { t.Error("IgnoreCase fail: Equality") } if r, _ := IgnoreCase(apple).Test([]byte("banana")); r { t.Error("IgnoreCase fail: shouldn't match") } if r, l := IgnoreCase(apple).Test(IgnoreCase(apple2)); !r || l != 5 { t.Error("IgnoreCase fail: should match") } if r, l := IgnoreCase(apple).TestR(IgnoreCase(apple2)); !r || l != 5 { t.Error("IgnoreCase fail: should match reverse") } if i := IgnoreCase("!bYt*e").NumSequences(); i != 16 { t.Errorf("IgnoreCase fail: numsequences expected %d, got %d", 16, i) } saver := persist.NewLoadSaver(nil) IgnoreCase(apple).Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loadIgnoreCase(loader) if !p.Equals(IgnoreCase(apple)) { t.Errorf("expecting %v, got %v", IgnoreCase(apple), p) } if seqs := IgnoreCase([]byte("a!cd")).Sequences(); len(seqs) != 8 { t.Errorf("IgnoreCase sequences %v", seqs) } }
func TestProcessFmt134(t *testing.T) { m, _, _ := Add(nil, SignatureSet{}, nil) b := m.(*Matcher) config.SetDistance(1000) config.SetRange(500) config.SetChoices(3) b.addSignature(tests.TestFmts[134]) saver := persist.NewLoadSaver(nil) Save(b, saver) loader := persist.NewLoadSaver(saver.Bytes()) b = Load(loader).(*Matcher) if len(b.keyFrames[0]) != 8 { for _, v := range b.keyFrames[0] { t.Errorf("%s\n", v) } } for _, t := range b.tests { t.maxLeftDistance = maxLength(t.left) t.maxRightDistance = maxLength(t.right) } if len(b.tests) != 8 { for _, v := range b.tests { t.Error(v.maxRightDistance) t.Error(v.right) } } }
func TestMatcher(t *testing.T) { ctypes = []ctype{{testTrigger, newTestReader}} // test adding count++ testMatcher, _, err := Add(Matcher{testContainerMatcher}, SignatureSet{ 0, [][]string{{"one", "two"}, {"one"}}, [][]frames.Signature{{tests.TestSignatures[3], tests.TestSignatures[4]}, {tests.TestSignatures[2]}}, }, nil, ) if err != nil { t.Fatal(err) } // test IO str := testMatcher.String() saver := persist.NewLoadSaver(nil) Save(testMatcher, saver) if len(saver.Bytes()) < 100 { t.Errorf("Save container: too small, only got %v", len(saver.Bytes())) } newcm := Load(persist.NewLoadSaver(saver.Bytes())) str2 := newcm.String() if len(str) != len(str2) { t.Errorf("Load container: expecting first matcher (%v), to equal second matcher (%v)", str, str2) } }
func TestNew(t *testing.T) { config.SetHome(filepath.Join("..", "..", "cmd", "roy", "data")) config.SetMIMEInfo("tika-mimetypes.xml")() mi, err := newMIMEInfo(config.MIMEInfo()) if err != nil { t.Error(err) } sigs, ids, err := mi.Signatures() if err != nil { t.Error(err) } for i, v := range sigs { if len(v) == 0 { t.Errorf("Empty signature: %s", ids[i]) } } id, _ := New() str := id.String() saver := persist.NewLoadSaver(nil) id.Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() id2 := Load(loader) if str != id2.String() { t.Errorf("Load identifier fail: got %s, expect %s", str, id2.String()) } }
func TestMask(t *testing.T) { apple := Mask{ pat: patterns.Sequence{'a', 'p', 'p', 0, 0, 'l', 'e'}, val: []byte{255, 255, 255, 0, 0, 255, 255}, } apple2 := Mask{ pat: patterns.Sequence{'a', 'p', 'p', 0, 0, 'l', 'e'}, val: []byte{255, 255, 255, 0, 0, 255, 255}, } if !apple.Equals(apple2) { t.Error("Mask fail: Equality") } if r, _ := apple.Test([]byte("apPyzle")); r { t.Error("Mask fail: shouldn't match") } if r, l := apple.Test([]byte("appyzle")); !r || l != 7 { t.Error("Mask fail: should match") } if r, l := apple.TestR([]byte("appyzle")); !r || l != 7 { t.Error("Mask fail: should match reverse") } saver := persist.NewLoadSaver(nil) apple.Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loadMask(loader) if !p.Equals(apple) { t.Errorf("expecting %s, got %s", apple, p) } seqsTest := Mask{ pat: patterns.Sequence("ap"), val: []byte{0xFF, 0xFE}, } if seqs := seqsTest.Sequences(); len(seqs) != 2 || seqs[1][1] != 'q' { t.Error(seqs) } pats, ints := unmask(apple) if len(ints) != 2 || ints[0] != 0 || ints[1] != 2 { t.Errorf("Unmask fail, got ints %v", ints) } if len(pats) != 2 || !pats[0].Equals(patterns.Sequence("app")) || !pats[1].Equals(patterns.Sequence("le")) { t.Errorf("Unmask fail, got pats %v", pats) } pats, ints = unmask(Mask{ pat: patterns.Sequence{'A', 'C', '0', '0', '0', '0'}, val: []byte{0xFF, 0xFF, 0xF0, 0xF0, 0xF0, 0xF0}, }) if len(ints) != 2 || ints[0] != 0 || ints[1] != 0 { t.Errorf("Unmask fail, got ints %v", ints) } if len(pats) != 2 || !pats[0].Equals(patterns.Sequence("AC")) || !pats[1].Equals(Mask{ pat: patterns.Sequence{'0', '0', '0', '0'}, val: []byte{0xF0, 0xF0, 0xF0, 0xF0}, }) { t.Errorf("Unmask fail, got pats %v", pats) } }
func TestSet(t *testing.T) { m := make(Map) m.Add("apple", "orange") m.Add("orange", "banana") m.Add("orange", "grapes") m.Add("banana", "grapes") m.Add("banana", "grapefruit") m.Complete() list := m.List([]string{"apple", "grapes", "grapes", "banana", "banana", "apple"}) list2 := m.List([]string{"grapefruit", "banana", "grapes"}) s := &Set{} s.Add(list, len(list), -1, -1) s.Add(list2, len(list2), -1, -1) // test save/load saver := persist.NewLoadSaver(nil) s.Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) s = Load(loader) // now test the waitset w := s.WaitSet() if !w.Check(8) { t.Error("Priority: should get continue signal") } if w.Put(8) { t.Error("Priority: should not be satisfied") } if !w.Put(1) { t.Error("Priority: should be satisfied") } w.Put(7) if !w.Check(6) { t.Error("Priority: expecting to be waiting on grapefruits") } wo := w.WaitingOn() if len(wo) != 2 { t.Error("Priority: expecting to be waiting on two") } if wo[0] != 6 { t.Error("Priority: expecting to be waiting on grapefruits") } l := w.Filter([]int{5, 6}) if len(l) != 1 { t.Error("Priority: bad filter, expecting to be waiting on grapefruits") } if l[0] != 6 { t.Error("Priority: bad filter, expecting to be waiting on grapefruits") } l = w.Filter([]int{1, 2}) if l != nil { t.Error("Priority: bad filter, nil list") } }
func TestMaxLength(t *testing.T) { test := &testTree{} test.add([2]int{0, 0}, []frames.Frame{}, []frames.Frame{tests.TestFrames[0], tests.TestFrames[3], tests.TestFrames[6]}) test.add([2]int{0, 0}, []frames.Frame{}, []frames.Frame{tests.TestFrames[1], tests.TestFrames[3]}) saver := persist.NewLoadSaver(nil) saveTests(saver, []*testTree{test, test}) loader := persist.NewLoadSaver(saver.Bytes()) tests := loadTests(loader) test = tests[1] if maxLength(test.right) != 33 { t.Errorf("maxLength fail: expecting 33 got %v", maxLength(test.right)) } }
func TestProcessFmt363(t *testing.T) { m, _, _ := Add(nil, SignatureSet{}, nil) b := m.(*Matcher) b.addSignature(tests.TestFmts[363]) saver := persist.NewLoadSaver(nil) Save(b, saver) loader := persist.NewLoadSaver(saver.Bytes()) b = Load(loader).(*Matcher) if len(b.keyFrames[0]) != 2 { for _, v := range b.keyFrames[0] { t.Errorf("%s\n", v) } } }
func TestIO(t *testing.T) { str := rm.String() saver := persist.NewLoadSaver(nil) Save(rm, saver) if len(saver.Bytes()) < 10 { t.Errorf("Save riff matcher: too small, only got %v", saver.Bytes()) } loader := persist.NewLoadSaver(saver.Bytes()) newrm := Load(loader) str2 := newrm.String() if str != str2 { t.Errorf("Load riff matcher: expecting first matcher (%v), to equal second matcher (%v)", str, str2) } }
func TestProcess(t *testing.T) { m, _, _ := Add(nil, SignatureSet{}, nil) b := m.(*Matcher) config.SetDistance(8192)() config.SetRange(2059)() config.SetChoices(9)() for i, v := range tests.TestSignatures { err := b.addSignature(v) if err != nil { t.Errorf("Unexpected error adding persist; sig %v; error %v", i, v) } } saver := persist.NewLoadSaver(nil) Save(b, saver) loader := persist.NewLoadSaver(saver.Bytes()) b = Load(loader).(*Matcher) if len(b.keyFrames) != 6 { t.Errorf("Expecting 6 keyframe slices, got %d", len(b.keyFrames)) } var tl int for _, v := range b.keyFrames { tl += len(v) } if tl != 12 { t.Errorf("Expecting a total of 12 keyframes, got %d", tl) } if len(b.tests) != 9 { t.Errorf("Expecting a total of 9 tests, got %d", len(b.tests)) } if len(b.bofSeq.set) != 4 { t.Errorf("Expecting 4 BOF seqs, got %d", len(b.bofSeq.set)) } e1 := wac.Seq{[]int64{0}, []wac.Choice{{[]byte{'t', 'e', 's', 't'}}}} if !seqEquals(b.bofSeq.set[0], e1) { t.Errorf("Expecting %v to equal %v", b.bofSeq.set[0], e1) } e2 := wac.Seq{[]int64{-1}, []wac.Choice{{[]byte{'t', 'e', 's', 't'}}}} if seqEquals(b.bofSeq.set[0], e2) { t.Errorf("Not expecting %v to equal %v", b.bofSeq.set[0], e2) } if len(b.eofSeq.set) != 2 { t.Errorf("Expecting two EOF seqs, got %d, first is %v", len(b.eofSeq.set), b.eofSeq.set[0]) } if len(b.bofFrames.set) != 1 { t.Errorf("Expecting one BOF Frame, got %d", len(b.bofFrames.set)) } if len(b.eofFrames.set) != 0 { t.Errorf("Expecting no EOF frame, got %d", len(b.eofFrames.set)) } }
func TestIO(t *testing.T) { sm, _, _ = Add(nil, SignatureSet{"*.bla", "*.doc", "*.ppt"}, nil) str := sm.String() saver := persist.NewLoadSaver(nil) Save(sm, saver) if len(saver.Bytes()) < 10 { t.Errorf("Save string matcher: too small, only got %v", saver.Bytes()) } loader := persist.NewLoadSaver(saver.Bytes()) newsm := Load(loader) str2 := newsm.String() if str != str2 { t.Errorf("Load string matcher: expecting first matcher (%v), to equal second matcher (%v)", str, str2) } }
// Save persists a Siegfried struct to disk (path) func (s *Siegfried) Save(path string) error { ls := persist.NewLoadSaver(nil) ls.SaveTime(s.C) namematcher.Save(s.nm, ls) mimematcher.Save(s.mm, ls) containermatcher.Save(s.cm, ls) xmlmatcher.Save(s.xm, ls) riffmatcher.Save(s.rm, ls) bytematcher.Save(s.bm, ls) textmatcher.Save(s.tm, ls) ls.SaveTinyUInt(len(s.ids)) for _, i := range s.ids { i.Save(ls) } if ls.Err != nil { return ls.Err } f, err := os.Create(path) if err != nil { return err } defer f.Close() _, err = f.Write(append(config.Magic(), byte(config.Version()[0]), byte(config.Version()[1]))) if err != nil { return err } z, err := flate.NewWriter(f, 1) if err != nil { return err } _, err = z.Write(ls.Bytes()) z.Close() return err }
func TestProcessFmt418(t *testing.T) { m, _, _ := Add(nil, SignatureSet{}, nil) b := m.(*Matcher) config.SetDistance(2000)() config.SetRange(500)() config.SetChoices(10)() b.addSignature(tests.TestFmts[418]) saver := persist.NewLoadSaver(nil) Save(b, saver) loader := persist.NewLoadSaver(saver.Bytes()) b = Load(loader).(*Matcher) if len(b.keyFrames[0]) != 2 { for _, v := range b.keyFrames[0] { t.Errorf("%s\n", v) } } }
func TestIO(t *testing.T) { bm, _, err := Add(nil, SignatureSet(tests.TestSignatures), nil) if err != nil { t.Error(err) } saver := persist.NewLoadSaver(nil) Save(bm, saver) if len(saver.Bytes()) < 100 { t.Errorf("Save bytematcher: too small, only got %v", len(saver.Bytes())) } newbm := Load(persist.NewLoadSaver(saver.Bytes())) nsaver := persist.NewLoadSaver(nil) Save(newbm, nsaver) if len(nsaver.Bytes()) != len(saver.Bytes()) { t.Fatalf("expecting the bms to match length: %d and %d", len(saver.Bytes()), len(nsaver.Bytes())) } if string(nsaver.Bytes()) != string(saver.Bytes()) { t.Errorf("Load bytematcher: expecting first bytematcher (%v), to equal second bytematcher (%v)", bm.String(), newbm.String()) } }
func TestLittle16(t *testing.T) { if !Little16(i16).Equals(Little16(i16)) { t.Error("Little16 fail: Equality") } if r, _ := Little16(i16).Test(b16); r { t.Error("Little16 fail: shouldn't match") } if r, l := Little16(i16).Test(l16); !r || l != 2 { t.Error("Little16 fail: should match") } if r, l := Little16(i16).TestR(l16); !r || l != 2 { t.Error("Little16 fail: should match reverse") } saver := persist.NewLoadSaver(nil) Little16(i16).Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loadLittle16(loader) if !p.Equals(Little16(i16)) { t.Errorf("expecting %d, got %s", i16, p) } }
func TestInt8(t *testing.T) { if !Int8(i8).Equals(Int8(i8)) { t.Error("Int8 fail: Equality") } if r, _ := Int8(i8).Test([]byte{7}); r { t.Error("Int8 fail: shouldn't match") } if r, l := Int8(i8).Test([]byte{i8}); !r || l != 1 { t.Error("Int8 fail: should match") } if r, l := Int8(i8).TestR([]byte{i8}); !r || l != 1 { t.Error("Int8 fail: should match reverse") } saver := persist.NewLoadSaver(nil) Int8(i8).Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loadInt8(loader) if !p.Equals(Int8(i8)) { t.Errorf("expecting %d, got %s", i8, p) } }
func TestLittle32(t *testing.T) { if !Little32(i32).Equals(Little32(i32)) { t.Error("Little32 fail: Equality") } if r, _ := Little32(i32).Test(b32); r { t.Error("Big32 fail: shouldn't match") } if r, l := Little32(i32).Test(l32); !r || l != 4 { t.Error("Little32 fail: should match") } if r, l := Little32(i32).TestR(l32); !r || l != 4 { t.Error("Little32 fail: should match") } saver := persist.NewLoadSaver(nil) Little32(i32).Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loadLittle32(loader) if !p.Equals(Little32(i32)) { t.Errorf("expecting %d, got %s", i32, p) } }
func TestSequence(t *testing.T) { if !TestSequences[0].Equals(TestSequences[1]) { t.Error("Seq fail: Equality") } if r, _ := TestSequences[0].Test([]byte{'t', 'o', 'o', 't'}); r { t.Error("Sequence fail: shouldn't match") } if _, l := TestSequences[2].Test([]byte{'t', 'e', 's', 't', 'y'}); l != 5 { t.Error("Sequence fail: should match") } reverseSeq := TestSequences[2].Reverse() if reverseSeq[1] != 't' || reverseSeq[2] != 's' || reverseSeq[3] != 'e' || reverseSeq[4] != 't' { t.Error("Sequence fail: Reverse") } saver := persist.NewLoadSaver(nil) TestSequences[0].Save(saver) loader := persist.NewLoadSaver(saver.Bytes()) _ = loader.LoadByte() p := loader.LoadBytes() if len(p) != 4 { t.Errorf("expecting %v, got %v", TestSequences[0], string(p)) } }
// Load creates a Siegfried struct and loads content from path func Load(path string) (*Siegfried, error) { errOpening := "siegfried: error opening signature file, got %v; try running `sf -update`" errNotSig := "siegfried: not a siegfried signature file; try running `sf -update`" errUpdateSig := "siegfried: signature file is incompatible with this version of sf; try running `sf -update`" fbuf, err := ioutil.ReadFile(path) if err != nil { return nil, fmt.Errorf(errOpening, err) } if len(fbuf) < len(config.Magic())+2 { return nil, fmt.Errorf(errNotSig) } if string(fbuf[:len(config.Magic())]) != string(config.Magic()) { return nil, fmt.Errorf(errNotSig) } if major, minor := fbuf[len(config.Magic())], fbuf[len(config.Magic())+1]; major < byte(config.Version()[0]) || (major == byte(config.Version()[0]) && minor < byte(config.Version()[1])) { return nil, fmt.Errorf(errUpdateSig) } r := bytes.NewBuffer(fbuf[len(config.Magic())+2:]) rc := flate.NewReader(r) defer rc.Close() buf, err := ioutil.ReadAll(rc) if err != nil { return nil, fmt.Errorf(errOpening, err) } ls := persist.NewLoadSaver(buf) return &Siegfried{ path: filepath.Base(path), C: ls.LoadTime(), nm: namematcher.Load(ls), mm: mimematcher.Load(ls), cm: containermatcher.Load(ls), xm: xmlmatcher.Load(ls), rm: riffmatcher.Load(ls), bm: bytematcher.Load(ls), tm: textmatcher.Load(ls), ids: func() []core.Identifier { ids := make([]core.Identifier, ls.LoadTinyUInt()) for i := range ids { ids[i] = core.LoadIdentifier(ls) } return ids }(), buffers: siegreader.New(), }, ls.Err }