config_test.go

package git

import (
"os"
"testing"
)

vartempConfig="./temp.gitconfig"

funcsetupConfig() (*Config, error) {
var (
c*Config
errerror
 )

c, err=OpenOndisk(tempConfig)
iferr!=nil {
returnnil, err
 }

err=c.SetString("foo.bar", "baz")
iferr!=nil {
returnnil, err
 }
err=c.SetBool("foo.bool", true)
iferr!=nil {
returnnil, err
 }
err=c.SetInt32("foo.int32", 32)
iferr!=nil {
returnnil, err
 }
err=c.SetInt64("foo.int64", 64)
iferr!=nil {
returnnil, err
 }

returnc, err
}

funccleanupConfig() {
os.Remove(tempConfig)
}

typeTestRunnerfunc(*Config, *testing.T)

vartests= []TestRunner{
// LookupString
func(c*Config, t*testing.T) {
val, err:=c.LookupString("foo.bar")
iferr!=nil {
t.Errorf("Got LookupString error: '%v', expected none\n", err)
 }
ifval!="baz" {
t.Errorf("Got '%s' from LookupString, expected 'bar'\n", val)
 }
 },
// LookupBool
func(c*Config, t*testing.T) {
val, err:=c.LookupBool("foo.bool")
iferr!=nil {
t.Errorf("Got LookupBool error: '%v', expected none\n", err)
 }
if!val {
t.Errorf("Got %t from LookupBool, expected 'false'\n", val)
 }
 },
// LookupInt32
func(c*Config, t*testing.T) {
val, err:=c.LookupInt32("foo.int32")
iferr!=nil {
t.Errorf("Got LookupInt32 error: '%v', expected none\n", err)
 }
ifval!=32 {
t.Errorf("Got %v, expected 32\n", val)
 }
 },
// LookupInt64
func(c*Config, t*testing.T) {
val, err:=c.LookupInt64("foo.int64")
iferr!=nil {
t.Errorf("Got LookupInt64 error: '%v', expected none\n", err)
 }
ifval!=64 {
t.Errorf("Got %v, expected 64\n", val)
 }
 },
}

funcTestConfigLookups(t*testing.T) {
t.Parallel()
var (
errerror
c*Config
 )

c, err=setupConfig()
defercleanupConfig()

iferr!=nil {
t.Errorf("Setup error: '%v'. Expected none\n", err)
return
 }
deferc.Free()

for_, test:=rangetests {
test(c, t)
 }
}

funcTestOpenDefault(t*testing.T) {

c, err:=OpenDefault()
iferr!=nil {
t.Errorf("OpenDefault error: '%v'. Expected none\n", err)
return
 }
deferc.Free()
}