package netann_test

import (
	"bytes"
	"crypto/rand"
	"encoding/binary"
	"fmt"
	"io"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/btcsuite/btcd/btcec"
	"github.com/btcsuite/btcd/wire"
	"github.com/lightningnetwork/lnd/channeldb"
	"github.com/lightningnetwork/lnd/lnwire"
	"github.com/lightningnetwork/lnd/netann"
)

// randOutpoint creates a random wire.Outpoint.
func randOutpoint(t *testing.T) wire.OutPoint {
	t.Helper()

	var buf [36]byte
	_, err := io.ReadFull(rand.Reader, buf[:])
	if err != nil {
		t.Fatalf("unable to generate random outpoint: %v", err)
	}

	op := wire.OutPoint{}
	copy(op.Hash[:], buf[:32])
	op.Index = binary.BigEndian.Uint32(buf[32:])

	return op
}

var shortChanIDs uint64

// createChannel generates a channeldb.OpenChannel with a random chanpoint and
// short channel id.
func createChannel(t *testing.T) *channeldb.OpenChannel {
	t.Helper()

	sid := atomic.AddUint64(&shortChanIDs, 1)

	return &channeldb.OpenChannel{
		ShortChannelID:  lnwire.NewShortChanIDFromInt(sid),
		ChannelFlags:    lnwire.FFAnnounceChannel,
		FundingOutpoint: randOutpoint(t),
	}
}

// createEdgePolicies generates an edge info and two directional edge policies.
// The remote party's public key is generated randomly, and then sorted against
// our `pubkey` with the direction bit set appropriately in the policies. Our
// update will be created with the disabled bit set if startEnabled is false.
func createEdgePolicies(t *testing.T, channel *channeldb.OpenChannel,
	pubkey *btcec.PublicKey, startEnabled bool) (*channeldb.ChannelEdgeInfo,
	*channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy) {

	var (
		pubkey1 [33]byte
		pubkey2 [33]byte
		dir1    lnwire.ChanUpdateChanFlags
		dir2    lnwire.ChanUpdateChanFlags
	)

	// Set pubkey1 to OUR pubkey.
	copy(pubkey1[:], pubkey.SerializeCompressed())

	// Set the disabled bit appropriately on our update.
	if !startEnabled {
		dir1 |= lnwire.ChanUpdateDisabled
	}

	// Generate and set pubkey2 for THEIR pubkey.
	privKey2, err := btcec.NewPrivateKey(btcec.S256())
	if err != nil {
		t.Fatalf("unable to generate key pair: %v", err)
	}
	copy(pubkey2[:], privKey2.PubKey().SerializeCompressed())

	// Set pubkey1 to the lower of the two pubkeys.
	if bytes.Compare(pubkey2[:], pubkey1[:]) < 0 {
		pubkey1, pubkey2 = pubkey2, pubkey1
		dir1, dir2 = dir2, dir1
	}

	// Now that the ordering has been established, set pubkey2's direction
	// bit.
	dir2 |= lnwire.ChanUpdateDirection

	return &channeldb.ChannelEdgeInfo{
			ChannelPoint:  channel.FundingOutpoint,
			NodeKey1Bytes: pubkey1,
			NodeKey2Bytes: pubkey2,
		},
		&channeldb.ChannelEdgePolicy{
			ChannelID:    channel.ShortChanID().ToUint64(),
			ChannelFlags: dir1,
			LastUpdate:   time.Now(),
			SigBytes:     make([]byte, 64),
		},
		&channeldb.ChannelEdgePolicy{
			ChannelID:    channel.ShortChanID().ToUint64(),
			ChannelFlags: dir2,
			LastUpdate:   time.Now(),
			SigBytes:     make([]byte, 64),
		}
}

type mockGraph struct {
	mu        sync.Mutex
	channels  []*channeldb.OpenChannel
	chanInfos map[wire.OutPoint]*channeldb.ChannelEdgeInfo
	chanPols1 map[wire.OutPoint]*channeldb.ChannelEdgePolicy
	chanPols2 map[wire.OutPoint]*channeldb.ChannelEdgePolicy
	sidToCid  map[lnwire.ShortChannelID]wire.OutPoint

	updates chan *lnwire.ChannelUpdate
}

func newMockGraph(t *testing.T, numChannels int,
	startActive, startEnabled bool, pubKey *btcec.PublicKey) *mockGraph {

	g := &mockGraph{
		channels:  make([]*channeldb.OpenChannel, 0, numChannels),
		chanInfos: make(map[wire.OutPoint]*channeldb.ChannelEdgeInfo),
		chanPols1: make(map[wire.OutPoint]*channeldb.ChannelEdgePolicy),
		chanPols2: make(map[wire.OutPoint]*channeldb.ChannelEdgePolicy),
		sidToCid:  make(map[lnwire.ShortChannelID]wire.OutPoint),
		updates:   make(chan *lnwire.ChannelUpdate, 2*numChannels),
	}

	for i := 0; i < numChannels; i++ {
		c := createChannel(t)

		info, pol1, pol2 := createEdgePolicies(
			t, c, pubKey, startEnabled,
		)

		g.addChannel(c)
		g.addEdgePolicy(c, info, pol1, pol2)
	}

	return g
}

func (g *mockGraph) FetchAllOpenChannels() ([]*channeldb.OpenChannel, error) {
	return g.chans(), nil
}

func (g *mockGraph) FetchChannelEdgesByOutpoint(
	op *wire.OutPoint) (*channeldb.ChannelEdgeInfo,
	*channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy, error) {

	g.mu.Lock()
	defer g.mu.Unlock()

	info, ok := g.chanInfos[*op]
	if !ok {
		return nil, nil, nil, channeldb.ErrEdgeNotFound
	}

	pol1 := g.chanPols1[*op]
	pol2 := g.chanPols2[*op]

	return info, pol1, pol2, nil
}

func (g *mockGraph) ApplyChannelUpdate(update *lnwire.ChannelUpdate) error {
	g.mu.Lock()
	defer g.mu.Unlock()

	outpoint, ok := g.sidToCid[update.ShortChannelID]
	if !ok {
		return fmt.Errorf("unknown short channel id: %v",
			update.ShortChannelID)
	}

	pol1 := g.chanPols1[outpoint]
	pol2 := g.chanPols2[outpoint]

	// Determine which policy we should update by making the flags on the
	// policies and updates, and seeing which match up.
	var update1 bool
	switch {
	case update.ChannelFlags&lnwire.ChanUpdateDirection ==
		pol1.ChannelFlags&lnwire.ChanUpdateDirection:
		update1 = true

	case update.ChannelFlags&lnwire.ChanUpdateDirection ==
		pol2.ChannelFlags&lnwire.ChanUpdateDirection:
		update1 = false

	default:
		return fmt.Errorf("unable to find policy to update")
	}

	timestamp := time.Unix(int64(update.Timestamp), 0)

	policy := &channeldb.ChannelEdgePolicy{
		ChannelID:    update.ShortChannelID.ToUint64(),
		ChannelFlags: update.ChannelFlags,
		LastUpdate:   timestamp,
		SigBytes:     make([]byte, 64),
	}

	if update1 {
		g.chanPols1[outpoint] = policy
	} else {
		g.chanPols2[outpoint] = policy
	}

	// Send the update to network. This channel should be sufficiently
	// buffered to avoid deadlocking.
	g.updates <- update

	return nil
}

func (g *mockGraph) chans() []*channeldb.OpenChannel {
	g.mu.Lock()
	defer g.mu.Unlock()

	channels := make([]*channeldb.OpenChannel, 0, len(g.channels))
	channels = append(channels, g.channels...)

	return channels
}

func (g *mockGraph) addChannel(channel *channeldb.OpenChannel) {
	g.mu.Lock()
	defer g.mu.Unlock()

	g.channels = append(g.channels, channel)
}

func (g *mockGraph) addEdgePolicy(c *channeldb.OpenChannel,
	info *channeldb.ChannelEdgeInfo,
	pol1, pol2 *channeldb.ChannelEdgePolicy) {

	g.mu.Lock()
	defer g.mu.Unlock()

	g.chanInfos[c.FundingOutpoint] = info
	g.chanPols1[c.FundingOutpoint] = pol1
	g.chanPols2[c.FundingOutpoint] = pol2
	g.sidToCid[c.ShortChanID()] = c.FundingOutpoint
}

func (g *mockGraph) removeChannel(channel *channeldb.OpenChannel) {
	g.mu.Lock()
	defer g.mu.Unlock()

	for i, c := range g.channels {
		if c.FundingOutpoint != channel.FundingOutpoint {
			continue
		}

		g.channels = append(g.channels[:i], g.channels[i+1:]...)
		delete(g.chanInfos, c.FundingOutpoint)
		delete(g.chanPols1, c.FundingOutpoint)
		delete(g.chanPols2, c.FundingOutpoint)
		delete(g.sidToCid, c.ShortChanID())
		return
	}
}

type mockSwitch struct {
	mu       sync.Mutex
	isActive map[lnwire.ChannelID]bool
}

func newMockSwitch() *mockSwitch {
	return &mockSwitch{
		isActive: make(map[lnwire.ChannelID]bool),
	}
}

func (s *mockSwitch) HasActiveLink(chanID lnwire.ChannelID) bool {
	s.mu.Lock()
	defer s.mu.Unlock()

	// If the link is found, we will returns it's active status. In the
	// real switch, it returns EligibleToForward().
	active, ok := s.isActive[chanID]
	if ok {
		return active
	}

	return false
}

func (s *mockSwitch) SetStatus(chanID lnwire.ChannelID, active bool) {
	s.mu.Lock()
	defer s.mu.Unlock()

	s.isActive[chanID] = active
}

func newManagerCfg(t *testing.T, numChannels int,
	startEnabled bool) (*netann.ChanStatusConfig, *mockGraph, *mockSwitch) {

	t.Helper()

	privKey, err := btcec.NewPrivateKey(btcec.S256())
	if err != nil {
		t.Fatalf("unable to generate key pair: %v", err)
	}

	graph := newMockGraph(
		t, numChannels, startEnabled, startEnabled, privKey.PubKey(),
	)
	htlcSwitch := newMockSwitch()

	cfg := &netann.ChanStatusConfig{
		ChanStatusSampleInterval: 50 * time.Millisecond,
		ChanEnableTimeout:        500 * time.Millisecond,
		ChanDisableTimeout:       time.Second,
		OurPubKey:                privKey.PubKey(),
		MessageSigner:            netann.NewNodeSigner(privKey),
		IsChannelActive:          htlcSwitch.HasActiveLink,
		ApplyChannelUpdate:       graph.ApplyChannelUpdate,
		DB:                       graph,
		Graph:                    graph,
	}

	return cfg, graph, htlcSwitch
}

type testHarness struct {
	t                  *testing.T
	numChannels        int
	graph              *mockGraph
	htlcSwitch         *mockSwitch
	mgr                *netann.ChanStatusManager
	ourPubKey          *btcec.PublicKey
	safeDisableTimeout time.Duration
}

// newHarness returns a new testHarness for testing a ChanStatusManager. The
// mockGraph will be populated with numChannels channels. The startActive and
// startEnabled govern the initial state of the channels wrt the htlcswitch and
// the network, respectively.
func newHarness(t *testing.T, numChannels int,
	startActive, startEnabled bool) testHarness {

	cfg, graph, htlcSwitch := newManagerCfg(t, numChannels, startEnabled)

	mgr, err := netann.NewChanStatusManager(cfg)
	if err != nil {
		t.Fatalf("unable to create chan status manager: %v", err)
	}

	err = mgr.Start()
	if err != nil {
		t.Fatalf("unable to start chan status manager: %v", err)
	}

	h := testHarness{
		t:                  t,
		numChannels:        numChannels,
		graph:              graph,
		htlcSwitch:         htlcSwitch,
		mgr:                mgr,
		ourPubKey:          cfg.OurPubKey,
		safeDisableTimeout: (3 * cfg.ChanDisableTimeout) / 2, // 1.5x
	}

	// Initialize link status as requested.
	if startActive {
		h.markActive(h.graph.channels)
	} else {
		h.markInactive(h.graph.channels)
	}

	return h
}

// markActive updates the active status of the passed channels within the mock
// switch to active.
func (h *testHarness) markActive(channels []*channeldb.OpenChannel) {
	h.t.Helper()

	for _, channel := range channels {
		chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
		h.htlcSwitch.SetStatus(chanID, true)
	}
}

// markInactive updates the active status of the passed channels within the mock
// switch to inactive.
func (h *testHarness) markInactive(channels []*channeldb.OpenChannel) {
	h.t.Helper()

	for _, channel := range channels {
		chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
		h.htlcSwitch.SetStatus(chanID, false)
	}
}

// assertEnables requests enables for all of the passed channels, and asserts
// that the errors returned from RequestEnable matches expErr.
func (h *testHarness) assertEnables(channels []*channeldb.OpenChannel, expErr error) {
	h.t.Helper()

	for _, channel := range channels {
		h.assertEnable(channel.FundingOutpoint, expErr)
	}
}

// assertDisables requests disables for all of the passed channels, and asserts
// that the errors returned from RequestDisable matches expErr.
func (h *testHarness) assertDisables(channels []*channeldb.OpenChannel, expErr error) {
	h.t.Helper()

	for _, channel := range channels {
		h.assertDisable(channel.FundingOutpoint, expErr)
	}
}

// assertEnable requests an enable for the given outpoint, and asserts that the
// returned error matches expErr.
func (h *testHarness) assertEnable(outpoint wire.OutPoint, expErr error) {
	h.t.Helper()

	err := h.mgr.RequestEnable(outpoint)
	if err != expErr {
		h.t.Fatalf("expected enable error: %v, got %v", expErr, err)
	}
}

// assertDisable requests a disable for the given outpoint, and asserts that the
// returned error matches expErr.
func (h *testHarness) assertDisable(outpoint wire.OutPoint, expErr error) {
	h.t.Helper()

	err := h.mgr.RequestDisable(outpoint)
	if err != expErr {
		h.t.Fatalf("expected disable error: %v, got %v", expErr, err)
	}
}

// assertNoUpdates waits for the specified duration, and asserts that no updates
// are announced on the network.
func (h *testHarness) assertNoUpdates(duration time.Duration) {
	h.t.Helper()

	h.assertUpdates(nil, false, duration)
}

// assertUpdates waits for the specified duration, asserting that an update
// are receive on the network for each of the passed OpenChannels, and that all
// of their disable bits are set to match expEnabled. The expEnabled parameter
// is ignored if channels is nil.
func (h *testHarness) assertUpdates(channels []*channeldb.OpenChannel,
	expEnabled bool, duration time.Duration) {

	h.t.Helper()

	// Compute an index of the expected short channel ids for which we want
	// to received updates.
	expSids := sidsFromChans(channels)

	timeout := time.After(duration)
	recvdSids := make(map[lnwire.ShortChannelID]struct{})
	for {
		select {
		case upd := <-h.graph.updates:
			// Assert that the received short channel id is one that
			// we expect. If no updates were expected, this will
			// always fail on the first update received.
			if _, ok := expSids[upd.ShortChannelID]; !ok {
				h.t.Fatalf("received update for unexpected "+
					"short chan id: %v", upd.ShortChannelID)
			}

			// Assert that the disabled bit is set properly.
			enabled := upd.ChannelFlags&lnwire.ChanUpdateDisabled !=
				lnwire.ChanUpdateDisabled
			if expEnabled != enabled {
				h.t.Fatalf("expected enabled: %v, actual: %v",
					expEnabled, enabled)
			}

			recvdSids[upd.ShortChannelID] = struct{}{}

		case <-timeout:
			// Time is up, assert that the correct number of unique
			// updates was received.
			if len(recvdSids) == len(channels) {
				return
			}

			h.t.Fatalf("expected %d updates, got %d",
				len(channels), len(recvdSids))
		}
	}
}

// sidsFromChans returns an index contain the short channel ids of each channel
// provided in the list of OpenChannels.
func sidsFromChans(
	channels []*channeldb.OpenChannel) map[lnwire.ShortChannelID]struct{} {

	sids := make(map[lnwire.ShortChannelID]struct{})
	for _, channel := range channels {
		sids[channel.ShortChanID()] = struct{}{}
	}
	return sids
}

type stateMachineTest struct {
	name         string
	startEnabled bool
	startActive  bool
	fn           func(testHarness)
}

var stateMachineTests = []stateMachineTest{
	{
		name:         "active and enabled is stable",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// No updates should be sent because being active and
			// enabled should be a stable state.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "inactive and disabled is stable",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// No updates should be sent because being inactive and
			// disabled should be a stable state.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "start disabled request enable",
		startActive:  true, // can't request enable unless active
		startEnabled: false,
		fn: func(h testHarness) {
			// Request enables for all channels.
			h.assertEnables(h.graph.chans(), nil)
			// Expect to see them all enabled on the network.
			h.assertUpdates(
				h.graph.chans(), true, h.safeDisableTimeout,
			)
		},
	},
	{
		name:         "start enabled request disable",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// Request disables for all channels.
			h.assertDisables(h.graph.chans(), nil)
			// Expect to see them all disabled on the network.
			h.assertUpdates(
				h.graph.chans(), false, h.safeDisableTimeout,
			)
		},
	},
	{
		name:         "request enable already enabled",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// Request enables for already enabled channels.
			h.assertEnables(h.graph.chans(), nil)
			// Manager shouldn't send out any updates.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "request disabled already disabled",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// Request disables for already enabled channels.
			h.assertDisables(h.graph.chans(), nil)
			// Manager shouldn't sent out any updates.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "detect and disable inactive",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// Simulate disconnection and have links go inactive.
			h.markInactive(h.graph.chans())
			// Should see all channels passively disabled.
			h.assertUpdates(
				h.graph.chans(), false, h.safeDisableTimeout,
			)
		},
	},
	{
		name:         "quick flap stays active",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// Simulate disconnection and have links go inactive.
			h.markInactive(h.graph.chans())
			// Allow 2 sample intervals to pass, but not long
			// enough for a disable to occur.
			time.Sleep(100 * time.Millisecond)
			// Simulate reconnect by making channels active.
			h.markActive(h.graph.chans())
			// Request that all channels be reenabled.
			h.assertEnables(h.graph.chans(), nil)
			// Pending disable should have been canceled, and
			// no updates sent. Channels remain enabled on the
			// network.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "no passive enable from becoming active",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// Simulate reconnect by making channels active.
			h.markActive(h.graph.chans())
			// No updates should be sent without explicit enable.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "enable inactive channel fails",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// Request enable of inactive channels, expect error
			// indicating that channel was not active.
			h.assertEnables(
				h.graph.chans(), netann.ErrEnableInactiveChan,
			)
			// No updates should be sent as a result of the failure.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "enable unknown channel fails",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// Create channels unknown to the graph.
			unknownChans := []*channeldb.OpenChannel{
				createChannel(h.t),
				createChannel(h.t),
				createChannel(h.t),
			}
			// Request that they be enabled, which should return an
			// error as the graph doesn't have an edge for them.
			h.assertEnables(
				unknownChans, channeldb.ErrEdgeNotFound,
			)
			// No updates should be sent as a result of the failure.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "disable unknown channel fails",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// Create channels unknown to the graph.
			unknownChans := []*channeldb.OpenChannel{
				createChannel(h.t),
				createChannel(h.t),
				createChannel(h.t),
			}
			// Request that they be disabled, which should return an
			// error as the graph doesn't have an edge for them.
			h.assertDisables(
				unknownChans, channeldb.ErrEdgeNotFound,
			)
			// No updates should be sent as a result of the failure.
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
	{
		name:         "add new channels",
		startActive:  false,
		startEnabled: false,
		fn: func(h testHarness) {
			// Allow the manager to enter a steady state for the
			// initial channel set.
			h.assertNoUpdates(h.safeDisableTimeout)

			// Add a new channels to the graph, but don't yet add
			// the edge policies. We should see no updates sent
			// since the manager can't access the policies.
			newChans := []*channeldb.OpenChannel{
				createChannel(h.t),
				createChannel(h.t),
				createChannel(h.t),
			}
			for _, c := range newChans {
				h.graph.addChannel(c)
			}
			h.assertNoUpdates(h.safeDisableTimeout)

			// Check that trying to enable the channel with unknown
			// edges results in a failure.
			h.assertEnables(newChans, channeldb.ErrEdgeNotFound)

			// Now, insert edge policies for the channel into the
			// graph, starting with the channel enabled, and mark
			// the link active.
			for _, c := range newChans {
				info, pol1, pol2 := createEdgePolicies(
					h.t, c, h.ourPubKey, true,
				)
				h.graph.addEdgePolicy(c, info, pol1, pol2)
			}
			h.markActive(newChans)

			// We expect no updates to be sent since the channel is
			// enabled and active.
			h.assertNoUpdates(h.safeDisableTimeout)

			// Finally, assert that enabling the channel doesn't
			// return an error now that everything is in place.
			h.assertEnables(newChans, nil)
		},
	},
	{
		name:         "remove channels then disable",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// Allow the manager to enter a steady state for the
			// initial channel set.
			h.assertNoUpdates(h.safeDisableTimeout)

			// Select half of the current channels to remove.
			channels := h.graph.chans()
			rmChans := channels[:len(channels)/2]

			// Mark the channel inactive and remove them from the
			// graph. This should trigger the manager to attempt a
			// mark the channel disabled, but will unable to do so
			// because it can't find the edge policies.
			h.markInactive(rmChans)
			for _, c := range rmChans {
				h.graph.removeChannel(c)
			}
			h.assertNoUpdates(h.safeDisableTimeout)

			// Check that trying to enable the channel with unknown
			// edges results in a failure.
			h.assertDisables(rmChans, channeldb.ErrEdgeNotFound)
		},
	},
	{
		name:         "disable channels then remove",
		startActive:  true,
		startEnabled: true,
		fn: func(h testHarness) {
			// Allow the manager to enter a steady state for the
			// initial channel set.
			h.assertNoUpdates(h.safeDisableTimeout)

			// Select half of the current channels to remove.
			channels := h.graph.chans()
			rmChans := channels[:len(channels)/2]

			// Check that trying to enable the channel with unknown
			// edges results in a failure.
			h.assertDisables(rmChans, nil)

			// Since the channels are still in the graph, we expect
			// these channels to be disabled on the network.
			h.assertUpdates(rmChans, false, h.safeDisableTimeout)

			// Finally, remove  the channels from the graph and
			// assert no more updates are sent.
			for _, c := range rmChans {
				h.graph.removeChannel(c)
			}
			h.assertNoUpdates(h.safeDisableTimeout)
		},
	},
}

// TestChanStatusManagerStateMachine tests the possible state transitions that
// can be taken by the ChanStatusManager.
func TestChanStatusManagerStateMachine(t *testing.T) {
	t.Parallel()

	for _, test := range stateMachineTests {
		tc := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			const numChannels = 10
			h := newHarness(
				t, numChannels, tc.startActive, tc.startEnabled,
			)
			defer h.mgr.Stop()

			tc.fn(h)
		})
	}
}