How to use Load method of config Package

Best Selenoid code snippet using config.Load

config_test.go

Source:config_test.go

...11	"github.com/hyperledger/fabric/core/config/configtest"12	"github.com/mitchellh/mapstructure"13	"github.com/stretchr/testify/require"14)15func TestLoadGoodConfig(t *testing.T) {16	cleanup := configtest.SetDevFabricConfigPath(t)17	defer cleanup()18	cc := &configCache{}19	cfg, err := cc.load()20	require.NoError(t, err)21	require.NotNil(t, cfg, "Could not load config")22	require.Nil(t, err, "Load good config returned unexpected error")23}24func TestMissingConfigValueOverridden(t *testing.T) {25	t.Run("when the value is missing and not overridden", func(t *testing.T) {26		cleanup := configtest.SetDevFabricConfigPath(t)27		defer cleanup()28		cc := &configCache{}29		cfg, err := cc.load()30		require.NotNil(t, cfg, "Could not load config")31		require.NoError(t, err, "Load good config returned unexpected error")32		require.Nil(t, cfg.Kafka.TLS.ClientRootCAs)33	})34	t.Run("when the value is missing and is overridden", func(t *testing.T) {35		os.Setenv("ORDERER_KAFKA_TLS_CLIENTROOTCAS", "msp/tlscacerts/tlsroot.pem")36		cleanup := configtest.SetDevFabricConfigPath(t)37		defer cleanup()38		cache := &configCache{}39		cfg, err := cache.load()40		require.NotNil(t, cfg, "Could not load config")41		require.NoError(t, err, "Load good config returned unexpected error")42		require.NotNil(t, cfg.Kafka.TLS.ClientRootCAs)43	})44}45func TestLoadCached(t *testing.T) {46	cleanup := configtest.SetDevFabricConfigPath(t)47	defer cleanup()48	// Load the initial config, update the environment, and load again.49	// With the caching behavior, the update should not be reflected50	initial, err := Load()51	require.NoError(t, err)52	os.Setenv("ORDERER_KAFKA_RETRY_SHORTINTERVAL", "120s")53	updated, err := Load()54	require.NoError(t, err)55	require.Equal(t, initial, updated, "expected %#v to equal %#v", updated, initial)56	// Change the configuration we got back and load again.57	// The new value should not contain the update to the initial58	initial.General.LocalMSPDir = "/test/bad/mspDir"59	updated, err = Load()60	require.NoError(t, err)61	require.NotEqual(t, initial, updated, "expected %#v to not equal %#v", updated, initial)62}63func TestLoadMissingConfigFile(t *testing.T) {64	envVar1 := "FABRIC_CFG_PATH"65	envVal1 := "invalid fabric cfg path"66	os.Setenv(envVar1, envVal1)67	defer os.Unsetenv(envVar1)68	cc := &configCache{}69	cfg, err := cc.load()70	require.Nil(t, cfg, "Loaded missing config file")71	require.NotNil(t, err, "Loaded missing config file without error")72}73func TestLoadMalformedConfigFile(t *testing.T) {74	name, err := ioutil.TempDir("", "hyperledger_fabric")75	require.Nil(t, err, "Error creating temp dir: %s", err)76	defer func() {77		err = os.RemoveAll(name)78		require.Nil(t, os.RemoveAll(name), "Error removing temp dir: %s", err)79	}()80	// Create a malformed orderer.yaml file in temp dir81	f, err := os.OpenFile(filepath.Join(name, "orderer.yaml"), os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)82	require.Nil(t, err, "Error creating file: %s", err)83	f.WriteString("General: 42")84	require.NoError(t, f.Close(), "Error closing file")85	envVar1 := "FABRIC_CFG_PATH"86	envVal1 := name87	os.Setenv(envVar1, envVal1)88	defer os.Unsetenv(envVar1)89	cc := &configCache{}90	cfg, err := cc.load()91	require.Nil(t, cfg, "Loaded missing config file")92	require.NotNil(t, err, "Loaded missing config file without error")93}94// TestEnvInnerVar verifies that with the Unmarshal function that95// the environmental overrides still work on internal vars.  This was96// a bug in the original viper implementation that is worked around in97// the Load codepath for now98func TestEnvInnerVar(t *testing.T) {99	envVar1 := "ORDERER_GENERAL_LISTENPORT"100	envVal1 := uint16(80)101	envVar2 := "ORDERER_KAFKA_RETRY_SHORTINTERVAL"102	envVal2 := "42s"103	os.Setenv(envVar1, fmt.Sprintf("%d", envVal1))104	os.Setenv(envVar2, envVal2)105	defer os.Unsetenv(envVar1)106	defer os.Unsetenv(envVar2)107	cleanup := configtest.SetDevFabricConfigPath(t)108	defer cleanup()109	cc := &configCache{}110	config, err := cc.load()111	require.NoError(t, err)112	require.NotNil(t, config, "Could not load config")113	require.Equal(t, config.General.ListenPort, envVal1, "Environmental override of inner config test 1 did not work")114	v2, _ := time.ParseDuration(envVal2)115	require.Equal(t, config.Kafka.Retry.ShortInterval, v2, "Environmental override of inner config test 2 did not work")116}117func TestKafkaTLSConfig(t *testing.T) {118	testCases := []struct {119		name        string120		tls         TLS121		shouldPanic bool122	}{123		{"Disabled", TLS{Enabled: false}, false},124		{"EnabledNoPrivateKey", TLS{Enabled: true, Certificate: "public.key"}, true},125		{"EnabledNoPublicKey", TLS{Enabled: true, PrivateKey: "private.key"}, true},126		{"EnabledNoTrustedRoots", TLS{Enabled: true, PrivateKey: "private.key", Certificate: "public.key"}, true},127	}128	for _, tc := range testCases {129		t.Run(tc.name, func(t *testing.T) {130			uconf := &TopLevel{Kafka: Kafka{TLS: tc.tls}}131			if tc.shouldPanic {132				require.Panics(t, func() { uconf.completeInitialization("/dummy/path") }, "Should panic")133			} else {134				require.NotPanics(t, func() { uconf.completeInitialization("/dummy/path") }, "Should not panic")135			}136		})137	}138}139func TestKafkaSASLPlain(t *testing.T) {140	testCases := []struct {141		name        string142		sasl        SASLPlain143		shouldPanic bool144	}{145		{"Disabled", SASLPlain{Enabled: false}, false},146		{"EnabledUserPassword", SASLPlain{Enabled: true, User: "user", Password: "pwd"}, false},147		{"EnabledNoUserPassword", SASLPlain{Enabled: true}, true},148		{"EnabledNoUser", SASLPlain{Enabled: true, Password: "pwd"}, true},149		{"EnabledNoPassword", SASLPlain{Enabled: true, User: "user"}, true},150	}151	for _, tc := range testCases {152		t.Run(tc.name, func(t *testing.T) {153			uconf := &TopLevel{Kafka: Kafka{SASLPlain: tc.sasl}}154			if tc.shouldPanic {155				require.Panics(t, func() { uconf.completeInitialization("/dummy/path") }, "Should panic")156			} else {157				require.NotPanics(t, func() { uconf.completeInitialization("/dummy/path") }, "Should not panic")158			}159		})160	}161}162func TestAdminTLSConfig(t *testing.T) {163	testCases := []struct {164		name        string165		tls         TLS166		shouldPanic bool167	}{168		{169			name: "no TLS",170			tls: TLS{171				Enabled:            false,172				ClientAuthRequired: false,173			},174			shouldPanic: false,175		},176		{177			name: "TLS enabled and ClientAuthRequired",178			tls: TLS{179				Enabled:            true,180				ClientAuthRequired: true,181			},182			shouldPanic: false,183		},184		{185			name: "TLS enabled and ClientAuthRequired set to false",186			tls: TLS{187				Enabled:            true,188				ClientAuthRequired: false,189			},190			shouldPanic: true,191		},192	}193	for _, tc := range testCases {194		t.Run(tc.name, func(t *testing.T) {195			uconf := &TopLevel{Admin: Admin{TLS: tc.tls}}196			if tc.shouldPanic {197				require.PanicsWithValue(t, "Admin.TLS.ClientAuthRequired must be set to true if Admin.TLS.Enabled is set to true", func() { uconf.completeInitialization("/dummy/path") })198			} else {199				require.NotPanics(t, func() { uconf.completeInitialization("/dummy/path") }, "Should not panic")200			}201		})202	}203}204func TestClusterDefaults(t *testing.T) {205	cleanup := configtest.SetDevFabricConfigPath(t)206	defer cleanup()207	cc := &configCache{}208	cfg, err := cc.load()209	require.NoError(t, err)210	require.Equal(t, cfg.General.Cluster.ReplicationMaxRetries, Defaults.General.Cluster.ReplicationMaxRetries)211}212func TestConsensusConfig(t *testing.T) {213	name, err := ioutil.TempDir("", "hyperledger_fabric")214	require.Nil(t, err, "Error creating temp dir: %s", err)215	defer func() {216		err = os.RemoveAll(name)217		require.Nil(t, os.RemoveAll(name), "Error removing temp dir: %s", err)218	}()219	content := `---220Consensus:221  Foo: bar222  Hello:223    World: 42224`225	f, err := os.OpenFile(filepath.Join(name, "orderer.yaml"), os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)226	require.Nil(t, err, "Error creating file: %s", err)227	f.WriteString(content)228	require.NoError(t, f.Close(), "Error closing file")229	envVar1 := "FABRIC_CFG_PATH"230	envVal1 := name231	os.Setenv(envVar1, envVal1)232	defer os.Unsetenv(envVar1)233	cc := &configCache{}234	conf, err := cc.load()235	require.NoError(t, err, "Load good config returned unexpected error")236	require.NotNil(t, conf, "Could not load config")237	consensus := conf.Consensus238	require.IsType(t, map[string]interface{}{}, consensus, "Expected Consensus to be of type map[string]interface{}")239	foo := &struct {240		Foo   string241		Hello struct {242			World int243		}244	}{}245	err = mapstructure.Decode(consensus, foo)246	require.NoError(t, err, "Failed to decode Consensus to struct")247	require.Equal(t, foo.Foo, "bar")248	require.Equal(t, foo.Hello.World, 42)249}250func TestConnectionTimeout(t *testing.T) {251	t.Run("without connection timeout overridden", func(t *testing.T) {252		cleanup := configtest.SetDevFabricConfigPath(t)253		defer cleanup()254		cc := &configCache{}255		cfg, err := cc.load()256		require.NotNil(t, cfg, "Could not load config")257		require.NoError(t, err, "Load good config returned unexpected error")258		require.Equal(t, cfg.General.ConnectionTimeout, time.Duration(0))259	})260	t.Run("with connection timeout overridden", func(t *testing.T) {261		os.Setenv("ORDERER_GENERAL_CONNECTIONTIMEOUT", "10s")262		defer os.Unsetenv("ORDERER_GENERAL_CONNECTIONTIMEOUT")263		cleanup := configtest.SetDevFabricConfigPath(t)264		defer cleanup()265		cc := &configCache{}266		cfg, err := cc.load()267		require.NotNil(t, cfg, "Could not load config")268		require.NoError(t, err, "Load good config returned unexpected error")269		require.Equal(t, cfg.General.ConnectionTimeout, 10*time.Second)270	})271}272func TestChannelParticipationDefaults(t *testing.T) {273	cleanup := configtest.SetDevFabricConfigPath(t)274	defer cleanup()275	cc := &configCache{}276	cfg, err := cc.load()277	require.NoError(t, err)278	require.Equal(t, cfg.ChannelParticipation.Enabled, Defaults.ChannelParticipation.Enabled)279	require.Equal(t, cfg.ChannelParticipation.MaxRequestBodySize, Defaults.ChannelParticipation.MaxRequestBodySize)280}...

configurator.go

Source:configurator.go

...26// Configurator defines the configuration manager.27type Configurator interface {28	// Use registers a custom configuration loader.29	// The last registered configuration loader will have the highest priority.30	Use(Loader) Configurator31	// AddFile adds one or more config files to the current loader.32	// The given parameter need to comply with the search rules supported33	// by filepath.Glob.34	// This method comes from the built-in configuration file loader.35	AddFile(string) error36	// Load loads the given config target.37	// If the given config target does not exist, ErrNotFound is returned.38	// We will give priority to the custom loader. If there is no available config loader39	// or all registered config loaders cannot load the config target (the semantic target40	// does not exist), it will be automatically delegated to the built-in config file loader.41	Load(string) (Item, error)42	// LoadJSON loads the given config target and binds it to the given object as json.43	LoadJSON(string, interface{}) error44	// LoadXML loads the given config target and binds it to the given object as xml.45	LoadXML(string, interface{}) error46	// LoadTOML loads the given config target and binds it to the given object as toml.47	LoadTOML(string, interface{}) error48	// LoadYAML loads the given config target and binds it to the given object as yaml.49	LoadYAML(string, interface{}) error50}51// New creates and returns a new Configurator instance.52func New() Configurator {53	fs := newFileLoader()54	return &configurator{fs: fs, loaders: []Loader{fs}}55}56// The configurator type is a built-in implementation of the Configurator interface.57type configurator struct {58	fs      *fileLoader59	loaders []Loader60}61// Use registers a custom configuration loader.62// The last registered configuration loader will have the highest priority.63func (o *configurator) Use(loader Loader) Configurator {64	o.loaders = append(o.loaders, loader)65	return o66}67// AddFile adds one or more config files to the current loader.68// The given parameter need to comply with the search rules supported69// by filepath.Glob.70// This method comes from the built-in configuration file loader.71func (o *configurator) AddFile(pattern string) error {72	return o.fs.AddFile(pattern)73}74// Load loads the given config target.75// If the given config target does not exist, ErrNotFound is returned.76// We will give priority to the custom loader. If there is no available config loader77// or all registered config loaders cannot load the config target (the semantic target78// does not exist), it will be automatically delegated to the built-in config file loader.79func (o *configurator) Load(target string) (Item, error) {80	for k := len(o.loaders) - 1; k >= 0; k-- {81		if item, err := o.loaders[k].Load(target); err == nil {82			if item != nil {83				return item, nil84			}85		} else {86			if err != ErrNotFound {87				return nil, err88			}89		}90	}91	return nil, ErrNotFound92}93// LoadJSON loads the given config target and binds it to the given object as json.94func (o *configurator) LoadJSON(target string, v interface{}) error {95	if item, err := o.Load(target); err != nil {96		return err97	} else {98		return item.JSON(v)99	}100}101// LoadXML loads the given config target and binds it to the given object as xml.102func (o *configurator) LoadXML(target string, v interface{}) error {103	if item, err := o.Load(target); err != nil {104		return err105	} else {106		return item.XML(v)107	}108}109// LoadTOML loads the given config target and binds it to the given object as toml.110func (o *configurator) LoadTOML(target string, v interface{}) error {111	if item, err := o.Load(target); err != nil {112		return err113	} else {114		return item.TOML(v)115	}116}117// LoadYAML loads the given config target and binds it to the given object as yaml.118func (o *configurator) LoadYAML(target string, v interface{}) error {119	if item, err := o.Load(target); err != nil {120		return err121	} else {122		return item.YAML(v)123	}124}...

value_test.go

Source:value_test.go

...11	"time"12)13func TestValue(t *testing.T) {14	var v Value15	if v.Load() != nil {16		t.Fatal("initial Value is not nil")17	}18	v.Store(42)19	x := v.Load()20	if xx, ok := x.(int); !ok || xx != 42 {21		t.Fatalf("wrong value: got %+v, want 42", x)22	}23	v.Store(84)24	x = v.Load()25	if xx, ok := x.(int); !ok || xx != 84 {26		t.Fatalf("wrong value: got %+v, want 84", x)27	}28}29func TestValueLarge(t *testing.T) {30	var v Value31	v.Store("foo")32	x := v.Load()33	if xx, ok := x.(string); !ok || xx != "foo" {34		t.Fatalf("wrong value: got %+v, want foo", x)35	}36	v.Store("barbaz")37	x = v.Load()38	if xx, ok := x.(string); !ok || xx != "barbaz" {39		t.Fatalf("wrong value: got %+v, want barbaz", x)40	}41}42func TestValuePanic(t *testing.T) {43	const nilErr = "sync/atomic: store of nil value into Value"44	const badErr = "sync/atomic: store of inconsistently typed value into Value"45	var v Value46	func() {47		defer func() {48			err := recover()49			if err != nilErr {50				t.Fatalf("inconsistent store panic: got '%v', want '%v'", err, nilErr)51			}52		}()53		v.Store(nil)54	}()55	v.Store(42)56	func() {57		defer func() {58			err := recover()59			if err != badErr {60				t.Fatalf("inconsistent store panic: got '%v', want '%v'", err, badErr)61			}62		}()63		v.Store("foo")64	}()65	func() {66		defer func() {67			err := recover()68			if err != nilErr {69				t.Fatalf("inconsistent store panic: got '%v', want '%v'", err, nilErr)70			}71		}()72		v.Store(nil)73	}()74}75func TestValueConcurrent(t *testing.T) {76	tests := [][]interface{}{77		{uint16(0), ^uint16(0), uint16(1 + 2<<8), uint16(3 + 4<<8)},78		{uint32(0), ^uint32(0), uint32(1 + 2<<16), uint32(3 + 4<<16)},79		{uint64(0), ^uint64(0), uint64(1 + 2<<32), uint64(3 + 4<<32)},80		{complex(0, 0), complex(1, 2), complex(3, 4), complex(5, 6)},81	}82	p := 4 * runtime.GOMAXPROCS(0)83	for _, test := range tests {84		var v Value85		done := make(chan bool)86		for i := 0; i < p; i++ {87			go func() {88				r := rand.New(rand.NewSource(rand.Int63()))89			loop:90				for j := 0; j < 1e5; j++ {91					x := test[r.Intn(len(test))]92					v.Store(x)93					x = v.Load()94					for _, x1 := range test {95						if x == x1 {96							continue loop97						}98					}99					t.Logf("loaded unexpected value %+v, want %+v", x, test)100					done <- false101				}102				done <- true103			}()104		}105		for i := 0; i < p; i++ {106			if !<-done {107				t.FailNow()108			}109		}110	}111}112func BenchmarkValueRead(b *testing.B) {113	var v Value114	v.Store(new(int))115	b.RunParallel(func(pb *testing.PB) {116		for pb.Next() {117			x := v.Load().(*int)118			if *x != 0 {119				b.Fatalf("wrong value: got %v, want 0", *x)120			}121		}122	})123}124// The following example shows how to use Value for periodic program config updates125// and propagation of the changes to worker goroutines.126func ExampleValue_config() {127	var config Value // holds current server configuration128	// Create initial config value and store into config.129	config.Store(loadConfig())130	go func() {131		// Reload config every 10 seconds132		// and update config value with the new version.133		for {134			time.Sleep(10 * time.Second)135			config.Store(loadConfig())136		}137	}()138	// Create worker goroutines that handle incoming requests139	// using the latest config value.140	for i := 0; i < 10; i++ {141		go func() {142			for r := range requests() {143				c := config.Load()144				// Handle request r using config c.145				_, _ = r, c146			}147		}()148	}149}150func loadConfig() map[string]string {151	return make(map[string]string)152}153func requests() chan int {154	return make(chan int)155}156// The following example shows how to maintain a scalable frequently read,157// but infrequently updated data structure using copy-on-write idiom.158func ExampleValue_readMostly() {159	type Map map[string]string160	var m Value161	m.Store(make(Map))162	var mu sync.Mutex // used only by writers163	// read function can be used to read the data without further synchronization164	read := func(key string) (val string) {165		m1 := m.Load().(Map)166		return m1[key]167	}168	// insert function can be used to update the data without further synchronization169	insert := func(key, val string) {170		mu.Lock() // synchronize with other potential writers171		defer mu.Unlock()172		m1 := m.Load().(Map) // load current value of the data structure173		m2 := make(Map)      // create a new value174		for k, v := range m1 {175			m2[k] = v // copy all data from the current object to the new one176		}177		m2[key] = val // do the update that we need178		m.Store(m2)   // atomically replace the current object with the new one179		// At this point all new readers start working with the new version.180		// The old version will be garbage collected once the existing readers181		// (if any) are done with it.182	}183	_, _ = read, insert184}...

main.go

Source:main.go

...91		updater.Bot.UserName))92	updater.Idle()93}94func registerHandlers(updater *gotgbot.Updater) {95	admins.LoadAdmins(updater)96	setting.LoadSetting(updater)97	private.LoadPm(updater)98	info.LoadInfo(updater)99	help.LoadHelp(updater)100	reporting.LoadReport(updater)101	listener.LoadSettingListener(updater)102	listener.LoadHelpListener(updater)103	listener.LoadStartListener(updater)104	listener.LoadReportListener(updater)105	listener.LoadLangListener(updater)106	listener.LoadUserListener(updater)107}108func main() {109	sql.InitDb()110	caching.InitRedis()111	caching.InitCache()112	function.LoadAllLang()113	multiInstance() // This is used if you want multiple bot running on single instance. Be aware that this can take much resources.114	//singleInstance() // This is used if you have only single instance. Do not use both of them!115}...

difficulty_test.go

Source:difficulty_test.go

...37func TestDifficulty(t *testing.T) {38	t.Parallel()39	dt := new(testMatcher)40	// Not difficulty-tests41	dt.skipLoad("hexencodetest.*")42	dt.skipLoad("crypto.*")43	dt.skipLoad("blockgenesistest\\.json")44	dt.skipLoad("genesishashestest\\.json")45	dt.skipLoad("keyaddrtest\\.json")46	dt.skipLoad("txtest\\.json")47	// files are 2 years old, contains strange values48	dt.skipLoad("difficultyCustomHomestead\\.json")49	dt.skipLoad("difficultyMorden\\.json")50	dt.skipLoad("difficultyOlimpic\\.json")51	dt.config("Ropsten", *params.TestnetChainConfig)52	dt.config("Morden", *params.TestnetChainConfig)53	dt.config("Frontier", params.ChainConfig{})54	dt.config("Homestead", params.ChainConfig{55		HomesteadBlock: big.NewInt(0),56	})57	dt.config("Byzantium", params.ChainConfig{58		ByzantiumBlock: big.NewInt(0),59	})60	dt.config("Frontier", *params.TestnetChainConfig)61	dt.config("MainNetwork", mainnetChainConfig)62	dt.config("CustomMainNetwork", mainnetChainConfig)63	dt.config("difficulty.json", mainnetChainConfig)64	dt.walk(t, difficultyTestDir, func(t *testing.T, name string, test *DifficultyTest) {...

Load

Using AI Code Generation

1import (2func main() {3		panic(fmt.Errorf("Fatal error config file: %s \n", err))4	}5	fmt.Println("value:", viper.Get("name"))6}7import (8func main() {9		panic(fmt.Errorf("Fatal error config file: %s \n", err))10	}11	fmt.Println("value:", viper.Get("name"))12}13import (14func main() {15	pflag.String("name", "golang", "help message for flagname")16	pflag.Parse()17	viper.BindPFlags(pflag.CommandLine)18		panic(fmt.Errorf("Fatal error config file: %s \n", err

Load

Using AI Code Generation

1import (2func main() {3        panic(fmt.Errorf("Fatal error config file: %s \n", err))4    }5    fmt.Println("Reading config file: ", viper.ConfigFileUsed())6}7import (8func main() {9        panic(fmt.Errorf("Fatal error config file: %s \n", err))10    }11    fmt.Println("Reading config file: ", viper.ConfigFileUsed())12}13import (14func main() {15        panic(fmt

Load

Using AI Code Generation

1import (2func main() {3    config, err := config.NewConfig("ini", "config.conf")4    if err != nil {5        fmt.Println("new config failed, err:", err)6    }7    appname := config.String("appname")8    if len(appname) == 0 {9        fmt.Println("read appname failed")10    }11    fmt.Println("appname:", appname)12    httpport, err := config.Int("httpport")13    if err != nil {14        fmt.Println("read httpport failed, err:", err)15    }16    fmt.Println("httpport:", httpport)17    runmode := config.String("runmode")18    if len(runmode) == 0 {19        fmt.Println("read runmode failed")20    }21    fmt.Println("runmode:", runmode)22    autorender, err := config.Bool("autorender")23    if err != nil {24        fmt.Println("read autorender failed, err:", err)25    }26    fmt.Println("autorender:", autorender)27    copyrequestbody, err := config.Bool("copyrequestbody")28    if err != nil {29        fmt.Println("read copyrequestbody failed, err:", err)30    }31    fmt.Println("copyrequestbody:", copyrequestbody)32    sessionon, err := config.Bool("sessionon")33    if err != nil {34        fmt.Println("read sessionon failed, err:", err)35    }36    fmt.Println("sessionon:", sessionon)37    enablegzip, err := config.Bool("enablegzip")38    if err != nil {39        fmt.Println("read enablegzip failed, err:", err)40    }41    fmt.Println("enablegzip:", enablegzip)42    enableadmin, err := config.Bool("enableadmin")43    if err != nil {44        fmt.Println("read enableadmin failed, err:", err)45    }46    fmt.Println("enableadmin:", enableadmin)47    logpath := config.String("logpath")48    if len(logpath) == 0 {49        fmt.Println("read logpath failed")50    }51    fmt.Println("logpath:", logpath)52}

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.