How to use notAction method of types Package

Best Ginkgo code snippet using types.notAction

canonical_policy.go

Source:canonical_policy.go

1package aws2import (3	"context"4	"encoding/json"5	"fmt"6	"net/url"7	"reflect"8	"sort"9	"strings"10	"github.com/turbot/go-kit/types"11	"github.com/turbot/steampipe-plugin-sdk/plugin"12	"github.com/turbot/steampipe-plugin-sdk/plugin/transform"13)14//15// https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html#policies-grammar-bnf16//17// Policy represents an IAM Policy document18// It would be nice if we could sort the fields (json keys) but postgres jsonb19// "does not preserve the order of object keys",20// per https://www.postgresql.org/docs/9.4/datatype-json.html21type Policy struct {22	Id         string     `json:"Id,omitempty"` // Optional, case sensitive23	Statements Statements `json:"Statement"`    // Required, array of Statements or single statement24	// 2012-10-17 or 2008-10-17 old policies, do NOT use this for new policies25	Version string `json:"Version"` // Required, version date string26}27// Statement represents a Statement in an IAM Policy.28// It would be nice if we could sort the fields (json keys) but postgres jsonb29// "does not preserve the order of object keys",30// per https://www.postgresql.org/docs/9.4/datatype-json.html31type Statement struct {32	Action       Value                  `json:"Action,omitempty"`       // Optional, string or array of strings, case insensitive33	Condition    map[string]interface{} `json:"Condition,omitempty"`    // Optional, map of conditions34	Effect       string                 `json:"Effect"`                 // Required, Allow or Deny, case sensitive35	NotAction    Value                  `json:"NotAction,omitempty"`    // Optional, string or array of strings, case insensitive36	NotPrincipal Principal              `json:"NotPrincipal,omitempty"` // Optional, string (*) or map of strings/arrays37	NotResource  CaseSensitiveValue     `json:"NotResource,omitempty"`  // Optional, string or array of strings, case sensitive38	Principal    Principal              `json:"Principal,omitempty"`    // Optional, string (*) or map of strings/arrays39	Resource     CaseSensitiveValue     `json:"Resource,omitempty"`     // Optional, string or array of strings, case sensitive40	Sid          string                 `json:"Sid,omitempty"`          // Optional, case sensitive41}42// tempStatement is used unmarshall to this struct, then copy to Statement to change string case43type tempStatement struct {44	Action       Value                  `json:"Action,omitempty"`       // Optional, string or array of strings, case insensitive45	Condition    map[string]interface{} `json:"Condition,omitempty"`    // Optional, map of conditions46	Effect       string                 `json:"Effect"`                 // Required, Allow or Deny, case sensitive47	NotAction    Value                  `json:"NotAction,omitempty"`    // Optional, string or array of strings, case insensitive48	NotPrincipal Principal              `json:"NotPrincipal,omitempty"` // Optional, string (*) or map of strings/arrays49	NotResource  CaseSensitiveValue     `json:"NotResource,omitempty"`  // Optional, string or array of strings, case sensitive50	Principal    Principal              `json:"Principal,omitempty"`    // Optional, string (*) or map of strings/arrays51	Resource     CaseSensitiveValue     `json:"Resource,omitempty"`     // Optional, string or array of strings, case sensitive52	Sid          string                 `json:"Sid,omitempty"`          // Optional, case sensitive53}54// Statements is an array of statements from an IAM policy55type Statements []Statement56// UnmarshalJSON for the Policy struct.  A policy can contain a single Statement or an57// array of statements, we always convert to array.  Currently, we do not sort these58// but we probably should....59func (statement *Statements) UnmarshalJSON(b []byte) error {60	var raw interface{}61	err := json.Unmarshal(b, &raw)62	if err != nil {63		return fmt.Errorf("UnmarshalJSON failed for Statements (raw): %s", url.QueryEscape(string(b)))64	}65	newStatements := make([]Statement, 0)66	switch raw.(type) {67	// Single Statement case68	case map[string]interface{}:69		var stmt Statement70		if err := json.Unmarshal(b, &stmt); err != nil {71			return fmt.Errorf("UnmarshalJSON failed for Statements (Single Statement): %s", url.QueryEscape(string(b)))72		}73		newStatements = append(newStatements, stmt)74		*statement = newStatements75	// Array of Statements case76	case []interface{}:77		var stmts []Statement78		if err := json.Unmarshal(b, &stmts); err != nil {79			return fmt.Errorf("UnmarshalJSON failed for Statements (Array of Statement): %s", url.QueryEscape(string(b)))80		}81		*statement = stmts82	default:83		return fmt.Errorf("invalid %s value element: allowed is only string or map[]interface{}", reflect.TypeOf(raw))84	}85	return nil86}87// UnmarshalJSON for the Statement struct88func (statement *Statement) UnmarshalJSON(b []byte) error {89	var newStatement tempStatement90	if err := json.Unmarshal(b, &newStatement); err != nil {91		return err92	}93	statement.Sid = newStatement.Sid94	statement.Effect = newStatement.Effect95	statement.Principal = newStatement.Principal96	statement.NotPrincipal = newStatement.NotPrincipal97	statement.Action = newStatement.Action98	statement.NotAction = newStatement.NotAction99	statement.Resource = newStatement.Resource100	statement.NotResource = newStatement.NotResource101	c, err := canonicalCondition(newStatement.Condition)102	if err != nil {103		return fmt.Errorf("error unmarshalling / converting condition: %s", err)104	}105	statement.Condition = c106	return nil107}108// canonicalCondition converts the conditions to a standard format for easier matching109// Note that:110//     - conditions keys are CASE INSENSITIVE - we convert them to lower case.111//     - Like other fields in IAM policies, the condition values can either be a string112//       or an array of strings - we always convery them to arrays for easier searching113//       and we remove duplicates114//     - condition values can be string, boolean, or numeric depending on the operator115//       key,  but whereever the a bool or int is accepted, a string representation is116//       also accepted - e.g. you can use `true` or `"true"`.  While it would probably117//       be ideal to cast to the ACTUAL type based on the operator, we currently cast118//       them all to strings - Its simpler, and the net effect is pretty much the same;119//       since postgres json functions only return text or jsonb, you need to cast120//       them explicitly in your query anyway....121func canonicalCondition(src map[string]interface{}) (map[string]interface{}, error) {122	newConditions := make(map[string]interface{})123	for operator, condition := range src {124		newCondition := make(map[string]interface{})125		for conditionKey, conditionValue := range condition.(map[string]interface{}) {126			// convert the condition key to lower case127			newKey := strings.ToLower(conditionKey)128			// convert the value to a slice of string....)129			newSlice, err := toSliceOfStrings(conditionValue)130			if err != nil {131				return nil, err132			}133			newSlice = uniqueStrings(newSlice)134			sort.Strings(newSlice)135			newCondition[newKey] = newSlice136		}137		newConditions[operator] = newCondition138	}139	return newConditions, nil140}141// Principal may be string '*' or a map of principaltype:value.  If '*', we add as an142// array element to the AWS principal type.143// Each value in the map may be a string or []string, we convert everything to []string144// and sort it and remove duplicates145type Principal map[string]interface{}146// UnmarshalJSON for the Principal struct147func (principal *Principal) UnmarshalJSON(b []byte) error {148	var raw interface{}149	if err := json.Unmarshal(b, &raw); err != nil {150		return err151	}152	switch typedValue := raw.(type) {153	case string:154		p := make(map[string]interface{})155		p["AWS"] = []string{typedValue}156		*principal = p157	case map[string]interface{}:158		// convert each sub item to array of string159		p := make(map[string]interface{})160		for k, v := range typedValue {161			newSlice, err := toSliceOfStrings(v)162			if err != nil {163				return nil164			}165			// remove duplicates and sort166			newSlice = uniqueStrings(newSlice)167			sort.Strings(newSlice)168			p[k] = newSlice169		}170		*principal = p171	default:172		return fmt.Errorf("invalid %s value element: allowed is only string or map[]interface{}", reflect.TypeOf(principal))173	}174	return nil175}176// Value is an AWS IAM value string or array.  AWS allows string or []string as value,177// we convert everything to []string to avoid casting.  We also sort these - order does178// not matter for arrays/lists in IAM policies, so we sort them for easier diffing,179// and remove duplicates since they're ignored anyway180type Value []string181// UnmarshalJSON for the Value struct182func (value *Value) UnmarshalJSON(b []byte) error {183	var raw interface{}184	err := json.Unmarshal(b, &raw)185	if err != nil {186		return err187	}188	// convert the value to an array of strings189	newSlice, err := toSliceOfStrings(raw)190	if err != nil {191		return err192	}193	//convert to lowercase194	var values []string195	for _, item := range newSlice {196		values = append(values, strings.ToLower(item))197	}198	// remove duplicates and sort199	values = uniqueStrings(values)200	sort.Strings(values)201	*value = values202	return nil203}204// CaseSensitiveValue is used for value arrays that care about case205// AWS allows string or []string as value, we convert everything to []string to206// avoid casting. We also sort these - order does not matter for arrays/lists207// in IAM policies, so we sort them for easier diffing and remove duplicates208// since they're ignored anyway209type CaseSensitiveValue []string210// UnmarshalJSON for the CaseSensitiveValue struct211func (value *CaseSensitiveValue) UnmarshalJSON(b []byte) error {212	var raw interface{}213	err := json.Unmarshal(b, &raw)214	if err != nil {215		return err216	}217	// convert the value to an array of strings218	newSlice, err := toSliceOfStrings(raw)219	if err != nil {220		return err221	}222	// remove duplicates and sort223	newSlice = uniqueStrings(newSlice)224	sort.Strings(newSlice)225	*value = newSlice226	return nil227}228// canonicalPolicy converts a (unescaped) policy string to canonical format229func canonicalPolicy(src string) (interface{}, error) {230	var policy Policy231	if err := json.Unmarshal([]byte(src), &policy); err != nil {232		return nil, fmt.Errorf("Convert policy failed unmarshalling source data: %+v.  src: %s", err, url.QueryEscape(src))233	}234	return policy, nil235}236//// UTILITY FUNCTIONS237// toSliceOfStrings converts a string or array value to an array of strings238func toSliceOfStrings(scalarOrSlice interface{}) ([]string, error) {239	newSlice := make([]string, 0)240	if reflect.TypeOf(scalarOrSlice).Kind() == reflect.Slice {241		for _, v := range scalarOrSlice.([]interface{}) {242			newSlice = append(newSlice, types.ToString(v))243		}244		return newSlice, nil245	}246	newSlice = append(newSlice, types.ToString(scalarOrSlice))247	return newSlice, nil248}249// uniqueStrings removes duplicate items from a slice of strings250func uniqueStrings(arr []string) []string {251	occured := map[string]bool{}252	result := []string{}253	for e := range arr {254		// check if already the mapped (if true)255		if !occured[arr[e]] {256			occured[arr[e]] = true257			// Append to result slice.258			result = append(result, arr[e])259		}260	}261	return result262}263//// TRANSFORM FUNCTIONS264// unescape a string.  Often (but not always), a policy doc is an escaped string,265// and it must be unescaped beofre converting to canonical form266func unescape(ctx context.Context, d *transform.TransformData) (interface{}, error) {267	logger := plugin.Logger(ctx)268	logger.Trace("unescape")269	// get the value of policy safely270	inputStr := types.SafeString(d.Value)271	data, err := url.QueryUnescape(inputStr)272	if err != nil {273		return nil, err274	}275	return data, nil276}277// policyToCanonical converts a (unescaped) IAM policy to a standardized form278func policyToCanonical(ctx context.Context, d *transform.TransformData) (interface{}, error) {279	logger := plugin.Logger(ctx)280	logger.Trace("policyStringToCanonical")281	data := types.SafeString(d.Value)282	if data == "" {283		return nil, nil284	}285	newPolicy, err := canonicalPolicy(data)286	if err != nil {287		logger.Error("policyStringToCanonical", "err", err)288		return nil, err289	}290	return newPolicy, nil291}292// Inline policies in canonical form293func inlinePoliciesToStd(ctx context.Context, d *transform.TransformData) (interface{}, error) {294	plugin.Logger(ctx).Trace("inlinePoliciesToStd")295	inlinePolicies := d.HydrateItem.([]map[string]interface{})296	var inlinePoliciesStd []map[string]interface{}297	if inlinePolicies == nil {298		return nil, nil299	}300	for _, inlinePolicy := range inlinePolicies {301		strPolicy, err := json.Marshal(inlinePolicy["PolicyDocument"])302		if err != nil {303			return nil, err304		}305		policyStd, errStd := canonicalPolicy(string(strPolicy))306		if errStd != nil {307			return nil, errStd308		}309		inlinePoliciesStd = append(inlinePoliciesStd, map[string]interface{}{310			"PolicyDocument": policyStd,311			"PolicyName":     inlinePolicy["PolicyName"],312		})313	}314	return inlinePoliciesStd, nil315}...

types.go

Source:types.go

1package iamrole2import (3	"encoding/json"4	"github.com/atlassian/voyager"5	"github.com/atlassian/voyager/pkg/orchestration/wiring/wiringutil/oap"6	"github.com/pkg/errors"7)8const (9	EC2ComputeType  ComputeType = "ec2Compute"10	KubeComputeType ComputeType = "kubeCompute"11)12type Spec struct {13	ServiceName           voyager.ServiceName    `json:"serviceId,omitempty"`14	OAPResourceName       string                 `json:"oapResourceName"`15	CreateInstanceProfile bool                   `json:"createInstanceProfile,omitempty"`16	AssumeRoles           []string               `json:"assumeRoles,omitempty"`17	ManagedPolicies       []string               `json:"managedPolicies,omitempty"`18	ServiceEnvironment    oap.ServiceEnvironment `json:"serviceEnvironment"`19	ComputeType           ComputeType            `json:"computeType"`20	PolicySnippets        map[string]string      `json:"policySnippets"`21}22type ComputeType string23type CfnAttributes struct {24	Template     string `json:"template"`25	TemplateBody string `json:"templateBody"`26}27type IamPolicyDocument struct {28	Version   string               `json:"Version"`29	ID        string               `json:"Id,omitempty"`30	Statement []IamPolicyStatement `json:"Statement"`31}32type IamPolicy struct {33	PolicyName     string            `json:"PolicyName"`34	PolicyDocument IamPolicyDocument `json:"PolicyDocument"`35}36type IamAssumeRoleStatement struct {37	Effect    string                 `json:"Effect"`38	Principal IamAssumeRolePrincipal `json:"Principal"`39	Action    string                 `json:"Action"`40}41type IamAssumeRolePrincipal struct {42	AWS     string   `json:"AWS,omitempty"`43	Service []string `json:"Service,omitempty"`44}45// This is an IamPolicyStatement which doesn't allow non-array elements.46// See UnmarshalJSON below.47type IamPolicyStatement struct {48	Sid          *string          `json:",omitempty"`49	Principal    *json.RawMessage `json:",omitempty"`50	NotPrincipal *json.RawMessage `json:",omitempty"`51	NotAction []string `json:",omitempty"`52	Action    []string `json:",omitempty"`53	Effect string54	Resource    []string `json:",omitempty"`55	NotResource []string `json:",omitempty"`56	Condition *json.RawMessage `json:",omitempty"`57}58// Convert annoying IAM 'array or string' format to array only on Unmarshal59// so we can have nice types.60func (s *IamPolicyStatement) UnmarshalJSON(b []byte) error {61	var rawStatement struct {62		Sid    *string63		Effect string64		Principal    *json.RawMessage65		NotPrincipal *json.RawMessage66		Condition *json.RawMessage67		NotAction *json.RawMessage68		Action    *json.RawMessage69		Resource    *json.RawMessage70		NotResource *json.RawMessage71	}72	if err := json.Unmarshal(b, &rawStatement); err != nil {73		return err74	}75	s.Sid = rawStatement.Sid76	s.Effect = rawStatement.Effect77	s.Principal = rawStatement.Principal78	s.NotPrincipal = rawStatement.Principal79	s.Condition = rawStatement.Condition80	if err := copyJSONToSlice(&s.NotAction, rawStatement.NotAction); err != nil {81		return errors.Wrap(err, "failed to convert IAM NotAction JSON to array")82	}83	if err := copyJSONToSlice(&s.Action, rawStatement.Action); err != nil {84		return errors.Wrap(err, "failed to convert IAM Action JSON to array")85	}86	if err := copyJSONToSlice(&s.Resource, rawStatement.Resource); err != nil {87		return errors.Wrap(err, "failed to convert IAM Resource JSON to array")88	}89	if err := copyJSONToSlice(&s.NotResource, rawStatement.NotResource); err != nil {90		return errors.Wrap(err, "failed to convert IAM NotResource JSON to array")91	}92	return nil93}94// Convert annoying IAM 'array or string' format to array only on Unmarshal95// so we can have nice types.96func (p *IamPolicyDocument) UnmarshalJSON(b []byte) error {97	var rawPolicy struct {98		Version   string99		ID        string `json:"Id,omitempty"`100		Statement *json.RawMessage101	}102	if err := json.Unmarshal(b, &rawPolicy); err != nil {103		return err104	}105	p.Version = rawPolicy.Version106	p.ID = rawPolicy.ID107	if rawPolicy.Statement == nil {108		return nil109	}110	// Attempt to interpret Statement as Object111	var statement IamPolicyStatement112	if err := json.Unmarshal(*rawPolicy.Statement, &statement); err == nil {113		p.Statement = []IamPolicyStatement{statement}114		return nil115	}116	// If we fail, try as array (and report error now, since this is the normal case)117	if err := json.Unmarshal(*rawPolicy.Statement, &p.Statement); err != nil {118		return errors.Wrap(err, "expecting object or array for IAM Statement")119	}120	return nil121}122func copyJSONToSlice(target *[]string, source *json.RawMessage) error {123	if source == nil {124		return nil125	}126	var vArray []string127	if err := json.Unmarshal(*source, &vArray); err == nil {128		*target = vArray129		return nil130	}131	var vString string132	if err := json.Unmarshal(*source, &vString); err != nil {133		return errors.Wrap(err, "expecting string or array")134	}135	*target = []string{vString}136	return nil137}...

notAction

Using AI Code Generation

1import "fmt"2func main() {3  ret = max(a, b)4  fmt.Printf("Max value is : %d", ret)5}6func max(num1, num2 int) int {7  if (num1 > num2) {8  } else {9  }10}11import "fmt"12func main() {13  ret = max(a, b)14  fmt.Printf("Max value is : %d", ret)15}16func max(num1, num2 int) int {17  if (num1 > num2) {18  } else {19  }20}21import "fmt"22func main() {23  ret = max(a, b)24  fmt.Printf("Max value is : %d", ret)25}26func max(num1, num2 int) int {27  if (num1 > num2) {28  } else {29  }30}31import "fmt"32func main() {33  ret = max(a, b)34  fmt.Printf("Max value is : %d", ret)35}36func max(num1, num2 int) int {37  if (num1 > num2) {38  } else {39  }40}41import "fmt"42func main() {

notAction

Using AI Code Generation

1import (2func main() {3    z01.PrintRune('a')4    z01.PrintRune('b')5    z01.PrintRune('c')6    z01.PrintRune('d')7    z01.PrintRune('e')8    z01.PrintRune('f')9    z01.PrintRune('g')10    z01.PrintRune('h')11    z01.PrintRune('i')12    z01.PrintRune('j')13    z01.PrintRune('k')14    z01.PrintRune('l')15    z01.PrintRune('m')16    z01.PrintRune('n')17    z01.PrintRune('o')18    z01.PrintRune('p')19    z01.PrintRune('q')20    z01.PrintRune('r')21    z01.PrintRune('s')22    z01.PrintRune('t')23    z01.PrintRune('u')24    z01.PrintRune('v')25    z01.PrintRune('w')26    z01.PrintRune('x')27    z01.PrintRune('y')28    z01.PrintRune('z')29    z01.PrintRune('30    z01.PrintRune('A')31    z01.PrintRune('B')32    z01.PrintRune('C')33    z01.PrintRune('D')34    z01.PrintRune('E')35    z01.PrintRune('F')36    z01.PrintRune('G')37    z01.PrintRune('H')38    z01.PrintRune('I')39    z01.PrintRune('J')40    z01.PrintRune('K')41    z01.PrintRune('L')42    z01.PrintRune('M')43    z01.PrintRune('N')44    z01.PrintRune('O')45    z01.PrintRune('P')46    z01.PrintRune('Q')47    z01.PrintRune('R')48    z01.PrintRune('S')49    z01.PrintRune('T')50    z01.PrintRune('U')51    z01.PrintRune('V')52    z01.PrintRune('W')53    z01.PrintRune('X')54    z01.PrintRune('Y')

notAction

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello World!")4	if err != nil {5		panic(err)6	}7	defer c.Close()8}9import (10func main() {11	fmt.Println("Hello World!")12	if err != nil {13		panic(err)14	}15	defer c.Close()

notAction

Using AI Code Generation

1import (2func main() {3	valid := validation.Validation{}4	valid.Required(1, "name").Message("name is required")5	valid.MaxSize("hello", 5, "name").Message("name max size is 5")6	valid.MinSize(6, 1, "age").Message("age min size is 1")7	valid.Range(7, 1, 10, "age").Message("age must between 1 and 10")8	valid.Match("hello", `^[a-zA-Z0-9_-]+$`, "name").Message("name must match")9	valid.Match("hello", `^[a-zA-Z0-9_-]+$`, "name").Message("name must match")10	valid.Alpha("hello", "name").Message("name must alpha")11	valid.Numeric("123", "name").Message("name must numeric")12	valid.AlphaNumeric("hello123", "name").Message("name must alpha numeric")13	valid.AlphaDash("hello_-", "name").Message("name must alpha dash")14	valid.Email("hello", "email").Message("email must email")15	valid.Ip("hello", "ip").Message("ip must ip")16	valid.Base64("hello", "base64").Message("base64 must base64")17	valid.Mobile("hello", "mobile").Message("mobile must mobile")18	valid.Tel("hello", "tel").Message("tel must tel")19	valid.Phone("hello", "phone").Message("phone must phone")20	valid.ZipCode("hello", "zipcode").Message("zipcode must zipcode")21	valid.Length("hello", 1, 10, "name").Message("name length must between 1 and 10")22	valid.In(11, []int{1, 2, 3}, "age").Message("age must in 1,2,3")23	valid.In(1, []int{1, 2, 3}, "age").Message("age must in 1,2,3")24	valid.NotIn(1, []int{1, 2, 3}, "age").Message("age must not in 1,2,3")25	valid.NotIn(11, []int{1, 2, 3}, "age").Message("age must not in 1,2,3")26	valid.Gt(1, 10, "age").Message("age must

notAction

Using AI Code Generation

1import "fmt"2func main() {3   var res = types.notAction()4   fmt.Println(res)5}6import "fmt"7func main() {8   var res = types.notAction()9   fmt.Println(res)10}11import "fmt"12func main() {13   var res = types.notAction()14   fmt.Println(res)15}16import "fmt"17func main() {18   var res = types.notAction()19   fmt.Println(res)20}21import "fmt"22func main() {23   var res = types.notAction()24   fmt.Println(res)25}26import "fmt"27func main() {28   var res = types.notAction()29   fmt.Println(res)30}31import "fmt"32func main() {33   var res = types.notAction()34   fmt.Println(res)35}36import "fmt"37func main() {38   var res = types.notAction()39   fmt.Println(res)40}41import "fmt"42func main() {43   var res = types.notAction()44   fmt.Println(res)45}

notAction

Using AI Code Generation

1import "fmt"2func main() {3   fmt.Println("Enter a number:")4   fmt.Scan(&n)5   fmt.Println("Number is:", n)6   if n%2==0 {7      fmt.Println("Even")8   } else {9      fmt.Println("Odd")10   }11}12import "fmt"13func main() {14   fmt.Println("Enter a number:")15   fmt.Scan(&n)16   fmt.Println("Number is:", n)17   if n%2==0 {18      fmt.Println("Even")19   } else {20      fmt.Println("Odd")21   }22}23import "fmt"24func main() {25   fmt.Println("Enter a number:")26   fmt.Scan(&n)27   fmt.Println("Number is:", n)28   if n%2==0 {29      fmt.Println("Even")30   } else {31      fmt.Println("Odd")32   }33}34import "fmt"35func main() {36   fmt.Println("Enter a number:")37   fmt.Scan(&n)38   fmt.Println("Number is:", n)39   if n%2==0 {40      fmt.Println("Even")41   } else {42      fmt.Println("Odd")43   }44}45import "fmt"46func main() {47   fmt.Println("Enter a number:")48   fmt.Scan(&n)49   fmt.Println("Number is:", n)50   if n%2==0 {51      fmt.Println("Even")52   } else {53      fmt.Println("Odd")54   }55}56import "fmt"57func main() {58   fmt.Println("Enter a number:")59   fmt.Scan(&n)60   fmt.Println("Number is:", n)61   if n%2==0 {62      fmt.Println("Even")63   } else {64      fmt.Println("Odd")65   }66}

notAction

Using AI Code Generation

1import (2func main() {3	var v interface{} = os.Args4	fmt.Println(reflect.TypeOf(v).NotAction())5}6import (7func main() {8	var v interface{} = os.Args9	fmt.Println(reflect.TypeOf(v).NotAction())10}11import (12func main() {13	var v interface{} = os.Args14	fmt.Println(reflect.TypeOf(v).NotAction())15}16import (17func main() {18	var v interface{} = os.Args19	fmt.Println(reflect.TypeOf(v).NotAction())20}21import (22func main() {23	var v interface{} = os.Args24	fmt.Println(reflect.TypeOf(v).NotAction())25}26import (27func main() {28	var v interface{} = os.Args29	fmt.Println(reflect.TypeOf(v).NotAction())30}31import (32func main() {33	var v interface{} = os.Args34	fmt.Println(reflect.TypeOf(v).NotAction())35}36import (37func main() {38	var v interface{} = os.Args39	fmt.Println(reflect.TypeOf(v).NotAction())40}41import (

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.