Пример #1
0
func TestGenerateSmatCorpus(t *testing.T) {
	for i, actionSeq := range smatActionSeqs {
		byteSequence, err := actionSeq.ByteEncoding(&smatContext{},
			smat.ActionID('S'), smat.ActionID('T'), actionMap)
		if err != nil {
			t.Fatalf("error from ByteEncoding, err: %v", err)
		}
		os.MkdirAll("workdir/corpus", 0700)
		ioutil.WriteFile(fmt.Sprintf("workdir/corpus/%d", i), byteSequence, 0600)
	}
}
Пример #2
0
func init() {
	var ids []int
	for actionId := range actionMap {
		ids = append(ids, int(actionId))
	}
	sort.Ints(ids)

	pct := 100 / len(actionMap)
	for _, actionId := range ids {
		runningPercentActions = append(runningPercentActions,
			smat.PercentAction{pct, smat.ActionID(actionId)})
	}

	actionMap[smat.ActionID('S')] = action("SETUP", setupFunc)
	actionMap[smat.ActionID('T')] = action("TEARDOWN", teardownFunc)
}
Пример #3
0
// Test the previous issues found by smat.
func TestSmatHits(t *testing.T) {
	smatDebugPrev := smatDebug
	smatDebug = true // Use true when diagnosing a crash.

	for i := 0; i < len(smatHits); i += 2 {
		desc := smatHits[i]
		hit := []byte(smatHits[i+1])

		log.Printf("testing smat hit: (%d) %s\n", i/2, desc)

		// fuzz the hit input
		smat.Fuzz(&smatContext{}, smat.ActionID('S'), smat.ActionID('T'),
			smatActionMap, hit)
	}

	smatDebug = smatDebugPrev
}
Пример #4
0
// Test the previous crashers found by smat.
func TestSmatCrashers(t *testing.T) {
	smatDebugPrev := smatDebug
	smatDebug = false // Use true when diagnosing a crash.

	// smat.Logger = log.New(os.Stderr, "smat ", log.LstdFlags)

	for i := 0; i < len(smatCrashers); i += 2 {
		desc := smatCrashers[i]
		crasher := []byte(smatCrashers[i+1])

		log.Printf("testing smat crasher: (%d) %s", i/2, desc)

		// fuzz the crasher input
		smat.Fuzz(&smatContext{}, smat.ActionID('S'), smat.ActionID('T'),
			actionMap, crasher)
	}

	smatDebug = smatDebugPrev
}
Пример #5
0
// fuzz test using state machine driven by byte stream.
func Fuzz(data []byte) int {
	return smat.Fuzz(&smatContext{}, smat.ActionID('S'), smat.ActionID('T'),
		actionMap, data)
}
Пример #6
0
}

type mirrorColl struct { // Used to validate coll and snapshot entries.
	kvs  map[string]string
	keys []string // Will be nil unless this is a snapshot.
}

type mirrorIter struct { // Used to validate iterator entries.
	pos int
	ss  *mirrorColl
}

// ------------------------------------------------------------------

var actionMap = smat.ActionMap{
	smat.ActionID('.'): action("      +batch", delta(func(c *smatContext) { c.curBatch++ })),
	smat.ActionID(','): action("      -batch", delta(func(c *smatContext) { c.curBatch-- })),
	smat.ActionID('{'): action("      +snapshot", delta(func(c *smatContext) { c.curSnapshot++ })),
	smat.ActionID('}'): action("      -snapshot", delta(func(c *smatContext) { c.curSnapshot-- })),
	smat.ActionID('['): action("      +itr", delta(func(c *smatContext) { c.curIterator++ })),
	smat.ActionID(']'): action("      -itr", delta(func(c *smatContext) { c.curIterator-- })),
	smat.ActionID(':'): action("      +key", delta(func(c *smatContext) { c.curKey++ })),
	smat.ActionID(';'): action("      -key", delta(func(c *smatContext) { c.curKey-- })),
	smat.ActionID('s'): action("    set", opSetFunc),
	smat.ActionID('d'): action("    del", opDelFunc),
	smat.ActionID('m'): action("    merge", opMergeFunc),
	smat.ActionID('g'): action("    get", opGetFunc),
	smat.ActionID('B'): action("  batchCreate", batchCreateFunc),
	smat.ActionID('b'): action("  batchExecute", batchExecuteFunc),
	smat.ActionID('H'): action("  snapshotCreate", snapshotCreateFunc),
	smat.ActionID('h'): action("  snapshotClose", snapshotCloseFunc),
Пример #7
0
func TestGenerateSmatCorpus(t *testing.T) {
	for i, actionSeq := range smatActionSeqs {
		byteSequence, err := actionSeq.ByteEncoding(&smatContext{},
			smat.ActionID('S'), smat.ActionID('T'), smatActionMap)
		if err != nil {
			t.Fatalf("error from ByteEncoding, err: %v, i: %d, actonSeq: %#v",
				err, i, actionSeq)
		}
		os.MkdirAll("workdir/corpus", 0700)
		ioutil.WriteFile(fmt.Sprintf("workdir/corpus/%d", i), byteSequence, 0600)
	}
}

var smatActionSeqs = []smat.ActionSeq{
	{
		smat.ActionID('X'),
		smat.ActionID('X'),
		smat.ActionID('Y'),
		smat.ActionID('Y'),
		smat.ActionID('<'),
		smat.ActionID('<'),
		smat.ActionID('*'),
		smat.ActionID('x'),
		smat.ActionID('y'),
		smat.ActionID('*'),
		smat.ActionID('['),
		smat.ActionID('['),
		smat.ActionID('B'),
		smat.ActionID('a'),
		smat.ActionID('o'),
		smat.ActionID('A'),
Пример #8
0
	// Two registers, x & y.
	x int
	y int

	actions int
}

type smatPair struct {
	bm *Bitmap
	bs *bitset.BitSet
}

// ------------------------------------------------------------------

var smatActionMap = smat.ActionMap{
	smat.ActionID('X'): smatAction("x++", smatWrap(func(c *smatContext) { c.x++ })),
	smat.ActionID('x'): smatAction("x--", smatWrap(func(c *smatContext) { c.x-- })),
	smat.ActionID('Y'): smatAction("y++", smatWrap(func(c *smatContext) { c.y++ })),
	smat.ActionID('y'): smatAction("y--", smatWrap(func(c *smatContext) { c.y-- })),
	smat.ActionID('*'): smatAction("x*y", smatWrap(func(c *smatContext) { c.x = c.x * c.y })),
	smat.ActionID('<'): smatAction("x<<", smatWrap(func(c *smatContext) { c.x = c.x << 1 })),

	smat.ActionID('^'): smatAction("swap", smatWrap(func(c *smatContext) { c.x, c.y = c.y, c.x })),

	smat.ActionID('['): smatAction(" pushPair", smatWrap(smatPushPair)),
	smat.ActionID(']'): smatAction(" popPair", smatWrap(smatPopPair)),

	smat.ActionID('B'): smatAction(" setBit", smatWrap(smatSetBit)),
	smat.ActionID('b'): smatAction(" removeBit", smatWrap(smatRemoveBit)),

	smat.ActionID('o'): smatAction(" or", smatWrap(smatOr)),
Пример #9
0
func TestGenerateSmatCorpus(t *testing.T) {
	for i, actionSeq := range smatActionSeqs {
		byteSequence, err := actionSeq.ByteEncoding(&smatContext{},
			smat.ActionID('S'), smat.ActionID('T'), actionMap)
		if err != nil {
			t.Fatalf("error from ByteEncoding, err: %v", err)
		}
		os.MkdirAll("workdir/corpus", 0700)
		ioutil.WriteFile(fmt.Sprintf("workdir/corpus/%d", i), byteSequence, 0600)
	}
}

var smatActionSeqs = []smat.ActionSeq{
	{
		smat.ActionID('g'),
		smat.ActionID('B'),
		smat.ActionID('s'),
		smat.ActionID('.'),
		smat.ActionID('d'),
		smat.ActionID('.'),
		smat.ActionID('s'),
		smat.ActionID('.'),
		smat.ActionID('b'),
		smat.ActionID('g'),
		smat.ActionID('H'),
		smat.ActionID('I'),
		smat.ActionID('>'),
		smat.ActionID('i'),
		smat.ActionID('h'),
		smat.ActionID('$'),