codebase: Replace !errors.Is(err, target) with testify (#1931)

* tests: Replace !errors.Is(err, target) with testify equivalents

* codebase: Manual !errors.Is(err, target) replacements

* typo: Replace errMisMatchedEvent with errMismatchedEvent

* tests: Enhance error messages for better output

* tests: Refactor error assertions in various test cases to use require and improve clarity

* misc linter: Fix assert should wording

* tests: Simplify assertions in TestCreateSignals for clarity and conciseness

* tests: Enhance assertion message in TestCreateSignals

backtester/engine/backtest_test.go

@@ -1,7 +1,6 @@
 package engine
 
 import (
-	"errors"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -59,20 +58,15 @@ func TestSetupFromConfig(t *testing.T) {
 	require.NoError(t, err)
 
 	err = bt.SetupFromConfig(nil, "", "", false)
-	if !errors.Is(err, errNilConfig) {
-		t.Errorf("received %v, expected %v", err, errNilConfig)
-	}
+	assert.ErrorIs(t, err, errNilConfig)
+
 	cfg := &config.Config{}
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, gctkline.ErrInvalidInterval) {
-		t.Errorf("received: %v, expected: %v", err, gctkline.ErrInvalidInterval)
-	}
+	assert.ErrorIs(t, err, gctkline.ErrInvalidInterval)
 
 	cfg.DataSettings.Interval = gctkline.OneMonth
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, base.ErrStrategyNotFound) {
-		t.Errorf("received: %v, expected: %v", err, base.ErrStrategyNotFound)
-	}
+	assert.ErrorIs(t, err, base.ErrStrategyNotFound)
 
 	const testExchange = "bitfinex"
 
@@ -85,9 +79,7 @@ func TestSetupFromConfig(t *testing.T) {
 		},
 	}
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, base.ErrStrategyNotFound) {
-		t.Errorf("received: %v, expected: %v", err, base.ErrStrategyNotFound)
-	}
+	assert.ErrorIs(t, err, base.ErrStrategyNotFound)
 
 	cfg.StrategySettings = config.StrategySettings{
 		Name: dollarcostaverage.Name,
@@ -103,24 +95,20 @@ func TestSetupFromConfig(t *testing.T) {
 	}
 	cfg.DataSettings.DataType = common.CandleStr
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, gctcommon.ErrDateUnset) {
-		t.Errorf("received: %v, expected: %v", err, gctcommon.ErrDateUnset)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
+
 	cfg.DataSettings.Interval = gctkline.OneMin
 	cfg.CurrencySettings[0].MakerFee = &decimal.Zero
 	cfg.CurrencySettings[0].TakerFee = &decimal.Zero
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, gctcommon.ErrDateUnset) {
-		t.Errorf("received: %v, expected: %v", err, gctcommon.ErrDateUnset)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
 
 	cfg.DataSettings.APIData.StartDate = time.Now().Truncate(gctkline.OneMin.Duration()).Add(-gctkline.OneMin.Duration() * 10)
 	cfg.DataSettings.APIData.EndDate = cfg.DataSettings.APIData.StartDate.Add(gctkline.OneMin.Duration() * 5)
 	cfg.DataSettings.APIData.InclusiveEndDate = true
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, holdings.ErrInitialFundsZero) {
-		t.Errorf("received: %v, expected: %v", err, holdings.ErrInitialFundsZero)
-	}
+	assert.ErrorIs(t, err, holdings.ErrInitialFundsZero)
+
 	cfg.FundingSettings.UseExchangeLevelFunding = true
 	cfg.FundingSettings.ExchangeLevelFunding = []config.ExchangeLevelFunding{
 		{
@@ -390,9 +378,7 @@ func TestLoadDataLive(t *testing.T) {
 		RequestFormat: &currency.PairFormat{Uppercase: true},
 	}
 	_, err = bt.loadData(cfg, exch, cp, asset.Spot, false)
-	if !errors.Is(err, gctkline.ErrCannotConstructInterval) {
-		t.Errorf("received: %v, expected: %v", err, gctkline.ErrCannotConstructInterval)
-	}
+	assert.ErrorIs(t, err, gctkline.ErrCannotConstructInterval)
 
 	cfg.DataSettings.Interval = gctkline.OneMin
 	_, err = bt.loadData(cfg, exch, cp, asset.Spot, false)
@@ -427,9 +413,7 @@ func TestReset(t *testing.T) {
 
 	bt = nil
 	err = bt.Reset()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestFullCycle(t *testing.T) {
@@ -539,18 +523,15 @@ func TestStop(t *testing.T) {
 	tt := bt.MetaData.DateEnded
 
 	err = bt.Stop()
-	if !errors.Is(err, errAlreadyRan) {
-		t.Errorf("received: %v, expected: %v", err, errAlreadyRan)
-	}
+	assert.ErrorIs(t, err, errAlreadyRan)
+
 	if !tt.Equal(bt.MetaData.DateEnded) {
 		t.Errorf("received '%v' expected '%v'", bt.MetaData.DateEnded, tt)
 	}
 
 	bt = nil
 	err = bt.Stop()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestFullCycleMulti(t *testing.T) {
@@ -644,9 +625,7 @@ func TestFullCycleMulti(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = bt.Run()
-	if !errors.Is(err, errNotSetup) {
-		t.Errorf("received: %v, expected: %v", err, errNotSetup)
-	}
+	assert.ErrorIs(t, err, errNotSetup)
 
 	bt.MetaData.DateLoaded = time.Now()
 	err = bt.Run()
@@ -676,15 +655,11 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 	bt := BackTest{
 		shutdown: make(chan struct{}),
 	}
-	expectedError := common.ErrNilEvent
 	err := bt.triggerLiquidationsForExchange(nil, nil)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.ErrorIs(t, err, common.ErrNilEvent)
 
 	cp := currency.NewBTCUSDT()
 	a := asset.USDTMarginedFutures
-	expectedError = gctcommon.ErrNilPointer
 	ev := &evkline.Kline{
 		Base: &event.Base{
 			Exchange:     testExchange,
@@ -693,9 +668,7 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 		},
 	}
 	err = bt.triggerLiquidationsForExchange(ev, nil)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.Portfolio = &portfolioOverride{}
 	pnl := &portfolio.PNLSummary{}
@@ -730,7 +703,6 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 		RangeHolder: &gctkline.IntervalRangeHolder{},
 	}
 	bt.Statistic = &statistics.Statistic{}
-	expectedError = nil
 
 	bt.EventQueue = &eventholder.Holder{}
 	bt.Funding = &funding.FundManager{}
@@ -738,24 +710,18 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = bt.Statistic.SetEventForOffset(ev)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.NoError(t, err, "SetEventForOffset should not error")
+
 	pnl.Exchange = ev.Exchange
 	pnl.Asset = ev.AssetType
 	pnl.Pair = ev.CurrencyPair
 	err = bt.triggerLiquidationsForExchange(ev, pnl)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.NoError(t, err, "triggerLiquidationsForExchange should not error")
+
 	ev2 := bt.EventQueue.NextEvent()
 	ev2o, ok := ev2.(order.Event)
-	if !ok {
-		t.Fatal("expected order event")
-	}
-	if ev2o.GetDirection() != gctorder.Short {
-		t.Error("expected liquidation order")
-	}
+	require.True(t, ok, "NextEvent must return an order event")
+	assert.Equal(t, gctorder.Short, ev2o.GetDirection())
 }
 
 func TestUpdateStatsForDataEvent(t *testing.T) {
@@ -766,11 +732,9 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
 		Portfolio: &fakeFolio{},
 		shutdown:  make(chan struct{}),
 	}
-	expectedError := common.ErrNilEvent
+
 	err := bt.updateStatsForDataEvent(nil, nil)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.ErrorIs(t, err, common.ErrNilEvent)
 
 	cp := currency.NewBTCUSDT()
 	a := asset.Futures
@@ -782,28 +746,21 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
 		},
 	}
 
-	expectedError = gctcommon.ErrNilPointer
 	err = bt.updateStatsForDataEvent(ev, nil)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
-	expectedError = nil
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
+
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetupFundingManager must not error")
+
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	pair, err := funding.CreateCollateral(b, quote)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateCollateral must not error")
+
 	bt.Funding = f
 	exch := &binance.Binance{}
 	exch.Name = testExchange
@@ -829,19 +786,14 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
 		},
 	}
 	_, err = bt.Portfolio.TrackFuturesOrder(fl, pair)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.NoError(t, err, "TrackFuturesOrder should not error")
 
 	err = bt.updateStatsForDataEvent(ev, pair)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.NoError(t, err, "updateStatsForDataEvent should not error")
 }
 
 func TestProcessSignalEvent(t *testing.T) {
 	t.Parallel()
-	var expectedError error
 	bt := &BackTest{
 		Statistic:  &fakeStats{},
 		Funding:    &funding.FundManager{},
@@ -860,29 +812,24 @@ func TestProcessSignalEvent(t *testing.T) {
 		},
 	}
 	err := bt.Statistic.SetEventForOffset(de)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetEventForOffset must not error")
+
 	ev := &signal.Signal{
 		Base: de.Base,
 	}
 
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetupFundingManager must not error")
+
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	pair, err := funding.CreateCollateral(b, quote)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateCollateral must not error")
+
 	bt.Funding = f
 	exch := &binance.Binance{}
 	exch.Name = testExchange
@@ -893,22 +840,17 @@ func TestProcessSignalEvent(t *testing.T) {
 	})
 	ev.Direction = gctorder.Short
 	err = bt.Statistic.SetEventForOffset(ev)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetEventForOffset must not error")
+
 	err = bt.processSignalEvent(ev, pair)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.NoError(t, err, "processSignalEvent should not error")
 }
 
 func TestProcessOrderEvent(t *testing.T) {
 	t.Parallel()
-	var expectedError error
 	pt, err := portfolio.Setup(&size.Size{}, &risk.Risk{}, decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "Setup must not error")
+
 	bt := &BackTest{
 		Statistic:  &statistics.Statistic{},
 		Funding:    &funding.FundManager{},
@@ -928,29 +870,24 @@ func TestProcessOrderEvent(t *testing.T) {
 		},
 	}
 	err = bt.Statistic.SetEventForOffset(de)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetEventForOffset must not error")
+
 	ev := &order.Order{
 		Base: de.Base,
 	}
 
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetupFundingManager must not error")
+
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	pair, err := funding.CreateCollateral(b, quote)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateCollateral must not error")
+
 	bt.Funding = f
 	exch := &binance.Binance{}
 	exch.Name = testExchange
@@ -959,9 +896,7 @@ func TestProcessOrderEvent(t *testing.T) {
 		Pair:     cp,
 		Asset:    a,
 	})
-	if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNotYetImplemented)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
 
 	bt.Exchange.SetExchangeAssetCurrencySettings(a, cp, &exchange.Settings{
 		Exchange: exch,
@@ -970,9 +905,8 @@ func TestProcessOrderEvent(t *testing.T) {
 	})
 	ev.Direction = gctorder.Short
 	err = bt.Statistic.SetEventForOffset(ev)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetEventForOffset must not error")
+
 	tt := time.Now()
 	bt.DataHolder = data.NewHandlerHolder()
 	k := &kline.DataFromKline{
@@ -1016,13 +950,11 @@ func TestProcessOrderEvent(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = bt.processOrderEvent(ev, pair)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "processOrderEvent must not error")
+
 	ev2 := bt.EventQueue.NextEvent()
-	if _, ok := ev2.(fill.Event); !ok {
-		t.Fatal("expected fill event")
-	}
+	_, ok := ev2.(fill.Event)
+	require.True(t, ok, "NextEvent must return a fill event")
 }
 
 func TestProcessFillEvent(t *testing.T) {
@@ -1127,7 +1059,6 @@ func TestProcessFillEvent(t *testing.T) {
 
 func TestProcessFuturesFillEvent(t *testing.T) {
 	t.Parallel()
-	var expectedError error
 	bt := &BackTest{
 		Statistic:  &fakeStats{},
 		Funding:    &funding.FundManager{},
@@ -1147,33 +1078,26 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 		},
 	}
 	err := bt.Statistic.SetEventForOffset(de)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetEventForOffset must note error")
+
 	ev := &fill.Fill{
 		Base: de.Base,
 	}
 	em := engine.NewExchangeManager()
 	exch, err := em.NewExchangeByName(testExchange)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	exch.SetDefaults()
 	err = em.Add(exch)
 	require.NoError(t, err)
 
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateItem must not error")
+
 	pair, err := funding.CreateCollateral(b, quote)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "CreateCollateral must not error")
 
 	bt.exchangeManager = em
 	bt.Exchange.SetExchangeAssetCurrencySettings(a, cp, &exchange.Settings{
@@ -1183,9 +1107,8 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 	})
 	ev.Direction = gctorder.Short
 	err = bt.Statistic.SetEventForOffset(ev)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	require.NoError(t, err, "SetEventForOffset must not error")
+
 	tt := time.Now()
 	bt.DataHolder = data.NewHandlerHolder()
 	k := &kline.DataFromKline{
@@ -1223,7 +1146,7 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ev.Order = &gctorder.Detail{
 		Exchange:  testExchange,
@@ -1236,12 +1159,10 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 		Date:      time.Now(),
 	}
 	err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, k)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = bt.processFuturesFillEvent(ev, pair)
-	if !errors.Is(err, expectedError) {
-		t.Errorf("received '%v' expected '%v'", err, expectedError)
-	}
+	assert.NoError(t, err, "processFuturesFillEvent should not error")
 }
 
 func TestCloseAllPositions(t *testing.T) {
@@ -1254,9 +1175,7 @@ func TestCloseAllPositions(t *testing.T) {
 	bt.Strategy = &dollarcostaverage.Strategy{}
 
 	err = bt.CloseAllPositions()
-	if !errors.Is(err, errLiveOnly) {
-		t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
-	}
+	assert.ErrorIs(t, err, errLiveOnly)
 
 	bt.shutdown = make(chan struct{})
 	dc := &dataChecker{
@@ -1265,16 +1184,12 @@ func TestCloseAllPositions(t *testing.T) {
 	}
 	bt.LiveDataHandler = dc
 	err = bt.CloseAllPositions()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.shutdown = make(chan struct{})
 	bt.Strategy = &binancecashandcarry.Strategy{}
 	err = bt.CloseAllPositions()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.shutdown = make(chan struct{})
 	bt.Portfolio = &fakeFolio{}
@@ -1327,9 +1242,7 @@ func TestRunLive(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = bt.RunLive()
-	if !errors.Is(err, errLiveOnly) {
-		t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
-	}
+	assert.ErrorIs(t, err, errLiveOnly)
 
 	bt.Funding = &funding.FundManager{}
 	bt.Reports = &report.Data{}
@@ -1457,17 +1370,14 @@ func TestLiveLoop(t *testing.T) {
 func TestSetExchangeCredentials(t *testing.T) {
 	t.Parallel()
 	err := setExchangeCredentials(nil, nil)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
+
 	cfg := &config.Config{}
 	f := &binanceus.Binanceus{}
 	f.SetDefaults()
 	b := f.GetBase()
 	err = setExchangeCredentials(cfg, b)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	ld := &config.LiveData{}
 	cfg.DataSettings = config.DataSettings{
@@ -1478,21 +1388,15 @@ func TestSetExchangeCredentials(t *testing.T) {
 
 	ld.RealOrders = true
 	err = setExchangeCredentials(cfg, b)
-	if !errors.Is(err, errIntervalUnset) {
-		t.Errorf("received '%v' expected '%v'", err, errIntervalUnset)
-	}
+	assert.ErrorIs(t, err, errIntervalUnset)
 
 	cfg.DataSettings.Interval = gctkline.OneMin
 	err = setExchangeCredentials(cfg, b)
-	if !errors.Is(err, errNoCredsNoLive) {
-		t.Errorf("received '%v' expected '%v'", err, errNoCredsNoLive)
-	}
+	assert.ErrorIs(t, err, errNoCredsNoLive)
 
 	cfg.DataSettings.LiveData.ExchangeCredentials = []config.Credentials{{}}
 	err = setExchangeCredentials(cfg, b)
-	if !errors.Is(err, gctexchange.ErrCredentialsAreEmpty) {
-		t.Errorf("received '%v' expected '%v'", err, gctexchange.ErrCredentialsAreEmpty)
-	}
+	assert.ErrorIs(t, err, gctexchange.ErrCredentialsAreEmpty)
 
 	// requires valid credentials here to get complete coverage
 	// enter them here
@@ -1547,9 +1451,7 @@ func TestGenerateSummary(t *testing.T) {
 
 	bt = nil
 	_, err = bt.GenerateSummary()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestSetupMetaData(t *testing.T) {
@@ -1573,9 +1475,7 @@ func TestSetupMetaData(t *testing.T) {
 
 	bt = nil
 	err = bt.SetupMetaData()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestIsRunning(t *testing.T) {
@@ -1713,9 +1613,8 @@ func TestExecuteStrategy(t *testing.T) {
 		shutdown:   make(chan struct{}),
 	}
 	err := bt.ExecuteStrategy(false)
-	if !errors.Is(err, errNotSetup) {
-		t.Errorf("received '%v' expected '%v'", err, errNotSetup)
-	}
+	assert.ErrorIs(t, err, errNotSetup)
+
 	id, err := uuid.NewV4()
 	assert.NoError(t, err)
 
@@ -1725,17 +1624,13 @@ func TestExecuteStrategy(t *testing.T) {
 	bt.MetaData.DateStarted = time.Now()
 	bt.m.Unlock()
 	err = bt.ExecuteStrategy(false)
-	if !errors.Is(err, errTaskIsRunning) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskIsRunning)
-	}
+	assert.ErrorIs(t, err, errTaskIsRunning)
 
 	err = bt.Stop()
 	assert.NoError(t, err)
 
 	err = bt.ExecuteStrategy(true)
-	if !errors.Is(err, errAlreadyRan) {
-		t.Errorf("received '%v' expected '%v'", err, errAlreadyRan)
-	}
+	assert.ErrorIs(t, err, errAlreadyRan)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Time{}
@@ -1764,20 +1659,14 @@ func TestExecuteStrategy(t *testing.T) {
 	bt.shutdown = make(chan struct{})
 	bt.m.Unlock()
 	err = bt.ExecuteStrategy(true)
-	if !errors.Is(err, errCannotHandleRequest) {
-		t.Errorf("received '%v' expected '%v'", err, errCannotHandleRequest)
-	}
+	assert.ErrorIs(t, err, errCannotHandleRequest)
 
 	err = bt.ExecuteStrategy(false)
-	if !errors.Is(err, errLiveOnly) {
-		t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
-	}
+	assert.ErrorIs(t, err, errLiveOnly)
 
 	bt = nil
 	err = bt.ExecuteStrategy(false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestNewBacktesterFromConfigs(t *testing.T) {
@@ -1816,9 +1705,8 @@ func TestProcessSingleDataEvent(t *testing.T) {
 	}
 
 	err := bt.processSingleDataEvent(nil, nil)
-	if !errors.Is(err, common.ErrNilEvent) {
-		t.Errorf("received '%v' expected '%v'", err, common.ErrNilEvent)
-	}
+	assert.ErrorIs(t, err, common.ErrNilEvent)
+
 	cp := currency.NewBTCUSDT()
 	a := asset.Spot
 	ev := &evkline.Kline{
@@ -1831,9 +1719,7 @@ func TestProcessSingleDataEvent(t *testing.T) {
 		},
 	}
 	err = bt.processSingleDataEvent(ev, nil)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
 	assert.NoError(t, err)

backtester/engine/live_test.go

@@ -1,7 +1,6 @@
 package engine
 
 import (
-	"errors"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -30,27 +29,19 @@ func TestSetupLiveDataHandler(t *testing.T) {
 	bt := &BackTest{}
 	var err error
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.exchangeManager = engine.NewExchangeManager()
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.DataHolder = &data.HandlerHolder{}
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.Reports = &report.Data{}
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt.Funding = &funding.FundManager{}
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
@@ -69,9 +60,7 @@ func TestSetupLiveDataHandler(t *testing.T) {
 
 	bt = nil
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestStart(t *testing.T) {
@@ -86,15 +75,11 @@ func TestStart(t *testing.T) {
 	dc.wg.Wait()
 	atomic.CompareAndSwapUint32(&dc.started, 0, 1)
 	err = dc.Start()
-	if !errors.Is(err, engine.ErrSubSystemAlreadyStarted) {
-		t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemAlreadyStarted)
-	}
+	assert.ErrorIs(t, err, engine.ErrSubSystemAlreadyStarted)
 
 	var dh *dataChecker
 	err = dh.Start()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestDataCheckerIsRunning(t *testing.T) {
@@ -122,9 +107,7 @@ func TestLiveHandlerStop(t *testing.T) {
 		shutdown: make(chan bool),
 	}
 	err := dc.Stop()
-	if !errors.Is(err, engine.ErrSubSystemNotStarted) {
-		t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
-	}
+	assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
 
 	dc.started = 1
 	err = dc.Stop()
@@ -132,15 +115,11 @@ func TestLiveHandlerStop(t *testing.T) {
 
 	dc.shutdown = make(chan bool)
 	err = dc.Stop()
-	if !errors.Is(err, engine.ErrSubSystemNotStarted) {
-		t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
-	}
+	assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
 
 	var dh *dataChecker
 	err = dh.Stop()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestLiveHandlerStopFromError(t *testing.T) {
@@ -149,14 +128,11 @@ func TestLiveHandlerStopFromError(t *testing.T) {
 		shutdownErr: make(chan bool, 10),
 	}
 	err := dc.SignalStopFromError(errNoCredsNoLive)
-	if !errors.Is(err, engine.ErrSubSystemNotStarted) {
-		t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
-	}
+	assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
 
 	err = dc.SignalStopFromError(nil)
-	if !errors.Is(err, errNilError) {
-		t.Errorf("received '%v' expected '%v'", err, errNilError)
-	}
+	assert.ErrorIs(t, err, errNilError)
+
 	dc.started = 1
 	var wg sync.WaitGroup
 	wg.Add(1)
@@ -169,9 +145,7 @@ func TestLiveHandlerStopFromError(t *testing.T) {
 
 	var dh *dataChecker
 	err = dh.SignalStopFromError(errNoCredsNoLive)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestDataFetcher(t *testing.T) {
@@ -185,22 +159,16 @@ func TestDataFetcher(t *testing.T) {
 	}
 	dc.wg.Add(1)
 	err := dc.DataFetcher()
-	if !errors.Is(err, engine.ErrSubSystemNotStarted) {
-		t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
-	}
+	assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
 
 	dc.started = 1
 	dc.wg.Add(1)
 	err = dc.DataFetcher()
-	if !errors.Is(err, ErrLiveDataTimeout) {
-		t.Errorf("received '%v' expected '%v'", err, ErrLiveDataTimeout)
-	}
+	assert.ErrorIs(t, err, ErrLiveDataTimeout)
 
 	var dh *dataChecker
 	err = dh.DataFetcher()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestUpdated(t *testing.T) {
@@ -238,48 +206,34 @@ func TestLiveHandlerReset(t *testing.T) {
 	}
 	var dh *dataChecker
 	err = dh.Reset()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestAppendDataSource(t *testing.T) {
 	t.Parallel()
 	dataHandler := &dataChecker{}
 	err := dataHandler.AppendDataSource(nil)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	setup := &liveDataSourceSetup{}
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	setup.exchange = &binance.Binance{}
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, common.ErrInvalidDataType) {
-		t.Errorf("received '%v' expected '%v'", err, common.ErrInvalidDataType)
-	}
+	assert.ErrorIs(t, err, common.ErrInvalidDataType)
 
 	setup.dataType = common.DataCandle
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, asset.ErrNotSupported) {
-		t.Errorf("received '%v' expected '%v'", err, asset.ErrNotSupported)
-	}
+	assert.ErrorIs(t, err, asset.ErrNotSupported)
 
 	setup.asset = asset.Spot
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
-		t.Errorf("received '%v' expected '%v'", err, currency.ErrCurrencyPairEmpty)
-	}
+	assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
 
 	setup.pair = currency.NewBTCUSDT()
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, kline.ErrInvalidInterval) {
-		t.Errorf("received '%v' expected '%v'", err, kline.ErrInvalidInterval)
-	}
+	assert.ErrorIs(t, err, kline.ErrInvalidInterval)
 
 	setup.interval = kline.OneDay
 	err = dataHandler.AppendDataSource(setup)
@@ -290,15 +244,11 @@ func TestAppendDataSource(t *testing.T) {
 	}
 
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, errDataSourceExists) {
-		t.Errorf("received '%v' expected '%v'", err, errDataSourceExists)
-	}
+	assert.ErrorIs(t, err, errDataSourceExists)
 
 	dataHandler = nil
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestFetchLatestData(t *testing.T) {
@@ -370,9 +320,7 @@ func TestLoadCandleData(t *testing.T) {
 		processedData:             make(map[int64]struct{}),
 	}
 	_, err := l.loadCandleData(time.Now())
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	exch := &binanceus.Binanceus{}
 	exch.SetDefaults()
@@ -407,9 +355,7 @@ func TestLoadCandleData(t *testing.T) {
 
 	var ldh *liveDataSourceDataHandler
 	_, err = ldh.loadCandleData(time.Now())
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestSetDataForClosingAllPositions(t *testing.T) {
@@ -464,14 +410,11 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = dataHandler.SetDataForClosingAllPositions()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	err = dataHandler.SetDataForClosingAllPositions(nil)
-	if !errors.Is(err, errNilData) {
-		t.Errorf("received '%v' expected '%v'", err, errNilData)
-	}
+	assert.ErrorIs(t, err, errNilData)
+
 	err = dataHandler.SetDataForClosingAllPositions(&signal.Signal{
 		Base: &event.Base{
 			Offset:         3,
@@ -516,9 +459,7 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
 
 	dataHandler = nil
 	err = dataHandler.SetDataForClosingAllPositions()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestIsRealOrders(t *testing.T) {
@@ -537,9 +478,7 @@ func TestUpdateFunding(t *testing.T) {
 	t.Parallel()
 	d := &dataChecker{}
 	err := d.UpdateFunding(false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	ff := &fakeFunding{}
 	d.funding = ff
@@ -567,9 +506,7 @@ func TestUpdateFunding(t *testing.T) {
 
 	d = nil
 	err = d.UpdateFunding(false)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestClosedChan(t *testing.T) {

backtester/engine/taskmanager_test.go

@@ -1,7 +1,6 @@
 package engine
 
 import (
-	"errors"
 	"testing"
 	"time"
 
@@ -26,9 +25,7 @@ func TestAddRun(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	err := rm.AddTask(nil)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 
 	bt := &BackTest{}
 	err = rm.AddTask(bt)
@@ -42,18 +39,15 @@ func TestAddRun(t *testing.T) {
 	}
 
 	err = rm.AddTask(bt)
-	if !errors.Is(err, errTaskAlreadyMonitored) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskAlreadyMonitored)
-	}
+	assert.ErrorIs(t, err, errTaskAlreadyMonitored)
+
 	if len(rm.tasks) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(rm.tasks), 1)
 	}
 
 	rm = nil
 	err = rm.AddTask(bt)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestGetSummary(t *testing.T) {
@@ -63,9 +57,7 @@ func TestGetSummary(t *testing.T) {
 	assert.NoError(t, err)
 
 	_, err = rm.GetSummary(id)
-	if !errors.Is(err, errTaskNotFound) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
-	}
+	assert.ErrorIs(t, err, errTaskNotFound)
 
 	bt := &BackTest{
 		Strategy:  &binancecashandcarry.Strategy{},
@@ -83,9 +75,7 @@ func TestGetSummary(t *testing.T) {
 
 	rm = nil
 	_, err = rm.GetSummary(id)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestList(t *testing.T) {
@@ -114,9 +104,7 @@ func TestList(t *testing.T) {
 
 	rm = nil
 	_, err = rm.List()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestStopRun(t *testing.T) {
@@ -133,9 +121,7 @@ func TestStopRun(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = rm.StopTask(id)
-	if !errors.Is(err, errTaskNotFound) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
-	}
+	assert.ErrorIs(t, err, errTaskNotFound)
 
 	bt := &BackTest{
 		Strategy:  &fakeStrat{},
@@ -147,9 +133,7 @@ func TestStopRun(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = rm.StopTask(bt.MetaData.ID)
-	if !errors.Is(err, errTaskHasNotRan) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskHasNotRan)
-	}
+	assert.ErrorIs(t, err, errTaskHasNotRan)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Now()
@@ -158,15 +142,11 @@ func TestStopRun(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = rm.StopTask(bt.MetaData.ID)
-	if !errors.Is(err, errAlreadyRan) {
-		t.Errorf("received '%v' expected '%v'", err, errAlreadyRan)
-	}
+	assert.ErrorIs(t, err, errAlreadyRan)
 
 	rm = nil
 	err = rm.StopTask(id)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestStopAllRuns(t *testing.T) {
@@ -200,9 +180,7 @@ func TestStopAllRuns(t *testing.T) {
 
 	rm = nil
 	_, err = rm.StopAllTasks()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestStartRun(t *testing.T) {
@@ -219,9 +197,7 @@ func TestStartRun(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = rm.StartTask(id)
-	if !errors.Is(err, errTaskNotFound) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
-	}
+	assert.ErrorIs(t, err, errTaskNotFound)
 
 	bt := &BackTest{
 		Strategy:   &binancecashandcarry.Strategy{},
@@ -237,9 +213,8 @@ func TestStartRun(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = rm.StartTask(bt.MetaData.ID)
-	if !errors.Is(err, errTaskIsRunning) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskIsRunning)
-	}
+	assert.ErrorIs(t, err, errTaskIsRunning)
+
 	bt.m.Lock()
 	bt.MetaData.DateEnded = time.Now()
 	bt.MetaData.Closed = true
@@ -247,15 +222,11 @@ func TestStartRun(t *testing.T) {
 	bt.m.Unlock()
 
 	err = rm.StartTask(bt.MetaData.ID)
-	if !errors.Is(err, errAlreadyRan) {
-		t.Errorf("received '%v' expected '%v'", err, errAlreadyRan)
-	}
+	assert.ErrorIs(t, err, errAlreadyRan)
 
 	rm = nil
 	err = rm.StartTask(id)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestStartAllRuns(t *testing.T) {
@@ -287,9 +258,7 @@ func TestStartAllRuns(t *testing.T) {
 
 	rm = nil
 	_, err = rm.StartAllTasks()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestClearRun(t *testing.T) {
@@ -300,9 +269,7 @@ func TestClearRun(t *testing.T) {
 	assert.NoError(t, err)
 
 	err = rm.ClearTask(id)
-	if !errors.Is(err, errTaskNotFound) {
-		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
-	}
+	assert.ErrorIs(t, err, errTaskNotFound)
 
 	bt := &BackTest{
 		Strategy:   &binancecashandcarry.Strategy{},
@@ -318,9 +285,7 @@ func TestClearRun(t *testing.T) {
 	bt.MetaData.DateStarted = time.Now()
 	bt.m.Unlock()
 	err = rm.ClearTask(bt.MetaData.ID)
-	if !errors.Is(err, errCannotClear) {
-		t.Errorf("received '%v' expected '%v'", err, errCannotClear)
-	}
+	assert.ErrorIs(t, err, errCannotClear)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Time{}
@@ -337,9 +302,7 @@ func TestClearRun(t *testing.T) {
 
 	rm = nil
 	err = rm.ClearTask(id)
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestClearAllRuns(t *testing.T) {
@@ -398,7 +361,5 @@ func TestClearAllRuns(t *testing.T) {
 
 	rm = nil
 	_, _, err = rm.ClearAllTasks()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }