func TestMapCreation(t *testing.T) { o := New(nil) assert.Nil(t, o) o = New("Tyler") assert.Nil(t, o) unconvertable := &Unconvertable{name: "Tyler"} o = New(unconvertable) assert.Nil(t, o) convertable := &Convertable{name: "Tyler"} o = New(convertable) if assert.NotNil(t, convertable) { assert.Equal(t, "Tyler", o["name"], "Tyler") } o = MSI() if assert.NotNil(t, o) { assert.NotNil(t, o) } o = MSI("name", "Tyler") if assert.NotNil(t, o) { if assert.NotNil(t, o) { assert.Equal(t, o["name"], "Tyler") } } }
func TestMapFromJSON(t *testing.T) { o := MustFromJSON(`{"name":"Mat"}`) if assert.NotNil(t, o) { if assert.NotNil(t, o) { assert.Equal(t, "Mat", o["name"]) } } }
func TestDefaultShouldDefaultMultipleFields(t *testing.T) { assert := assert.New(t) type S struct { A string `default:"i am a string"` B string C int `default:"1"` } s := S{} assert.Equal(s.A, "") assert.Equal(s.B, "") assert.Equal(s.C, 0) v, err := SetDefault(&s, "A") assert.Nil(err) assert.Equal(s.A, "i am a string") assert.Equal(s.A, v) _, err = SetDefault(&s, "B") assert.NotNil(err) assert.Equal(s.B, "") v, err = SetDefault(&s, "C") assert.Nil(err) assert.Equal(s.C, 1) assert.Equal(s.C, v) }
func TestScheduleShouldStartAndStop(t *testing.T) { defer glog.Flush() assert := assert.New(t) unit := 10 * time.Millisecond calledCount := 0 testF := func(start time.Time, dur time.Time) { remainder := start.Nanosecond() % int(unit) assert.Equal(0, remainder, "Start not truncated to 10ms") calledCount++ } s := schedule.Schedule{ Callback: testF, Period: unit, } assert.NotNil(s) sleepCount := 3 start := time.Now() err := s.Start() assert.Nil(err) time.Sleep(unit * time.Duration(sleepCount)) s.Stop() elapsed := time.Since(start) assert.True(calledCount >= sleepCount && calledCount <= int(elapsed/unit)) }
func TestMapFromURLQuery(t *testing.T) { m, err := FromURLQuery("name=tyler&state=UT") if assert.NoError(t, err) && assert.NotNil(t, m) { assert.Equal(t, "tyler", m.Get("name").Str()) assert.Equal(t, "UT", m.Get("state").Str()) } }
func TestScheduleShouldNotDoubleStart(t *testing.T) { defer glog.Flush() assert := assert.New(t) s := schedule.Schedule{ Callback: func(start time.Time, dur time.Time) {}, Period: time.Millisecond, } assert.NotNil(s) err := s.Start() assert.Nil(err) err = s.Start() assert.NotNil(err) s.Stop() }
func TestDynamicConfiguratonValidateShouldFailNilConf(t *testing.T) { assert := assert.New(t) dc := config.DynamicConfiguration{ Type: "test", Conf: nil, } err := dc.Validate() assert.NotNil(err) }
func Test_Mock_TestData(t *testing.T) { var mockedService *TestExampleImplementation = new(TestExampleImplementation) if assert.NotNil(t, mockedService.TestData()) { mockedService.TestData().Set("something", 123) assert.Equal(t, 123, mockedService.TestData().Get("something").Data()) } }
func TestDefaultShouldDefaultErrorOnMissingField(t *testing.T) { assert := assert.New(t) type S struct { A string `default:"a"` } s := S{} _, err := SetDefault(&s, "B") assert.NotNil(err) }
func TestDefaultShouldDefaultErrorOnMissingTag(t *testing.T) { assert := assert.New(t) type S struct { A string } s := S{} _, err := SetDefault(&s, "A") assert.NotNil(err) }
func TestDefaultShouldNotDefaultInvalidBool(t *testing.T) { assert := assert.New(t) type S struct { A bool `default:"invalid"` } s := S{} assert.Equal(s.A, false) _, err := SetDefault(&s, "A") assert.NotNil(err) }
func TestSetAllDefaultsShouldErrorOnNonPtr(t *testing.T) { assert := assert.New(t) type S struct { A string `default:"i am a string"` } s := S{} assert.Equal(s.A, "") err := SetAllDefaults(s) assert.NotNil(err) }
func TestDefaultShouldNotDefaultInvalidFloat(t *testing.T) { assert := assert.New(t) type S struct { A float64 `default:"1.0a"` } s := S{} assert.Equal(s.A, 0.0) _, err := SetDefault(&s, "A") assert.NotNil(err) }
func TestDefaultShouldNotDefaultInvalidUint(t *testing.T) { assert := assert.New(t) type S struct { A uint `default:"-1"` } s := S{} assert.Equal(s.A, uint(0)) _, err := SetDefault(&s, "A") assert.NotNil(err) }
func Test_Mock_findExpectedCall(t *testing.T) { m := new(Mock) m.On("One", 1).Return("one") m.On("Two", 2).Return("two") m.On("Two", 3).Return("three") f, c := m.findExpectedCall("Two", 3) if assert.Equal(t, 2, f) { if assert.NotNil(t, c) { assert.Equal(t, "Two", c.Method) assert.Equal(t, 3, c.Arguments[0]) assert.Equal(t, "three", c.ReturnArguments[0]) } } }