func (s *workerSuite) TestSetMembersErrorIsNotFatal(c *gc.C) {
	coretesting.SkipIfI386(c, "lp:1425569")

	DoTestForIPv4AndIPv6(func(ipVersion TestIPVersion) {
		st := NewFakeState()
		InitState(c, st, 3, ipVersion)
		st.session.setStatus(mkStatuses("0p 1s 2s", ipVersion))
		var setCount voyeur.Value
		st.errors.setErrorFuncFor("Session.Set", func() error {
			setCount.Set(true)
			return errors.New("sample")
		})
		s.PatchValue(&initialRetryInterval, 10*time.Microsecond)
		s.PatchValue(&maxRetryInterval, coretesting.ShortWait/4)

		w := newWorker(st, noPublisher{})
		defer func() {
			c.Check(worker.Stop(w), gc.IsNil)
		}()

		// See that the worker is retrying.
		setCountW := setCount.Watch()
		mustNext(c, setCountW)
		mustNext(c, setCountW)
		mustNext(c, setCountW)
	})
}

// WatchValue returns a NotifyWatcher that triggers
// when the given value changes. Its Wait and Err methods
// never return a non-nil error.
func WatchValue(val *voyeur.Value) state.NotifyWatcher {
	n := &notifier{
		w:       val.Watch(),
		changes: make(chan struct{}),
	}
	go n.loop()
	return n
}

// WatchStrings returns a StringsWatcher that triggers
// when the given value changes. Its Wait and Err methods
// never return a non-nil error.
func WatchStrings(val *voyeur.Value) state.StringsWatcher {
	n := &stringsNotifier{
		w:       val.Watch(),
		changes: make(chan []string),
	}
	go n.loop()
	return n
}

func (s *workerSuite) TestSetMembersErrorIsNotFatal(c *gc.C) {
	testForIPv4AndIPv6(func(ipVersion testIPVersion) {
		st := newFakeState()
		initState(c, st, 3, ipVersion)
		st.session.setStatus(mkStatuses("0p 1s 2s", ipVersion))
		var isSet voyeur.Value
		count := 0
		setErrorFuncFor("Session.Set", func() error {
			isSet.Set(count)
			count++
			return errors.New("sample")
		})
		s.PatchValue(&initialRetryInterval, 10*time.Microsecond)
		s.PatchValue(&maxRetryInterval, coretesting.ShortWait/4)

		expectedIterations := 0
		for d := initialRetryInterval; d < maxRetryInterval*2; d *= 2 {
			expectedIterations++
		}

		w := newWorker(st, noPublisher{})
		defer func() {
			c.Check(worker.Stop(w), gc.IsNil)
		}()
		isSetWatcher := isSet.Watch()

		n0 := mustNext(c, isSetWatcher).(int)
		time.Sleep(maxRetryInterval * 2)
		n1 := mustNext(c, isSetWatcher).(int)

		// The worker should have backed off exponentially...
		c.Assert(n1-n0, jc.LessThan, expectedIterations+1)
		c.Logf("actual iterations %d; expected iterations %d", n1-n0, expectedIterations)

		// ... but only up to the maximum retry interval
		n0 = mustNext(c, isSetWatcher).(int)
		time.Sleep(maxRetryInterval * 2)
		n1 = mustNext(c, isSetWatcher).(int)

		c.Assert(n1-n0, jc.LessThan, 3)
		resetErrors()
	})
}