# How to use flatten method of regression Package

Best Keploy code snippet using regression.flatten

regression.go

Source:regression.go

...326 err := json.Unmarshal([]byte(body), &result)327 if err != nil {328 return err329 }330 j := flatten(result)331 for k, v := range j {332 nk := "body"333 if k != "" {334 nk = nk + "." + k335 }336 m[nk] = v337 }338 } else {339 // add it as raw text340 m["body"] = []string{body}341 }342 return nil343}344// Flatten takes a map and returns a new one where nested maps are replaced345// by dot-delimited keys.346// examples of valid jsons - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#examples347func flatten(j interface{}) map[string][]string {348 if j == nil {349 return map[string][]string{"": {""}}350 }351 o := make(map[string][]string)352 x := reflect.ValueOf(j)353 switch x.Kind() {354 case reflect.Map:355 m, ok := j.(map[string]interface{})356 if !ok {357 return map[string][]string{}358 }359 for k, v := range m {360 nm := flatten(v)361 for nk, nv := range nm {362 fk := k363 if nk != "" {364 fk = fk + "." + nk365 }366 o[fk] = nv367 }368 }369 case reflect.Bool:370 o[""] = []string{strconv.FormatBool(x.Bool())}371 case reflect.Float64:372 o[""] = []string{strconv.FormatFloat(x.Float(), 'E', -1, 64)}373 case reflect.String:374 o[""] = []string{x.String()}375 case reflect.Slice:376 child, ok := j.([]interface{})377 if !ok {378 return map[string][]string{}379 }380 for _, av := range child {381 nm := flatten(av)382 for nk, nv := range nm {383 if ov, exists := o[nk]; exists {384 o[nk] = append(ov, nv...)385 } else {386 o[nk] = nv387 }388 }389 }390 default:391 fmt.Println("found invalid value in json", j, x.Kind())392 }393 return o394}395func (r *Regression) fillCache(ctx context.Context, t *models.TestCase) (string, error) {396 index := fmt.Sprintf("%s-%s-%s", t.CID, t.AppID, t.URI)397 _, ok1 := r.noisyFields[index]398 _, ok2 := r.fieldCounts[index]399 if ok1 && ok2 {400 return index, nil401 }402 r.mu.Lock()403 defer r.mu.Unlock()404 // check again after the lock405 _, ok1 = r.noisyFields[index]406 _, ok2 = r.fieldCounts[index]407 if !ok1 || !ok2 {408 var anchors []map[string][]string409 fieldCounts, noisyFields := map[string]map[string]int{}, map[string]bool{}410 tcs, err := r.tdb.GetKeys(ctx, t.CID, t.AppID, t.URI)411 if err != nil {412 return "", err413 }414 for _, v := range tcs {415 //var appAnchors map[string][]string416 //for _, a := range v.Anchors {417 // appAnchors[a] = v.AllKeys[a]418 //}419 anchors = append(anchors, v.Anchors)420 for k, v1 := range v.AllKeys {421 if fieldCounts[k] == nil {422 fieldCounts[k] = map[string]int{}423 }424 for _, v2 := range v1 {425 fieldCounts[k][v2] = fieldCounts[k][v2] + 1426 }427 if !isAnchor(fieldCounts[k]) {428 noisyFields[k] = true429 }430 }431 }432 r.fieldCounts[index], r.noisyFields[index], r.anchors[index] = fieldCounts, noisyFields, anchors433 }434 return index, nil435}436func (r *Regression) isDup(ctx context.Context, t *models.TestCase) (bool, error) {437 reqKeys := map[string][]string{}438 filterKeys := map[string][]string{}439 index, err := r.fillCache(ctx, t)440 if err != nil {441 return false, err442 }443 // add headers444 for k, v := range t.HttpReq.Header {445 reqKeys["header."+k] = []string{strings.Join(v, "")}446 }447 // add url params448 for k, v := range t.HttpReq.URLParams {449 reqKeys["url_params."+k] = []string{v}450 }451 // add body if it is a valid json452 if json.Valid([]byte(t.HttpReq.Body)) {453 var result interface{}454 err = json.Unmarshal([]byte(t.HttpReq.Body), &result)455 if err != nil {456 return false, err457 }458 body := flatten(result)459 for k, v := range body {460 nk := "body"461 if k != "" {462 nk = nk + "." + k463 }464 reqKeys[nk] = v465 }466 }467 isAnchorChange := false468 for k, v := range reqKeys {469 if !r.noisyFields[index][k] {470 // update field count471 for _, s := range v {472 if _, ok := r.fieldCounts[index][k]; !ok {...

logger.go

Source:logger.go

1package logger2import (3 "context"4 "fmt"5 "io"6 "io/ioutil"7 "os"8 "path/filepath"9 "strings"10 "sync/atomic"11 "time"12 "github.com/hashicorp/go-multierror"13 "github.com/pkg/errors"14 "github.com/qlik-oss/gopherciser/helpers"15 "github.com/rs/zerolog"16)17type (18 // MsgWriter implement to write log entry19 MsgWriter interface {20 // WriteMessage to log21 WriteMessage(msg *LogChanMsg) error22 // Set log level23 Level(lvl LogLevel)24 }25 // Logger container for writer and close functions26 Logger struct {27 Writer MsgWriter28 closeFuncs []func() error29 }30 // LogLevel of logging31 LogLevel int32 //Message container33 message struct {34 Tick uint6435 Time time.Time36 Level LogLevel37 Message string38 }39 // LogChanMsg container for row to be logged40 LogChanMsg struct {41 message42 SessionEntry43 ActionEntry44 *ephemeralEntry45 }46 // LogSettings settings47 LogSettings struct {48 Traffic bool49 Metrics bool50 Debug bool51 Regression bool52 }53 // Log main struct to keep track of and propagate log entries to loggers. Close finished will be signaled on Closed channel.54 Log struct {55 loggers []*Logger56 logChan chan *LogChanMsg57 closeFlag atomic.Value58 Closed chan interface{}59 Settings LogSettings60 regressionLogger RegressionLoggerCloser61 }62)63// When adding a new level also:64// * Add it to the String function65// * Add it in the StartLogger switch case if not to be logged on info level66const (67 UnknownLevel LogLevel = iota68 ResultLevel69 ErrorLevel70 WarningLevel71 InfoLevel72 MetricsLevel73 TrafficLevel74 DebugLevel75)76func (l LogLevel) String() string {77 switch l {78 case ResultLevel:79 return "result"80 case ErrorLevel:81 return "error"82 case WarningLevel:83 return "warning"84 case InfoLevel:85 return "info"86 case DebugLevel:87 return "debug"88 case TrafficLevel:89 return "traffic"90 case MetricsLevel:91 return "metric"92 default:93 return "unknown"94 }95}96// NewLog instance97func NewLog(settings LogSettings) *Log {98 return &Log{99 logChan: make(chan *LogChanMsg, 200),100 Settings: settings,101 Closed: make(chan interface{}),102 }103}104// NewLogger instance105func NewLogger(w MsgWriter) *Logger {106 return &Logger{107 Writer: w,108 }109}110// NewLogChanMsg create new LogChanMsg, to be used for testing purposes111func NewEmptyLogChanMsg() *LogChanMsg {112 return &LogChanMsg{message{},113 SessionEntry{},114 ActionEntry{},115 &ephemeralEntry{}}116}117// NewLogEntry create new LogEntry using current logger118func (log *Log) NewLogEntry() *LogEntry {119 return NewLogEntry(log)120}121// AddLoggers to be used for logging122func (log *Log) AddLoggers(loggers ...*Logger) {123 if log.loggers == nil {124 log.loggers = []*Logger{}125 log.loggers = append(log.loggers, loggers...)126 return127 }128 log.loggers = append(log.loggers, loggers...)129}130// SetRegressionLoggerFile to be used for logging regression data to file. The131// file name is chosen, using backupName, to match the name of the standard132// log file.133func (log *Log) SetRegressionLoggerFile(fileName string) error {134 fileName = strings.TrimSuffix(backupName(fileName), filepath.Ext(fileName)) + ".regression"135 f, err := NewWriter(fileName)136 if err != nil {137 return errors.WithStack(err)138 }139 log.regressionLogger = NewRegressionLogger(f, HeaderEntry{"ID_FORMAT", "sessionID.actionID.objectID"})140 return nil141}142// CloseWithTimeout functions with custom timeout143func (log *Log) CloseWithTimeout(timeout time.Duration) error {144 log.closeFlag.Store(true)145 //wait for all logs to be written or max 5 minutes146 ctx, cancel := context.WithTimeout(context.Background(), timeout)147 defer cancel()148 WaitForChanClose(ctx, log.Closed)149 var mErr *multierror.Error150 if log.loggers != nil {151 for _, v := range log.loggers {152 if err := v.Close(); err != nil {153 mErr = multierror.Append(mErr, err)154 }155 }156 log.loggers = nil157 }158 if log.regressionLogger != nil {159 log.regressionLogger.Close()160 }161 return errors.WithStack(helpers.FlattenMultiError(mErr))162}163// Close functions with default timeout of 5 minutes164func (log *Log) Close() error {165 return errors.WithStack(log.CloseWithTimeout(5 * time.Minute))166}167// StartLogger start async reading on log channel168func (log *Log) StartLogger(ctx context.Context) {169 go log.logListen(ctx)170}171func (log *Log) logListen(ctx context.Context) {172 doClose := false173 for {174 if flag, ok := log.closeFlag.Load().(bool); ok && flag {175 doClose = true176 }177 select {178 case msg, ok := <-log.logChan:179 if log.onLogChanMsg(msg, ok) {180 return181 }182 case <-ctx.Done():183 doClose = true184 for {185 select {186 case msg, ok := <-log.logChan:187 if log.onLogChanMsg(msg, ok) {188 return189 }190 case <-time.After(time.Millisecond * 50):191 // logChan is never closed, but this is only executed when the program terminates192 close(log.Closed)193 return194 }195 }196 case <-time.After(time.Millisecond * 50):197 if doClose {198 close(log.logChan)199 }200 }201 }202}203func (log *Log) onLogChanMsg(msg *LogChanMsg, ok bool) bool {204 if !ok {205 close(log.Closed) //Notify logger closed206 return true207 }208 for _, l := range log.loggers {209 if l == nil || l.Writer == nil {210 continue211 }212 if err := l.Writer.WriteMessage(msg); err != nil {213 _, _ = fmt.Fprintf(os.Stderr, "Error writing log: %v\n", err)214 }215 }216 return false217}218// Write log message, should be done in go routine to not block219func (log *Log) Write(msg *LogChanMsg) {220 if msg == nil {221 return222 }223 for _, l := range log.loggers {224 if l == nil || l.Writer == nil {225 continue226 }227 if err := l.Writer.WriteMessage(msg); err != nil {228 _, _ = fmt.Fprintf(os.Stderr, "Error writing log: %v\n", err)229 }230 }231}232// SetMetrics level on logging for all loggers233func (log *Log) SetMetrics() {234 if log == nil {235 return236 }237 for _, l := range log.loggers {238 l.Writer.Level(MetricsLevel)239 }240}241// SetTraffic level on logging for all loggers242func (log *Log) SetTraffic() {243 if log == nil {244 return245 }246 for _, l := range log.loggers {247 l.Writer.Level(TrafficLevel)248 }249}250// SetDebug level on logging for all loggers251func (log *Log) SetDebug() {252 if log == nil {253 return254 }255 for _, l := range log.loggers {256 l.Writer.Level(DebugLevel)257 }258}259// Close logger260func (logger *Logger) Close() error {261 if logger == nil {262 return nil263 }264 var mErr *multierror.Error265 if logger.closeFuncs != nil {266 for _, v := range logger.closeFuncs {267 if err := v(); err != nil {268 mErr = multierror.Append(mErr, err)269 }270 }271 }272 return errors.WithStack(helpers.FlattenMultiError(mErr))273}274// AddCloseFunc add sub logger close function to be called upon logger close275func (logger *Logger) AddCloseFunc(f func() error) {276 if logger == nil {277 return278 }279 if logger.closeFuncs == nil {280 logger.closeFuncs = []func() error{f}281 return282 }283 logger.closeFuncs = append(logger.closeFuncs, f)284}285// CreateStdoutJSONLogger create logger for JSON on terminal for later adding to loggers list286func CreateStdoutJSONLogger() *Logger {287 zerolog.LevelFieldName = "zerologlevel"288 zlgr := zerolog.New(os.Stdout)289 zlgr = zlgr.Level(zerolog.InfoLevel)290 jsonWriter := NewJSONWriter(&zlgr)291 return NewLogger(jsonWriter)292}293// CreateJSONLogger with io.Writer294func CreateJSONLogger(writer io.Writer, closeFunc func() error) *Logger {295 zerolog.LevelFieldName = "zerologlevel"296 zlgr := zerolog.New(writer)297 zlgr = zlgr.Level(zerolog.InfoLevel)298 jsonLogger := NewLogger(NewJSONWriter(&zlgr))299 if closeFunc != nil {300 jsonLogger.AddCloseFunc(closeFunc)301 }302 return jsonLogger303}304// CreateTSVLogger with io.Writer305func CreateTSVLogger(header []string, writer io.Writer, closeFunc func() error) (*Logger, error) {306 tsvWriter := NewTSVWriter(header, writer)307 tsvLogger := NewLogger(tsvWriter)308 if closeFunc != nil {309 tsvLogger.AddCloseFunc(closeFunc)310 }311 if err := tsvWriter.WriteHeader(); err != nil {312 return nil, errors.Wrap(err, "Failed writing TSV header")313 }314 return tsvLogger, nil315}316// CreateStdoutLogger create logger for JSON on terminal for later adding to loggers list317func CreateStdoutLogger() *Logger {318 zlgr := zerolog.New(zerolog.ConsoleWriter{319 Out: os.Stdout,320 NoColor: false,321 })322 zlgr = zlgr.Level(zerolog.InfoLevel)323 jsonWriter := NewJSONWriter(&zlgr)324 return NewLogger(jsonWriter)325}326// CreateDummyLogger auto discarding all entries327func CreateDummyLogger() *Logger {328 dummyWriter := NewTSVWriter(nil, ioutil.Discard)329 dummyLogger := NewLogger(dummyWriter)330 return dummyLogger331}332// WaitForChanClose which ever comes first context cancel or c closed. Returns instantly if channel is nil.333func WaitForChanClose(ctx context.Context, c chan interface{}) {334 if c == nil {335 return336 }337 select {338 case <-ctx.Done():339 case <-c:340 }341}...

representation_test.go

Source:representation_test.go

1package factable2import (3 "bytes"4 "errors"5 "time"6 "github.com/LiveRamp/gazette/v2/pkg/message"7 "github.com/cockroachdb/cockroach/util/encoding"8 gc "github.com/go-check/check"9)10func (s *SchemaSuite) TestDimensionRoundTripRegressionCases(c *gc.C) {11 var schema, err = NewSchema(makeExtractors(), makeTestConfig())12 c.Assert(err, gc.IsNil)13 var input = schema.Extract.Mapping[mapIdentTag](message.Envelope{14 Message: testRecord{15 anInt: 3,16 aTime: time.Unix(12345, 0),17 aStr: "hello",18 aFloat: 12345.0,19 }})[0]20 var cases = []struct {21 dim DimTag22 expect Field23 expectEncoding []byte24 }{25 {DimMVTag, int64(9999), []byte{0xf7, 0x27, 0xf}}, // MVTag prefix.26 {dimAnIntTag, int64(3), []byte{0x8b}}, // DimensionType_VARINT.27 {dimAFloatTag, 12345.0, []byte{0x05, 0x40, 0xc8, 0x1c, 0x80, 0x0, 0x0, 0x0, 0x0}}, // DimensionType_FLOAT.28 {dimAStrTag, "hello", []byte{0x12, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0, 0x1}}, // DimensionType_STRING.29 {dimATimeTag, time.Unix(12345, 0), []byte{0x14, 0xf7, 0x30, 0x39, 0x88}}, // DimensionType_TIMESTAMP.30 }31 var tags []DimTag32 for _, tc := range cases {33 tags = append(tags, tc.dim)34 }35 var b = []byte{0xff} // Arbitrary prefix, which is passed through.36 b = encoding.EncodeVarintAscending(b, 9999) // MVTag prefix.37 b = schema.ExtractAndMarshalDimensions(b, tags[1:], input) // Extract fields, excepting DimMVTag.38 var bb = b[1:]39 for _, tc := range cases {40 // Use DequeDimension to pop individual dimensions and confirm their expected encoding.41 var next []byte42 next, err = schema.DequeDimension(bb, tc.dim)43 c.Check(err, gc.IsNil)44 c.Check(bb[:len(bb)-len(next)], gc.DeepEquals, tc.expectEncoding)45 bb = next46 }47 c.Check(bb, gc.HasLen, 0) // Input fully consumed.48 // Expect UnmarshalDimensions recovers expected input fields, including MVTag.49 c.Check(schema.UnmarshalDimensions(b[1:], tags, func(field Field) error {50 c.Check(field, gc.Equals, cases[0].expect)51 cases = cases[1:]52 return nil53 }), gc.IsNil)54 // Expect UnmarshalDimensions passes through an error.55 c.Check(schema.UnmarshalDimensions(b[1:], tags, func(Field) error {56 return errors.New("foobar")57 }), gc.ErrorMatches, "foobar")58}59func (s *SchemaSuite) TestMetricRoundTripRegressionCases(c *gc.C) {60 var schema, err = NewSchema(makeExtractors(), makeTestConfig())61 c.Assert(err, gc.IsNil)62 var input = schema.Extract.Mapping[mapIdentTag](message.Envelope{63 Message: testRecord{64 anInt: 1,65 otherStr: "hello",66 aFloat: 12345.0,67 }})[0]68 var otherInput = schema.Extract.Mapping[mapIdentTag](message.Envelope{69 Message: testRecord{70 anInt: 3,71 otherStr: "world",72 aFloat: 678910.0,73 }})[0]74 var cases = []struct {75 met MetTag76 expect []byte77 expectReduce []byte78 }{79 {80 met: metAnIntSumTag, // MetricType_VARINT_SUM.81 expect: []byte{0x89}, // 1.82 expectReduce: []byte{0x8c}, // 4.83 },84 {85 met: metAnIntGaugeTag, // MetricType_VARINT_GAUGE.86 expect: []byte{0x89}, // 1.87 expectReduce: []byte{0x89}, // 1 (|input| is reduced into |otherInput|).88 },89 {90 met: metAFloatSumTag, // MetricType_FLOAT_SUM.91 expect: []byte{0x05, 0x40, 0xc8, 0x1c, 0x80, 0x0, 0x0, 0x0, 0x0},92 expectReduce: []byte{0x05, 0x41, 0x25, 0x18, 0x6e, 0x0, 0x0, 0x0, 0x0},93 },94 {95 met: metOtherStrUniqTag, // MetricType_STRING_HLL.96 expect: []byte{97 0x9d, // Varint length prefix.98 0x48, 0x59, 0x4c, 0x4c, // "HYLL"99 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x72, 0xf5, 0x88, 0x4d, 0x8},100 expectReduce: []byte{101 0xa0,102 0x48, 0x59, 0x4c, 0x4c,103 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5c, 0x70, 0x84, 0x56, 0x83, 0x88, 0x4d, 0x8},104 },105 }106 for _, tc := range cases {107 var tags = []MetTag{tc.met}108 var aggs = make([]Aggregate, 1)109 schema.InitAggregates(tags, aggs)110 schema.FoldMetrics(tags, aggs, input)111 // Expect MarshalMetric passes through the prefix, appending the encoding.112 var b = schema.MarshalMetrics([]byte{0xff}, tags, aggs)113 c.Check(b[1:], gc.DeepEquals, tc.expect)114 var bb = append(b[:1:1], bytes.Repeat(b[1:], 2)...)115 // Expect UnmarshalMetrics recovers the input Aggregate, and consumes the precise encoding.116 c.Check(schema.UnmarshalMetrics(bb[1:], []MetTag{tc.met, tc.met}, func(agg2 Aggregate) error {117 c.Check(agg2, gc.DeepEquals, aggs[0])118 return nil119 }), gc.IsNil)120 // Expect dequeMetric pops the precise metric encoding.121 rem, err := schema.dequeMetric(bb[1:], tc.met)122 c.Check(err, gc.IsNil)123 c.Check(rem, gc.DeepEquals, b[1:])124 // Reset Aggregate & fold second RelationRow.125 schema.InitAggregates([]MetTag{tc.met}, aggs)126 schema.FoldMetrics([]MetTag{tc.met}, aggs, otherInput)127 // Expect ReduceMetrics over |b| pops the precise metric encoding.128 rem, err = schema.ReduceMetrics(bb[1:], []MetTag{tc.met}, aggs)129 c.Check(err, gc.IsNil)130 c.Check(rem, gc.DeepEquals, b[1:])131 // And that it reduces the expected aggregate.132 c.Check(schema.MarshalMetrics(nil, []MetTag{tc.met}, aggs), gc.DeepEquals, tc.expectReduce)133 }134}135func (s *SchemaSuite) TestFlatten(c *gc.C) {136 var (137 anInt int64 = 12345138 aFloat float64 = 5678139 aStrHLL = BuildStrHLL("foo", "bar", "baz")140 )141 c.Check(Flatten(&anInt), gc.Equals, anInt)142 c.Check(Flatten(&aFloat), gc.Equals, aFloat)143 c.Check(Flatten(aStrHLL), gc.Equals, int64(3))144}...

flatten

Using AI Code Generation

1import (2func main() {3 r := new(regression.Regression)4 r.SetObserved("Y")5 r.SetVar(0, "X")6 r.Train(regression.Data{7 {Y: 1, X: 1},8 {Y: 2, X: 2},9 {Y: 3, X: 3},10 {Y: 4, X: 4},11 })12 r.Run()13 fmt.Printf("%0.2f\n", r.Coeff(0))14 fmt.Printf("%0.2f\n", r.Coeff(1))15 r.SetVar(0, "X2")16 r.Train(regression.Data{17 {Y: 1, X2: 1},18 {Y: 2, X2: 2},19 {Y: 3, X2: 3},20 {Y: 4, X2: 4},21 })22 r.Run()23 fmt.Printf("%0.2f\n", r.Coeff(0))24 fmt.Printf("%0.2f\n", r.Coeff(1))25}

flatten

Using AI Code Generation

1import (2func main() {3 obs = append(obs, regression.DataPoint(2.0, []float64{1.0, 0.0}))4 obs = append(obs, regression.DataPoint(4.0, []float64{0.0, 2.0}))5 obs = append(obs, regression.DataPoint(6.0, []float64{2.0, 0.0}))6 obs = append(obs, regression.DataPoint(8.0, []float64{0.0, 2.0}))7 r := new(regression.Regression)8 r.SetObs(obs)9 r.Flatten(1)10 fmt.Printf("obs: %v11}12obs: [{2 [1 0]} {4 [0 2]} {6 [2 0]} {8 [0 2]}]

flatten

Using AI Code Generation

1import (2func main() {3 r.SetObserved("Price")4 r.SetVar(0, "Size")5 r.SetVar(1, "Bedrooms")6 r.SetVar(2, "Bathrooms")7 f, err := os.Open(filename)8 if err != nil {9 log.Fatal(err)10 }11 defer f.Close()12 trainingData, err := regression.ParseCSV(f)13 if err != nil {14 log.Fatal(err)15 }16 r.Train(trainingData)17 result := r.Predict([]float64{2100, 4, 2})18 fmt.Printf("Predicted price for a 4 bedroom, 2 bath, 2100 sq ft house: $%.2f\n", result)19 if err := r.Save("model.gob"); err != nil {20 log.Fatal(err)21 }22 r2, err := regression.Load("model.gob")23 if err != nil {24 log.Fatal(err)25 }26 result2 := r2.Predict([]float64{2100, 4, 2})27 fmt.Printf("Predicted price for a 4 bedroom, 2 bath, 2100 sq ft house:$%.2f\n", result2)28}

flatten

Using AI Code Generation

1import (2func main() {3 r.SetObserved("y")4 r.SetVar(0, "x1")5 r.SetVar(1, "x2")6 r.Train(regression.Data{7 regression.Observation{Y: 1, X: []float64{1, 1}},8 regression.Observation{Y: 2, X: []float64{2, 2}},9 regression.Observation{Y: 3, X: []float64{3, 3}},10 })11 coeffs := r.Coeffs()12 fmt.Println("coeffs before flatten", coeffs)13 f := mat64.Flatten(nil, coeffs)14 fmt.Println("coeffs after flatten", f)15}

## 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.

## LambdaTest Learning Hubs:

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

## Run Keploy automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

## Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!