Macros: Create extensive tests

src/engine/enginebuffer.h

@@ -236,19 +236,19 @@ class EngineBuffer : public EngineObject {
     friend class CueControlTest;
 
     LoopingControl* m_pLoopingControl; // used for testes
+    FRIEND_TEST(EngineBufferTest, ScalerNoTransport);
+    FRIEND_TEST(EngineSyncTest, HalfDoubleBpmTest);
+    FRIEND_TEST(EngineSyncTest, HalfDoubleThenPlay);
+    FRIEND_TEST(EngineSyncTest, UserTweakBeatDistance);
+    FRIEND_TEST(EngineSyncTest, UserTweakPreservedInSeek);
+    FRIEND_TEST(EngineSyncTest, BeatMapQantizePlay);
     FRIEND_TEST(LoopingControlTest, LoopScale_HalvesLoop);
     FRIEND_TEST(LoopingControlTest, LoopMoveTest);
     FRIEND_TEST(LoopingControlTest, LoopResizeSeek);
     FRIEND_TEST(LoopingControlTest, ReloopToggleButton_DoesNotJumpAhead);
     FRIEND_TEST(LoopingControlTest, ReloopAndStopButton);
     FRIEND_TEST(LoopingControlTest, Beatjump_JumpsByBeats);
     FRIEND_TEST(SyncControlTest, TestDetermineBpmMultiplier);
-    FRIEND_TEST(EngineSyncTest, HalfDoubleBpmTest);
-    FRIEND_TEST(EngineSyncTest, HalfDoubleThenPlay);
-    FRIEND_TEST(EngineSyncTest, UserTweakBeatDistance);
-    FRIEND_TEST(EngineSyncTest, UserTweakPreservedInSeek);
-    FRIEND_TEST(EngineSyncTest, BeatMapQantizePlay);
-    FRIEND_TEST(EngineBufferTest, ScalerNoTransport);
 
     ChannelHandle m_channel;
     bool m_bHotcueJumpPending;

src/recording/macromanager.h

@@ -94,7 +94,8 @@ class MacroManager : public RecordingManagerBase {
     Macro getMacro();
 
   private:
-    FRIEND_TEST(MacroManagerTest, claimRecording);
+    FRIEND_TEST(MacroManagerTest, ClaimRecording);
+    FRIEND_TEST(MacroManagerTest, RecordCueJump);
 
     /// Checks if ths channel is recording, otherwise tries to claim it.
     /// Returns true if this channel is recording.

src/test/macromanager_test.cpp

@@ -6,24 +6,61 @@
 #include <QDebug>
 
 #include "mixxxtest.h"
-
-class MacroManagerTest : protected MixxxTest {
-};
+#include "signalpathtest.h"
 
 TEST(MacrosTest, CreateMacro) {
     auto macro = new Macro();
     ASSERT_EQ(macro->m_length, 0);
 }
 
-TEST(MacroManagerTest, claimRecording) {
-    auto handle = ChannelHandleFactory().getOrCreateHandle("");
+TEST(MacroManagerTest, ClaimRecording) {
     auto mgr = MacroManager();
-    qDebug() << "Handle" << handle.handle();
-    ASSERT_EQ(mgr.m_macroRecordingState.load(), MacroState::Disabled);
+    EXPECT_EQ(mgr.isRecordingActive(), false);
+    mgr.claimRecording();
+    EXPECT_EQ(mgr.isRecordingActive(), false);
+    mgr.m_macroRecordingState.store(MacroState::Armed);
+    mgr.claimRecording();
+    EXPECT_EQ(mgr.isRecordingActive(), true);
+}
+
+TEST(MacroManagerTest, RecordCueJump) {
+    auto mgr = MacroManager();
+    ChannelHandle handle = ChannelHandleFactory().getOrCreateHandle("");
+    EXPECT_EQ(mgr.m_macroRecordingState.load(), MacroState::Disabled);
     mgr.notifyCueJump(handle, 0, 1);
-    ASSERT_EQ(mgr.m_macroRecordingState.load(), MacroState::Disabled);
-    ASSERT_EQ(mgr.m_activeChannel, nullptr);
+    EXPECT_EQ(mgr.m_activeChannel, nullptr);
     mgr.m_macroRecordingState.store(MacroState::Armed);
     mgr.notifyCueJump(handle, 0, 1);
-    ASSERT_EQ(mgr.m_activeChannel->handle(), handle.handle());
-}
+    EXPECT_EQ(mgr.m_activeChannel->handle(), handle.handle());
+    EXPECT_EQ(mgr.m_recordedMacro.actions[0].position, 0);
+    EXPECT_EQ(mgr.m_recordedMacro.actions[0].target, 1);
+    EXPECT_EQ(mgr.checkOrClaimRecording(handle), true);
+}
+
+TEST(MacroManagerTest, RecordingToggleControl) {
+    auto mgr = MacroManager();
+    ControlObject::set(ConfigKey(kMacroRecordingKey, "recording_toggle"), 1);
+    EXPECT_EQ(mgr.isRecordingActive(), true);
+    ControlObject::set(ConfigKey(kMacroRecordingKey, "recording_toggle"), 0);
+    EXPECT_EQ(mgr.isRecordingActive(), true);
+    ControlObject::set(ConfigKey(kMacroRecordingKey, "recording_toggle"), 1);
+    EXPECT_EQ(mgr.isRecordingActive(), false);
+}
+
+class MacroManagerE2ETest : public SignalPathTest {
+  public:
+    MacroManagerE2ETest()
+            : SignalPathTest(new MacroManager()) {
+    }
+};
+
+TEST_F(MacroManagerE2ETest, RecordSeek) {
+    auto mgr = m_pMacroManager;
+    ControlObject::toggle(ConfigKey(kMacroRecordingKey, "recording_toggle"));
+    ASSERT_EQ(mgr->isRecordingActive(), true);
+    //ControlObject::toggle(ConfigKey("[Channel1]", "hotcue_1_activate"));
+    m_pChannel1->getEngineBuffer()->slotControlSeekAbs(10);
+    //m_pChannel1->getEngineBuffer()->queueNewPlaypos(1000, EngineBuffer::SEEK_EXACT);
+    ProcessBuffer();
+    EXPECT_EQ(mgr->getMacro().m_length, 1);
+}

src/test/signalpathtest.h

@@ -1,25 +1,24 @@
-#ifndef ENGINEBACKENDTEST_H_
-#define ENGINEBACKENDTEST_H_
+#pragma once
 
-#include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
-#include <QtDebug>
 #include <QTest>
+#include <QtDebug>
 
-#include "preferences/usersettings.h"
 #include "control/controlobject.h"
-#include "mixer/deck.h"
 #include "effects/effectsmanager.h"
-#include "engine/enginebuffer.h"
 #include "engine/bufferscalers/enginebufferscale.h"
 #include "engine/channels/enginechannel.h"
 #include "engine/channels/enginedeck.h"
-#include "engine/enginemaster.h"
 #include "engine/controls/ratecontrol.h"
+#include "engine/enginebuffer.h"
+#include "engine/enginemaster.h"
 #include "engine/sync/enginesync.h"
+#include "mixer/deck.h"
 #include "mixer/previewdeck.h"
 #include "mixer/sampler.h"
+#include "preferences/usersettings.h"
 #include "test/mixxxtest.h"
 #include "util/defs.h"
 #include "util/memory.h"
@@ -28,8 +27,8 @@
 #include "waveform/guitick.h"
 #include "waveform/visualsmanager.h"
 
-using ::testing::Return;
 using ::testing::_;
+using ::testing::Return;
 
 // Subclass of EngineMaster that provides access to the master buffer object
 // for comparison.
@@ -57,36 +56,35 @@ class TestEngineMaster : public EngineMaster {
 
 class BaseSignalPathTest : public MixxxTest {
   protected:
-    BaseSignalPathTest() {
-        m_pGuiTick = std::make_unique<GuiTick>();
-        m_pChannelHandleFactory = std::make_shared<ChannelHandleFactory>();
-        m_pNumDecks = new ControlObject(ConfigKey("[Master]", "num_decks"));
-        m_pEffectsManager = new EffectsManager(nullptr, config(), m_pChannelHandleFactory);
-        m_pVisualsManager = new VisualsManager();
-        m_pEngineMaster = new TestEngineMaster(m_pConfig, "[Master]",
-                                               m_pEffectsManager, m_pChannelHandleFactory,
-                                               false);
+    explicit BaseSignalPathTest(MacroManager* pMacroManager = nullptr)
+            : m_pMacroManager(pMacroManager),
+              m_pGuiTick(std::make_unique<GuiTick>()),
+              m_pChannelHandleFactory(std::make_shared<ChannelHandleFactory>()),
+              m_pNumDecks(new ControlObject(ConfigKey("[Master]", "num_decks"))),
+              m_pEffectsManager(new EffectsManager(nullptr, config(), m_pChannelHandleFactory)),
+              m_pVisualsManager(),
+              m_pEngineMaster(new TestEngineMaster(m_pConfig, "[Master]", m_pEffectsManager, m_pChannelHandleFactory, false)) {
 
         m_pMixerDeck1 = new Deck(nullptr,
                 m_pConfig,
                 m_pEngineMaster,
-                nullptr,
+                pMacroManager,
                 m_pEffectsManager,
                 m_pVisualsManager,
                 EngineChannel::CENTER,
                 m_sGroup1);
         m_pMixerDeck2 = new Deck(nullptr,
                 m_pConfig,
                 m_pEngineMaster,
-                nullptr,
+                pMacroManager,
                 m_pEffectsManager,
                 m_pVisualsManager,
                 EngineChannel::CENTER,
                 m_sGroup2);
         m_pMixerDeck3 = new Deck(nullptr,
                 m_pConfig,
                 m_pEngineMaster,
-                nullptr,
+                pMacroManager,
                 m_pEffectsManager,
                 m_pVisualsManager,
                 EngineChannel::CENTER,
@@ -163,8 +161,7 @@ class BaseSignalPathTest : public MixxxTest {
     // Use tools/AudioPlot.py to look at the reference file and make sure it
     // looks correct.  Each line of the generated file contains the left sample
     // followed by the right sample.
-    void assertBufferMatchesReference(const CSAMPLE* pBuffer, const int iBufferSize,
-                                   QString reference_title, const double delta=.0001) {
+    void assertBufferMatchesReference(const CSAMPLE* pBuffer, const int iBufferSize, QString reference_title, const double delta = .0001) {
         QFile f(QDir::currentPath() + "/src/test/reference_buffers/" + reference_title);
         bool pass = true;
         int i = 0;
@@ -225,8 +222,11 @@ class BaseSignalPathTest : public MixxxTest {
     ChannelHandleFactoryPointer m_pChannelHandleFactory;
     ControlObject* m_pNumDecks;
     std::unique_ptr<GuiTick> m_pGuiTick;
+
     VisualsManager* m_pVisualsManager;
     EffectsManager* m_pEffectsManager;
+    MacroManager* m_pMacroManager;
+
     EngineSync* m_pEngineSync;
     TestEngineMaster* m_pEngineMaster;
     Deck *m_pMixerDeck1, *m_pMixerDeck2, *m_pMixerDeck3;
@@ -248,7 +248,8 @@ class BaseSignalPathTest : public MixxxTest {
 
 class SignalPathTest : public BaseSignalPathTest {
   protected:
-    SignalPathTest() {
+    SignalPathTest(MacroManager* pMacroManager = nullptr)
+            : BaseSignalPathTest(pMacroManager) {
         const QString kTrackLocationTest = QDir::currentPath() + "/src/test/sine-30.wav";
         TrackPointer pTrack(Track::newTemporary(kTrackLocationTest));
 
@@ -257,5 +258,3 @@ class SignalPathTest : public BaseSignalPathTest {
         loadTrack(m_pMixerDeck3, pTrack);
     }
 };
-
-#endif /* ENGINEBACKENDTEST_H_ */