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
}
