How to use Serialize method of compiler Package

Best Syzkaller code snippet using compiler.Serialize

search_test.go

Source:search_test.go

...17import "testing"18import "strings"19import "reflect"20import "git-wip-us.apache.org/repos/asf/lucy-clownfish.git/runtime/go/clownfish"21func checkQuerySerialize(t *testing.T, query Query) {22	folder := NewRAMFolder("")23	outStream, _ := folder.OpenOut("foo")24	query.serialize(outStream)25	outStream.Close()26	inStream, _ := folder.OpenIn("foo")27	dupe := clownfish.GetClass(query).MakeObj().(Query).deserialize(inStream)28	if !query.Equals(dupe) {29		t.Errorf("Unsuccessful serialization round trip -- expected '%v', got '%v'",30				 query.ToString(), dupe.ToString())31	}32}33func checkQueryDumpLoad(t *testing.T, query Query) {34	dupe := clownfish.GetClass(query).MakeObj().(Query)35	dupe = dupe.Load(query.Dump()).(Query)36	if !query.Equals(dupe) {37		t.Errorf("Unsuccessful Dump/Load round trip -- expected '%v', got '%v'",38				 query.ToString(), dupe.ToString())39	}40}41func checkQueryEquals(t *testing.T, query Query) {42	if !query.Equals(query) {43		t.Error("Equals self")44	}45	if query.Equals("blah") {46		t.Error("Equals against Go string")47	}48}49func checkQueryMakeCompiler(t *testing.T, query Query) {50	index := createTestIndex("foo", "bar", "baz")51	searcher, _ := OpenIndexSearcher(index)52	compiler, err := query.MakeCompiler(searcher, 1.0, false)53	if _, ok := compiler.(Compiler); !ok || err != nil {54		t.Error("MakeCompiler for %v failed: %v", query, err)55	}56}57// Test whether ToString() yields a string which contains "foo".58func checkQueryToStringHasFoo(t *testing.T, query Query) {59	if got := query.ToString(); !strings.Contains(got, "foo") {60		t.Errorf("Unexpected stringification: '%v'", got)61	}62}63func TestTermQueryMisc(t *testing.T) {64	query := NewTermQuery("content", "foo")65	checkQuerySerialize(t, query)66	checkQueryDumpLoad(t, query)67	checkQueryEquals(t, query)68	checkQueryMakeCompiler(t, query)69	checkQueryToStringHasFoo(t, query)70}71func TestTermQueryAccessors(t *testing.T) {72	query := NewTermQuery("content", "foo")73	if got := query.GetField(); got != "content" {74		t.Errorf("Expected 'content', got '%v'", got)75	}76	if got := query.GetTerm().(string); got != "foo" {77		t.Errorf("Expected 'foo', got '%v'", got)78	}79}80func TestTermCompilerMisc(t *testing.T) {81	folder := createTestIndex("foo", "bar", "baz")82	searcher, _ := OpenIndexSearcher(folder)83	query := NewTermQuery("content", "foo")84	compiler := NewTermCompiler(query, searcher, 1.0)85	checkQuerySerialize(t, compiler) 86	checkQueryEquals(t, compiler)87	checkQueryToStringHasFoo(t, compiler)88	segReaders := searcher.GetReader().SegReaders()89	matcher, err := compiler.MakeMatcher(segReaders[0].(SegReader), false)90	if matcher == nil || err != nil {91		t.Errorf("MakeMatcher: %v", err)92	}93}94func TestTermCompilerWeighting(t *testing.T) {95	index := createTestIndex("foo", "bar", "baz")96	searcher, _ := OpenIndexSearcher(index)97	query := NewTermQuery("content", "foo")98	compiler := NewTermCompiler(query, searcher, 1.0)99	_ = compiler.SumOfSquaredWeights()100	_ = compiler.GetWeight()101	compiler.ApplyNormFactor(10.0)102}103func TestPhraseQueryMisc(t *testing.T) {104	terms := []interface{}{"foo", "bar"}105	query := NewPhraseQuery("content", terms)106	checkQuerySerialize(t, query)107	checkQueryDumpLoad(t, query)108	checkQueryEquals(t, query)109	checkQueryMakeCompiler(t, query)110	checkQueryToStringHasFoo(t, query)111}112func TestPhraseQueryAccessors(t *testing.T) {113	terms := []interface{}{"foo", "bar"}114	query := NewPhraseQuery("content", terms)115	if field := query.GetField(); field != "content" {116		t.Errorf("Expected 'content', got '%v'", field)117	}118	if got := query.GetTerms(); !reflect.DeepEqual(terms, got) {119		t.Errorf("Expected '%v', got '%v'", terms, got)120	}121}122func TestPhraseCompilerMisc(t *testing.T) {123	folder := createTestIndex("foo", "bar", "baz")124	searcher, _ := OpenIndexSearcher(folder)125	terms := []interface{}{"foo", "bar"}126	query := NewPhraseQuery("content", terms)127	compiler := NewPhraseCompiler(query, searcher, 1.0)128	checkQuerySerialize(t, compiler) 129	checkQueryEquals(t, compiler)130	checkQueryToStringHasFoo(t, compiler)131}132func TestPhraseCompilerWeighting(t *testing.T) {133	index := createTestIndex("foo", "bar", "baz")134	searcher, _ := OpenIndexSearcher(index)135	terms := []interface{}{"foo", "bar"}136	query := NewPhraseQuery("content", terms)137	compiler := NewPhraseCompiler(query, searcher, 1.0)138	_ = compiler.SumOfSquaredWeights()139	_ = compiler.GetWeight()140	compiler.ApplyNormFactor(10.0)141}142func TestANDQueryBasics(t *testing.T) {143	children := []Query{144		NewTermQuery("content", "foo"),145		NewTermQuery("content", "bar"),146	}147	query := NewANDQuery(children)148	checkQuerySerialize(t, query)149	checkQueryDumpLoad(t, query)150	checkQueryEquals(t, query)151	checkQueryMakeCompiler(t, query)152	checkQueryToStringHasFoo(t, query)153}154func TestORQueryBasics(t *testing.T) {155	children := []Query{156		NewTermQuery("content", "foo"),157		NewTermQuery("content", "bar"),158	}159	query := NewORQuery(children)160	checkQuerySerialize(t, query)161	checkQueryDumpLoad(t, query)162	checkQueryEquals(t, query)163	checkQueryMakeCompiler(t, query)164	checkQueryToStringHasFoo(t, query)165}166func TestReqOptQueryBasics(t *testing.T) {167	req := NewTermQuery("content", "foo")168	opt := NewTermQuery("content", "bar")169	query := NewRequiredOptionalQuery(req, opt)170	checkQuerySerialize(t, query)171	checkQueryDumpLoad(t, query)172	checkQueryEquals(t, query)173	checkQueryMakeCompiler(t, query)174	checkQueryToStringHasFoo(t, query)175}176func TestReqOptQueryAccessors(t *testing.T) {177	req := NewTermQuery("content", "foo")178	opt := NewTermQuery("content", "bar")179	query := NewRequiredOptionalQuery(req, opt)180	if query.GetRequiredQuery().TOPTR() != req.TOPTR() {181		t.Errorf("GetRequiredQuery")182	}183	if query.GetOptionalQuery().TOPTR() != opt.TOPTR() {184		t.Errorf("GetOptionalQuery")185	}186}187func TestNOTQueryBasics(t *testing.T) {188	negated := NewTermQuery("content", "foo")189	query := NewNOTQuery(negated)190	checkQuerySerialize(t, query)191	checkQueryDumpLoad(t, query)192	checkQueryEquals(t, query)193	checkQueryMakeCompiler(t, query)194	checkQueryToStringHasFoo(t, query)195}196func TestNOTQueryAccessors(t *testing.T) {197	negated := NewTermQuery("content", "foo")198	query := NewNOTQuery(negated)199	if query.GetNegatedQuery().TOPTR() != negated.TOPTR() {200		t.Errorf("GetNegatedQuery")201	}202}203func TestMatchAllQueryBasics(t *testing.T) {204	query := NewMatchAllQuery()205	checkQuerySerialize(t, query)206	checkQueryDumpLoad(t, query)207	checkQueryEquals(t, query)208	checkQueryMakeCompiler(t, query)209}210func TestNOMatchQueryBasics(t *testing.T) {211	query := NewNoMatchQuery()212	checkQuerySerialize(t, query)213	checkQueryDumpLoad(t, query)214	checkQueryEquals(t, query)215	checkQueryMakeCompiler(t, query)216}217func TestRangeQueryBasics(t *testing.T) {218	query := NewRangeQuery("content", "fab", "foo", true, true)219	checkQuerySerialize(t, query)220	checkQueryDumpLoad(t, query)221	checkQueryEquals(t, query)222	checkQueryMakeCompiler(t, query)223	checkQueryToStringHasFoo(t, query)224}225func TestLeafQueryBasics(t *testing.T) {226	query := NewLeafQuery("content", "foo")227	checkQuerySerialize(t, query)228	checkQueryDumpLoad(t, query)229	checkQueryEquals(t, query)230	checkQueryToStringHasFoo(t, query)231}232func checkMatcher(t *testing.T, matcher Matcher, supportsScore bool) {233	if got := matcher.Next(); got != 42 {234		t.Error("Next: %d", got)235	}236	if got := matcher.GetDocID(); got != 42 {237		t.Error("GetDocID: %d", got)238	}239	if supportsScore {240		if score := matcher.Score(); score != 2 {241			t.Error("Score: %f", score)...

serializer.go

Source:serializer.go

...8	"github.com/marianogappa/predictions/core"9	"github.com/marianogappa/predictions/printer"10	"github.com/rs/zerolog/log"11)12// PredictionSerializer is the component that serializes a Prediction to a string representation, to be persisted or13// returned in an API call.14type PredictionSerializer struct {15	mkt *core.IMarket16}17// NewPredictionSerializer constructs a PredictionSerializer.18func NewPredictionSerializer(market *core.IMarket) PredictionSerializer {19	return PredictionSerializer{mkt: market}20}21// PreSerialize serializes a Prediction to a compiler.Prediction, but doesn't take the extra step of serializing it to a22// JSON []byte.23func (s PredictionSerializer) PreSerialize(p *core.Prediction) (compiler.Prediction, error) {24	pp, err := marshalPrePredict(p.PrePredict)25	if err != nil {26		return compiler.Prediction{}, err27	}28	pd, err := marshalPredict(p.Predict)29	if err != nil {30		return compiler.Prediction{}, err31	}32	return compiler.Prediction{33		UUID:            p.UUID,34		Version:         p.Version,35		CreatedAt:       p.CreatedAt,36		Reporter:        p.Reporter,37		PostAuthor:      p.PostAuthor,38		PostAuthorURL:   p.PostAuthorURL,39		PostedAt:        p.PostedAt,40		PostURL:         p.PostURL,41		Given:           marshalGiven(p.Given),42		PrePredict:      pp,43		Predict:         pd,44		PredictionState: marshalPredictionState(p.State),45		Type:            p.Type.String(),46		Paused:          p.Paused,47		Hidden:          p.Hidden,48		Deleted:         p.Deleted,49	}, nil50}51// PreSerializeForDB serializes a Prediction to a compiler.Prediction, but doesn't take the extra step of serializing it52// to a JSON []byte.53func (s PredictionSerializer) PreSerializeForDB(p *core.Prediction) (compiler.Prediction, error) {54	pp, err := marshalPrePredict(p.PrePredict)55	if err != nil {56		return compiler.Prediction{}, err57	}58	pd, err := marshalPredict(p.Predict)59	if err != nil {60		return compiler.Prediction{}, err61	}62	return compiler.Prediction{63		UUID:            p.UUID,64		Version:         p.Version,65		CreatedAt:       p.CreatedAt,66		Reporter:        p.Reporter,67		PostAuthor:      p.PostAuthor,68		PostAuthorURL:   p.PostAuthorURL,69		PostedAt:        p.PostedAt,70		PostURL:         p.PostURL,71		Given:           marshalGiven(p.Given),72		PrePredict:      pp,73		Predict:         pd,74		PredictionState: marshalPredictionState(p.State),75		Type:            p.Type.String(),76	}, nil77}78// Serialize serializes a Prediction to a JSON []byte. It is meant to be used for persisting, but must not be used79// by the API. There's a separate PreSerializeForAPI method for that purpose.80func (s PredictionSerializer) Serialize(p *core.Prediction) ([]byte, error) {81	pre, err := s.PreSerialize(p)82	if err != nil {83		return nil, err84	}85	return json.Marshal(pre)86}87// SerializeForDB serializes a Prediction to a JSON []byte. It is meant to be used for persisting, but must only be used88// by the DB.89func (s PredictionSerializer) SerializeForDB(p *core.Prediction) ([]byte, error) {90	pre, err := s.PreSerializeForDB(p)91	if err != nil {92		return nil, err93	}94	return json.Marshal(pre)95}96// PreSerializeForAPI serializes a Prediction to a compiler.Prediction, but doesn't take the extra step of serializing97// it to a JSON []byte. It is meant to be used only by the API.98func (s PredictionSerializer) PreSerializeForAPI(p *core.Prediction, includeSummary bool) (compiler.Prediction, error) {99	pred := compiler.Prediction{100		UUID:            p.UUID,101		Version:         p.Version,102		CreatedAt:       p.CreatedAt,103		Reporter:        p.Reporter,104		PostAuthor:      p.PostAuthor,105		PostAuthorURL:   p.PostAuthorURL,106		PostedAt:        p.PostedAt,107		PostURL:         p.PostURL,108		PredictionState: marshalPredictionState(p.State),109		Type:            p.Type.String(),110		PredictionText:  printer.NewPredictionPrettyPrinter(*p).String(),111		Summary:         compiler.PredictionSummary{},112		Paused:          p.Paused,113		Hidden:          p.Hidden,114		Deleted:         p.Deleted,115	}116	if includeSummary && s.mkt != nil {117		var err error118		pred.Summary, err = s.BuildPredictionMarketSummary(*p)119		if err != nil {120			log.Error().Err(err).Msg("compiler.PreSerializeForAPI: writing summary failed")121			return pred, err122		}123	}124	return pred, nil125}126// SerializeForAPI serializes a Prediction to a JSON []byte. It is meant to be used only by the API.127func (s PredictionSerializer) SerializeForAPI(p *core.Prediction, includeSummary bool) ([]byte, error) {128	pred, err := s.PreSerializeForAPI(p, includeSummary)129	if err != nil {130		return nil, err131	}132	return json.Marshal(pred)133}134func marshalInnerCondition(c *core.Condition) string {135	if c.Operator == "BETWEEN" {136		return fmt.Sprintf(`%v BETWEEN %v AND %v`, c.Operands[0].Str, c.Operands[1].Str, c.Operands[2].Str)137	}138	return fmt.Sprintf(`%v %v %v`, c.Operands[0].Str, c.Operator, c.Operands[1].Str)139}140func marshalGiven(given map[string]*core.Condition) map[string]compiler.Condition {141	result := map[string]compiler.Condition{}142	for key, cond := range given {143		c := compiler.Condition{144			Condition:        marshalInnerCondition(cond),145			FromISO8601:      core.ISO8601(time.Unix(int64(cond.FromTs), 0).Format(time.RFC3339)),146			ToISO8601:        core.ISO8601(time.Unix(int64(cond.ToTs), 0).Format(time.RFC3339)),147			ToDuration:       cond.ToDuration,148			Assumed:          cond.Assumed,149			ErrorMarginRatio: cond.ErrorMarginRatio,150			State: compiler.ConditionState{151				Status:    cond.State.Status.String(),152				LastTs:    cond.State.LastTs,153				LastTicks: cond.State.LastTicks,154				Value:     cond.State.Value.String(),155			},156		}157		result[key] = c158	}159	return result160}161func marshalBoolExpr(b *core.BoolExpr, nestLevel int) (*string, error) {162	if b == nil {163		return nil, nil164	}165	var prefix, suffix string166	if nestLevel > 0 {167		prefix = "("168		suffix = ")"169	}170	switch b.Operator {171	case core.LITERAL:172		return &b.Literal.Name, nil173	case core.AND, core.OR:174		operator := " and "175		if b.Operator == core.OR {176			operator = " or "177		}178		operands := []string{}179		for _, operand := range b.Operands {180			s, err := marshalBoolExpr(operand, nestLevel+1)181			if err != nil {182				return nil, err183			}184			if s == nil {185				continue186			}187			operands = append(operands, *s)188		}189		s := fmt.Sprintf("%v%v%v", prefix, strings.Join(operands, operator), suffix)190		return &s, nil191	case core.NOT:192		operand, err := marshalBoolExpr(b.Operands[0], nestLevel+1)193		if err != nil {194			return nil, err195		}196		s := fmt.Sprintf("%vnot %v%v", prefix, *operand, suffix)197		return &s, nil198	}199	return nil, fmt.Errorf("marshalBoolExpr: unknown operator '%v'", b.Operator)200}201func marshalPrePredict(pp core.PrePredict) (*compiler.PrePredict, error) {202	wrongIf, err := marshalBoolExpr(pp.WrongIf, 0)203	if err != nil {204		return nil, err205	}206	annulledIf, err := marshalBoolExpr(pp.AnnulledIf, 0)207	if err != nil {208		return nil, err209	}210	predictIf, err := marshalBoolExpr(pp.Predict, 0)211	if err != nil {212		return nil, err213	}214	result := &compiler.PrePredict{215		WrongIf:                           wrongIf,216		AnnulledIf:                        annulledIf,217		Predict:                           predictIf,218		AnnulledIfPredictIsFalse:          pp.AnnulledIfPredictIsFalse,219		IgnoreUndecidedIfPredictIsDefined: pp.IgnoreUndecidedIfPredictIsDefined,220	}221	return result, nil222}223func marshalPredict(p core.Predict) (compiler.Predict, error) {224	wrongIf, err := marshalBoolExpr(p.WrongIf, 0)225	if err != nil {226		return compiler.Predict{}, err227	}228	annulledIf, err := marshalBoolExpr(p.AnnulledIf, 0)229	if err != nil {230		return compiler.Predict{}, err231	}232	predictIf, err := marshalBoolExpr(&p.Predict, 0)233	if err != nil {234		return compiler.Predict{}, err235	}236	result := compiler.Predict{237		WrongIf:                           wrongIf,238		AnnulledIf:                        annulledIf,239		Predict:                           *predictIf,240		IgnoreUndecidedIfPredictIsDefined: p.IgnoreUndecidedIfPredictIsDefined,241	}242	return result, nil243}244func marshalPredictionState(ps core.PredictionState) compiler.PredictionState {245	return compiler.PredictionState{246		Status: ps.Status.String(),247		LastTs: ps.LastTs,248		Value:  ps.Value.String(),249	}250}251// AccountSerializer is the component that serializes an Account to a string representation, to be persisted or returned252// in an API call.253type AccountSerializer struct{}254// NewAccountSerializer constructs an AccountSerializer.255func NewAccountSerializer() AccountSerializer {256	return AccountSerializer{}257}258// Account is the struct that represents a post author's social media account.259type Account struct {260	URL           string   `json:"url"`261	AccountType   string   `json:"accountType"`262	Handle        string   `json:"handle"`263	FollowerCount int      `json:"followerCount"`264	Thumbnails    []string `json:"thumbnails"`265	Name          string   `json:"name"`266	Description   string   `json:"description"`267	CreatedAt     string   `json:"createdAt,omitempty"`268}269// PreSerialize serializes an Account to a compiler.Account, but doesn't take the extra step of serializing it to a270// JSON []byte.271func (s AccountSerializer) PreSerialize(p *core.Account) (Account, error) {272	thumbs := []string{}273	for _, thumb := range p.Thumbnails {274		thumbs = append(thumbs, thumb.String())275	}276	createdAt := ""277	if p.CreatedAt != nil {278		createdAt = p.CreatedAt.Format(time.RFC3339)279	}280	return Account{281		URL:           p.URL.String(),282		AccountType:   p.AccountType,283		Handle:        p.Handle,284		FollowerCount: p.FollowerCount,285		Thumbnails:    thumbs,286		Name:          p.Name,287		Description:   p.Description,288		CreatedAt:     createdAt,289	}, nil290}291// Serialize serializes an Account to a JSON []byte.292func (s AccountSerializer) Serialize(p *core.Account) ([]byte, error) {293	acc, err := s.PreSerialize(p)294	if err != nil {295		return nil, err296	}297	return json.Marshal(acc)298}...

compile.go

Source:compile.go

1package lex2import (3	"fmt"4	"log"5	"strings"6	"github.com/inspirer/textmapper/tm-go/status"7	"github.com/inspirer/textmapper/tm-go/util/container"8)9type Pattern struct {10	Name   string11	RE     *Regexp12	Text   string // of RE13	Origin status.SourceNode14}15type inst struct {16	consume symlist // An empty list means we cannot advance to the next instruction.17	links   []int   // Relative offsets of other instructions that should be considered at the same time.18	rule    *Rule   // The rule to be accepted.19	trace   trace   // core() instructions only: the trace of this instruction20}21func (i inst) core() bool {22	return i.rule != nil || len(i.consume) != 023}24func (i inst) String() string {25	var sb strings.Builder26	i.trace.toString(&sb)27	return sb.String()28}29type trace struct {30	pattern *Pattern // The pattern that produced a given instruction.31	offset  int      // The corresponding offset in pattern.Text.32	caller  *trace   // The last pattern in this chain is a Rule.33}34func (t *trace) toString(sb *strings.Builder) {35	if t.caller != nil {36		t.caller.toString(sb)37		sb.WriteString(" -> ")38	} else {39		sb.WriteString(t.pattern.Name)40		sb.WriteString(": ")41	}42	fmt.Fprintf(sb, "/%v<STATE>%v/", t.pattern.Text[:t.offset], t.pattern.Text[t.offset:])43}44// reCompiler translates a set of regular expressions into a single list of instructions.45type reCompiler struct {46	sets       []charset47	out        []inst48	consume    []int49	runes      map[rune]int // index in sets50	inExternal map[string]bool51	err        error52}53func newCompiler() *reCompiler {54	return &reCompiler{55		runes:      make(map[rune]int),56		inExternal: make(map[string]bool),57	}58}59func (c *reCompiler) addPattern(p *Pattern, action int, rule *Rule) (int, error) {60	c.err = nil61	ret := c.next()62	t := trace{pattern: p}63	c.serialize(p.RE, rule.Resolver, t)64	t.offset = len(t.pattern.Text)65	accept := c.emit(nil, t)66	c.out[accept].rule = rule67	transitiveClosure(c.out[ret:])68	for _, delta := range c.out[ret].links {69		dst := ret + delta70		if c.out[dst].rule != nil {71			c.errorf("`%v` accepts empty text", p.Name)72			break73		}74	}75	return ret, c.err76}77func (c *reCompiler) compile() (ins []inst, inputMap []RangeEntry) {78	symlists, inputMap := compressCharsets(c.sets)79	for i, id := range c.consume {80		if id >= 0 {81			c.out[i].consume = symlists[id]82		}83	}84	for src := range c.out {85		nlinks := c.out[src].links[:0]86		for _, delta := range c.out[src].links {87			if c.out[src+delta].core() {88				nlinks = append(nlinks, delta)89			}90		}91		c.out[src].links = nlinks92	}93	return c.out, inputMap94}95func (c *reCompiler) serialize(re *Regexp, resolver Resolver, t trace) {96	if c.err != nil {97		return98	}99	switch re.op {100	case opLiteral:101		for i, r := range re.text {102			t.offset = re.offset + i103			c.emit(charset{r, r}, t)104		}105	case opCharClass:106		t.offset = re.offset107		c.emit(re.charset, t)108	case opExternal:109		t.offset = re.offset110		if re.text == "eoi" {111			eoi := c.emit(nil, t)112			c.out[eoi].consume = symlist{EOI}113			return114		}115		if _, ok := c.inExternal[re.text]; ok {116			c.errorf("named patterns cannot recursively depend on each other (in %s)", re.text)117			return118		}119		pattern := resolver.Resolve(re.text)120		if pattern == nil {121			c.errorf("cannot find named pattern: %s", re.text)122			return123		}124		c.inExternal[re.text] = true125		child := trace{pattern: pattern, caller: &t}126		c.serialize(pattern.RE, resolver, child)127		delete(c.inExternal, re.text)128	case opRepeat:129		if re.min > 16 || re.max > 16 {130			c.errorf("cannot expand the regexp, too many entities to repeat (max. 16)")131			return132		}133		barrier := c.emit(nil, trace{})134		c.link(barrier, c.next())135		var last int136		for i := 0; i < re.min; i++ {137			last = c.next()138			c.serialize(re.sub[0], resolver, t)139		}140		if re.max == -1 {141			if re.min == 0 {142				last = c.next()143				c.serialize(re.sub[0], resolver, t)144			}145			barrier := c.emit(nil, trace{})146			c.link(barrier, last)147			c.link(barrier, c.next())148			if re.min == 0 {149				c.link(last, c.next())150			}151		} else if re.max > re.min {152			var subs []int153			for i := re.max - re.min; i > 0; i-- {154				subs = append(subs, c.next())155				c.serialize(re.sub[0], resolver, t)156			}157			barrier := c.emit(nil, trace{})158			for _, sub := range subs {159				c.link(sub, c.next())160			}161			c.link(barrier, c.next())162		}163	case opAlternate:164		alt := c.emit(nil, trace{})165		var ends []int166		for _, s := range re.sub {167			c.link(alt, c.next())168			c.serialize(s, resolver, t)169			ends = append(ends, c.emit(nil, trace{}))170		}171		for _, end := range ends {172			c.link(end, c.next())173		}174	case opConcat:175		for _, s := range re.sub {176			c.serialize(s, resolver, t)177		}178	default:179		log.Fatal("unknown regexp operation")180	}181}182func (c *reCompiler) errorf(format string, a ...interface{}) {183	if c.err == nil {184		c.err = fmt.Errorf(format, a...)185	}186}187func (c *reCompiler) next() int {188	return len(c.out)189}190func (c *reCompiler) link(src, dst int) {191	c.out[src].links = append(c.out[src].links, dst-src)192}193func (c *reCompiler) emit(cs charset, t trace) int {194	c.out = append(c.out, inst{trace: t})195	id := -1196	if len(cs) != 0 {197		if len(cs) == 2 && cs[0] == cs[1] {198			r := cs[0]199			var ok bool200			id, ok = c.runes[r]201			if !ok {202				id = len(c.sets)203				c.sets = append(c.sets, []rune{r, r})204				c.runes[r] = id205			}206		} else {207			id = len(c.sets)208			c.sets = append(c.sets, cs)209		}210	}211	c.consume = append(c.consume, id)212	return len(c.out) - 1213}214func transitiveClosure(code []inst) {215	seen := container.NewBitSet(len(code))216	var visit func(int, int)217	visit = func(origin, src int) {218		for _, delta := range code[src].links {219			dst := src + delta220			if !seen.Get(dst) {221				code[origin].links = append(code[origin].links, dst-origin)222				seen.Set(dst)223				visit(origin, dst)224			}225		}226	}227	for src, ins := range code {228		if len(ins.links) == 0 {229			continue230		}231		seen.ClearAll(len(code))232		seen.Set(src)233		for _, delta := range ins.links {234			seen.Set(src + delta)235		}236		for _, delta := range ins.links {237			visit(src, src+delta)238		}239	}240}...

Serialize

Using AI Code Generation

1import (2func main() {3    fmt.Println("Hello World")4    req := new(plugin.CodeGeneratorRequest)5    req.FileToGenerate = append(req.FileToGenerate, "2.proto")6    fileDescriptorProto := new(descriptor.FileDescriptorProto)7    fileDescriptorProto.Name = proto.String("2.proto")8    req.ProtoFile = append(req.ProtoFile, fileDescriptorProto)9    data, err := proto.Marshal(req)10    if err != nil {11        fmt.Println("error in serializing the request object")12    }13    fmt.Println(data)14}

Serialize

Using AI Code Generation

1import (2func main() {3    vm := otto.New()4    vm.Run(`5        function add(a, b) {6            return a + b;7        }8    serialized, err := vm.Compile("add", "add(1, 2)")9    if err != nil {

Serialize

Using AI Code Generation

1import (2func main() {3    compiler := otto.New()4    compiler.Run(`5        function add(a, b) {6            return a + b;7        }8    serialized, err := compiler.Compile("add(40, 2)")9    if err != nil {10        panic(err)11    }12    fmt.Println(serialized)13}14import (15func main() {16    compiler := otto.New()17    compiler.Run(`18        function add(a, b) {19            return a + b;20        }21    value, err := compiler.Run("add(40, 2)")22    if err != nil {23        panic(err)24    }25    fmt.Println(value)26}27import (28func main() {29    compiler := otto.New()30    compiler.Run(`31        function add(a, b) {32            return a + b;33        }34    value, err := compiler.Run("add(40, 2)")35    if err != nil {36        panic(err)37    }38    fmt.Println(value)39}40import (41func main() {42    compiler := otto.New()43    compiler.Run(`44        function add(a, b) {45            return a + b;46        }47    value, err := compiler.Run("add(40, 2)")48    if err != nil {49        panic(err)50    }51    fmt.Println(value)52}53import (54func main() {55    compiler := otto.New()56    compiler.Run(`57        function add(a, b) {58            return a + b;59        }

Serialize

Using AI Code Generation

1import (2func main() {3    var code = []byte{0x60, 0x10, 0x60, 0x0f, 0x01}4    var compiler = vm.NewEVMCompiler()5    var bytecode, err = compiler.Compile(code)6    if err != nil {7        fmt.Println(err)8    } else {9        fmt.Printf("%x", bytecode)10    }11}

Serialize

Using AI Code Generation

1compiler.Serialize("2.exe");2compiler.Deserialize("2.exe");3compiler.Execute();4compiler.Execute();5compiler.Execute();6compiler.Execute();7compiler.Execute();8compiler.Execute();9compiler.Execute();10compiler.Execute();11compiler.Execute();12compiler.Execute();13compiler.Execute();14compiler.Execute();15compiler.Execute();16compiler.Execute();17compiler.Execute();18compiler.Execute();19compiler.Execute();

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.